MrMonopoly/raylib
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

fix sw_quad_sort_cw

Browse Source
This commit is contained in:
Bigfoot71 2025-05-17 21:14:55 +02:00
parent 903f56ca7b
commit 88c24f8de7
1 changed files with 52 additions and 31 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

77
src/external/rlsw.h vendored
View File

@ -2770,48 +2770,69 @@ static inline void sw_quad_sort_cw(const sw_vertex_t** output)
// //
// The goal is: // The goal is:
// - v0: top-left (minimum Y, then minimum X) // - v0: top-left (minimum Y, then minimum X)
// - v1: top-right (same Y row as v0, maximum X) // - v1: top-right (minimum Y row, maximum X)
// - v3: bottom-left (maximum Y, minimum X)
// - v2: bottom-right (maximum Y, maximum X) // - v2: bottom-right (maximum Y, maximum X)
// - v3: bottom-left (maximum Y, minimum X)
const sw_vertex_t* input = RLSW.vertexBuffer; const sw_vertex_t* input = RLSW.vertexBuffer;
// Find indices of vertices with min Y (top) and max Y (bottom) // Separate vertices into top and bottom based on Y-coordinate
int minYIndex = 0, maxYIndex = 0; const sw_vertex_t* top[2] = {NULL, NULL};
const sw_vertex_t* bottom[2] = {NULL, NULL};
int topCount = 0, bottomCount = 0;
// Find minimum and maximum Y
float minY = input[0].screen[1];
float maxY = input[0].screen[1];
for (int i = 1; i < 4; i++) { for (int i = 1; i < 4; i++) {
if (input[i].screen[1] < input[minYIndex].screen[1]) minYIndex = i; if (input[i].screen[1] < minY) minY = input[i].screen[1];
if (input[i].screen[1] > input[maxYIndex].screen[1]) maxYIndex = i; if (input[i].screen[1] > maxY) maxY = input[i].screen[1];
} }
// Find indices of the remaining two vertices // Separate vertices based on Y-coordinate
int others[2], idx = 0;
for (int i = 0; i < 4; i++) { for (int i = 0; i < 4; i++) {
if (i != minYIndex && i != maxYIndex) { if (input[i].screen[1] == minY && topCount < 2) {
others[idx++] = i; top[topCount++] = &input[i];
} else if (input[i].screen[1] == maxY && bottomCount < 2) {
bottom[bottomCount++] = &input[i];
} }
} }
// Determine left/right among the middle vertices by X coordinate // If we don't have enough top/bottom vertices (e.g., Y values are all different),
int leftMidIndex = (input[others[0]].screen[0] < input[others[1]].screen[0]) ? others[0] : others[1]; // classify vertices as top or bottom based on whether they're closer to minY or maxY
int rightMidIndex = (leftMidIndex == others[0]) ? others[1] : others[0]; for (int i = 0; i < 4; i++) {
if (topCount < 2 && &input[i] != top[0] && &input[i] != bottom[0] && &input[i] != bottom[1]) {
// Assign top vertices: v0 = top-left, v1 = top-right if (fabs(input[i].screen[1] - minY) <= fabs(input[i].screen[1] - maxY)) {
if (input[minYIndex].screen[0] < input[leftMidIndex].screen[0]) { top[topCount++] = &input[i];
output[0] = &input[minYIndex]; // v0: top-left }
output[1] = &input[leftMidIndex]; // v1: top-right }
} else { if (bottomCount < 2 && &input[i] != top[0] && &input[i] != top[1] && &input[i] != bottom[0]) {
output[0] = &input[leftMidIndex]; if (fabs(input[i].screen[1] - maxY) < fabs(input[i].screen[1] - minY)) {
output[1] = &input[minYIndex]; bottom[bottomCount++] = &input[i];
}
}
} }
// Assign bottom vertices: v3 = bottom-left, v2 = bottom-right // Sort top vertices by X (left to right)
if (input[maxYIndex].screen[0] < input[rightMidIndex].screen[0]) { if (topCount == 2 && top[0]->screen[0] > top[1]->screen[0]) {
output[3] = &input[maxYIndex]; // v3: bottom-left const sw_vertex_t* temp = top[0];
output[2] = &input[rightMidIndex]; // v2: bottom-right top[0] = top[1];
} else { top[1] = temp;
output[3] = &input[rightMidIndex];
output[2] = &input[maxYIndex];
} }
// Sort bottom vertices by X (left to right)
if (bottomCount == 2 && bottom[0]->screen[0] > bottom[1]->screen[0]) {
const sw_vertex_t* temp = bottom[0];
bottom[0] = bottom[1];
bottom[1] = temp;
}
// Assign vertices in clockwise order as per the required layout
output[0] = top[0]; // v0: top-left
output[1] = top[topCount-1]; // v1: top-right
output[2] = bottom[bottomCount-1]; // v2: bottom-right
output[3] = bottom[0]; // v3: bottom-left
} }
// REVIEW: Could a perfectly aligned quad, where one of the four points has a different depth, still appear perfectly aligned from a certain point of view? // REVIEW: Could a perfectly aligned quad, where one of the four points has a different depth, still appear perfectly aligned from a certain point of view?