From 2e436129b046bca67739198059cfa5d74a9df6dc Mon Sep 17 00:00:00 2001 From: Lenny Maiorani Date: Thu, 27 Jan 2022 17:18:07 -0700 Subject: [PATCH] LibSoftGPU: Dispatch based on ClipPlane enum at compile-time The `ClipPlane` enum is being looped over at run-time performing run-time dispatch to determine the comparison operation in `point_within_clip_plane`. Change this `for` loop to be linear code which dispatches using a template parameter. This allows for the `point_within_clip_plane` function to do compile-time dispatch. Note: This linear code can become a compile-time loop when static reflection lands in C++2[y|z] allowing looping over the reflected `enum class`. --- Userland/Libraries/LibSoftGPU/Clipper.cpp | 70 +++++++++++++---------- Userland/Libraries/LibSoftGPU/Clipper.h | 3 +- 2 files changed, 40 insertions(+), 33 deletions(-) diff --git a/Userland/Libraries/LibSoftGPU/Clipper.cpp b/Userland/Libraries/LibSoftGPU/Clipper.cpp index e5839b00b7..51e021f37e 100644 --- a/Userland/Libraries/LibSoftGPU/Clipper.cpp +++ b/Userland/Libraries/LibSoftGPU/Clipper.cpp @@ -1,54 +1,57 @@ /* * Copyright (c) 2021, Jesse Buhagiar * Copyright (c) 2021, Stephan Unverwerth + * Copyright (c) 2022, the SerenityOS developers. * * SPDX-License-Identifier: BSD-2-Clause */ -#include -#include +#include +#include #include +#include namespace SoftGPU { -static constexpr FloatVector4 clip_plane_normals[] = { - { 1, 0, 0, 0 }, // Left Plane - { -1, 0, 0, 0 }, // Right Plane - { 0, -1, 0, 0 }, // Top Plane - { 0, 1, 0, 0 }, // Bottom plane - { 0, 0, 1, 0 }, // Near Plane - { 0, 0, -1, 0 } // Far Plane -}; - -static constexpr bool point_within_clip_plane(FloatVector4 const& vertex, Clipper::ClipPlane plane) +template +static constexpr bool point_within_clip_plane(FloatVector4 const& vertex) { - switch (plane) { - case Clipper::ClipPlane::LEFT: + if constexpr (plane == Clipper::ClipPlane::LEFT) { return vertex.x() >= -vertex.w(); - case Clipper::ClipPlane::RIGHT: + } else if constexpr (plane == Clipper::ClipPlane::RIGHT) { return vertex.x() <= vertex.w(); - case Clipper::ClipPlane::TOP: + } else if constexpr (plane == Clipper::ClipPlane::TOP) { return vertex.y() <= vertex.w(); - case Clipper::ClipPlane::BOTTOM: + } else if constexpr (plane == Clipper::ClipPlane::BOTTOM) { return vertex.y() >= -vertex.w(); - case Clipper::ClipPlane::NEAR: + } else if constexpr (plane == Clipper::ClipPlane::NEAR) { return vertex.z() >= -vertex.w(); - case Clipper::ClipPlane::FAR: + } else if constexpr (plane == Clipper::ClipPlane::FAR) { return vertex.z() <= vertex.w(); } - return false; } -static Vertex clip_intersection_point(Vertex const& p1, Vertex const& p2, Clipper::ClipPlane plane) +template +static constexpr Vertex clip_intersection_point(Vertex const& p1, Vertex const& p2) { + constexpr FloatVector4 clip_plane_normals[] = { + { 1, 0, 0, 0 }, // Left Plane + { -1, 0, 0, 0 }, // Right Plane + { 0, -1, 0, 0 }, // Top Plane + { 0, 1, 0, 0 }, // Bottom plane + { 0, 0, 1, 0 }, // Near Plane + { 0, 0, -1, 0 } // Far Plane + }; + constexpr auto clip_plane_normal = clip_plane_normals[to_underlying(plane)]; + // See https://www.microsoft.com/en-us/research/wp-content/uploads/1978/01/p245-blinn.pdf // "Clipping Using Homogeneous Coordinates" Blinn/Newell, 1978 float const w1 = p1.clip_coordinates.w(); float const w2 = p2.clip_coordinates.w(); - float const x1 = clip_plane_normals[to_underlying(plane)].dot(p1.clip_coordinates); - float const x2 = clip_plane_normals[to_underlying(plane)].dot(p2.clip_coordinates); + float const x1 = clip_plane_normal.dot(p1.clip_coordinates); + float const x2 = clip_plane_normal.dot(p2.clip_coordinates); float const a = (w1 + x1) / ((w1 + x1) - (w2 + x2)); Vertex out; @@ -62,21 +65,21 @@ static Vertex clip_intersection_point(Vertex const& p1, Vertex const& p2, Clippe return out; } -static void clip_plane(Vector& read_list, Vector& write_list, Clipper::ClipPlane plane) +template +FLATTEN static constexpr void clip_plane(Vector& read_list, Vector& write_list) { auto read_from = &read_list; auto write_to = &write_list; write_to->clear_with_capacity(); - // FIXME C++23. Static reflection will provide looping over all enum values. for (size_t i = 0; i < read_from->size(); i++) { auto const& curr_vec = read_from->at((i + 1) % read_from->size()); auto const& prev_vec = read_from->at(i); - bool const is_curr_point_within_clip_plane = point_within_clip_plane(curr_vec.clip_coordinates, plane); - bool const is_prev_point_within_clip_plane = point_within_clip_plane(prev_vec.clip_coordinates, plane); + bool const is_curr_point_within_clip_plane = point_within_clip_plane(curr_vec.clip_coordinates); + bool const is_prev_point_within_clip_plane = point_within_clip_plane(prev_vec.clip_coordinates); if (is_curr_point_within_clip_plane != is_prev_point_within_clip_plane) { - auto const intersect = clip_intersection_point(prev_vec, curr_vec, plane); + auto const intersect = clip_intersection_point(prev_vec, curr_vec); write_to->append(intersect); } @@ -91,10 +94,15 @@ void Clipper::clip_triangle_against_frustum(Vector& input_verts) list_a = input_verts; list_b.clear_with_capacity(); - for (size_t plane = 0; plane < NUMBER_OF_CLIPPING_PLANES; plane++) { - clip_plane(list_a, list_b, static_cast(plane)); - } + // FIXME C++23. Static reflection will provide looping over all enum values. + clip_plane(list_a, list_b); + clip_plane(list_a, list_b); + clip_plane(list_a, list_b); + clip_plane(list_a, list_b); + clip_plane(list_a, list_b); + clip_plane(list_a, list_b); input_verts = list_a; } + } diff --git a/Userland/Libraries/LibSoftGPU/Clipper.h b/Userland/Libraries/LibSoftGPU/Clipper.h index 87b14c4c4a..14063d18a8 100644 --- a/Userland/Libraries/LibSoftGPU/Clipper.h +++ b/Userland/Libraries/LibSoftGPU/Clipper.h @@ -1,5 +1,6 @@ /* * Copyright (c) 2021, Jesse Buhagiar + * Copyright (c) 2022, the SerenityOS developers. * * SPDX-License-Identifier: BSD-2-Clause */ @@ -13,8 +14,6 @@ namespace SoftGPU { class Clipper final { - static constexpr u8 NUMBER_OF_CLIPPING_PLANES = 6; - public: enum class ClipPlane : u8 { LEFT = 0,