RGBCube/serenity
1
Fork 0
mirror of https://github.com/RGBCube/serenity synced 2025-07-27 00:47:45 +00:00
Code Issues Activity Actions

LibGL+LibGPU+LibSoftGPU: Move Vertex.h to LibGPU

Browse source
This commit is contained in:
Stephan Unverwerth 2022-03-27 15:43:51 +02:00 • committed by Andreas Kling
parent 5bf224708f
commit 5d2740217f
11 changed files with 37 additions and 34 deletions
Download patch file Download diff file Expand all files Collapse all files

2
Userland/Libraries/LibGL/GLContext.cpp
View file

@ -577,7 +577,7 @@ void GLContext::gl_vertex(GLdouble x, GLdouble y, GLdouble z, GLdouble w)
{ {
APPEND_TO_CALL_LIST_AND_RETURN_IF_NEEDED(gl_vertex, x, y, z, w); APPEND_TO_CALL_LIST_AND_RETURN_IF_NEEDED(gl_vertex, x, y, z, w);
SoftGPU::Vertex vertex; GPU::Vertex vertex;
vertex.position = { static_cast<float>(x), static_cast<float>(y), static_cast<float>(z), static_cast<float>(w) }; vertex.position = { static_cast<float>(x), static_cast<float>(y), static_cast<float>(z), static_cast<float>(w) };
vertex.color = m_current_vertex_color; vertex.color = m_current_vertex_color;

4
Userland/Libraries/LibGL/GLContext.h
View file

@ -19,13 +19,13 @@
#include <LibGL/Tex/TextureUnit.h> #include <LibGL/Tex/TextureUnit.h>
#include <LibGPU/DeviceInfo.h> #include <LibGPU/DeviceInfo.h>
#include <LibGPU/Light.h> #include <LibGPU/Light.h>
#include <LibGPU/Vertex.h>
#include <LibGfx/Bitmap.h> #include <LibGfx/Bitmap.h>
#include <LibGfx/Matrix4x4.h> #include <LibGfx/Matrix4x4.h>
#include <LibGfx/Rect.h> #include <LibGfx/Rect.h>
#include <LibGfx/Vector3.h> #include <LibGfx/Vector3.h>
#include <LibSoftGPU/Clipper.h> #include <LibSoftGPU/Clipper.h>
#include <LibSoftGPU/Device.h> #include <LibSoftGPU/Device.h>
#include <LibSoftGPU/Vertex.h>
namespace GL { namespace GL {
@ -219,7 +219,7 @@ private:
Vector<FloatVector4> m_current_vertex_tex_coord; Vector<FloatVector4> m_current_vertex_tex_coord;
FloatVector3 m_current_vertex_normal { 0.0f, 0.0f, 1.0f }; FloatVector3 m_current_vertex_normal { 0.0f, 0.0f, 1.0f };
Vector<SoftGPU::Vertex> m_vertex_list; Vector<GPU::Vertex> m_vertex_list;
GLenum m_error = GL_NO_ERROR; GLenum m_error = GL_NO_ERROR;
bool m_in_draw_state = false; bool m_in_draw_state = false;

4
Userland/Libraries/LibGPU/Config.h
View file

@ -16,4 +16,8 @@ using ColorType = u32; // BGRA:8888
using DepthType = float; using DepthType = float;
using StencilType = u8; using StencilType = u8;
// FIXME: This constant was originally introduced in LibSoftGPU and is currently used in the Vertex struct.
// Once we refactor the interface this should move back into LibSoftGPU.
static constexpr int NUM_SAMPLERS = 2;
} }

6
Userland/Libraries/LibSoftGPU/Vertex.h → Userland/Libraries/LibGPU/Vertex.h
View file

@ -8,11 +8,11 @@
#pragma once #pragma once
#include <AK/Array.h> #include <AK/Array.h>
#include <LibGPU/Config.h>
#include <LibGfx/Vector3.h> #include <LibGfx/Vector3.h>
#include <LibGfx/Vector4.h> #include <LibGfx/Vector4.h>
#include <LibSoftGPU/Config.h>
namespace SoftGPU { namespace GPU {
struct Vertex { struct Vertex {
FloatVector4 position; FloatVector4 position;
@ -20,7 +20,7 @@ struct Vertex {
FloatVector4 clip_coordinates; FloatVector4 clip_coordinates;
FloatVector4 window_coordinates; FloatVector4 window_coordinates;
FloatVector4 color; FloatVector4 color;
Array<FloatVector4, NUM_SAMPLERS> tex_coords; Array<FloatVector4, GPU::NUM_SAMPLERS> tex_coords;
FloatVector3 normal; FloatVector3 normal;
}; };

12
Userland/Libraries/LibSoftGPU/Clipper.cpp
View file

@ -7,9 +7,9 @@
*/ */
#include <AK/Vector.h> #include <AK/Vector.h>
#include <LibGPU/Vertex.h>
#include <LibGfx/Vector4.h> #include <LibGfx/Vector4.h>
#include <LibSoftGPU/Clipper.h> #include <LibSoftGPU/Clipper.h>
#include <LibSoftGPU/Vertex.h>
namespace SoftGPU { namespace SoftGPU {
@ -33,7 +33,7 @@ static constexpr bool point_within_clip_plane(FloatVector4 const& vertex)
} }
template<Clipper::ClipPlane plane> template<Clipper::ClipPlane plane>
static constexpr Vertex clip_intersection_point(Vertex const& p1, Vertex const& p2) static constexpr GPU::Vertex clip_intersection_point(GPU::Vertex const& p1, GPU::Vertex const& p2)
{ {
constexpr FloatVector4 clip_plane_normals[] = { constexpr FloatVector4 clip_plane_normals[] = {
{ 1, 0, 0, 0 }, // Left Plane { 1, 0, 0, 0 }, // Left Plane
@ -54,19 +54,19 @@ static constexpr Vertex clip_intersection_point(Vertex const& p1, Vertex const&
float const x2 = clip_plane_normal.dot(p2.clip_coordinates); float const x2 = clip_plane_normal.dot(p2.clip_coordinates);
float const a = (w1 + x1) / ((w1 + x1) - (w2 + x2)); float const a = (w1 + x1) / ((w1 + x1) - (w2 + x2));
Vertex out; GPU::Vertex out;
out.position = mix(p1.position, p2.position, a); out.position = mix(p1.position, p2.position, a);
out.eye_coordinates = mix(p1.eye_coordinates, p2.eye_coordinates, a); out.eye_coordinates = mix(p1.eye_coordinates, p2.eye_coordinates, a);
out.clip_coordinates = mix(p1.clip_coordinates, p2.clip_coordinates, a); out.clip_coordinates = mix(p1.clip_coordinates, p2.clip_coordinates, a);
out.color = mix(p1.color, p2.color, a); out.color = mix(p1.color, p2.color, a);
for (size_t i = 0; i < NUM_SAMPLERS; ++i) for (size_t i = 0; i < GPU::NUM_SAMPLERS; ++i)
out.tex_coords[i] = mix(p1.tex_coords[i], p2.tex_coords[i], a); out.tex_coords[i] = mix(p1.tex_coords[i], p2.tex_coords[i], a);
out.normal = mix(p1.normal, p2.normal, a); out.normal = mix(p1.normal, p2.normal, a);
return out; return out;
} }
template<Clipper::ClipPlane plane> template<Clipper::ClipPlane plane>
FLATTEN static constexpr void clip_plane(Vector<Vertex>& read_list, Vector<Vertex>& write_list) FLATTEN static constexpr void clip_plane(Vector<GPU::Vertex>& read_list, Vector<GPU::Vertex>& write_list)
{ {
auto read_from = &read_list; auto read_from = &read_list;
auto write_to = &write_list; auto write_to = &write_list;
@ -89,7 +89,7 @@ FLATTEN static constexpr void clip_plane(Vector<Vertex>& read_list, Vector<Verte
swap(write_list, read_list); swap(write_list, read_list);
} }
void Clipper::clip_triangle_against_frustum(Vector<Vertex>& input_verts) void Clipper::clip_triangle_against_frustum(Vector<GPU::Vertex>& input_verts)
{ {
list_a = input_verts; list_a = input_verts;
list_b.clear_with_capacity(); list_b.clear_with_capacity();

8
Userland/Libraries/LibSoftGPU/Clipper.h
View file

@ -8,8 +8,8 @@
#pragma once #pragma once
#include <AK/Vector.h> #include <AK/Vector.h>
#include <LibGPU/Vertex.h>
#include <LibGfx/Vector4.h> #include <LibGfx/Vector4.h>
#include <LibSoftGPU/Vertex.h>
namespace SoftGPU { namespace SoftGPU {
@ -26,11 +26,11 @@ public:
Clipper() = default; Clipper() = default;
void clip_triangle_against_frustum(Vector<Vertex>& input_vecs); void clip_triangle_against_frustum(Vector<GPU::Vertex>& input_vecs);
private: private:
Vector<Vertex> list_a; Vector<GPU::Vertex> list_a;
Vector<Vertex> list_b; Vector<GPU::Vertex> list_b;
}; };
} }

1
Userland/Libraries/LibSoftGPU/Config.h
View file

@ -17,7 +17,6 @@
namespace SoftGPU { namespace SoftGPU {
static constexpr bool ENABLE_STATISTICS_OVERLAY = false; static constexpr bool ENABLE_STATISTICS_OVERLAY = false;
static constexpr int NUM_SAMPLERS = 2;
static constexpr int MILLISECONDS_PER_STATISTICS_PERIOD = 500; static constexpr int MILLISECONDS_PER_STATISTICS_PERIOD = 500;
static constexpr int NUM_LIGHTS = 8; static constexpr int NUM_LIGHTS = 8;

16
Userland/Libraries/LibSoftGPU/Device.cpp
View file

@ -184,9 +184,9 @@ void Device::rasterize_triangle(Triangle const& triangle)
return; return;
// Vertices // Vertices
Vertex const& vertex0 = triangle.vertices[0]; GPU::Vertex const& vertex0 = triangle.vertices[0];
Vertex const& vertex1 = triangle.vertices[1]; GPU::Vertex const& vertex1 = triangle.vertices[1];
Vertex const& vertex2 = triangle.vertices[2]; GPU::Vertex const& vertex2 = triangle.vertices[2];
// Calculate area of the triangle for later tests // Calculate area of the triangle for later tests
FloatVector2 const v0 = vertex0.window_coordinates.xy(); FloatVector2 const v0 = vertex0.window_coordinates.xy();
@ -510,7 +510,7 @@ void Device::rasterize_triangle(Triangle const& triangle)
else else
quad.vertex_color = expand4(vertex0.color); quad.vertex_color = expand4(vertex0.color);
for (size_t i = 0; i < NUM_SAMPLERS; ++i) for (size_t i = 0; i < GPU::NUM_SAMPLERS; ++i)
quad.texture_coordinates[i] = interpolate(expand4(vertex0.tex_coords[i]), expand4(vertex1.tex_coords[i]), expand4(vertex2.tex_coords[i]), quad.barycentrics); quad.texture_coordinates[i] = interpolate(expand4(vertex0.tex_coords[i]), expand4(vertex1.tex_coords[i]), expand4(vertex2.tex_coords[i]), quad.barycentrics);
if (m_options.fog_enabled) if (m_options.fog_enabled)
@ -582,14 +582,14 @@ GPU::DeviceInfo Device::info() const
return { return {
.vendor_name = "SerenityOS", .vendor_name = "SerenityOS",
.device_name = "SoftGPU", .device_name = "SoftGPU",
.num_texture_units = NUM_SAMPLERS, .num_texture_units = GPU::NUM_SAMPLERS,
.num_lights = NUM_LIGHTS, .num_lights = NUM_LIGHTS,
.stencil_bits = sizeof(GPU::StencilType) * 8, .stencil_bits = sizeof(GPU::StencilType) * 8,
.supports_npot_textures = true, .supports_npot_textures = true,
}; };
} }
static void generate_texture_coordinates(Vertex& vertex, RasterizerOptions const& options) static void generate_texture_coordinates(GPU::Vertex& vertex, RasterizerOptions const& options)
{ {
auto generate_coordinate = [&](size_t texcoord_index, size_t config_index) -> float { auto generate_coordinate = [&](size_t texcoord_index, size_t config_index) -> float {
auto mode = options.texcoord_generation_config[texcoord_index][config_index].mode; auto mode = options.texcoord_generation_config[texcoord_index][config_index].mode;
@ -640,7 +640,7 @@ static void generate_texture_coordinates(Vertex& vertex, RasterizerOptions const
} }
void Device::draw_primitives(GPU::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<Vertex> const& vertices, Vector<size_t> const& enabled_texture_units) FloatMatrix4x4 const& texture_transform, Vector<GPU::Vertex> const& vertices, Vector<size_t> const& enabled_texture_units)
{ {
// At this point, the user has effectively specified that they are done with defining the geometry // At this point, the user has effectively specified that they are done with defining the geometry
// of what they want to draw. We now need to do a few things (https://www.khronos.org/opengl/wiki/Rendering_Pipeline_Overview): // of what they want to draw. We now need to do a few things (https://www.khronos.org/opengl/wiki/Rendering_Pipeline_Overview):
@ -954,7 +954,7 @@ void Device::draw_primitives(GPU::PrimitiveType primitive_type, FloatMatrix4x4 c
} }
// Apply texture transformation // Apply texture transformation
for (size_t i = 0; i < NUM_SAMPLERS; ++i) { for (size_t i = 0; i < GPU::NUM_SAMPLERS; ++i) {
triangle.vertices[0].tex_coords[i] = texture_transform * triangle.vertices[0].tex_coords[i]; triangle.vertices[0].tex_coords[i] = texture_transform * triangle.vertices[0].tex_coords[i];
triangle.vertices[1].tex_coords[i] = texture_transform * triangle.vertices[1].tex_coords[i]; triangle.vertices[1].tex_coords[i] = texture_transform * triangle.vertices[1].tex_coords[i];
triangle.vertices[2].tex_coords[i] = texture_transform * triangle.vertices[2].tex_coords[i]; triangle.vertices[2].tex_coords[i] = texture_transform * triangle.vertices[2].tex_coords[i];

12
Userland/Libraries/LibSoftGPU/Device.h
View file

@ -21,6 +21,7 @@
#include <LibGPU/SamplerConfig.h> #include <LibGPU/SamplerConfig.h>
#include <LibGPU/StencilConfiguration.h> #include <LibGPU/StencilConfiguration.h>
#include <LibGPU/TexCoordGenerationConfig.h> #include <LibGPU/TexCoordGenerationConfig.h>
#include <LibGPU/Vertex.h>
#include <LibGfx/Bitmap.h> #include <LibGfx/Bitmap.h>
#include <LibGfx/Matrix3x3.h> #include <LibGfx/Matrix3x3.h>
#include <LibGfx/Matrix4x4.h> #include <LibGfx/Matrix4x4.h>
@ -34,7 +35,6 @@
#include <LibSoftGPU/Image.h> #include <LibSoftGPU/Image.h>
#include <LibSoftGPU/Sampler.h> #include <LibSoftGPU/Sampler.h>
#include <LibSoftGPU/Triangle.h> #include <LibSoftGPU/Triangle.h>
#include <LibSoftGPU/Vertex.h>
namespace SoftGPU { namespace SoftGPU {
@ -71,8 +71,8 @@ struct RasterizerOptions {
GPU::WindingOrder front_face { GPU::WindingOrder::CounterClockwise }; GPU::WindingOrder front_face { GPU::WindingOrder::CounterClockwise };
bool cull_back { true }; bool cull_back { true };
bool cull_front { false }; bool cull_front { false };
Array<u8, NUM_SAMPLERS> texcoord_generation_enabled_coordinates {}; Array<u8, GPU::NUM_SAMPLERS> texcoord_generation_enabled_coordinates {};
Array<Array<GPU::TexCoordGenerationConfig, 4>, NUM_SAMPLERS> texcoord_generation_config {}; Array<Array<GPU::TexCoordGenerationConfig, 4>, GPU::NUM_SAMPLERS> texcoord_generation_config {};
Gfx::IntRect viewport; Gfx::IntRect viewport;
bool lighting_enabled { false }; bool lighting_enabled { false };
bool color_material_enabled { false }; bool color_material_enabled { false };
@ -88,7 +88,7 @@ public:
GPU::DeviceInfo info() const; GPU::DeviceInfo info() const;
void draw_primitives(GPU::PrimitiveType, FloatMatrix4x4 const& model_view_transform, FloatMatrix4x4 const& projection_transform, FloatMatrix4x4 const& texture_transform, Vector<Vertex> const& vertices, Vector<size_t> const& enabled_texture_units); void draw_primitives(GPU::PrimitiveType, FloatMatrix4x4 const& model_view_transform, FloatMatrix4x4 const& projection_transform, FloatMatrix4x4 const& texture_transform, Vector<GPU::Vertex> const& vertices, Vector<size_t> const& enabled_texture_units);
void resize(Gfx::IntSize const& min_size); void resize(Gfx::IntSize const& min_size);
void clear_color(FloatVector4 const&); void clear_color(FloatVector4 const&);
void clear_depth(GPU::DepthType); void clear_depth(GPU::DepthType);
@ -129,8 +129,8 @@ private:
Clipper m_clipper; Clipper m_clipper;
Vector<Triangle> m_triangle_list; Vector<Triangle> m_triangle_list;
Vector<Triangle> m_processed_triangles; Vector<Triangle> m_processed_triangles;
Vector<Vertex> m_clipped_vertices; Vector<GPU::Vertex> m_clipped_vertices;
Array<Sampler, NUM_SAMPLERS> m_samplers; Array<Sampler, GPU::NUM_SAMPLERS> m_samplers;
Vector<size_t> m_enabled_texture_units; Vector<size_t> m_enabled_texture_units;
AlphaBlendFactors m_alpha_blend_factors; AlphaBlendFactors m_alpha_blend_factors;
Array<GPU::Light, NUM_LIGHTS> m_lights; Array<GPU::Light, NUM_LIGHTS> m_lights;

2
Userland/Libraries/LibSoftGPU/PixelQuad.h
View file

@ -19,7 +19,7 @@ struct PixelQuad final {
Vector3<AK::SIMD::f32x4> barycentrics; Vector3<AK::SIMD::f32x4> barycentrics;
AK::SIMD::f32x4 depth; AK::SIMD::f32x4 depth;
Vector4<AK::SIMD::f32x4> vertex_color; Vector4<AK::SIMD::f32x4> vertex_color;
Array<Vector4<AK::SIMD::f32x4>, NUM_SAMPLERS> texture_coordinates; Array<Vector4<AK::SIMD::f32x4>, GPU::NUM_SAMPLERS> texture_coordinates;
Vector4<AK::SIMD::f32x4> out_color; Vector4<AK::SIMD::f32x4> out_color;
AK::SIMD::f32x4 fog_depth; AK::SIMD::f32x4 fog_depth;
AK::SIMD::i32x4 mask; AK::SIMD::i32x4 mask;

4
Userland/Libraries/LibSoftGPU/Triangle.h
View file

@ -7,12 +7,12 @@
#pragma once #pragma once
#include <LibSoftGPU/Vertex.h> #include <LibGPU/Vertex.h>
namespace SoftGPU { namespace SoftGPU {
struct Triangle { struct Triangle {
Vertex vertices[3]; GPU::Vertex vertices[3];
}; };
} }