Stowage/ladybird
2
0
Fork 0
mirror of https://github.com/LadybirdBrowser/ladybird.git synced 2025-11-06 08:10:58 +00:00
Code Issues Projects Releases Packages Wiki Activity
ladybird/Userland/Libraries/LibSoftGPU/Clipper.cpp

106 lines
4 KiB
C++
Raw Normal View History

LibGL: Move polygon clipping to `Clipper` class This code has also been optimised to be much more memory friendly by removing a _lot_ of extraneous copies. The result is that, when profiled, it's around 8x faster than the previous implementation. Co-Authored-By: Ali Mohammad Pur <ali.mpfard@gmail.com>
2021-05-04 23:00:45 +10:00
/*
* Copyright (c) 2021, Jesse Buhagiar <jooster669@gmail.com>
LibGL: Fix clipping and interpolate vertex attributes The previous clipping implementation was problematic especially when clipping against the near plane. Triangles are now correctly clipped using homogenous coordinates against all frustum planes. Texture coordinates and vertex colors are now correctly interpolated. The earier implementation was just a placeholder.
2021-08-16 19:22:08 +02:00
* Copyright (c) 2021, Stephan Unverwerth <s.unverwerth@serenityos.org>
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`.
2022-01-27 17:18:07 -07:00
* Copyright (c) 2022, the SerenityOS developers.
LibGL: Move polygon clipping to `Clipper` class This code has also been optimised to be much more memory friendly by removing a _lot_ of extraneous copies. The result is that, when profiled, it's around 8x faster than the previous implementation. Co-Authored-By: Ali Mohammad Pur <ali.mpfard@gmail.com>
2021-05-04 23:00:45 +10:00
*
* SPDX-License-Identifier: BSD-2-Clause
*/
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`.
2022-01-27 17:18:07 -07:00
#include <AK/Vector.h>
LibGL+LibGPU+LibSoftGPU: Move Vertex.h to LibGPU
2022-03-27 15:43:51 +02:00
#include <LibGPU/Vertex.h>
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`.
2022-01-27 17:18:07 -07:00
#include <LibGfx/Vector4.h>
LibGL+LibSoftGPU: Move rendering related code to LibSoftGPU library This introduces a new library, LibSoftGPU, that incorporates all rendering related features that formerly resided within LibGL itself. Going forward we will make both libraries completely independent from each other allowing LibGL to load different, possibly accelerated, rendering backends.
2021-12-16 20:32:38 +01:00
#include <LibSoftGPU/Clipper.h>
LibGL: Move polygon clipping to `Clipper` class This code has also been optimised to be much more memory friendly by removing a _lot_ of extraneous copies. The result is that, when profiled, it's around 8x faster than the previous implementation. Co-Authored-By: Ali Mohammad Pur <ali.mpfard@gmail.com>
2021-05-04 23:00:45 +10:00
LibGL+LibSoftGPU: Move rendering related code to LibSoftGPU library This introduces a new library, LibSoftGPU, that incorporates all rendering related features that formerly resided within LibGL itself. Going forward we will make both libraries completely independent from each other allowing LibGL to load different, possibly accelerated, rendering backends.
2021-12-16 20:32:38 +01:00
namespace SoftGPU {
LibGL: Fix clipping and interpolate vertex attributes The previous clipping implementation was problematic especially when clipping against the near plane. Triangles are now correctly clipped using homogenous coordinates against all frustum planes. Texture coordinates and vertex colors are now correctly interpolated. The earier implementation was just a placeholder.
2021-08-16 19:22:08 +02:00
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`.
2022-01-27 17:18:07 -07:00
template<Clipper::ClipPlane plane>
static constexpr bool point_within_clip_plane(FloatVector4 const& vertex)
LibGL: Move polygon clipping to `Clipper` class This code has also been optimised to be much more memory friendly by removing a _lot_ of extraneous copies. The result is that, when profiled, it's around 8x faster than the previous implementation. Co-Authored-By: Ali Mohammad Pur <ali.mpfard@gmail.com>
2021-05-04 23:00:45 +10:00
{
LibSoftGPU: Remove superfluous braces in `Clipper`
2022-04-10 02:45:41 +02:00
if constexpr (plane == Clipper::ClipPlane::LEFT)
LibGL: Do not exclude points on the clip planes Most resources seem to suggest that points on the clip planes are also inside the frustum, e.g.: https://www.cubic.org/docs/3dclip.htm This seems to resolve some rendering issues in Grim Fandango in OpenGL mode where the screen remained black. This was because of quads being drawn with their vertex positions exactly on the clip planes.
2021-12-02 00:46:32 +01:00
return vertex.x() >= -vertex.w();
LibSoftGPU: Remove superfluous braces in `Clipper`
2022-04-10 02:45:41 +02:00
else if constexpr (plane == Clipper::ClipPlane::RIGHT)
LibGL: Do not exclude points on the clip planes Most resources seem to suggest that points on the clip planes are also inside the frustum, e.g.: https://www.cubic.org/docs/3dclip.htm This seems to resolve some rendering issues in Grim Fandango in OpenGL mode where the screen remained black. This was because of quads being drawn with their vertex positions exactly on the clip planes.
2021-12-02 00:46:32 +01:00
return vertex.x() <= vertex.w();
LibSoftGPU: Remove superfluous braces in `Clipper`
2022-04-10 02:45:41 +02:00
else if constexpr (plane == Clipper::ClipPlane::TOP)
LibGL: Do not exclude points on the clip planes Most resources seem to suggest that points on the clip planes are also inside the frustum, e.g.: https://www.cubic.org/docs/3dclip.htm This seems to resolve some rendering issues in Grim Fandango in OpenGL mode where the screen remained black. This was because of quads being drawn with their vertex positions exactly on the clip planes.
2021-12-02 00:46:32 +01:00
return vertex.y() <= vertex.w();
LibSoftGPU: Remove superfluous braces in `Clipper`
2022-04-10 02:45:41 +02:00
else if constexpr (plane == Clipper::ClipPlane::BOTTOM)
LibGL: Do not exclude points on the clip planes Most resources seem to suggest that points on the clip planes are also inside the frustum, e.g.: https://www.cubic.org/docs/3dclip.htm This seems to resolve some rendering issues in Grim Fandango in OpenGL mode where the screen remained black. This was because of quads being drawn with their vertex positions exactly on the clip planes.
2021-12-02 00:46:32 +01:00
return vertex.y() >= -vertex.w();
LibSoftGPU: Remove superfluous braces in `Clipper`
2022-04-10 02:45:41 +02:00
else if constexpr (plane == Clipper::ClipPlane::NEAR)
LibGL: Do not exclude points on the clip planes Most resources seem to suggest that points on the clip planes are also inside the frustum, e.g.: https://www.cubic.org/docs/3dclip.htm This seems to resolve some rendering issues in Grim Fandango in OpenGL mode where the screen remained black. This was because of quads being drawn with their vertex positions exactly on the clip planes.
2021-12-02 00:46:32 +01:00
return vertex.z() >= -vertex.w();
LibSoftGPU: Remove superfluous braces in `Clipper`
2022-04-10 02:45:41 +02:00
else if constexpr (plane == Clipper::ClipPlane::FAR)
LibGL: Do not exclude points on the clip planes Most resources seem to suggest that points on the clip planes are also inside the frustum, e.g.: https://www.cubic.org/docs/3dclip.htm This seems to resolve some rendering issues in Grim Fandango in OpenGL mode where the screen remained black. This was because of quads being drawn with their vertex positions exactly on the clip planes.
2021-12-02 00:46:32 +01:00
return vertex.z() <= vertex.w();
LibGL: Move polygon clipping to `Clipper` class This code has also been optimised to be much more memory friendly by removing a _lot_ of extraneous copies. The result is that, when profiled, it's around 8x faster than the previous implementation. Co-Authored-By: Ali Mohammad Pur <ali.mpfard@gmail.com>
2021-05-04 23:00:45 +10:00
return false;
}
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`.
2022-01-27 17:18:07 -07:00
template<Clipper::ClipPlane plane>
LibGL+LibGPU+LibSoftGPU: Move Vertex.h to LibGPU
2022-03-27 15:43:51 +02:00
static constexpr GPU::Vertex clip_intersection_point(GPU::Vertex const& p1, GPU::Vertex const& p2)
LibGL: Move polygon clipping to `Clipper` class This code has also been optimised to be much more memory friendly by removing a _lot_ of extraneous copies. The result is that, when profiled, it's around 8x faster than the previous implementation. Co-Authored-By: Ali Mohammad Pur <ali.mpfard@gmail.com>
2021-05-04 23:00:45 +10:00
{
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`.
2022-01-27 17:18:07 -07:00
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)];
LibGL: Fix clipping and interpolate vertex attributes The previous clipping implementation was problematic especially when clipping against the near plane. Triangles are now correctly clipped using homogenous coordinates against all frustum planes. Texture coordinates and vertex colors are now correctly interpolated. The earier implementation was just a placeholder.
2021-08-16 19:22:08 +02:00
// See https://www.microsoft.com/en-us/research/wp-content/uploads/1978/01/p245-blinn.pdf
Libraries: Fix typos
2021-09-30 20:03:41 -04:00
// "Clipping Using Homogeneous Coordinates" Blinn/Newell, 1978
LibGL: Move polygon clipping to `Clipper` class This code has also been optimised to be much more memory friendly by removing a _lot_ of extraneous copies. The result is that, when profiled, it's around 8x faster than the previous implementation. Co-Authored-By: Ali Mohammad Pur <ali.mpfard@gmail.com>
2021-05-04 23:00:45 +10:00
LibSoftGPU: Add const to Clipper where possible
2022-01-23 12:39:32 -07:00
float const w1 = p1.clip_coordinates.w();
float const w2 = p2.clip_coordinates.w();
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`.
2022-01-27 17:18:07 -07:00
float const x1 = clip_plane_normal.dot(p1.clip_coordinates);
float const x2 = clip_plane_normal.dot(p2.clip_coordinates);
LibSoftGPU: Add const to Clipper where possible
2022-01-23 12:39:32 -07:00
float const a = (w1 + x1) / ((w1 + x1) - (w2 + x2));
LibGL: Move polygon clipping to `Clipper` class This code has also been optimised to be much more memory friendly by removing a _lot_ of extraneous copies. The result is that, when profiled, it's around 8x faster than the previous implementation. Co-Authored-By: Ali Mohammad Pur <ali.mpfard@gmail.com>
2021-05-04 23:00:45 +10:00
LibGL+LibGPU+LibSoftGPU: Move Vertex.h to LibGPU
2022-03-27 15:43:51 +02:00
GPU::Vertex out;
LibSoftGPU: Use `AK::mix` instead of manual interpolation
2022-01-04 15:02:30 +01:00
out.position = mix(p1.position, p2.position, a);
out.eye_coordinates = mix(p1.eye_coordinates, p2.eye_coordinates, a);
out.clip_coordinates = mix(p1.clip_coordinates, p2.clip_coordinates, a);
out.color = mix(p1.color, p2.color, a);
LibGL+LibGPU+LibSoftGPU: Move Vertex.h to LibGPU
2022-03-27 15:43:51 +02:00
for (size_t i = 0; i < GPU::NUM_SAMPLERS; ++i)
LibGL+LibSoftGPU: Add multiple texture coordinates to vertex struct We now have one set of texture coordinates per texture unit. Texture coordinate generation and texture coordinate assignment is currently only stubbed. This will be rectified in another commit.
2022-01-15 18:33:55 +01:00
out.tex_coords[i] = mix(p1.tex_coords[i], p2.tex_coords[i], a);
LibSoftGPU: Also interpolate normal during triangle clipping
2022-01-06 21:45:02 +01:00
out.normal = mix(p1.normal, p2.normal, a);
LibGL: Fix clipping and interpolate vertex attributes The previous clipping implementation was problematic especially when clipping against the near plane. Triangles are now correctly clipped using homogenous coordinates against all frustum planes. Texture coordinates and vertex colors are now correctly interpolated. The earier implementation was just a placeholder.
2021-08-16 19:22:08 +02:00
return out;
LibGL: Move polygon clipping to `Clipper` class This code has also been optimised to be much more memory friendly by removing a _lot_ of extraneous copies. The result is that, when profiled, it's around 8x faster than the previous implementation. Co-Authored-By: Ali Mohammad Pur <ali.mpfard@gmail.com>
2021-05-04 23:00:45 +10:00
}
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`.
2022-01-27 17:18:07 -07:00
template<Clipper::ClipPlane plane>
LibSoftGPU: Optimize clipping code Three optimizations are applied: 1. If the list of vertices to clip is empty, return immediately after clearing the output list. 2. Remember the previous vertex instead of recalculating whether it is within the clip plane. 3. Instead of copying and swapping lists around, operate on the input and output lists directly. This prevents a lot of `malloc`/`free` traffic as a result of vector assignments. This takes the clipping code CPU load from 3.9% down to 1.8% for Quake 3 on my machine.
2022-04-10 02:50:26 +02:00
FLATTEN static constexpr void clip_plane(Vector<GPU::Vertex>& input_list, Vector<GPU::Vertex>& output_list)
LibGL: Move polygon clipping to `Clipper` class This code has also been optimised to be much more memory friendly by removing a _lot_ of extraneous copies. The result is that, when profiled, it's around 8x faster than the previous implementation. Co-Authored-By: Ali Mohammad Pur <ali.mpfard@gmail.com>
2021-05-04 23:00:45 +10:00
{
LibSoftGPU: Optimize clipping code Three optimizations are applied: 1. If the list of vertices to clip is empty, return immediately after clearing the output list. 2. Remember the previous vertex instead of recalculating whether it is within the clip plane. 3. Instead of copying and swapping lists around, operate on the input and output lists directly. This prevents a lot of `malloc`/`free` traffic as a result of vector assignments. This takes the clipping code CPU load from 3.9% down to 1.8% for Quake 3 on my machine.
2022-04-10 02:50:26 +02:00
output_list.clear_with_capacity();
LibGL: Move polygon clipping to `Clipper` class This code has also been optimised to be much more memory friendly by removing a _lot_ of extraneous copies. The result is that, when profiled, it's around 8x faster than the previous implementation. Co-Authored-By: Ali Mohammad Pur <ali.mpfard@gmail.com>
2021-05-04 23:00:45 +10:00
LibSoftGPU: Optimize clipping code Three optimizations are applied: 1. If the list of vertices to clip is empty, return immediately after clearing the output list. 2. Remember the previous vertex instead of recalculating whether it is within the clip plane. 3. Instead of copying and swapping lists around, operate on the input and output lists directly. This prevents a lot of `malloc`/`free` traffic as a result of vector assignments. This takes the clipping code CPU load from 3.9% down to 1.8% for Quake 3 on my machine.
2022-04-10 02:50:26 +02:00
auto input_list_size = input_list.size();
if (input_list_size == 0)
return;
LibGL: Move polygon clipping to `Clipper` class This code has also been optimised to be much more memory friendly by removing a _lot_ of extraneous copies. The result is that, when profiled, it's around 8x faster than the previous implementation. Co-Authored-By: Ali Mohammad Pur <ali.mpfard@gmail.com>
2021-05-04 23:00:45 +10:00
LibSoftGPU: Optimize clipping code Three optimizations are applied: 1. If the list of vertices to clip is empty, return immediately after clearing the output list. 2. Remember the previous vertex instead of recalculating whether it is within the clip plane. 3. Instead of copying and swapping lists around, operate on the input and output lists directly. This prevents a lot of `malloc`/`free` traffic as a result of vector assignments. This takes the clipping code CPU load from 3.9% down to 1.8% for Quake 3 on my machine.
2022-04-10 02:50:26 +02:00
auto const* prev_vec = &input_list.data()[0];
auto is_prev_point_within_clip_plane = point_within_clip_plane<plane>(prev_vec->clip_coordinates);
for (size_t i = 1; i <= input_list_size; i++) {
auto const& curr_vec = input_list[i % input_list_size];
auto const is_curr_point_within_clip_plane = point_within_clip_plane<plane>(curr_vec.clip_coordinates);
if (is_curr_point_within_clip_plane != is_prev_point_within_clip_plane)
output_list.append(clip_intersection_point<plane>(*prev_vec, curr_vec));
LibSoftGPU: Simplify clipping logic The clipping logic is not DRY (Don't Repeat Yourself). The same logic is repeated in multiple parts of an `if-else` statement. This can be simplified to contain fewer branches and eliminate the redundant code.
2022-01-27 17:18:49 -07:00
if (is_curr_point_within_clip_plane)
LibSoftGPU: Optimize clipping code Three optimizations are applied: 1. If the list of vertices to clip is empty, return immediately after clearing the output list. 2. Remember the previous vertex instead of recalculating whether it is within the clip plane. 3. Instead of copying and swapping lists around, operate on the input and output lists directly. This prevents a lot of `malloc`/`free` traffic as a result of vector assignments. This takes the clipping code CPU load from 3.9% down to 1.8% for Quake 3 on my machine.
2022-04-10 02:50:26 +02:00
output_list.append(curr_vec);
prev_vec = &curr_vec;
is_prev_point_within_clip_plane = is_curr_point_within_clip_plane;
LibSoftGPU: Reduce Clipper class interface to minimum Much of the `Clipper` class can be made free functions and their scope limited. The purpose of this is to prepare the interface for a change to more compile-time dispatch.
2022-01-08 13:55:23 -07:00
}
}
LibGL+LibGPU+LibSoftGPU: Move Vertex.h to LibGPU
2022-03-27 15:43:51 +02:00
void Clipper::clip_triangle_against_frustum(Vector<GPU::Vertex>& input_verts)
LibSoftGPU: Reduce Clipper class interface to minimum Much of the `Clipper` class can be made free functions and their scope limited. The purpose of this is to prepare the interface for a change to more compile-time dispatch.
2022-01-08 13:55:23 -07:00
{
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`.
2022-01-27 17:18:07 -07:00
// FIXME C++23. Static reflection will provide looping over all enum values.
LibSoftGPU: Optimize clipping code Three optimizations are applied: 1. If the list of vertices to clip is empty, return immediately after clearing the output list. 2. Remember the previous vertex instead of recalculating whether it is within the clip plane. 3. Instead of copying and swapping lists around, operate on the input and output lists directly. This prevents a lot of `malloc`/`free` traffic as a result of vector assignments. This takes the clipping code CPU load from 3.9% down to 1.8% for Quake 3 on my machine.
2022-04-10 02:50:26 +02:00
clip_plane<ClipPlane::LEFT>(input_verts, m_vertex_buffer);
clip_plane<ClipPlane::RIGHT>(m_vertex_buffer, input_verts);
clip_plane<ClipPlane::TOP>(input_verts, m_vertex_buffer);
clip_plane<ClipPlane::BOTTOM>(m_vertex_buffer, input_verts);
clip_plane<ClipPlane::NEAR>(input_verts, m_vertex_buffer);
clip_plane<ClipPlane::FAR>(m_vertex_buffer, input_verts);
LibGL: Fix clipping and interpolate vertex attributes The previous clipping implementation was problematic especially when clipping against the near plane. Triangles are now correctly clipped using homogenous coordinates against all frustum planes. Texture coordinates and vertex colors are now correctly interpolated. The earier implementation was just a placeholder.
2021-08-16 19:22:08 +02:00
}
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`.
2022-01-27 17:18:07 -07:00
LibGL: Move polygon clipping to `Clipper` class This code has also been optimised to be much more memory friendly by removing a _lot_ of extraneous copies. The result is that, when profiled, it's around 8x faster than the previous implementation. Co-Authored-By: Ali Mohammad Pur <ali.mpfard@gmail.com>
2021-05-04 23:00:45 +10:00
}
Reference in a new issue Copy permalink