From 24d420312c6a8a2d1488b54c712e625a1d6b02e2 Mon Sep 17 00:00:00 2001 From: Stephan Unverwerth Date: Tue, 15 Mar 2022 01:11:58 +0100 Subject: [PATCH] LibGL+LibGPU+LibSoftGPU: Move Enums.h to LibGPU --- Userland/Libraries/LibGL/GLContext.cpp | 168 ++++++++--------- .../Libraries/{LibSoftGPU => LibGPU}/Enums.h | 6 +- Userland/Libraries/LibSoftGPU/Config.h | 4 + Userland/Libraries/LibSoftGPU/Device.cpp | 176 +++++++++--------- Userland/Libraries/LibSoftGPU/Device.h | 38 ++-- Userland/Libraries/LibSoftGPU/Image.h | 3 +- 6 files changed, 198 insertions(+), 197 deletions(-) rename Userland/Libraries/{LibSoftGPU => LibGPU}/Enums.h (94%) diff --git a/Userland/Libraries/LibGL/GLContext.cpp b/Userland/Libraries/LibGL/GLContext.cpp index f57c6f99b5..3c08102143 100644 --- a/Userland/Libraries/LibGL/GLContext.cpp +++ b/Userland/Libraries/LibGL/GLContext.cpp @@ -15,11 +15,11 @@ #include #include #include +#include #include #include #include #include -#include #include __attribute__((visibility("hidden"))) GL::GLContext* g_gl_context; @@ -359,21 +359,21 @@ void GLContext::gl_end() sync_device_config(); - SoftGPU::PrimitiveType primitive_type; + GPU::PrimitiveType primitive_type; switch (m_current_draw_mode) { case GL_TRIANGLES: - primitive_type = SoftGPU::PrimitiveType::Triangles; + primitive_type = GPU::PrimitiveType::Triangles; break; case GL_TRIANGLE_STRIP: case GL_QUAD_STRIP: - primitive_type = SoftGPU::PrimitiveType::TriangleStrip; + primitive_type = GPU::PrimitiveType::TriangleStrip; break; case GL_TRIANGLE_FAN: case GL_POLYGON: - primitive_type = SoftGPU::PrimitiveType::TriangleFan; + primitive_type = GPU::PrimitiveType::TriangleFan; break; case GL_QUADS: - primitive_type = SoftGPU::PrimitiveType::Quads; + primitive_type = GPU::PrimitiveType::Quads; break; default: VERIFY_NOT_REACHED(); @@ -1036,7 +1036,7 @@ void GLContext::gl_front_face(GLenum face) m_front_face = face; auto rasterizer_options = m_rasterizer.options(); - rasterizer_options.front_face = (face == GL_CW) ? SoftGPU::WindingOrder::Clockwise : SoftGPU::WindingOrder::CounterClockwise; + rasterizer_options.front_face = (face == GL_CW) ? GPU::WindingOrder::Clockwise : GPU::WindingOrder::CounterClockwise; m_rasterizer.set_options(rasterizer_options); } @@ -1266,27 +1266,27 @@ void GLContext::gl_blend_func(GLenum src_factor, GLenum dst_factor) { switch (factor) { case GL_ZERO: - return SoftGPU::BlendFactor::Zero; + return GPU::BlendFactor::Zero; case GL_ONE: - return SoftGPU::BlendFactor::One; + return GPU::BlendFactor::One; case GL_SRC_ALPHA: - return SoftGPU::BlendFactor::SrcAlpha; + return GPU::BlendFactor::SrcAlpha; case GL_ONE_MINUS_SRC_ALPHA: - return SoftGPU::BlendFactor::OneMinusSrcAlpha; + return GPU::BlendFactor::OneMinusSrcAlpha; case GL_SRC_COLOR: - return SoftGPU::BlendFactor::SrcColor; + return GPU::BlendFactor::SrcColor; case GL_ONE_MINUS_SRC_COLOR: - return SoftGPU::BlendFactor::OneMinusSrcColor; + return GPU::BlendFactor::OneMinusSrcColor; case GL_DST_ALPHA: - return SoftGPU::BlendFactor::DstAlpha; + return GPU::BlendFactor::DstAlpha; case GL_ONE_MINUS_DST_ALPHA: - return SoftGPU::BlendFactor::OneMinusDstAlpha; + return GPU::BlendFactor::OneMinusDstAlpha; case GL_DST_COLOR: - return SoftGPU::BlendFactor::DstColor; + return GPU::BlendFactor::DstColor; case GL_ONE_MINUS_DST_COLOR: - return SoftGPU::BlendFactor::OneMinusDstColor; + return GPU::BlendFactor::OneMinusDstColor; case GL_SRC_ALPHA_SATURATE: - return SoftGPU::BlendFactor::SrcAlphaSaturate; + return GPU::BlendFactor::SrcAlphaSaturate; default: VERIFY_NOT_REACHED(); } @@ -1324,28 +1324,28 @@ void GLContext::gl_alpha_func(GLenum func, GLclampf ref) switch (func) { case GL_NEVER: - options.alpha_test_func = SoftGPU::AlphaTestFunction::Never; + options.alpha_test_func = GPU::AlphaTestFunction::Never; break; case GL_ALWAYS: - options.alpha_test_func = SoftGPU::AlphaTestFunction::Always; + options.alpha_test_func = GPU::AlphaTestFunction::Always; break; case GL_LESS: - options.alpha_test_func = SoftGPU::AlphaTestFunction::Less; + options.alpha_test_func = GPU::AlphaTestFunction::Less; break; case GL_LEQUAL: - options.alpha_test_func = SoftGPU::AlphaTestFunction::LessOrEqual; + options.alpha_test_func = GPU::AlphaTestFunction::LessOrEqual; break; case GL_EQUAL: - options.alpha_test_func = SoftGPU::AlphaTestFunction::Equal; + options.alpha_test_func = GPU::AlphaTestFunction::Equal; break; case GL_NOTEQUAL: - options.alpha_test_func = SoftGPU::AlphaTestFunction::NotEqual; + options.alpha_test_func = GPU::AlphaTestFunction::NotEqual; break; case GL_GEQUAL: - options.alpha_test_func = SoftGPU::AlphaTestFunction::GreaterOrEqual; + options.alpha_test_func = GPU::AlphaTestFunction::GreaterOrEqual; break; case GL_GREATER: - options.alpha_test_func = SoftGPU::AlphaTestFunction::Greater; + options.alpha_test_func = GPU::AlphaTestFunction::Greater; break; default: VERIFY_NOT_REACHED(); @@ -2301,28 +2301,28 @@ void GLContext::gl_depth_func(GLenum func) switch (func) { case GL_NEVER: - options.depth_func = SoftGPU::DepthTestFunction::Never; + options.depth_func = GPU::DepthTestFunction::Never; break; case GL_ALWAYS: - options.depth_func = SoftGPU::DepthTestFunction::Always; + options.depth_func = GPU::DepthTestFunction::Always; break; case GL_LESS: - options.depth_func = SoftGPU::DepthTestFunction::Less; + options.depth_func = GPU::DepthTestFunction::Less; break; case GL_LEQUAL: - options.depth_func = SoftGPU::DepthTestFunction::LessOrEqual; + options.depth_func = GPU::DepthTestFunction::LessOrEqual; break; case GL_EQUAL: - options.depth_func = SoftGPU::DepthTestFunction::Equal; + options.depth_func = GPU::DepthTestFunction::Equal; break; case GL_NOTEQUAL: - options.depth_func = SoftGPU::DepthTestFunction::NotEqual; + options.depth_func = GPU::DepthTestFunction::NotEqual; break; case GL_GEQUAL: - options.depth_func = SoftGPU::DepthTestFunction::GreaterOrEqual; + options.depth_func = GPU::DepthTestFunction::GreaterOrEqual; break; case GL_GREATER: - options.depth_func = SoftGPU::DepthTestFunction::Greater; + options.depth_func = GPU::DepthTestFunction::Greater; break; default: VERIFY_NOT_REACHED(); @@ -2467,14 +2467,14 @@ void GLContext::gl_polygon_mode(GLenum face, GLenum mode) return; } - auto map_mode = [](GLenum mode) -> SoftGPU::PolygonMode { + auto map_mode = [](GLenum mode) -> GPU::PolygonMode { switch (mode) { case GL_FILL: - return SoftGPU::PolygonMode::Fill; + return GPU::PolygonMode::Fill; case GL_LINE: - return SoftGPU::PolygonMode::Line; + return GPU::PolygonMode::Line; case GL_POINT: - return SoftGPU::PolygonMode::Point; + return GPU::PolygonMode::Point; default: VERIFY_NOT_REACHED(); } @@ -2550,13 +2550,13 @@ void GLContext::gl_fogi(GLenum pname, GLint param) case GL_FOG_MODE: switch (param) { case GL_LINEAR: - options.fog_mode = SoftGPU::FogMode::Linear; + options.fog_mode = GPU::FogMode::Linear; break; case GL_EXP: - options.fog_mode = SoftGPU::FogMode::Exp; + options.fog_mode = GPU::FogMode::Exp; break; case GL_EXP2: - options.fog_mode = SoftGPU::FogMode::Exp2; + options.fog_mode = GPU::FogMode::Exp2; break; } break; @@ -2730,7 +2730,7 @@ void GLContext::gl_light_model(GLenum pname, GLfloat x, GLfloat y, GLfloat z, GL case GL_LIGHT_MODEL_COLOR_CONTROL: { GLenum color_control = static_cast(x); RETURN_WITH_ERROR_IF(color_control != GL_SINGLE_COLOR && color_control != GL_SEPARATE_SPECULAR_COLOR, GL_INVALID_ENUM); - lighting_params.color_control = (color_control == GL_SINGLE_COLOR) ? SoftGPU::ColorControl::SingleColor : SoftGPU::ColorControl::SeparateSpecularColor; + lighting_params.color_control = (color_control == GL_SINGLE_COLOR) ? GPU::ColorControl::SingleColor : GPU::ColorControl::SeparateSpecularColor; break; } case GL_LIGHT_MODEL_LOCAL_VIEWER: @@ -3031,33 +3031,33 @@ void GLContext::sync_light_state() options.color_material_enabled = m_color_material_enabled; switch (m_color_material_face) { case GL_BACK: - options.color_material_face = SoftGPU::ColorMaterialFace::Back; + options.color_material_face = GPU::ColorMaterialFace::Back; break; case GL_FRONT: - options.color_material_face = SoftGPU::ColorMaterialFace::Front; + options.color_material_face = GPU::ColorMaterialFace::Front; break; case GL_FRONT_AND_BACK: - options.color_material_face = SoftGPU::ColorMaterialFace::FrontAndBack; + options.color_material_face = GPU::ColorMaterialFace::FrontAndBack; break; default: VERIFY_NOT_REACHED(); } switch (m_color_material_mode) { case GL_AMBIENT: - options.color_material_mode = SoftGPU::ColorMaterialMode::Ambient; + options.color_material_mode = GPU::ColorMaterialMode::Ambient; break; case GL_AMBIENT_AND_DIFFUSE: - options.color_material_mode = SoftGPU::ColorMaterialMode::Ambient; - options.color_material_mode = SoftGPU::ColorMaterialMode::Diffuse; + options.color_material_mode = GPU::ColorMaterialMode::Ambient; + options.color_material_mode = GPU::ColorMaterialMode::Diffuse; break; case GL_DIFFUSE: - options.color_material_mode = SoftGPU::ColorMaterialMode::Diffuse; + options.color_material_mode = GPU::ColorMaterialMode::Diffuse; break; case GL_EMISSION: - options.color_material_mode = SoftGPU::ColorMaterialMode::Emissive; + options.color_material_mode = GPU::ColorMaterialMode::Emissive; break; case GL_SPECULAR: - options.color_material_mode = SoftGPU::ColorMaterialMode::Specular; + options.color_material_mode = GPU::ColorMaterialMode::Specular; break; default: VERIFY_NOT_REACHED(); @@ -3069,8 +3069,8 @@ void GLContext::sync_light_state() m_rasterizer.set_light_state(light_id, current_light_state); } - m_rasterizer.set_material_state(SoftGPU::Face::Front, m_material_states[Face::Front]); - m_rasterizer.set_material_state(SoftGPU::Face::Back, m_material_states[Face::Back]); + m_rasterizer.set_material_state(GPU::Face::Front, m_material_states[Face::Front]); + m_rasterizer.set_material_state(GPU::Face::Back, m_material_states[Face::Back]); } void GLContext::sync_device_texcoord_config() @@ -3083,7 +3083,7 @@ void GLContext::sync_device_texcoord_config() for (size_t i = 0; i < m_device_info.num_texture_units; ++i) { - u8 enabled_coordinates = SoftGPU::TexCoordGenerationCoordinate::None; + u8 enabled_coordinates = GPU::TexCoordGenerationCoordinate::None; for (GLenum capability = GL_TEXTURE_GEN_S; capability <= GL_TEXTURE_GEN_Q; ++capability) { auto const context_coordinate_config = texture_coordinate_generation(i, capability); if (!context_coordinate_config.enabled) @@ -3092,19 +3092,19 @@ void GLContext::sync_device_texcoord_config() SoftGPU::TexCoordGenerationConfig* texcoord_generation_config; switch (capability) { case GL_TEXTURE_GEN_S: - enabled_coordinates |= SoftGPU::TexCoordGenerationCoordinate::S; + enabled_coordinates |= GPU::TexCoordGenerationCoordinate::S; texcoord_generation_config = &options.texcoord_generation_config[i][0]; break; case GL_TEXTURE_GEN_T: - enabled_coordinates |= SoftGPU::TexCoordGenerationCoordinate::T; + enabled_coordinates |= GPU::TexCoordGenerationCoordinate::T; texcoord_generation_config = &options.texcoord_generation_config[i][1]; break; case GL_TEXTURE_GEN_R: - enabled_coordinates |= SoftGPU::TexCoordGenerationCoordinate::R; + enabled_coordinates |= GPU::TexCoordGenerationCoordinate::R; texcoord_generation_config = &options.texcoord_generation_config[i][2]; break; case GL_TEXTURE_GEN_Q: - enabled_coordinates |= SoftGPU::TexCoordGenerationCoordinate::Q; + enabled_coordinates |= GPU::TexCoordGenerationCoordinate::Q; texcoord_generation_config = &options.texcoord_generation_config[i][3]; break; default: @@ -3113,21 +3113,21 @@ void GLContext::sync_device_texcoord_config() switch (context_coordinate_config.generation_mode) { case GL_OBJECT_LINEAR: - texcoord_generation_config->mode = SoftGPU::TexCoordGenerationMode::ObjectLinear; + texcoord_generation_config->mode = GPU::TexCoordGenerationMode::ObjectLinear; texcoord_generation_config->coefficients = context_coordinate_config.object_plane_coefficients; break; case GL_EYE_LINEAR: - texcoord_generation_config->mode = SoftGPU::TexCoordGenerationMode::EyeLinear; + texcoord_generation_config->mode = GPU::TexCoordGenerationMode::EyeLinear; texcoord_generation_config->coefficients = context_coordinate_config.eye_plane_coefficients; break; case GL_SPHERE_MAP: - texcoord_generation_config->mode = SoftGPU::TexCoordGenerationMode::SphereMap; + texcoord_generation_config->mode = GPU::TexCoordGenerationMode::SphereMap; break; case GL_REFLECTION_MAP: - texcoord_generation_config->mode = SoftGPU::TexCoordGenerationMode::ReflectionMap; + texcoord_generation_config->mode = GPU::TexCoordGenerationMode::ReflectionMap; break; case GL_NORMAL_MAP: - texcoord_generation_config->mode = SoftGPU::TexCoordGenerationMode::NormalMap; + texcoord_generation_config->mode = GPU::TexCoordGenerationMode::NormalMap; break; } } @@ -3143,28 +3143,28 @@ void GLContext::sync_stencil_configuration() return; m_stencil_configuration_dirty = false; - auto set_device_stencil = [&](SoftGPU::Face face, StencilFunctionOptions func, StencilOperationOptions op) { + auto set_device_stencil = [&](GPU::Face face, StencilFunctionOptions func, StencilOperationOptions op) { SoftGPU::StencilConfiguration device_configuration; // Stencil test function - auto map_func = [](GLenum func) -> SoftGPU::StencilTestFunction { + auto map_func = [](GLenum func) -> GPU::StencilTestFunction { switch (func) { case GL_ALWAYS: - return SoftGPU::StencilTestFunction::Always; + return GPU::StencilTestFunction::Always; case GL_EQUAL: - return SoftGPU::StencilTestFunction::Equal; + return GPU::StencilTestFunction::Equal; case GL_GEQUAL: - return SoftGPU::StencilTestFunction::GreaterOrEqual; + return GPU::StencilTestFunction::GreaterOrEqual; case GL_GREATER: - return SoftGPU::StencilTestFunction::Greater; + return GPU::StencilTestFunction::Greater; case GL_LESS: - return SoftGPU::StencilTestFunction::Less; + return GPU::StencilTestFunction::Less; case GL_LEQUAL: - return SoftGPU::StencilTestFunction::LessOrEqual; + return GPU::StencilTestFunction::LessOrEqual; case GL_NEVER: - return SoftGPU::StencilTestFunction::Never; + return GPU::StencilTestFunction::Never; case GL_NOTEQUAL: - return SoftGPU::StencilTestFunction::NotEqual; + return GPU::StencilTestFunction::NotEqual; } VERIFY_NOT_REACHED(); }; @@ -3173,24 +3173,24 @@ void GLContext::sync_stencil_configuration() device_configuration.test_mask = func.mask; // Stencil operation - auto map_operation = [](GLenum operation) -> SoftGPU::StencilOperation { + auto map_operation = [](GLenum operation) -> GPU::StencilOperation { switch (operation) { case GL_DECR: - return SoftGPU::StencilOperation::Decrement; + return GPU::StencilOperation::Decrement; case GL_DECR_WRAP: - return SoftGPU::StencilOperation::DecrementWrap; + return GPU::StencilOperation::DecrementWrap; case GL_INCR: - return SoftGPU::StencilOperation::Increment; + return GPU::StencilOperation::Increment; case GL_INCR_WRAP: - return SoftGPU::StencilOperation::IncrementWrap; + return GPU::StencilOperation::IncrementWrap; case GL_INVERT: - return SoftGPU::StencilOperation::Invert; + return GPU::StencilOperation::Invert; case GL_KEEP: - return SoftGPU::StencilOperation::Keep; + return GPU::StencilOperation::Keep; case GL_REPLACE: - return SoftGPU::StencilOperation::Replace; + return GPU::StencilOperation::Replace; case GL_ZERO: - return SoftGPU::StencilOperation::Zero; + return GPU::StencilOperation::Zero; } VERIFY_NOT_REACHED(); }; @@ -3201,8 +3201,8 @@ void GLContext::sync_stencil_configuration() m_rasterizer.set_stencil_configuration(face, device_configuration); }; - set_device_stencil(SoftGPU::Face::Front, m_stencil_function[Face::Front], m_stencil_operation[Face::Front]); - set_device_stencil(SoftGPU::Face::Back, m_stencil_function[Face::Back], m_stencil_operation[Face::Back]); + set_device_stencil(GPU::Face::Front, m_stencil_function[Face::Front], m_stencil_operation[Face::Front]); + set_device_stencil(GPU::Face::Back, m_stencil_function[Face::Back], m_stencil_operation[Face::Back]); } void GLContext::build_extension_string() diff --git a/Userland/Libraries/LibSoftGPU/Enums.h b/Userland/Libraries/LibGPU/Enums.h similarity index 94% rename from Userland/Libraries/LibSoftGPU/Enums.h rename to Userland/Libraries/LibGPU/Enums.h index 9f228b15e5..27d53e8f93 100644 --- a/Userland/Libraries/LibSoftGPU/Enums.h +++ b/Userland/Libraries/LibGPU/Enums.h @@ -8,11 +8,7 @@ #include -namespace SoftGPU { - -using ColorType = u32; // BGRA:8888 -using DepthType = float; -using StencilType = u8; +namespace GPU { enum class AlphaTestFunction { Never, diff --git a/Userland/Libraries/LibSoftGPU/Config.h b/Userland/Libraries/LibSoftGPU/Config.h index 28d5370a69..24b80e38e5 100644 --- a/Userland/Libraries/LibSoftGPU/Config.h +++ b/Userland/Libraries/LibSoftGPU/Config.h @@ -23,4 +23,8 @@ static constexpr int NUM_LIGHTS = 8; // FIXME: make this dynamically configurable through ConfigServer static constexpr bool CLAMP_DEPRECATED_BEHAVIOR = false; +using ColorType = u32; // BGRA:8888 +using DepthType = float; +using StencilType = u8; + } diff --git a/Userland/Libraries/LibSoftGPU/Device.cpp b/Userland/Libraries/LibSoftGPU/Device.cpp index 5c49674949..d6e287c6ff 100644 --- a/Userland/Libraries/LibSoftGPU/Device.cpp +++ b/Userland/Libraries/LibSoftGPU/Device.cpp @@ -97,79 +97,79 @@ void Device::setup_blend_factors() m_alpha_blend_factors = {}; switch (m_options.blend_source_factor) { - case BlendFactor::Zero: + case GPU::BlendFactor::Zero: break; - case BlendFactor::One: + case GPU::BlendFactor::One: m_alpha_blend_factors.src_constant = { 1.0f, 1.0f, 1.0f, 1.0f }; break; - case BlendFactor::SrcColor: + case GPU::BlendFactor::SrcColor: m_alpha_blend_factors.src_factor_src_color = 1; break; - case BlendFactor::OneMinusSrcColor: + case GPU::BlendFactor::OneMinusSrcColor: m_alpha_blend_factors.src_constant = { 1.0f, 1.0f, 1.0f, 1.0f }; m_alpha_blend_factors.src_factor_src_color = -1; break; - case BlendFactor::SrcAlpha: + case GPU::BlendFactor::SrcAlpha: m_alpha_blend_factors.src_factor_src_alpha = 1; break; - case BlendFactor::OneMinusSrcAlpha: + case GPU::BlendFactor::OneMinusSrcAlpha: m_alpha_blend_factors.src_constant = { 1.0f, 1.0f, 1.0f, 1.0f }; m_alpha_blend_factors.src_factor_src_alpha = -1; break; - case BlendFactor::DstAlpha: + case GPU::BlendFactor::DstAlpha: m_alpha_blend_factors.src_factor_dst_alpha = 1; break; - case BlendFactor::OneMinusDstAlpha: + case GPU::BlendFactor::OneMinusDstAlpha: m_alpha_blend_factors.src_constant = { 1.0f, 1.0f, 1.0f, 1.0f }; m_alpha_blend_factors.src_factor_dst_alpha = -1; break; - case BlendFactor::DstColor: + case GPU::BlendFactor::DstColor: m_alpha_blend_factors.src_factor_dst_color = 1; break; - case BlendFactor::OneMinusDstColor: + case GPU::BlendFactor::OneMinusDstColor: m_alpha_blend_factors.src_constant = { 1.0f, 1.0f, 1.0f, 1.0f }; m_alpha_blend_factors.src_factor_dst_color = -1; break; - case BlendFactor::SrcAlphaSaturate: + case GPU::BlendFactor::SrcAlphaSaturate: default: VERIFY_NOT_REACHED(); } switch (m_options.blend_destination_factor) { - case BlendFactor::Zero: + case GPU::BlendFactor::Zero: break; - case BlendFactor::One: + case GPU::BlendFactor::One: m_alpha_blend_factors.dst_constant = { 1.0f, 1.0f, 1.0f, 1.0f }; break; - case BlendFactor::SrcColor: + case GPU::BlendFactor::SrcColor: m_alpha_blend_factors.dst_factor_src_color = 1; break; - case BlendFactor::OneMinusSrcColor: + case GPU::BlendFactor::OneMinusSrcColor: m_alpha_blend_factors.dst_constant = { 1.0f, 1.0f, 1.0f, 1.0f }; m_alpha_blend_factors.dst_factor_src_color = -1; break; - case BlendFactor::SrcAlpha: + case GPU::BlendFactor::SrcAlpha: m_alpha_blend_factors.dst_factor_src_alpha = 1; break; - case BlendFactor::OneMinusSrcAlpha: + case GPU::BlendFactor::OneMinusSrcAlpha: m_alpha_blend_factors.dst_constant = { 1.0f, 1.0f, 1.0f, 1.0f }; m_alpha_blend_factors.dst_factor_src_alpha = -1; break; - case BlendFactor::DstAlpha: + case GPU::BlendFactor::DstAlpha: m_alpha_blend_factors.dst_factor_dst_alpha = 1; break; - case BlendFactor::OneMinusDstAlpha: + case GPU::BlendFactor::OneMinusDstAlpha: m_alpha_blend_factors.dst_constant = { 1.0f, 1.0f, 1.0f, 1.0f }; m_alpha_blend_factors.dst_factor_dst_alpha = -1; break; - case BlendFactor::DstColor: + case GPU::BlendFactor::DstColor: m_alpha_blend_factors.dst_factor_dst_color = 1; break; - case BlendFactor::OneMinusDstColor: + case GPU::BlendFactor::OneMinusDstColor: m_alpha_blend_factors.dst_constant = { 1.0f, 1.0f, 1.0f, 1.0f }; m_alpha_blend_factors.dst_factor_dst_color = -1; break; - case BlendFactor::SrcAlphaSaturate: + case GPU::BlendFactor::SrcAlphaSaturate: default: VERIFY_NOT_REACHED(); } @@ -180,7 +180,7 @@ void Device::rasterize_triangle(Triangle const& triangle) INCREASE_STATISTICS_COUNTER(g_num_rasterized_triangles, 1); // Return if alpha testing is a no-op - if (m_options.enable_alpha_test && m_options.alpha_test_func == AlphaTestFunction::Never) + if (m_options.enable_alpha_test && m_options.alpha_test_func == GPU::AlphaTestFunction::Never) return; // Vertices @@ -262,33 +262,33 @@ void Device::rasterize_triangle(Triangle const& triangle) auto stencil_buffer = m_frame_buffer->stencil_buffer(); // Stencil configuration and writing - auto const& stencil_configuration = m_stencil_configuration[Face::Front]; + auto const& stencil_configuration = m_stencil_configuration[GPU::Face::Front]; auto const stencil_reference_value = stencil_configuration.reference_value & stencil_configuration.test_mask; - auto write_to_stencil = [](StencilType* stencil_ptrs[4], i32x4 stencil_value, StencilOperation op, StencilType reference_value, StencilType write_mask, i32x4 pixel_mask) { - if (write_mask == 0 || op == StencilOperation::Keep) + auto write_to_stencil = [](StencilType* stencil_ptrs[4], i32x4 stencil_value, GPU::StencilOperation op, StencilType reference_value, StencilType write_mask, i32x4 pixel_mask) { + if (write_mask == 0 || op == GPU::StencilOperation::Keep) return; switch (op) { - case StencilOperation::Decrement: + case GPU::StencilOperation::Decrement: stencil_value = (stencil_value & ~write_mask) | (max(stencil_value - 1, expand4(0)) & write_mask); break; - case StencilOperation::DecrementWrap: + case GPU::StencilOperation::DecrementWrap: stencil_value = (stencil_value & ~write_mask) | (((stencil_value - 1) & 0xFF) & write_mask); break; - case StencilOperation::Increment: + case GPU::StencilOperation::Increment: stencil_value = (stencil_value & ~write_mask) | (min(stencil_value + 1, expand4(0xFF)) & write_mask); break; - case StencilOperation::IncrementWrap: + case GPU::StencilOperation::IncrementWrap: stencil_value = (stencil_value & ~write_mask) | (((stencil_value + 1) & 0xFF) & write_mask); break; - case StencilOperation::Invert: + case GPU::StencilOperation::Invert: stencil_value ^= write_mask; break; - case StencilOperation::Replace: + case GPU::StencilOperation::Replace: stencil_value = (stencil_value & ~write_mask) | (reference_value & write_mask); break; - case StencilOperation::Zero: + case GPU::StencilOperation::Zero: stencil_value &= ~write_mask; break; default: @@ -344,28 +344,28 @@ void Device::rasterize_triangle(Triangle const& triangle) i32x4 stencil_test_passed; switch (stencil_configuration.test_function) { - case StencilTestFunction::Always: + case GPU::StencilTestFunction::Always: stencil_test_passed = expand4(~0); break; - case StencilTestFunction::Equal: + case GPU::StencilTestFunction::Equal: stencil_test_passed = stencil_value == stencil_reference_value; break; - case StencilTestFunction::Greater: + case GPU::StencilTestFunction::Greater: stencil_test_passed = stencil_value > stencil_reference_value; break; - case StencilTestFunction::GreaterOrEqual: + case GPU::StencilTestFunction::GreaterOrEqual: stencil_test_passed = stencil_value >= stencil_reference_value; break; - case StencilTestFunction::Less: + case GPU::StencilTestFunction::Less: stencil_test_passed = stencil_value < stencil_reference_value; break; - case StencilTestFunction::LessOrEqual: + case GPU::StencilTestFunction::LessOrEqual: stencil_test_passed = stencil_value <= stencil_reference_value; break; - case StencilTestFunction::Never: + case GPU::StencilTestFunction::Never: stencil_test_passed = expand4(0); break; - case StencilTestFunction::NotEqual: + case GPU::StencilTestFunction::NotEqual: stencil_test_passed = stencil_value != stencil_reference_value; break; default: @@ -407,19 +407,19 @@ void Device::rasterize_triangle(Triangle const& triangle) i32x4 depth_test_passed; switch (m_options.depth_func) { - case DepthTestFunction::Always: + case GPU::DepthTestFunction::Always: depth_test_passed = expand4(~0); break; - case DepthTestFunction::Never: + case GPU::DepthTestFunction::Never: depth_test_passed = expand4(0); break; - case DepthTestFunction::Greater: + case GPU::DepthTestFunction::Greater: depth_test_passed = quad.depth > depth; break; - case DepthTestFunction::GreaterOrEqual: + case GPU::DepthTestFunction::GreaterOrEqual: depth_test_passed = quad.depth >= depth; break; - case DepthTestFunction::NotEqual: + case GPU::DepthTestFunction::NotEqual: #ifdef __SSE__ depth_test_passed = quad.depth != depth; #else @@ -431,7 +431,7 @@ void Device::rasterize_triangle(Triangle const& triangle) }; #endif break; - case DepthTestFunction::Equal: + case GPU::DepthTestFunction::Equal: #ifdef __SSE__ depth_test_passed = quad.depth == depth; #else @@ -454,10 +454,10 @@ void Device::rasterize_triangle(Triangle const& triangle) }; #endif break; - case DepthTestFunction::LessOrEqual: + case GPU::DepthTestFunction::LessOrEqual: depth_test_passed = quad.depth <= depth; break; - case DepthTestFunction::Less: + case GPU::DepthTestFunction::Less: depth_test_passed = quad.depth < depth; break; default: @@ -518,7 +518,7 @@ void Device::rasterize_triangle(Triangle const& triangle) shade_fragments(quad); - if (m_options.enable_alpha_test && m_options.alpha_test_func != AlphaTestFunction::Always && !test_alpha(quad)) + if (m_options.enable_alpha_test && m_options.alpha_test_func != GPU::AlphaTestFunction::Always && !test_alpha(quad)) continue; // Write to depth buffer @@ -595,15 +595,15 @@ static void generate_texture_coordinates(Vertex& vertex, RasterizerOptions const auto mode = options.texcoord_generation_config[texcoord_index][config_index].mode; switch (mode) { - case TexCoordGenerationMode::ObjectLinear: { + case GPU::TexCoordGenerationMode::ObjectLinear: { auto coefficients = options.texcoord_generation_config[texcoord_index][config_index].coefficients; return coefficients.dot(vertex.position); } - case TexCoordGenerationMode::EyeLinear: { + case GPU::TexCoordGenerationMode::EyeLinear: { auto coefficients = options.texcoord_generation_config[texcoord_index][config_index].coefficients; return coefficients.dot(vertex.eye_coordinates); } - case TexCoordGenerationMode::SphereMap: { + case GPU::TexCoordGenerationMode::SphereMap: { auto const eye_unit = vertex.eye_coordinates.normalized(); FloatVector3 const eye_unit_xyz = eye_unit.xyz(); auto const normal = vertex.normal; @@ -612,14 +612,14 @@ static void generate_texture_coordinates(Vertex& vertex, RasterizerOptions const auto const reflection_value = reflection[config_index]; return reflection_value / (2 * reflection.length()) + 0.5f; } - case TexCoordGenerationMode::ReflectionMap: { + case GPU::TexCoordGenerationMode::ReflectionMap: { auto const eye_unit = vertex.eye_coordinates.normalized(); FloatVector3 const eye_unit_xyz = eye_unit.xyz(); auto const normal = vertex.normal; auto reflection = eye_unit_xyz - normal * 2 * normal.dot(eye_unit_xyz); return reflection[config_index]; } - case TexCoordGenerationMode::NormalMap: { + case GPU::TexCoordGenerationMode::NormalMap: { return vertex.normal[config_index]; } default: @@ -631,15 +631,15 @@ static void generate_texture_coordinates(Vertex& vertex, RasterizerOptions const auto& tex_coord = vertex.tex_coords[i]; auto const enabled_coords = options.texcoord_generation_enabled_coordinates[i]; tex_coord = { - ((enabled_coords & TexCoordGenerationCoordinate::S) > 0) ? generate_coordinate(i, 0) : tex_coord.x(), - ((enabled_coords & TexCoordGenerationCoordinate::T) > 0) ? generate_coordinate(i, 1) : tex_coord.y(), - ((enabled_coords & TexCoordGenerationCoordinate::R) > 0) ? generate_coordinate(i, 2) : tex_coord.z(), - ((enabled_coords & TexCoordGenerationCoordinate::Q) > 0) ? generate_coordinate(i, 3) : tex_coord.w(), + ((enabled_coords & GPU::TexCoordGenerationCoordinate::S) > 0) ? generate_coordinate(i, 0) : tex_coord.x(), + ((enabled_coords & GPU::TexCoordGenerationCoordinate::T) > 0) ? generate_coordinate(i, 1) : tex_coord.y(), + ((enabled_coords & GPU::TexCoordGenerationCoordinate::R) > 0) ? generate_coordinate(i, 2) : tex_coord.z(), + ((enabled_coords & GPU::TexCoordGenerationCoordinate::Q) > 0) ? generate_coordinate(i, 3) : tex_coord.w(), }; } } -void Device::draw_primitives(PrimitiveType primitive_type, FloatMatrix4x4 const& model_view_transform, FloatMatrix4x4 const& projection_transform, +void Device::draw_primitives(GPU::PrimitiveType primitive_type, FloatMatrix4x4 const& model_view_transform, FloatMatrix4x4 const& projection_transform, FloatMatrix4x4 const& texture_transform, Vector const& vertices, Vector const& enabled_texture_units) { // At this point, the user has effectively specified that they are done with defining the geometry @@ -658,7 +658,7 @@ void Device::draw_primitives(PrimitiveType primitive_type, FloatMatrix4x4 const& m_processed_triangles.clear_with_capacity(); // Let's construct some triangles - if (primitive_type == PrimitiveType::Triangles) { + if (primitive_type == GPU::PrimitiveType::Triangles) { Triangle triangle; if (vertices.size() < 3) return; @@ -669,7 +669,7 @@ void Device::draw_primitives(PrimitiveType primitive_type, FloatMatrix4x4 const& m_triangle_list.append(triangle); } - } else if (primitive_type == PrimitiveType::Quads) { + } else if (primitive_type == GPU::PrimitiveType::Quads) { // We need to construct two triangles to form the quad Triangle triangle; if (vertices.size() < 4) @@ -687,7 +687,7 @@ void Device::draw_primitives(PrimitiveType primitive_type, FloatMatrix4x4 const& triangle.vertices[2] = vertices.at(i); m_triangle_list.append(triangle); } - } else if (primitive_type == PrimitiveType::TriangleFan) { + } else if (primitive_type == GPU::PrimitiveType::TriangleFan) { Triangle triangle; triangle.vertices[0] = vertices.at(0); // Root vertex is always the vertex defined first @@ -697,7 +697,7 @@ void Device::draw_primitives(PrimitiveType primitive_type, FloatMatrix4x4 const& triangle.vertices[2] = vertices.at(i + 1); m_triangle_list.append(triangle); } - } else if (primitive_type == PrimitiveType::TriangleStrip) { + } else if (primitive_type == GPU::PrimitiveType::TriangleStrip) { Triangle triangle; if (vertices.size() < 3) return; @@ -753,22 +753,22 @@ void Device::draw_primitives(PrimitiveType primitive_type, FloatMatrix4x4 const& auto specular = material.specular; if (m_options.color_material_enabled - && (m_options.color_material_face == ColorMaterialFace::Front || m_options.color_material_face == ColorMaterialFace::FrontAndBack)) { + && (m_options.color_material_face == GPU::ColorMaterialFace::Front || m_options.color_material_face == GPU::ColorMaterialFace::FrontAndBack)) { switch (m_options.color_material_mode) { - case ColorMaterialMode::Ambient: + case GPU::ColorMaterialMode::Ambient: ambient = vertex.color; break; - case ColorMaterialMode::AmbientAndDiffuse: + case GPU::ColorMaterialMode::AmbientAndDiffuse: ambient = vertex.color; diffuse = vertex.color; break; - case ColorMaterialMode::Diffuse: + case GPU::ColorMaterialMode::Diffuse: diffuse = vertex.color; break; - case ColorMaterialMode::Emissive: + case GPU::ColorMaterialMode::Emissive: emissive = vertex.color; break; - case ColorMaterialMode::Specular: + case GPU::ColorMaterialMode::Specular: specular = vertex.color; break; } @@ -916,7 +916,7 @@ void Device::draw_primitives(PrimitiveType primitive_type, FloatMatrix4x4 const& // Generate texture coordinates if at least one coordinate is enabled bool texture_coordinate_generation_enabled = false; for (auto const coordinates_enabled : m_options.texcoord_generation_enabled_coordinates) { - if (coordinates_enabled != TexCoordGenerationCoordinate::None) { + if (coordinates_enabled != GPU::TexCoordGenerationCoordinate::None) { texture_coordinate_generation_enabled = true; break; } @@ -935,7 +935,7 @@ void Device::draw_primitives(PrimitiveType primitive_type, FloatMatrix4x4 const& continue; if (m_options.enable_culling) { - bool is_front = (m_options.front_face == WindingOrder::CounterClockwise ? area > 0 : area < 0); + bool is_front = (m_options.front_face == GPU::WindingOrder::CounterClockwise ? area > 0 : area < 0); if (!is_front && m_options.cull_back) continue; @@ -977,13 +977,13 @@ ALWAYS_INLINE void Device::shade_fragments(PixelQuad& quad) // FIXME: Implement more blend modes switch (sampler.config().fixed_function_texture_env_mode) { - case TextureEnvMode::Modulate: + case SoftGPU::TextureEnvMode::Modulate: quad.out_color = quad.out_color * texel; break; - case TextureEnvMode::Replace: + case SoftGPU::TextureEnvMode::Replace: quad.out_color = texel; break; - case TextureEnvMode::Decal: { + case SoftGPU::TextureEnvMode::Decal: { auto dst_alpha = texel.w(); quad.out_color.set_x(mix(quad.out_color.x(), texel.x(), dst_alpha)); quad.out_color.set_y(mix(quad.out_color.y(), texel.y(), dst_alpha)); @@ -1002,14 +1002,14 @@ ALWAYS_INLINE void Device::shade_fragments(PixelQuad& quad) if (m_options.fog_enabled) { auto factor = expand4(0.0f); switch (m_options.fog_mode) { - case FogMode::Linear: + case GPU::FogMode::Linear: factor = (m_options.fog_end - quad.fog_depth) / (m_options.fog_end - m_options.fog_start); break; - case FogMode::Exp: { + case GPU::FogMode::Exp: { auto argument = -m_options.fog_density * quad.fog_depth; factor = exp(argument); } break; - case FogMode::Exp2: { + case GPU::FogMode::Exp2: { auto argument = m_options.fog_density * quad.fog_depth; argument *= -argument; factor = exp(argument); @@ -1032,26 +1032,26 @@ ALWAYS_INLINE bool Device::test_alpha(PixelQuad& quad) auto const ref_value = expand4(m_options.alpha_test_ref_value); switch (m_options.alpha_test_func) { - case AlphaTestFunction::Less: + case GPU::AlphaTestFunction::Less: quad.mask &= alpha < ref_value; break; - case AlphaTestFunction::Equal: + case GPU::AlphaTestFunction::Equal: quad.mask &= alpha == ref_value; break; - case AlphaTestFunction::LessOrEqual: + case GPU::AlphaTestFunction::LessOrEqual: quad.mask &= alpha <= ref_value; break; - case AlphaTestFunction::Greater: + case GPU::AlphaTestFunction::Greater: quad.mask &= alpha > ref_value; break; - case AlphaTestFunction::NotEqual: + case GPU::AlphaTestFunction::NotEqual: quad.mask &= alpha != ref_value; break; - case AlphaTestFunction::GreaterOrEqual: + case GPU::AlphaTestFunction::GreaterOrEqual: quad.mask &= alpha >= ref_value; break; - case AlphaTestFunction::Never: - case AlphaTestFunction::Always: + case GPU::AlphaTestFunction::Never: + case GPU::AlphaTestFunction::Always: default: VERIFY_NOT_REACHED(); } @@ -1241,12 +1241,12 @@ void Device::set_light_state(unsigned int light_id, Light const& light) m_lights.at(light_id) = light; } -void Device::set_material_state(Face face, Material const& material) +void Device::set_material_state(GPU::Face face, Material const& material) { m_materials[face] = material; } -void Device::set_stencil_configuration(Face face, StencilConfiguration const& stencil_configuration) +void Device::set_stencil_configuration(GPU::Face face, StencilConfiguration const& stencil_configuration) { m_stencil_configuration[face] = stencil_configuration; } diff --git a/Userland/Libraries/LibSoftGPU/Device.h b/Userland/Libraries/LibSoftGPU/Device.h index 2577a1a18d..0551a9903e 100644 --- a/Userland/Libraries/LibSoftGPU/Device.h +++ b/Userland/Libraries/LibSoftGPU/Device.h @@ -12,6 +12,7 @@ #include #include #include +#include #include #include #include @@ -22,7 +23,6 @@ #include #include #include -#include #include #include #include @@ -34,7 +34,7 @@ namespace SoftGPU { struct TexCoordGenerationConfig { - TexCoordGenerationMode mode { TexCoordGenerationMode::EyeLinear }; + GPU::TexCoordGenerationMode mode { GPU::TexCoordGenerationMode::EyeLinear }; FloatVector4 coefficients {}; }; @@ -44,19 +44,19 @@ struct RasterizerOptions { bool enable_depth_test { false }; bool enable_depth_write { true }; bool enable_alpha_test { false }; - AlphaTestFunction alpha_test_func { AlphaTestFunction::Always }; + GPU::AlphaTestFunction alpha_test_func { GPU::AlphaTestFunction::Always }; float alpha_test_ref_value { 0 }; bool enable_blending { false }; - BlendFactor blend_source_factor { BlendFactor::One }; - BlendFactor blend_destination_factor { BlendFactor::One }; + GPU::BlendFactor blend_source_factor { GPU::BlendFactor::One }; + GPU::BlendFactor blend_destination_factor { GPU::BlendFactor::One }; u32 color_mask { 0xffffffff }; float depth_min { 0.f }; float depth_max { 1.f }; - DepthTestFunction depth_func { DepthTestFunction::Less }; - PolygonMode polygon_mode { PolygonMode::Fill }; + GPU::DepthTestFunction depth_func { GPU::DepthTestFunction::Less }; + GPU::PolygonMode polygon_mode { GPU::PolygonMode::Fill }; FloatVector4 fog_color { 0.0f, 0.0f, 0.0f, 0.0f }; float fog_density { 1.0f }; - FogMode fog_mode { FogMode::Exp }; + GPU::FogMode fog_mode { GPU::FogMode::Exp }; bool fog_enabled { false }; float fog_start { 0.0f }; float fog_end { 1.0f }; @@ -68,7 +68,7 @@ struct RasterizerOptions { float depth_offset_constant { 0 }; bool depth_offset_enabled { false }; bool enable_culling { false }; - WindingOrder front_face { WindingOrder::CounterClockwise }; + GPU::WindingOrder front_face { GPU::WindingOrder::CounterClockwise }; bool cull_back { true }; bool cull_front { false }; Array texcoord_generation_enabled_coordinates {}; @@ -76,14 +76,14 @@ struct RasterizerOptions { Gfx::IntRect viewport; bool lighting_enabled { false }; bool color_material_enabled { false }; - ColorMaterialFace color_material_face { ColorMaterialFace::FrontAndBack }; - ColorMaterialMode color_material_mode { ColorMaterialMode::AmbientAndDiffuse }; + GPU::ColorMaterialFace color_material_face { GPU::ColorMaterialFace::FrontAndBack }; + GPU::ColorMaterialMode color_material_mode { GPU::ColorMaterialMode::AmbientAndDiffuse }; }; struct LightModelParameters { FloatVector4 scene_ambient_color { 0.2f, 0.2f, 0.2f, 1.0f }; bool viewer_at_infinity { false }; - ColorControl color_control { ColorControl::SingleColor }; + GPU::ColorControl color_control { GPU::ColorControl::SingleColor }; bool two_sided_lighting { false }; }; @@ -99,13 +99,13 @@ struct RasterPosition { }; struct StencilConfiguration { - StencilTestFunction test_function; + GPU::StencilTestFunction test_function; StencilType reference_value; StencilType test_mask; - StencilOperation on_stencil_test_fail; - StencilOperation on_depth_test_fail; - StencilOperation on_pass; + GPU::StencilOperation on_stencil_test_fail; + GPU::StencilOperation on_depth_test_fail; + GPU::StencilOperation on_pass; StencilType write_mask; }; @@ -115,7 +115,7 @@ public: GPU::DeviceInfo info() const; - void draw_primitives(PrimitiveType, FloatMatrix4x4 const& model_view_transform, FloatMatrix4x4 const& projection_transform, FloatMatrix4x4 const& texture_transform, Vector const& vertices, Vector const& enabled_texture_units); + void draw_primitives(GPU::PrimitiveType, FloatMatrix4x4 const& model_view_transform, FloatMatrix4x4 const& projection_transform, FloatMatrix4x4 const& texture_transform, Vector const& vertices, Vector const& enabled_texture_units); void resize(Gfx::IntSize const& min_size); void clear_color(FloatVector4 const&); void clear_depth(DepthType); @@ -134,8 +134,8 @@ public: void set_sampler_config(unsigned, SamplerConfig const&); void set_light_state(unsigned, Light const&); - void set_material_state(Face, Material const&); - void set_stencil_configuration(Face, StencilConfiguration const&); + void set_material_state(GPU::Face, Material const&); + void set_stencil_configuration(GPU::Face, StencilConfiguration const&); RasterPosition raster_position() const { return m_raster_position; } void set_raster_position(RasterPosition const& raster_position); diff --git a/Userland/Libraries/LibSoftGPU/Image.h b/Userland/Libraries/LibSoftGPU/Image.h index b7a4a16a80..8c31007d06 100644 --- a/Userland/Libraries/LibSoftGPU/Image.h +++ b/Userland/Libraries/LibSoftGPU/Image.h @@ -10,10 +10,11 @@ #include #include #include +#include #include #include #include -#include +#include #include #include