From 031e8ee47797efbd7cb2a2c20cc6def3ce13d8ca Mon Sep 17 00:00:00 2001 From: Alug Date: Mon, 6 Oct 2025 18:14:59 +0200 Subject: [PATCH 01/27] WIP: column buffering/flushing system it "works" so far no performance improvement everything but fully opague columns dont work for now until fixed really messy and needs to be templated when working from prboom & eternity engine --- src/r_draw.h | 3 + src/r_draw_column.cpp | 183 ++++++++++++- src/r_draw_flush.cpp | 599 ++++++++++++++++++++++++++++++++++++++++++ src/r_main.cpp | 4 + src/r_plane.cpp | 11 +- 5 files changed, 783 insertions(+), 17 deletions(-) create mode 100644 src/r_draw_flush.cpp diff --git a/src/r_draw.h b/src/r_draw.h index bcd734e50..232e6c8ce 100644 --- a/src/r_draw.h +++ b/src/r_draw.h @@ -252,6 +252,9 @@ void R_Draw2sMultiPatchTranslucentColumn(drawcolumndata_t* dc); void R_DrawFogColumn(drawcolumndata_t* dc); +void R_ResetColumnBuffer(void); +void R_DrawSkyColumn(drawcolumndata_t *dc); + // span drawers void R_DrawSpan(drawspandata_t* ds); diff --git a/src/r_draw_column.cpp b/src/r_draw_column.cpp index bae220e6d..ccb5c5403 100644 --- a/src/r_draw_column.cpp +++ b/src/r_draw_column.cpp @@ -21,6 +21,8 @@ // a has a constant z depth from top to bottom. // +#include "r_draw_flush.cpp" + enum DrawColumnType { DC_BASIC = 0x0000, @@ -69,7 +71,9 @@ static constexpr UINT8 R_DrawColumnPixel(drawcolumndata_t* dc, UINT8 * restrict } } - return R_GetColumnTranslucent(dc, dest, col, colormap); + //return R_GetColumnTranslucent(dc, dest, col, colormap); + // dont return any other shit for now + return col; } /** \brief The R_DrawColumn function @@ -150,6 +154,7 @@ static void R_DrawColumnTemplate(drawcolumndata_t *dc) } R_DrawColumnTemplate(&dc_copy); + if (solid) { dc_copy.yl = bheight; @@ -184,16 +189,25 @@ static void R_DrawColumnTemplate(drawcolumndata_t *dc) intptr_t frac; const intptr_t fracstep = dc->iscale; - const intptr_t heightmask = dc->sourcelength-1; + const intptr_t heightmask = dc->sourcelength-1; // CPhipps - specify type constexpr INT32 npow2min = -1; const INT32 npow2max = dc->sourcelength; - const INT32 stride = vid.width; const UINT8 * restrict source = dc->source; const lighttable_t * restrict colormap = dc->colormap; + UINT8 * restrict dest; + // Framebuffer destination address. - UINT8 * restrict dest = R_Address(dc->x, dc->yl); + // SoM: MAGIC + /*if constexpr (Type & (DrawColumnType::DC_COLORMAP | DrawColumnType::DC_TRANSMAP)) + dest = R_GetBufferColormapTrans(dc); + else if constexpr (Type & DrawColumnType::DC_TRANSMAP) + dest = R_GetBufferTrans(dc); + else if constexpr (Type & DrawColumnType::DC_COLORMAP) + dest = R_GetBufferColormap(dc); + else*/ + dest = R_GetBufferOpaque(dc); count++; @@ -205,15 +219,15 @@ static void R_DrawColumnTemplate(drawcolumndata_t *dc) case 255: case 127: { - while(count--) + while (count--) { *dest = R_DrawColumnPixel(dc, dest, (frac>>FRACBITS) & heightmask, source, colormap); - dest += stride; + dest += 4; frac += fracstep; } } break; - case -1: + case npow2min: { if (frac < 0) // adjust in case we underread @@ -223,7 +237,7 @@ static void R_DrawColumnTemplate(drawcolumndata_t *dc) while (--count >= 0) { *dest = R_DrawColumnPixel(dc, dest, frac>>FRACBITS, source, colormap); - dest += stride; + dest += 4; frac += fracstep; } } @@ -235,11 +249,11 @@ static void R_DrawColumnTemplate(drawcolumndata_t *dc) while ((count -= 2) >= 0) // texture height is a power of 2 -- killough { *dest = R_DrawColumnPixel(dc, dest, (frac>>FRACBITS) & heightmask, source, colormap); - dest += stride; + dest += 4; frac += fracstep; *dest = R_DrawColumnPixel(dc, dest, (frac>>FRACBITS) & heightmask, source, colormap); - dest += stride; + dest += 4; frac += fracstep; } @@ -277,7 +291,7 @@ static void R_DrawColumnTemplate(drawcolumndata_t *dc) // and a few bytes after as well *dest = R_DrawColumnPixel(dc, dest, CLAMP((frac >> FRACBITS), npow2min, npow2max), source, colormap); - dest += stride; + dest += 4; #if __SIZEOF_POINTER__ < 8 // 64-bit systems have large enough numbers for this to be a non-issue // Avoid overflow. @@ -354,3 +368,150 @@ void R_DrawFogColumn(drawcolumndata_t* dc) dest += stride; } while (count--); } + +// blunt copy paste for now +// cant share a global buffer between threads for obvious reasons lmao +void R_DrawSkyColumn(drawcolumndata_t *dc) +{ + INT32 count; + + count = dc->yh - dc->yl; + + if (count < 0) // Zero length, column does not exceed a pixel. + { + return; + } + + if ((unsigned)dc->x >= (unsigned)vid.width || dc->yl < 0 || dc->yh >= vid.height) + { + return; + } + + { + // Inner loop that does the actual texture mapping, + // e.g. a DDA-lile scaling. + // This is as fast as it gets. (Yeah, right!!! -- killough) + // + // killough 2/1/98: more performance tuning + + intptr_t frac; + const intptr_t fracstep = dc->iscale; + const intptr_t heightmask = dc->sourcelength-1; + constexpr INT32 npow2min = -1; + const INT32 npow2max = dc->sourcelength; + const INT32 stride = vid.width; + + const UINT8 * restrict source = dc->source; + const lighttable_t * restrict colormap = dc->colormap; + + // Framebuffer destination address. + UINT8 * restrict dest = R_Address(dc->x, dc->yl); + + count++; + + // Determine scaling, which is the only mapping to be done. + frac = (dc->texturemid + FixedMul((dc->yl << FRACBITS) - centeryfrac, fracstep)); + + switch (heightmask) + { + case 255: + case 127: + { + while(count--) + { + *dest = R_DrawColumnPixel(dc, dest, (frac>>FRACBITS) & heightmask, source, colormap); + dest += stride; + frac += fracstep; + } + } + break; + case -1: + { + if (frac < 0) + // adjust in case we underread + frac += fracstep; + + // texture has no height, so just go + while (--count >= 0) + { + *dest = R_DrawColumnPixel(dc, dest, frac>>FRACBITS, source, colormap); + dest += stride; + frac += fracstep; + } + } + break; + default: + { + if (!(dc->sourcelength & heightmask)) // power of 2 -- killough + { + while ((count -= 2) >= 0) // texture height is a power of 2 -- killough + { + *dest = R_DrawColumnPixel(dc, dest, (frac>>FRACBITS) & heightmask, source, colormap); + dest += stride; + frac += fracstep; + + *dest = R_DrawColumnPixel(dc, dest, (frac>>FRACBITS) & heightmask, source, colormap); + dest += stride; + frac += fracstep; + } + + if (count & 1) + { + *dest = R_DrawColumnPixel(dc, dest, (frac>>FRACBITS) & heightmask, source, colormap); + } + } + else + { + const intptr_t fixed_heightmask = dc->texheight << FRACBITS; + + if (frac < 0) + { + while ((frac += fixed_heightmask) < 0) + { + ; + } + } + else + { + while (frac >= fixed_heightmask) + { + frac -= fixed_heightmask; + } + } + + do + { + // Re-map color indices from wall texture column + // using a lighting/special effects LUT. + // heightmask is the Tutti-Frutti fix + + // -1 is the lower clamp bound because column posts have a "safe" byte before the real data + // and a few bytes after as well + *dest = R_DrawColumnPixel(dc, dest, CLAMP((frac >> FRACBITS), npow2min, npow2max), source, colormap); + + dest += stride; + +#if __SIZEOF_POINTER__ < 8 // 64-bit systems have large enough numbers for this to be a non-issue + // Avoid overflow. + if (fracstep > 0x7FFFFFFF - frac) + { + frac += fracstep - fixed_heightmask; + } + else +#endif + { + frac += fracstep; + } + + while (frac >= fixed_heightmask) + { + frac -= fixed_heightmask; + } + } + while (--count); + } + } + break; + } + } +} diff --git a/src/r_draw_flush.cpp b/src/r_draw_flush.cpp new file mode 100644 index 000000000..657e185b5 --- /dev/null +++ b/src/r_draw_flush.cpp @@ -0,0 +1,599 @@ +// SONIC ROBO BLAST 2 KART +//----------------------------------------------------------------------------- +// Copyright (C) 2025 by Kart Krew. +// Copyright (C) 2020 by Sonic Team Junior. +// Copyright (C) 2000 by DooM Legacy Team. +// Copyright (C) 1996 by id Software, Inc. +// +// This program is free software distributed under the +// terms of the GNU General Public License, version 2. +// See the 'LICENSE' file for more details. +//----------------------------------------------------------------------------- +/// \file r_draw_flush.cpp +/// \brief column flush functions +/// \note no includes because this is included as part of r_draw.cpp + +enum ColumnFlushType +{ + FLUSH_NONE, + FLUSH_OPAQUE, + FLUSH_TRANS, + FLUSH_COLORMAP, + FLUSH_COLORMAP_TRANS +}; + +static int temp_x = 0; +static int tempyl[4], tempyh[4]; +static UINT8 tempbuf[MAXVIDWIDTH * 4]; +static int startx = 0; +static int commontop, commonbot; +static ColumnFlushType temptype = FLUSH_NONE; +static const UINT8 *temptranmap = NULL; +static const UINT8 *temptranslation = NULL; + +static void R_FlushColumns(void); + +static void R_FlushWholeError(void) +{ + I_Error("R_FlushWholeColumns called without being initialized.\n"); +} + +static void R_FlushHTError(void) +{ + I_Error("R_FlushHTColumns called without being initialized.\n"); +} + +static void R_QuadFlushError(void) +{ + I_Error("R_FlushQuadColumn called without being initialized.\n"); +} + +// +// R_FlushWholeOpaque +// +// Flushes the entire columns in the buffer, one at a time. +// This is used when a quad flush isn't possible. +// Opaque version -- no remapping whatsoever. +// +static void R_FlushWholeOpaque(void) +{ + UINT8 *source; + UINT8 *dest; + INT32 count, yl; + const restrict INT32 stride = vid.width; + + while (--temp_x >= 0) + { + yl = tempyl[temp_x]; + source = &tempbuf[temp_x + (yl << 2)]; + dest = R_Address(startx + temp_x, yl); + count = tempyh[temp_x] - yl + 1; + + while (--count >= 0) + { + *dest = *source; + source += 4; + dest += stride; + } + } +} + +// +// R_FlushHTOpaque +// +// Flushes the head and tail of columns in the buffer in +// preparation for a quad flush. +// Opaque version -- no remapping whatsoever. +// +static void R_FlushHTOpaque(void) +{ + UINT8 *source; + UINT8 *dest; + INT32 count, colnum = 0; + INT32 yl, yh; + const restrict INT32 stride = vid.width; + + while (colnum < 4) + { + yl = tempyl[colnum]; + yh = tempyh[colnum]; + + // flush column head + if (yl < commontop) + { + source = &tempbuf[colnum + (yl << 2)]; + dest = R_Address(startx + colnum, yl); + count = commontop - yl; + + while (--count >= 0) + { + *dest = *source; + source += 4; + dest += stride; + } + } + + // flush column tail + if (yh > commonbot) + { + source = &tempbuf[colnum + ((commonbot + 1) << 2)]; + dest = R_Address(startx + colnum, commonbot + 1); + count = yh - commonbot; + + while (--count >= 0) + { + *dest = *source; + source += 4; + dest += stride; + } + } + ++colnum; + } +} + +static void R_FlushQuadOpaque(void) +{ + UINT8 *source = &tempbuf[commontop << 2]; + UINT8 *dest = R_Address(startx, commontop); + INT32 count; + const restrict INT32 stride = vid.width; + + count = commonbot - commontop + 1; + + if ((sizeof(int) == 4) && (((intptr_t)source % 4) == 0) && (((intptr_t)dest % 4) == 0)) + { + while(--count >= 0) + { + *(int *)dest = *(int *)source; + source += 4 * sizeof(UINT8); + dest += stride * sizeof(UINT8); + } + } + else + { + while(--count >= 0) + { + dest[0] = source[0]; + dest[1] = source[1]; + dest[2] = source[2]; + dest[3] = source[3]; + source += 4 * sizeof(UINT8); + dest += stride * sizeof(UINT8); + } + } + + while(--count >= 0) + { + dest[0] = source[0]; + dest[1] = source[1]; + dest[2] = source[2]; + dest[3] = source[3]; + source += 4 * sizeof(UINT8); + dest += stride * sizeof(UINT8); + } +} + +static void R_FlushWholeTrans(void) +{ + UINT8 *source; + UINT8 *dest; + INT32 count, yl; + const restrict INT32 stride = vid.width; + + while (--temp_x >= 0) + { + yl = tempyl[temp_x]; + source = &tempbuf[temp_x + (yl << 2)]; + dest = R_Address(startx + temp_x, yl); + count = tempyh[temp_x] - yl + 1; + + while (--count >= 0) + { + *dest = temptranmap[(*dest << 8) + *source]; + source += 4; + dest += stride; + } + } +} + +static void R_FlushHTTrans(void) +{ + UINT8 *source; + UINT8 *dest; + INT32 count; + INT32 colnum = 0, yl, yh; + const restrict INT32 stride = vid.width; + + while (colnum < 4) + { + yl = tempyl[colnum]; + yh = tempyh[colnum]; + + // flush column head + if (yl < commontop) + { + source = &tempbuf[colnum + (yl << 2)]; + dest = R_Address(startx + colnum, yl); + count = commontop - yl; + + while (--count >= 0) + { + *dest = temptranmap[(*dest << 8) + *source]; + source += 4; + dest += stride; + } + } + + // flush column tail + if (yh > commonbot) + { + source = &tempbuf[colnum + ((commonbot + 1) << 2)]; + dest = R_Address(startx + colnum, commonbot + 1); + count = yh - commonbot; + + while (--count >= 0) + { + *dest = temptranmap[(*dest << 8) + *source]; + source += 4; + dest += stride; + } + } + + ++colnum; + } +} + +static void R_FlushQuadTrans(void) +{ + UINT8 *source = &tempbuf[commontop << 2]; + UINT8 *dest = R_Address(startx, commontop); + INT32 count; + const restrict INT32 stride = vid.width; + + count = commonbot - commontop + 1; + + while (--count >= 0) + { + dest[0] = temptranmap[(dest[0] << 8) + source[0]]; + dest[1] = temptranmap[(dest[1] << 8) + source[1]]; + dest[2] = temptranmap[(dest[2] << 8) + source[2]]; + dest[3] = temptranmap[(dest[3] << 8) + source[3]]; + source += 4; + dest += stride; + } +} + +static void R_FlushWholeColormap(void) +{ + UINT8 *source; + UINT8 *dest; + INT32 count, yl; + const restrict INT32 stride = vid.width; + + while (--temp_x >= 0) + { + yl = tempyl[temp_x]; + source = &tempbuf[temp_x + (yl << 2)]; + dest = R_Address(startx + temp_x, yl); + count = tempyh[temp_x] - yl + 1; + + while (--count >= 0) + { + *dest = temptranslation[*source]; + source += 4; + dest += stride; + } + } +} + +static void R_FlushHTColormap(void) +{ + UINT8 *source; + UINT8 *dest; + INT32 count; + INT32 colnum = 0, yl, yh; + const restrict INT32 stride = vid.width; + + while (colnum < 4) + { + yl = tempyl[colnum]; + yh = tempyh[colnum]; + + // flush column head + if (yl < commontop) + { + source = &tempbuf[colnum + (yl << 2)]; + dest = R_Address(startx + colnum, yl); + count = commontop - yl; + + while (--count >= 0) + { + *dest = temptranslation[*source]; + source += 4; + dest += stride; + } + } + + // flush column tail + if (yh > commonbot) + { + source = &tempbuf[colnum + ((commonbot + 1) << 2)]; + dest = R_Address(startx + colnum, commonbot + 1); + count = yh - commonbot; + + while (--count >= 0) + { + *dest = temptranslation[*source]; + source += 4; + dest += stride; + } + } + + ++colnum; + } +} + +static void R_FlushQuadColormap(void) +{ + UINT8 *source = &tempbuf[commontop << 2]; + UINT8 *dest = R_Address(startx, commontop); + INT32 count; + const restrict INT32 stride = vid.width; + + count = commonbot - commontop + 1; + + while (--count >= 0) + { + dest[0] = temptranslation[source[0]]; + dest[1] = temptranslation[source[1]]; + dest[2] = temptranslation[source[2]]; + dest[3] = temptranslation[source[3]]; + source += 4; + dest += stride; + } +} + +static void R_FlushWholeColormapTrans(void) +{ + UINT8 *source; + UINT8 *dest; + INT32 count, yl; + const restrict INT32 stride = vid.width; + + while (--temp_x >= 0) + { + yl = tempyl[temp_x]; + source = &tempbuf[temp_x + (yl << 2)]; + dest = R_Address(startx + temp_x, yl); + count = tempyh[temp_x] - yl + 1; + + while (--count >= 0) + { + *dest = temptranmap[(*dest << 8) + temptranslation[*source]]; + source += 4; + dest += stride; + } + } +} + +static void R_FlushHTColormapTrans(void) +{ + UINT8 *source; + UINT8 *dest; + INT32 count; + INT32 colnum = 0, yl, yh; + const restrict INT32 stride = vid.width; + + while (colnum < 4) + { + yl = tempyl[colnum]; + yh = tempyh[colnum]; + + // flush column head + if (yl < commontop) + { + source = &tempbuf[colnum + (yl << 2)]; + dest = R_Address(startx + colnum, yl); + count = commontop - yl; + + while (--count >= 0) + { + *dest = temptranmap[(*dest << 8) + temptranslation[*source]]; + source += 4; + dest += stride; + } + } + + // flush column tail + if (yh > commonbot) + { + source = &tempbuf[colnum + ((commonbot + 1) << 2)]; + dest = R_Address(startx + colnum, commonbot + 1); + count = yh - commonbot; + + while (--count >= 0) + { + *dest = temptranmap[(*dest << 8) + temptranslation[*source]]; + source += 4; + dest += stride; + } + } + + ++colnum; + } +} + +static void R_FlushQuadColormapTrans(void) +{ + UINT8 *source = &tempbuf[commontop << 2]; + UINT8 *dest = R_Address(startx, commontop); + INT32 count; + const restrict INT32 stride = vid.width; + + count = commonbot - commontop + 1; + + while (--count >= 0) + { + dest[0] = temptranmap[(dest[0] << 8) + temptranslation[source[0]]]; + dest[1] = temptranmap[(dest[1] << 8) + temptranslation[source[1]]]; + dest[2] = temptranmap[(dest[2] << 8) + temptranslation[source[2]]]; + dest[3] = temptranmap[(dest[3] << 8) + temptranslation[source[3]]]; + source += 4; + dest += stride; + } +} + +static void (*R_FlushWholeColumns)(void) = R_FlushWholeError; +static void (*R_FlushHTColumns)(void) = R_FlushHTError; +static void (*R_FlushQuadColumn)(void) = R_QuadFlushError; + +static void R_FlushColumns(void) +{ + if (temp_x != 4 || commontop >= commonbot) + R_FlushWholeColumns(); + else + { + R_FlushHTColumns(); + R_FlushQuadColumn(); + } + + temp_x = 0; +} + +// +// R_ResetColumnBuffer +// +void R_ResetColumnBuffer(void) +{ + if (temp_x) + R_FlushColumns(); + + temptype = FLUSH_NONE; + R_FlushWholeColumns = R_FlushWholeError; + R_FlushHTColumns = R_FlushHTError; + R_FlushQuadColumn = R_QuadFlushError; +} + +static UINT8 *R_GetBufferOpaque(drawcolumndata_t *dc) +{ + if (temp_x == 4 || + (temp_x && (temptype != FLUSH_OPAQUE || temp_x + startx != dc->x))) + R_FlushColumns(); + + if (!temp_x) + { + startx = dc->x; + tempyl[0] = commontop = dc->yl; + tempyh[0] = commonbot = dc->yh; + temptype = FLUSH_OPAQUE; + R_FlushWholeColumns = R_FlushWholeOpaque; + R_FlushHTColumns = R_FlushHTOpaque; + R_FlushQuadColumn = R_FlushQuadOpaque; + temp_x += 1; + return &tempbuf[dc->yl << 2]; + } + + tempyl[temp_x] = dc->yl; + tempyh[temp_x] = dc->yh; + + if (dc->yl > commontop) + commontop = dc->yl; + if (dc->yh < commonbot) + commonbot = dc->yh; + + return &tempbuf[(dc->yl << 2) + temp_x++]; +} + +static UINT8 *R_GetBufferTrans(drawcolumndata_t *dc) +{ + if (temp_x == 4 || dc->transmap != temptranmap || + (temp_x && (temptype != FLUSH_TRANS || temp_x + startx != dc->x))) + R_FlushColumns(); + + if (!temp_x) + { + startx = dc->x; + tempyl[0] = commontop = dc->yl; + tempyh[0] = commonbot = dc->yh; + temptype = FLUSH_TRANS; + temptranmap = dc->transmap; + R_FlushWholeColumns = R_FlushWholeTrans; + R_FlushHTColumns = R_FlushHTTrans; + R_FlushQuadColumn = R_FlushQuadTrans; + temp_x += 1; + return &tempbuf[dc->yl << 2]; + } + + tempyl[temp_x] = dc->yl; + tempyh[temp_x] = dc->yh; + + if (dc->yl > commontop) + commontop = dc->yl; + if (dc->yh < commonbot) + commonbot = dc->yh; + + return &tempbuf[(dc->yl << 2) + temp_x++]; +} + +static UINT8 *R_GetBufferColormap(drawcolumndata_t *dc) +{ + if (temp_x == 4 || dc->translation != temptranslation || + (temp_x && (temptype != FLUSH_COLORMAP || temp_x + startx != dc->x))) + R_FlushColumns(); + + if (!temp_x) + { + startx = dc->x; + tempyl[0] = commontop = dc->yl; + tempyh[0] = commonbot = dc->yh; + temptype = FLUSH_COLORMAP; + temptranslation = dc->translation; + R_FlushWholeColumns = R_FlushWholeColormap; + R_FlushHTColumns = R_FlushHTColormap; + R_FlushQuadColumn = R_FlushQuadColormap; + temp_x += 1; + return &tempbuf[dc->yl << 2]; + } + + tempyl[temp_x] = dc->yl; + tempyh[temp_x] = dc->yh; + + if (dc->yl > commontop) + commontop = dc->yl; + if (dc->yh < commonbot) + commonbot = dc->yh; + + return &tempbuf[(dc->yl << 2) + temp_x++]; +} + +static UINT8 *R_GetBufferColormapTrans(drawcolumndata_t *dc) +{ + if (temp_x == 4 || dc->translation != temptranslation || dc->transmap != temptranmap || + (temp_x && (temptype != FLUSH_COLORMAP_TRANS || temp_x + startx != dc->x))) + R_FlushColumns(); + + if (!temp_x) + { + startx = dc->x; + tempyl[0] = commontop = dc->yl; + tempyh[0] = commonbot = dc->yh; + temptype = FLUSH_COLORMAP_TRANS; + temptranslation = dc->translation; + temptranmap = dc->transmap; + R_FlushWholeColumns = R_FlushWholeColormapTrans; + R_FlushHTColumns = R_FlushHTColormapTrans; + R_FlushQuadColumn = R_FlushQuadColormapTrans; + temp_x += 1; + return &tempbuf[dc->yl << 2]; + } + + tempyl[temp_x] = dc->yl; + tempyh[temp_x] = dc->yh; + + if (dc->yl > commontop) + commontop = dc->yl; + if (dc->yh < commonbot) + commonbot = dc->yh; + + return &tempbuf[(dc->yl << 2) + temp_x++]; +} diff --git a/src/r_main.cpp b/src/r_main.cpp index 08f1e68a1..132349a82 100644 --- a/src/r_main.cpp +++ b/src/r_main.cpp @@ -1409,7 +1409,9 @@ void R_RenderPlayerView(player_t *player) R_ClipSprites(drawsegs, NULL); R_DrawSkyPlanes(); // draw the fucker again to prevent some artifacts R_DrawPlanes(); + //R_ResetColumnBuffer(); R_DrawMasked(masks, nummasks); + //R_ResetColumnBuffer(); } PS_STOP_TIMING(ps_skyboxtime); @@ -1493,6 +1495,7 @@ void R_RenderPlayerView(player_t *player) PS_START_TIMING(ps_sw_planetime); if (!skybox) R_DrawSkyPlanes(); + R_ResetColumnBuffer(); R_DrawPlanes(); PS_STOP_TIMING(ps_sw_planetime); // draw mid texture and sprite @@ -1500,6 +1503,7 @@ void R_RenderPlayerView(player_t *player) PS_START_TIMING(ps_sw_maskedtime); R_DrawMasked(masks, nummasks); PS_STOP_TIMING(ps_sw_maskedtime); + R_ResetColumnBuffer(); free(masks); diff --git a/src/r_plane.cpp b/src/r_plane.cpp index 475e8a44d..16e344bdf 100644 --- a/src/r_plane.cpp +++ b/src/r_plane.cpp @@ -716,13 +716,10 @@ void R_DrawPlanes(void) visplane_t *pl; INT32 i; drawspandata_t ds = {}; -#ifdef HAVE_THREADS - srb2::ThreadPool::Sema tp_sema; -#endif - R_UpdatePlaneRipple(&ds); #ifdef HAVE_THREADS + srb2::ThreadPool::Sema tp_sema; srb2::g_main_threadpool->begin_sema(); #endif for (i = 0; i < MAXVISPLANES; i++, pl++) @@ -837,7 +834,8 @@ static void R_DrawSkyPlane(visplane_t *pl, void(*colfunc2)(drawcolumndata_t*), b dc.x = x + i; dc.source = R_GetColumn(texture, -angle); // get negative of angle for each column to display sky correct way round! --Monster Iestyn 27/01/18 - colfunc2(&dc); + //colfunc2(&dc); + R_DrawSkyColumn(&dc); } }; @@ -874,7 +872,8 @@ static void R_DrawSkyPlane(visplane_t *pl, void(*colfunc2)(drawcolumndata_t*), b R_GetColumn(texturetranslation[skytexture], -angle); // get negative of angle for each column to display sky correct way round! --Monster Iestyn 27/01/18 - colfunc2(&dc); + //colfunc2(&dc); + R_DrawSkyColumn(&dc); } #endif } From e852c23441c74e35ab65152e6228689f1c1d6f51 Mon Sep 17 00:00:00 2001 From: Alug Date: Mon, 6 Oct 2025 18:34:03 +0200 Subject: [PATCH 02/27] move the temp columndata into a struct TODO:dynamic allocate our temporary screen buffer --- src/r_draw_flush.cpp | 356 ++++++++++++++++++++++--------------------- 1 file changed, 183 insertions(+), 173 deletions(-) diff --git a/src/r_draw_flush.cpp b/src/r_draw_flush.cpp index 657e185b5..8eb1d6266 100644 --- a/src/r_draw_flush.cpp +++ b/src/r_draw_flush.cpp @@ -22,14 +22,24 @@ enum ColumnFlushType FLUSH_COLORMAP_TRANS }; -static int temp_x = 0; -static int tempyl[4], tempyh[4]; -static UINT8 tempbuf[MAXVIDWIDTH * 4]; -static int startx = 0; -static int commontop, commonbot; -static ColumnFlushType temptype = FLUSH_NONE; -static const UINT8 *temptranmap = NULL; -static const UINT8 *temptranslation = NULL; +typedef struct drawcolumndata_temp_s +{ + intptr_t x; + intptr_t yl[4], yh[4]; + + // e6y: resolution limitation is removed + // not for now kek + UINT8 buf[MAXVIDWIDTH * 4]; + + intptr_t startx; + ColumnFlushType type; + intptr_t commontop, commonbot; + const UINT8 *tranmap; + // SoM 7-28-04: Fix the fuzz problem. + const UINT8 *translation; +} drawcolumndata_temp_t; + +drawcolumndata_temp_t temp_dc = {}; static void R_FlushColumns(void); @@ -62,12 +72,12 @@ static void R_FlushWholeOpaque(void) INT32 count, yl; const restrict INT32 stride = vid.width; - while (--temp_x >= 0) + while (--temp_dc.x >= 0) { - yl = tempyl[temp_x]; - source = &tempbuf[temp_x + (yl << 2)]; - dest = R_Address(startx + temp_x, yl); - count = tempyh[temp_x] - yl + 1; + yl = temp_dc.yl[temp_dc.x]; + source = &temp_dc.buf[temp_dc.x + (yl << 2)]; + dest = R_Address(temp_dc.startx + temp_dc.x, yl); + count = temp_dc.yh[temp_dc.x] - yl + 1; while (--count >= 0) { @@ -95,15 +105,15 @@ static void R_FlushHTOpaque(void) while (colnum < 4) { - yl = tempyl[colnum]; - yh = tempyh[colnum]; + yl = temp_dc.yl[colnum]; + yh = temp_dc.yh[colnum]; // flush column head - if (yl < commontop) + if (yl < temp_dc.commontop) { - source = &tempbuf[colnum + (yl << 2)]; - dest = R_Address(startx + colnum, yl); - count = commontop - yl; + source = &temp_dc.buf[colnum + (yl << 2)]; + dest = R_Address(temp_dc.startx + colnum, yl); + count = temp_dc.commontop - yl; while (--count >= 0) { @@ -114,11 +124,11 @@ static void R_FlushHTOpaque(void) } // flush column tail - if (yh > commonbot) + if (yh > temp_dc.commonbot) { - source = &tempbuf[colnum + ((commonbot + 1) << 2)]; - dest = R_Address(startx + colnum, commonbot + 1); - count = yh - commonbot; + source = &temp_dc.buf[colnum + ((temp_dc.commonbot + 1) << 2)]; + dest = R_Address(temp_dc.startx + colnum, temp_dc.commonbot + 1); + count = yh - temp_dc.commonbot; while (--count >= 0) { @@ -133,12 +143,12 @@ static void R_FlushHTOpaque(void) static void R_FlushQuadOpaque(void) { - UINT8 *source = &tempbuf[commontop << 2]; - UINT8 *dest = R_Address(startx, commontop); + UINT8 *source = &temp_dc.buf[temp_dc.commontop << 2]; + UINT8 *dest = R_Address(temp_dc.startx, temp_dc.commontop); INT32 count; const restrict INT32 stride = vid.width; - count = commonbot - commontop + 1; + count = temp_dc.commonbot - temp_dc.commontop + 1; if ((sizeof(int) == 4) && (((intptr_t)source % 4) == 0) && (((intptr_t)dest % 4) == 0)) { @@ -180,16 +190,16 @@ static void R_FlushWholeTrans(void) INT32 count, yl; const restrict INT32 stride = vid.width; - while (--temp_x >= 0) + while (--temp_dc.x >= 0) { - yl = tempyl[temp_x]; - source = &tempbuf[temp_x + (yl << 2)]; - dest = R_Address(startx + temp_x, yl); - count = tempyh[temp_x] - yl + 1; + yl = temp_dc.yl[temp_dc.x]; + source = &temp_dc.buf[temp_dc.x + (yl << 2)]; + dest = R_Address(temp_dc.startx + temp_dc.x, yl); + count = temp_dc.yh[temp_dc.x] - yl + 1; while (--count >= 0) { - *dest = temptranmap[(*dest << 8) + *source]; + *dest = temp_dc.tranmap[(*dest << 8) + *source]; source += 4; dest += stride; } @@ -206,34 +216,34 @@ static void R_FlushHTTrans(void) while (colnum < 4) { - yl = tempyl[colnum]; - yh = tempyh[colnum]; + yl = temp_dc.yl[colnum]; + yh = temp_dc.yh[colnum]; // flush column head - if (yl < commontop) + if (yl < temp_dc.commontop) { - source = &tempbuf[colnum + (yl << 2)]; - dest = R_Address(startx + colnum, yl); - count = commontop - yl; + source = &temp_dc.buf[colnum + (yl << 2)]; + dest = R_Address(temp_dc.startx + colnum, yl); + count = temp_dc.commontop - yl; while (--count >= 0) { - *dest = temptranmap[(*dest << 8) + *source]; + *dest = temp_dc.tranmap[(*dest << 8) + *source]; source += 4; dest += stride; } } // flush column tail - if (yh > commonbot) + if (yh > temp_dc.commonbot) { - source = &tempbuf[colnum + ((commonbot + 1) << 2)]; - dest = R_Address(startx + colnum, commonbot + 1); - count = yh - commonbot; + source = &temp_dc.buf[colnum + ((temp_dc.commonbot + 1) << 2)]; + dest = R_Address(temp_dc.startx + colnum, temp_dc.commonbot + 1); + count = yh - temp_dc.commonbot; while (--count >= 0) { - *dest = temptranmap[(*dest << 8) + *source]; + *dest = temp_dc.tranmap[(*dest << 8) + *source]; source += 4; dest += stride; } @@ -245,19 +255,19 @@ static void R_FlushHTTrans(void) static void R_FlushQuadTrans(void) { - UINT8 *source = &tempbuf[commontop << 2]; - UINT8 *dest = R_Address(startx, commontop); + UINT8 *source = &temp_dc.buf[temp_dc.commontop << 2]; + UINT8 *dest = R_Address(temp_dc.startx, temp_dc.commontop); INT32 count; const restrict INT32 stride = vid.width; - count = commonbot - commontop + 1; + count = temp_dc.commonbot - temp_dc.commontop + 1; while (--count >= 0) { - dest[0] = temptranmap[(dest[0] << 8) + source[0]]; - dest[1] = temptranmap[(dest[1] << 8) + source[1]]; - dest[2] = temptranmap[(dest[2] << 8) + source[2]]; - dest[3] = temptranmap[(dest[3] << 8) + source[3]]; + dest[0] = temp_dc.tranmap[(dest[0] << 8) + source[0]]; + dest[1] = temp_dc.tranmap[(dest[1] << 8) + source[1]]; + dest[2] = temp_dc.tranmap[(dest[2] << 8) + source[2]]; + dest[3] = temp_dc.tranmap[(dest[3] << 8) + source[3]]; source += 4; dest += stride; } @@ -270,16 +280,16 @@ static void R_FlushWholeColormap(void) INT32 count, yl; const restrict INT32 stride = vid.width; - while (--temp_x >= 0) + while (--temp_dc.x >= 0) { - yl = tempyl[temp_x]; - source = &tempbuf[temp_x + (yl << 2)]; - dest = R_Address(startx + temp_x, yl); - count = tempyh[temp_x] - yl + 1; + yl = temp_dc.yl[temp_dc.x]; + source = &temp_dc.buf[temp_dc.x + (yl << 2)]; + dest = R_Address(temp_dc.startx + temp_dc.x, yl); + count = temp_dc.yh[temp_dc.x] - yl + 1; while (--count >= 0) { - *dest = temptranslation[*source]; + *dest = temp_dc.translation[*source]; source += 4; dest += stride; } @@ -296,34 +306,34 @@ static void R_FlushHTColormap(void) while (colnum < 4) { - yl = tempyl[colnum]; - yh = tempyh[colnum]; + yl = temp_dc.yl[colnum]; + yh = temp_dc.yh[colnum]; // flush column head - if (yl < commontop) + if (yl < temp_dc.commontop) { - source = &tempbuf[colnum + (yl << 2)]; - dest = R_Address(startx + colnum, yl); - count = commontop - yl; + source = &temp_dc.buf[colnum + (yl << 2)]; + dest = R_Address(temp_dc.startx + colnum, yl); + count = temp_dc.commontop - yl; while (--count >= 0) { - *dest = temptranslation[*source]; + *dest = temp_dc.translation[*source]; source += 4; dest += stride; } } // flush column tail - if (yh > commonbot) + if (yh > temp_dc.commonbot) { - source = &tempbuf[colnum + ((commonbot + 1) << 2)]; - dest = R_Address(startx + colnum, commonbot + 1); - count = yh - commonbot; + source = &temp_dc.buf[colnum + ((temp_dc.commonbot + 1) << 2)]; + dest = R_Address(temp_dc.startx + colnum, temp_dc.commonbot + 1); + count = yh - temp_dc.commonbot; while (--count >= 0) { - *dest = temptranslation[*source]; + *dest = temp_dc.translation[*source]; source += 4; dest += stride; } @@ -335,19 +345,19 @@ static void R_FlushHTColormap(void) static void R_FlushQuadColormap(void) { - UINT8 *source = &tempbuf[commontop << 2]; - UINT8 *dest = R_Address(startx, commontop); + UINT8 *source = &temp_dc.buf[temp_dc.commontop << 2]; + UINT8 *dest = R_Address(temp_dc.startx, temp_dc.commontop); INT32 count; const restrict INT32 stride = vid.width; - count = commonbot - commontop + 1; + count = temp_dc.commonbot - temp_dc.commontop + 1; while (--count >= 0) { - dest[0] = temptranslation[source[0]]; - dest[1] = temptranslation[source[1]]; - dest[2] = temptranslation[source[2]]; - dest[3] = temptranslation[source[3]]; + dest[0] = temp_dc.translation[source[0]]; + dest[1] = temp_dc.translation[source[1]]; + dest[2] = temp_dc.translation[source[2]]; + dest[3] = temp_dc.translation[source[3]]; source += 4; dest += stride; } @@ -360,16 +370,16 @@ static void R_FlushWholeColormapTrans(void) INT32 count, yl; const restrict INT32 stride = vid.width; - while (--temp_x >= 0) + while (--temp_dc.x >= 0) { - yl = tempyl[temp_x]; - source = &tempbuf[temp_x + (yl << 2)]; - dest = R_Address(startx + temp_x, yl); - count = tempyh[temp_x] - yl + 1; + yl = temp_dc.yl[temp_dc.x]; + source = &temp_dc.buf[temp_dc.x + (yl << 2)]; + dest = R_Address(temp_dc.startx + temp_dc.x, yl); + count = temp_dc.yh[temp_dc.x] - yl + 1; while (--count >= 0) { - *dest = temptranmap[(*dest << 8) + temptranslation[*source]]; + *dest = temp_dc.tranmap[(*dest << 8) + temp_dc.translation[*source]]; source += 4; dest += stride; } @@ -386,34 +396,34 @@ static void R_FlushHTColormapTrans(void) while (colnum < 4) { - yl = tempyl[colnum]; - yh = tempyh[colnum]; + yl = temp_dc.yl[colnum]; + yh = temp_dc.yh[colnum]; // flush column head - if (yl < commontop) + if (yl < temp_dc.commontop) { - source = &tempbuf[colnum + (yl << 2)]; - dest = R_Address(startx + colnum, yl); - count = commontop - yl; + source = &temp_dc.buf[colnum + (yl << 2)]; + dest = R_Address(temp_dc.startx + colnum, yl); + count = temp_dc.commontop - yl; while (--count >= 0) { - *dest = temptranmap[(*dest << 8) + temptranslation[*source]]; + *dest = temp_dc.tranmap[(*dest << 8) + temp_dc.translation[*source]]; source += 4; dest += stride; } } // flush column tail - if (yh > commonbot) + if (yh > temp_dc.commonbot) { - source = &tempbuf[colnum + ((commonbot + 1) << 2)]; - dest = R_Address(startx + colnum, commonbot + 1); - count = yh - commonbot; + source = &temp_dc.buf[colnum + ((temp_dc.commonbot + 1) << 2)]; + dest = R_Address(temp_dc.startx + colnum, temp_dc.commonbot + 1); + count = yh - temp_dc.commonbot; while (--count >= 0) { - *dest = temptranmap[(*dest << 8) + temptranslation[*source]]; + *dest = temp_dc.tranmap[(*dest << 8) + temp_dc.translation[*source]]; source += 4; dest += stride; } @@ -425,19 +435,19 @@ static void R_FlushHTColormapTrans(void) static void R_FlushQuadColormapTrans(void) { - UINT8 *source = &tempbuf[commontop << 2]; - UINT8 *dest = R_Address(startx, commontop); + UINT8 *source = &temp_dc.buf[temp_dc.commontop << 2]; + UINT8 *dest = R_Address(temp_dc.startx, temp_dc.commontop); INT32 count; const restrict INT32 stride = vid.width; - count = commonbot - commontop + 1; + count = temp_dc.commonbot - temp_dc.commontop + 1; while (--count >= 0) { - dest[0] = temptranmap[(dest[0] << 8) + temptranslation[source[0]]]; - dest[1] = temptranmap[(dest[1] << 8) + temptranslation[source[1]]]; - dest[2] = temptranmap[(dest[2] << 8) + temptranslation[source[2]]]; - dest[3] = temptranmap[(dest[3] << 8) + temptranslation[source[3]]]; + dest[0] = temp_dc.tranmap[(dest[0] << 8) + temp_dc.translation[source[0]]]; + dest[1] = temp_dc.tranmap[(dest[1] << 8) + temp_dc.translation[source[1]]]; + dest[2] = temp_dc.tranmap[(dest[2] << 8) + temp_dc.translation[source[2]]]; + dest[3] = temp_dc.tranmap[(dest[3] << 8) + temp_dc.translation[source[3]]]; source += 4; dest += stride; } @@ -449,7 +459,7 @@ static void (*R_FlushQuadColumn)(void) = R_QuadFlushError; static void R_FlushColumns(void) { - if (temp_x != 4 || commontop >= commonbot) + if (temp_dc.x != 4 || temp_dc.commontop >= temp_dc.commonbot) R_FlushWholeColumns(); else { @@ -457,7 +467,7 @@ static void R_FlushColumns(void) R_FlushQuadColumn(); } - temp_x = 0; + temp_dc.x = 0; } // @@ -465,10 +475,10 @@ static void R_FlushColumns(void) // void R_ResetColumnBuffer(void) { - if (temp_x) + if (temp_dc.x) R_FlushColumns(); - temptype = FLUSH_NONE; + temp_dc.type = FLUSH_NONE; R_FlushWholeColumns = R_FlushWholeError; R_FlushHTColumns = R_FlushHTError; R_FlushQuadColumn = R_QuadFlushError; @@ -476,124 +486,124 @@ void R_ResetColumnBuffer(void) static UINT8 *R_GetBufferOpaque(drawcolumndata_t *dc) { - if (temp_x == 4 || - (temp_x && (temptype != FLUSH_OPAQUE || temp_x + startx != dc->x))) + if (temp_dc.x == 4 || + (temp_dc.x && (temp_dc.type != FLUSH_OPAQUE || temp_dc.x + temp_dc.startx != dc->x))) R_FlushColumns(); - if (!temp_x) + if (!temp_dc.x) { - startx = dc->x; - tempyl[0] = commontop = dc->yl; - tempyh[0] = commonbot = dc->yh; - temptype = FLUSH_OPAQUE; + temp_dc.startx = dc->x; + temp_dc.yl[0] = temp_dc.commontop = dc->yl; + temp_dc.yh[0] = temp_dc.commonbot = dc->yh; + temp_dc.type = FLUSH_OPAQUE; R_FlushWholeColumns = R_FlushWholeOpaque; R_FlushHTColumns = R_FlushHTOpaque; R_FlushQuadColumn = R_FlushQuadOpaque; - temp_x += 1; - return &tempbuf[dc->yl << 2]; + temp_dc.x += 1; + return &temp_dc.buf[dc->yl << 2]; } - tempyl[temp_x] = dc->yl; - tempyh[temp_x] = dc->yh; + temp_dc.yl[temp_dc.x] = dc->yl; + temp_dc.yh[temp_dc.x] = dc->yh; - if (dc->yl > commontop) - commontop = dc->yl; - if (dc->yh < commonbot) - commonbot = dc->yh; + if (dc->yl > temp_dc.commontop) + temp_dc.commontop = dc->yl; + if (dc->yh < temp_dc.commonbot) + temp_dc.commonbot = dc->yh; - return &tempbuf[(dc->yl << 2) + temp_x++]; + return &temp_dc.buf[(dc->yl << 2) + temp_dc.x++]; } static UINT8 *R_GetBufferTrans(drawcolumndata_t *dc) { - if (temp_x == 4 || dc->transmap != temptranmap || - (temp_x && (temptype != FLUSH_TRANS || temp_x + startx != dc->x))) + if (temp_dc.x == 4 || dc->transmap != temp_dc.tranmap || + (temp_dc.x && (temp_dc.type != FLUSH_TRANS || temp_dc.x + temp_dc.startx != dc->x))) R_FlushColumns(); - if (!temp_x) + if (!temp_dc.x) { - startx = dc->x; - tempyl[0] = commontop = dc->yl; - tempyh[0] = commonbot = dc->yh; - temptype = FLUSH_TRANS; - temptranmap = dc->transmap; + temp_dc.startx = dc->x; + temp_dc.yl[0] = temp_dc.commontop = dc->yl; + temp_dc.yh[0] = temp_dc.commonbot = dc->yh; + temp_dc.type = FLUSH_TRANS; + temp_dc.tranmap = dc->transmap; R_FlushWholeColumns = R_FlushWholeTrans; R_FlushHTColumns = R_FlushHTTrans; R_FlushQuadColumn = R_FlushQuadTrans; - temp_x += 1; - return &tempbuf[dc->yl << 2]; + temp_dc.x += 1; + return &temp_dc.buf[dc->yl << 2]; } - tempyl[temp_x] = dc->yl; - tempyh[temp_x] = dc->yh; + temp_dc.yl[temp_dc.x] = dc->yl; + temp_dc.yh[temp_dc.x] = dc->yh; - if (dc->yl > commontop) - commontop = dc->yl; - if (dc->yh < commonbot) - commonbot = dc->yh; + if (dc->yl > temp_dc.commontop) + temp_dc.commontop = dc->yl; + if (dc->yh < temp_dc.commonbot) + temp_dc.commonbot = dc->yh; - return &tempbuf[(dc->yl << 2) + temp_x++]; + return &temp_dc.buf[(dc->yl << 2) + temp_dc.x++]; } static UINT8 *R_GetBufferColormap(drawcolumndata_t *dc) { - if (temp_x == 4 || dc->translation != temptranslation || - (temp_x && (temptype != FLUSH_COLORMAP || temp_x + startx != dc->x))) + if (temp_dc.x == 4 || dc->translation != temp_dc.translation || + (temp_dc.x && (temp_dc.type != FLUSH_COLORMAP || temp_dc.x + temp_dc.startx != dc->x))) R_FlushColumns(); - if (!temp_x) + if (!temp_dc.x) { - startx = dc->x; - tempyl[0] = commontop = dc->yl; - tempyh[0] = commonbot = dc->yh; - temptype = FLUSH_COLORMAP; - temptranslation = dc->translation; + temp_dc.startx = dc->x; + temp_dc.yl[0] = temp_dc.commontop = dc->yl; + temp_dc.yh[0] = temp_dc.commonbot = dc->yh; + temp_dc.type = FLUSH_COLORMAP; + temp_dc.translation = dc->translation; R_FlushWholeColumns = R_FlushWholeColormap; R_FlushHTColumns = R_FlushHTColormap; R_FlushQuadColumn = R_FlushQuadColormap; - temp_x += 1; - return &tempbuf[dc->yl << 2]; + temp_dc.x += 1; + return &temp_dc.buf[dc->yl << 2]; } - tempyl[temp_x] = dc->yl; - tempyh[temp_x] = dc->yh; + temp_dc.yl[temp_dc.x] = dc->yl; + temp_dc.yh[temp_dc.x] = dc->yh; - if (dc->yl > commontop) - commontop = dc->yl; - if (dc->yh < commonbot) - commonbot = dc->yh; + if (dc->yl > temp_dc.commontop) + temp_dc.commontop = dc->yl; + if (dc->yh < temp_dc.commonbot) + temp_dc.commonbot = dc->yh; - return &tempbuf[(dc->yl << 2) + temp_x++]; + return &temp_dc.buf[(dc->yl << 2) + temp_dc.x++]; } static UINT8 *R_GetBufferColormapTrans(drawcolumndata_t *dc) { - if (temp_x == 4 || dc->translation != temptranslation || dc->transmap != temptranmap || - (temp_x && (temptype != FLUSH_COLORMAP_TRANS || temp_x + startx != dc->x))) + if (temp_dc.x == 4 || dc->translation != temp_dc.translation || dc->transmap != temp_dc.tranmap || + (temp_dc.x && (temp_dc.type != FLUSH_COLORMAP_TRANS || temp_dc.x + temp_dc.startx != dc->x))) R_FlushColumns(); - if (!temp_x) + if (!temp_dc.x) { - startx = dc->x; - tempyl[0] = commontop = dc->yl; - tempyh[0] = commonbot = dc->yh; - temptype = FLUSH_COLORMAP_TRANS; - temptranslation = dc->translation; - temptranmap = dc->transmap; + temp_dc.startx = dc->x; + temp_dc.yl[0] = temp_dc.commontop = dc->yl; + temp_dc.yh[0] = temp_dc.commonbot = dc->yh; + temp_dc.type = FLUSH_COLORMAP_TRANS; + temp_dc.translation = dc->translation; + temp_dc.tranmap = dc->transmap; R_FlushWholeColumns = R_FlushWholeColormapTrans; R_FlushHTColumns = R_FlushHTColormapTrans; R_FlushQuadColumn = R_FlushQuadColormapTrans; - temp_x += 1; - return &tempbuf[dc->yl << 2]; + temp_dc.x += 1; + return &temp_dc.buf[dc->yl << 2]; } - tempyl[temp_x] = dc->yl; - tempyh[temp_x] = dc->yh; + temp_dc.yl[temp_dc.x] = dc->yl; + temp_dc.yh[temp_dc.x] = dc->yh; - if (dc->yl > commontop) - commontop = dc->yl; - if (dc->yh < commonbot) - commonbot = dc->yh; + if (dc->yl > temp_dc.commontop) + temp_dc.commontop = dc->yl; + if (dc->yh < temp_dc.commonbot) + temp_dc.commonbot = dc->yh; - return &tempbuf[(dc->yl << 2) + temp_x++]; + return &temp_dc.buf[(dc->yl << 2) + temp_dc.x++]; } From e68136de3eaa7080a5533af8993468754bf2b2fa Mon Sep 17 00:00:00 2001 From: Alug Date: Mon, 6 Oct 2025 19:12:52 +0200 Subject: [PATCH 03/27] remove tempbuf resolution limit by allocating it dynamically per our actual screen resolution --- src/r_draw.cpp | 81 ++++++++++++++++++++++++++++++++++++++++++++ src/r_draw_flush.cpp | 76 ----------------------------------------- 2 files changed, 81 insertions(+), 76 deletions(-) diff --git a/src/r_draw.cpp b/src/r_draw.cpp index c8a09745a..86b9fa5e1 100644 --- a/src/r_draw.cpp +++ b/src/r_draw.cpp @@ -489,6 +489,81 @@ void R_FlushTranslationColormapCache(void) // in reality, the few routines that can work for either mode, are // put here +enum ColumnFlushType +{ + FLUSH_NONE, + FLUSH_OPAQUE, + FLUSH_TRANS, + FLUSH_COLORMAP, + FLUSH_COLORMAP_TRANS +}; + +typedef struct drawcolumndata_temp_s +{ + intptr_t x; + intptr_t yl[4], yh[4]; + + // e6y: resolution limitation is removed + UINT8 *buf; + + intptr_t startx; + ColumnFlushType type; + intptr_t commontop, commonbot; + const UINT8 *tranmap; + // SoM 7-28-04: Fix the fuzz problem. + const UINT8 *translation; +} drawcolumndata_temp_t; + +drawcolumndata_temp_t temp_dc = {}; + +static void R_FlushColumns(void); + +static void R_FlushWholeError(void) +{ + I_Error("R_FlushWholeColumns called without being initialized.\n"); +} + +static void R_FlushHTError(void) +{ + I_Error("R_FlushHTColumns called without being initialized.\n"); +} + +static void R_QuadFlushError(void) +{ + I_Error("R_FlushQuadColumn called without being initialized.\n"); +} + +static void (*R_FlushWholeColumns)(void) = R_FlushWholeError; +static void (*R_FlushHTColumns)(void) = R_FlushHTError; +static void (*R_FlushQuadColumn)(void) = R_QuadFlushError; + +static void R_FlushColumns(void) +{ + if (temp_dc.x != 4 || temp_dc.commontop >= temp_dc.commonbot) + R_FlushWholeColumns(); + else + { + R_FlushHTColumns(); + R_FlushQuadColumn(); + } + + temp_dc.x = 0; +} + +// +// R_ResetColumnBuffer +// +void R_ResetColumnBuffer(void) +{ + if (temp_dc.x) + R_FlushColumns(); + + temp_dc.type = FLUSH_NONE; + R_FlushWholeColumns = R_FlushWholeError; + R_FlushHTColumns = R_FlushHTError; + R_FlushQuadColumn = R_QuadFlushError; +} + /** \brief The R_InitViewBuffer function Creates lookup tables for getting the framebuffer address @@ -536,6 +611,12 @@ void R_InitViewBuffer(INT32 width, INT32 height) linesize = vid.width; // killough 11/98 renderscreen = vid.screens[0]; // haleyjd 07/02/14 + + if (temp_dc.buf) + Z_Free(temp_dc.buf); + + memset(&temp_dc, 0, sizeof(temp_dc)); + temp_dc.buf = static_cast(Z_Calloc((vid.height * 4) * sizeof(*temp_dc.buf), PU_STATIC, NULL)); } /** \brief viewborder patches lump numbers diff --git a/src/r_draw_flush.cpp b/src/r_draw_flush.cpp index 8eb1d6266..b9b5ef04e 100644 --- a/src/r_draw_flush.cpp +++ b/src/r_draw_flush.cpp @@ -13,51 +13,6 @@ /// \brief column flush functions /// \note no includes because this is included as part of r_draw.cpp -enum ColumnFlushType -{ - FLUSH_NONE, - FLUSH_OPAQUE, - FLUSH_TRANS, - FLUSH_COLORMAP, - FLUSH_COLORMAP_TRANS -}; - -typedef struct drawcolumndata_temp_s -{ - intptr_t x; - intptr_t yl[4], yh[4]; - - // e6y: resolution limitation is removed - // not for now kek - UINT8 buf[MAXVIDWIDTH * 4]; - - intptr_t startx; - ColumnFlushType type; - intptr_t commontop, commonbot; - const UINT8 *tranmap; - // SoM 7-28-04: Fix the fuzz problem. - const UINT8 *translation; -} drawcolumndata_temp_t; - -drawcolumndata_temp_t temp_dc = {}; - -static void R_FlushColumns(void); - -static void R_FlushWholeError(void) -{ - I_Error("R_FlushWholeColumns called without being initialized.\n"); -} - -static void R_FlushHTError(void) -{ - I_Error("R_FlushHTColumns called without being initialized.\n"); -} - -static void R_QuadFlushError(void) -{ - I_Error("R_FlushQuadColumn called without being initialized.\n"); -} - // // R_FlushWholeOpaque // @@ -453,37 +408,6 @@ static void R_FlushQuadColormapTrans(void) } } -static void (*R_FlushWholeColumns)(void) = R_FlushWholeError; -static void (*R_FlushHTColumns)(void) = R_FlushHTError; -static void (*R_FlushQuadColumn)(void) = R_QuadFlushError; - -static void R_FlushColumns(void) -{ - if (temp_dc.x != 4 || temp_dc.commontop >= temp_dc.commonbot) - R_FlushWholeColumns(); - else - { - R_FlushHTColumns(); - R_FlushQuadColumn(); - } - - temp_dc.x = 0; -} - -// -// R_ResetColumnBuffer -// -void R_ResetColumnBuffer(void) -{ - if (temp_dc.x) - R_FlushColumns(); - - temp_dc.type = FLUSH_NONE; - R_FlushWholeColumns = R_FlushWholeError; - R_FlushHTColumns = R_FlushHTError; - R_FlushQuadColumn = R_QuadFlushError; -} - static UINT8 *R_GetBufferOpaque(drawcolumndata_t *dc) { if (temp_dc.x == 4 || From 3c9292c13756f5ebfae337a33f8a6f0ffa702233 Mon Sep 17 00:00:00 2001 From: Alug Date: Mon, 6 Oct 2025 19:22:45 +0200 Subject: [PATCH 04/27] reorder column flush functions also add some comments that used to be in drawcolumn X) --- src/r_draw.cpp | 13 +- src/r_draw_column.cpp | 12 +- src/r_draw_flush.cpp | 308 +++++++++++++++++++++--------------------- 3 files changed, 175 insertions(+), 158 deletions(-) diff --git a/src/r_draw.cpp b/src/r_draw.cpp index 86b9fa5e1..b2cad26e0 100644 --- a/src/r_draw.cpp +++ b/src/r_draw.cpp @@ -516,8 +516,10 @@ typedef struct drawcolumndata_temp_s drawcolumndata_temp_t temp_dc = {}; -static void R_FlushColumns(void); - +// +// Error functions that will abort if R_FlushColumns tries to flush +// columns without a column type. +// static void R_FlushWholeError(void) { I_Error("R_FlushWholeColumns called without being initialized.\n"); @@ -553,10 +555,17 @@ static void R_FlushColumns(void) // // R_ResetColumnBuffer // +// haleyjd 09/13/04: new function to call from main rendering loop +// which gets rid of the unnecessary reset of various variables during +// column drawing. +// void R_ResetColumnBuffer(void) { + // haleyjd 10/06/05: this must not be done if x == 0! if (temp_dc.x) + { R_FlushColumns(); + } temp_dc.type = FLUSH_NONE; R_FlushWholeColumns = R_FlushWholeError; diff --git a/src/r_draw_column.cpp b/src/r_draw_column.cpp index ccb5c5403..cef7f85cd 100644 --- a/src/r_draw_column.cpp +++ b/src/r_draw_column.cpp @@ -84,8 +84,18 @@ static void R_DrawColumnTemplate(drawcolumndata_t *dc) { INT32 count; + // leban 1/17/99: + // removed the + 1 here, adjusted the if test, and added an increment + // later. this helps a compiler pipeline a bit better. the x86 + // assembler also does this. count = dc->yh - dc->yl; + // leban 1/17/99: + // this case isn't executed too often. depending on how many instructions + // there are between here and the second if test below, this case could + // be moved down and might save instructions overall. since there are + // probably different wads that favor one way or the other, i'll leave + // this alone for now. if (count < 0) // Zero length, column does not exceed a pixel. { return; @@ -285,7 +295,7 @@ static void R_DrawColumnTemplate(drawcolumndata_t *dc) { // Re-map color indices from wall texture column // using a lighting/special effects LUT. - // heightmask is the Tutti-Frutti fix + // heightmask is the Tutti-Frutti fix -- killough // -1 is the lower clamp bound because column posts have a "safe" byte before the real data // and a few bytes after as well diff --git a/src/r_draw_flush.cpp b/src/r_draw_flush.cpp index b9b5ef04e..b77ece5d5 100644 --- a/src/r_draw_flush.cpp +++ b/src/r_draw_flush.cpp @@ -14,11 +14,10 @@ /// \note no includes because this is included as part of r_draw.cpp // -// R_FlushWholeOpaque +// R_FlushWhole // // Flushes the entire columns in the buffer, one at a time. // This is used when a quad flush isn't possible. -// Opaque version -- no remapping whatsoever. // static void R_FlushWholeOpaque(void) { @@ -43,12 +42,80 @@ static void R_FlushWholeOpaque(void) } } +static void R_FlushWholeTrans(void) +{ + UINT8 *source; + UINT8 *dest; + INT32 count, yl; + const restrict INT32 stride = vid.width; + + while (--temp_dc.x >= 0) + { + yl = temp_dc.yl[temp_dc.x]; + source = &temp_dc.buf[temp_dc.x + (yl << 2)]; + dest = R_Address(temp_dc.startx + temp_dc.x, yl); + count = temp_dc.yh[temp_dc.x] - yl + 1; + + while (--count >= 0) + { + *dest = temp_dc.tranmap[(*dest << 8) + *source]; + source += 4; + dest += stride; + } + } +} + +static void R_FlushWholeColormap(void) +{ + UINT8 *source; + UINT8 *dest; + INT32 count, yl; + const restrict INT32 stride = vid.width; + + while (--temp_dc.x >= 0) + { + yl = temp_dc.yl[temp_dc.x]; + source = &temp_dc.buf[temp_dc.x + (yl << 2)]; + dest = R_Address(temp_dc.startx + temp_dc.x, yl); + count = temp_dc.yh[temp_dc.x] - yl + 1; + + while (--count >= 0) + { + *dest = temp_dc.translation[*source]; + source += 4; + dest += stride; + } + } +} + +static void R_FlushWholeColormapTrans(void) +{ + UINT8 *source; + UINT8 *dest; + INT32 count, yl; + const restrict INT32 stride = vid.width; + + while (--temp_dc.x >= 0) + { + yl = temp_dc.yl[temp_dc.x]; + source = &temp_dc.buf[temp_dc.x + (yl << 2)]; + dest = R_Address(temp_dc.startx + temp_dc.x, yl); + count = temp_dc.yh[temp_dc.x] - yl + 1; + + while (--count >= 0) + { + *dest = temp_dc.tranmap[(*dest << 8) + temp_dc.translation[*source]]; + source += 4; + dest += stride; + } + } +} + // -// R_FlushHTOpaque +// R_FlushHT // // Flushes the head and tail of columns in the buffer in // preparation for a quad flush. -// Opaque version -- no remapping whatsoever. // static void R_FlushHTOpaque(void) { @@ -96,71 +163,6 @@ static void R_FlushHTOpaque(void) } } -static void R_FlushQuadOpaque(void) -{ - UINT8 *source = &temp_dc.buf[temp_dc.commontop << 2]; - UINT8 *dest = R_Address(temp_dc.startx, temp_dc.commontop); - INT32 count; - const restrict INT32 stride = vid.width; - - count = temp_dc.commonbot - temp_dc.commontop + 1; - - if ((sizeof(int) == 4) && (((intptr_t)source % 4) == 0) && (((intptr_t)dest % 4) == 0)) - { - while(--count >= 0) - { - *(int *)dest = *(int *)source; - source += 4 * sizeof(UINT8); - dest += stride * sizeof(UINT8); - } - } - else - { - while(--count >= 0) - { - dest[0] = source[0]; - dest[1] = source[1]; - dest[2] = source[2]; - dest[3] = source[3]; - source += 4 * sizeof(UINT8); - dest += stride * sizeof(UINT8); - } - } - - while(--count >= 0) - { - dest[0] = source[0]; - dest[1] = source[1]; - dest[2] = source[2]; - dest[3] = source[3]; - source += 4 * sizeof(UINT8); - dest += stride * sizeof(UINT8); - } -} - -static void R_FlushWholeTrans(void) -{ - UINT8 *source; - UINT8 *dest; - INT32 count, yl; - const restrict INT32 stride = vid.width; - - while (--temp_dc.x >= 0) - { - yl = temp_dc.yl[temp_dc.x]; - source = &temp_dc.buf[temp_dc.x + (yl << 2)]; - dest = R_Address(temp_dc.startx + temp_dc.x, yl); - count = temp_dc.yh[temp_dc.x] - yl + 1; - - while (--count >= 0) - { - *dest = temp_dc.tranmap[(*dest << 8) + *source]; - source += 4; - dest += stride; - } - } -} - static void R_FlushHTTrans(void) { UINT8 *source; @@ -208,49 +210,6 @@ static void R_FlushHTTrans(void) } } -static void R_FlushQuadTrans(void) -{ - UINT8 *source = &temp_dc.buf[temp_dc.commontop << 2]; - UINT8 *dest = R_Address(temp_dc.startx, temp_dc.commontop); - INT32 count; - const restrict INT32 stride = vid.width; - - count = temp_dc.commonbot - temp_dc.commontop + 1; - - while (--count >= 0) - { - dest[0] = temp_dc.tranmap[(dest[0] << 8) + source[0]]; - dest[1] = temp_dc.tranmap[(dest[1] << 8) + source[1]]; - dest[2] = temp_dc.tranmap[(dest[2] << 8) + source[2]]; - dest[3] = temp_dc.tranmap[(dest[3] << 8) + source[3]]; - source += 4; - dest += stride; - } -} - -static void R_FlushWholeColormap(void) -{ - UINT8 *source; - UINT8 *dest; - INT32 count, yl; - const restrict INT32 stride = vid.width; - - while (--temp_dc.x >= 0) - { - yl = temp_dc.yl[temp_dc.x]; - source = &temp_dc.buf[temp_dc.x + (yl << 2)]; - dest = R_Address(temp_dc.startx + temp_dc.x, yl); - count = temp_dc.yh[temp_dc.x] - yl + 1; - - while (--count >= 0) - { - *dest = temp_dc.translation[*source]; - source += 4; - dest += stride; - } - } -} - static void R_FlushHTColormap(void) { UINT8 *source; @@ -298,49 +257,6 @@ static void R_FlushHTColormap(void) } } -static void R_FlushQuadColormap(void) -{ - UINT8 *source = &temp_dc.buf[temp_dc.commontop << 2]; - UINT8 *dest = R_Address(temp_dc.startx, temp_dc.commontop); - INT32 count; - const restrict INT32 stride = vid.width; - - count = temp_dc.commonbot - temp_dc.commontop + 1; - - while (--count >= 0) - { - dest[0] = temp_dc.translation[source[0]]; - dest[1] = temp_dc.translation[source[1]]; - dest[2] = temp_dc.translation[source[2]]; - dest[3] = temp_dc.translation[source[3]]; - source += 4; - dest += stride; - } -} - -static void R_FlushWholeColormapTrans(void) -{ - UINT8 *source; - UINT8 *dest; - INT32 count, yl; - const restrict INT32 stride = vid.width; - - while (--temp_dc.x >= 0) - { - yl = temp_dc.yl[temp_dc.x]; - source = &temp_dc.buf[temp_dc.x + (yl << 2)]; - dest = R_Address(temp_dc.startx + temp_dc.x, yl); - count = temp_dc.yh[temp_dc.x] - yl + 1; - - while (--count >= 0) - { - *dest = temp_dc.tranmap[(*dest << 8) + temp_dc.translation[*source]]; - source += 4; - dest += stride; - } - } -} - static void R_FlushHTColormapTrans(void) { UINT8 *source; @@ -388,6 +304,88 @@ static void R_FlushHTColormapTrans(void) } } +static void R_FlushQuadOpaque(void) +{ + UINT8 *source = &temp_dc.buf[temp_dc.commontop << 2]; + UINT8 *dest = R_Address(temp_dc.startx, temp_dc.commontop); + INT32 count; + const restrict INT32 stride = vid.width; + + count = temp_dc.commonbot - temp_dc.commontop + 1; + + if ((sizeof(int) == 4) && (((intptr_t)source % 4) == 0) && (((intptr_t)dest % 4) == 0)) + { + while(--count >= 0) + { + *(int *)dest = *(int *)source; + source += 4 * sizeof(UINT8); + dest += stride * sizeof(UINT8); + } + } + else + { + while(--count >= 0) + { + dest[0] = source[0]; + dest[1] = source[1]; + dest[2] = source[2]; + dest[3] = source[3]; + source += 4 * sizeof(UINT8); + dest += stride * sizeof(UINT8); + } + } + + while(--count >= 0) + { + dest[0] = source[0]; + dest[1] = source[1]; + dest[2] = source[2]; + dest[3] = source[3]; + source += 4 * sizeof(UINT8); + dest += stride * sizeof(UINT8); + } +} + +static void R_FlushQuadTrans(void) +{ + UINT8 *source = &temp_dc.buf[temp_dc.commontop << 2]; + UINT8 *dest = R_Address(temp_dc.startx, temp_dc.commontop); + INT32 count; + const restrict INT32 stride = vid.width; + + count = temp_dc.commonbot - temp_dc.commontop + 1; + + while (--count >= 0) + { + dest[0] = temp_dc.tranmap[(dest[0] << 8) + source[0]]; + dest[1] = temp_dc.tranmap[(dest[1] << 8) + source[1]]; + dest[2] = temp_dc.tranmap[(dest[2] << 8) + source[2]]; + dest[3] = temp_dc.tranmap[(dest[3] << 8) + source[3]]; + source += 4; + dest += stride; + } +} + +static void R_FlushQuadColormap(void) +{ + UINT8 *source = &temp_dc.buf[temp_dc.commontop << 2]; + UINT8 *dest = R_Address(temp_dc.startx, temp_dc.commontop); + INT32 count; + const restrict INT32 stride = vid.width; + + count = temp_dc.commonbot - temp_dc.commontop + 1; + + while (--count >= 0) + { + dest[0] = temp_dc.translation[source[0]]; + dest[1] = temp_dc.translation[source[1]]; + dest[2] = temp_dc.translation[source[2]]; + dest[3] = temp_dc.translation[source[3]]; + source += 4; + dest += stride; + } +} + static void R_FlushQuadColormapTrans(void) { UINT8 *source = &temp_dc.buf[temp_dc.commontop << 2]; From 2753052ee73e459b02c489a797ac49f1e49be5ee Mon Sep 17 00:00:00 2001 From: Alug Date: Mon, 6 Oct 2025 19:45:31 +0200 Subject: [PATCH 05/27] fix FlushColumns being called without being initialized aack --- src/r_draw_flush.cpp | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/src/r_draw_flush.cpp b/src/r_draw_flush.cpp index b77ece5d5..b1bbb464f 100644 --- a/src/r_draw_flush.cpp +++ b/src/r_draw_flush.cpp @@ -438,7 +438,7 @@ static UINT8 *R_GetBufferOpaque(drawcolumndata_t *dc) static UINT8 *R_GetBufferTrans(drawcolumndata_t *dc) { - if (temp_dc.x == 4 || dc->transmap != temp_dc.tranmap || + if (temp_dc.x == 4 || (temp_dc.x && (temp_dc.type != FLUSH_TRANS || temp_dc.x + temp_dc.startx != dc->x))) R_FlushColumns(); @@ -469,7 +469,7 @@ static UINT8 *R_GetBufferTrans(drawcolumndata_t *dc) static UINT8 *R_GetBufferColormap(drawcolumndata_t *dc) { - if (temp_dc.x == 4 || dc->translation != temp_dc.translation || + if (temp_dc.x == 4 || (temp_dc.x && (temp_dc.type != FLUSH_COLORMAP || temp_dc.x + temp_dc.startx != dc->x))) R_FlushColumns(); @@ -500,7 +500,7 @@ static UINT8 *R_GetBufferColormap(drawcolumndata_t *dc) static UINT8 *R_GetBufferColormapTrans(drawcolumndata_t *dc) { - if (temp_dc.x == 4 || dc->translation != temp_dc.translation || dc->transmap != temp_dc.tranmap || + if (temp_dc.x == 4 || (temp_dc.x && (temp_dc.type != FLUSH_COLORMAP_TRANS || temp_dc.x + temp_dc.startx != dc->x))) R_FlushColumns(); From 2b6185d7d6339917e2803bb392bd84f7b18ac47f Mon Sep 17 00:00:00 2001 From: Alug Date: Mon, 6 Oct 2025 20:02:58 +0200 Subject: [PATCH 06/27] reenable colormapped / translucent columns --- src/r_draw_column.cpp | 8 +++----- 1 file changed, 3 insertions(+), 5 deletions(-) diff --git a/src/r_draw_column.cpp b/src/r_draw_column.cpp index cef7f85cd..d7954cf52 100644 --- a/src/r_draw_column.cpp +++ b/src/r_draw_column.cpp @@ -71,9 +71,7 @@ static constexpr UINT8 R_DrawColumnPixel(drawcolumndata_t* dc, UINT8 * restrict } } - //return R_GetColumnTranslucent(dc, dest, col, colormap); - // dont return any other shit for now - return col; + return R_GetColumnTranslucent(dc, dest, col, colormap); } /** \brief The R_DrawColumn function @@ -210,13 +208,13 @@ static void R_DrawColumnTemplate(drawcolumndata_t *dc) // Framebuffer destination address. // SoM: MAGIC - /*if constexpr (Type & (DrawColumnType::DC_COLORMAP | DrawColumnType::DC_TRANSMAP)) + if constexpr (Type & (DrawColumnType::DC_COLORMAP | DrawColumnType::DC_TRANSMAP)) dest = R_GetBufferColormapTrans(dc); else if constexpr (Type & DrawColumnType::DC_TRANSMAP) dest = R_GetBufferTrans(dc); else if constexpr (Type & DrawColumnType::DC_COLORMAP) dest = R_GetBufferColormap(dc); - else*/ + else dest = R_GetBufferOpaque(dc); count++; From e4ac394d293b9769b12a9a83bba074426b698969 Mon Sep 17 00:00:00 2001 From: Indev Date: Mon, 6 Oct 2025 21:17:36 +0300 Subject: [PATCH 07/27] Fix DC_COLORMAP and DC_TRANSMAP column drawers always using DC_COLORMAP|DC_TRANSMAP func --- src/r_draw_column.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/r_draw_column.cpp b/src/r_draw_column.cpp index d7954cf52..a24318a35 100644 --- a/src/r_draw_column.cpp +++ b/src/r_draw_column.cpp @@ -208,7 +208,7 @@ static void R_DrawColumnTemplate(drawcolumndata_t *dc) // Framebuffer destination address. // SoM: MAGIC - if constexpr (Type & (DrawColumnType::DC_COLORMAP | DrawColumnType::DC_TRANSMAP)) + if constexpr ((Type & (DrawColumnType::DC_COLORMAP | DrawColumnType::DC_TRANSMAP)) == (DrawColumnType::DC_COLORMAP | DrawColumnType::DC_TRANSMAP)) dest = R_GetBufferColormapTrans(dc); else if constexpr (Type & DrawColumnType::DC_TRANSMAP) dest = R_GetBufferTrans(dc); From 955812bd8d0a1824dc7abb9cd47cddc0a6195653 Mon Sep 17 00:00:00 2001 From: Alug Date: Mon, 6 Oct 2025 22:09:27 +0200 Subject: [PATCH 08/27] template the flush functions --- src/r_draw_column.cpp | 7 +- src/r_draw_flush.cpp | 574 ++++++++++++++---------------------------- 2 files changed, 188 insertions(+), 393 deletions(-) diff --git a/src/r_draw_column.cpp b/src/r_draw_column.cpp index a24318a35..c2275fbd4 100644 --- a/src/r_draw_column.cpp +++ b/src/r_draw_column.cpp @@ -204,11 +204,12 @@ static void R_DrawColumnTemplate(drawcolumndata_t *dc) const UINT8 * restrict source = dc->source; const lighttable_t * restrict colormap = dc->colormap; - UINT8 * restrict dest; - // Framebuffer destination address. // SoM: MAGIC - if constexpr ((Type & (DrawColumnType::DC_COLORMAP | DrawColumnType::DC_TRANSMAP)) == (DrawColumnType::DC_COLORMAP | DrawColumnType::DC_TRANSMAP)) + UINT8 * restrict dest; + + if constexpr ((Type & (DrawColumnType::DC_COLORMAP | DrawColumnType::DC_TRANSMAP)) + == (DrawColumnType::DC_COLORMAP | DrawColumnType::DC_TRANSMAP)) dest = R_GetBufferColormapTrans(dc); else if constexpr (Type & DrawColumnType::DC_TRANSMAP) dest = R_GetBufferTrans(dc); diff --git a/src/r_draw_flush.cpp b/src/r_draw_flush.cpp index b1bbb464f..23fd4beb3 100644 --- a/src/r_draw_flush.cpp +++ b/src/r_draw_flush.cpp @@ -19,10 +19,11 @@ // Flushes the entire columns in the buffer, one at a time. // This is used when a quad flush isn't possible. // -static void R_FlushWholeOpaque(void) +template +static void R_FlushWhole(void) { - UINT8 *source; - UINT8 *dest; + UINT8 * restrict source; + UINT8 * restrict dest; INT32 count, yl; const restrict INT32 stride = vid.width; @@ -35,81 +36,40 @@ static void R_FlushWholeOpaque(void) while (--count >= 0) { - *dest = *source; + if constexpr (Type & ColumnFlushType::FLUSH_OPAQUE) + { + *dest = *source; + } + else if constexpr (Type & ColumnFlushType::FLUSH_TRANS) + { + *dest = temp_dc.tranmap[(*dest << 8) + *source]; + } + else if constexpr (Type & ColumnFlushType::FLUSH_COLORMAP) + { + *dest = temp_dc.translation[*source]; + } + else if constexpr (Type & ColumnFlushType::FLUSH_COLORMAP_TRANS) + { + *dest = temp_dc.tranmap[(*dest << 8) + temp_dc.translation[*source]]; + } + source += 4; dest += stride; } } } -static void R_FlushWholeTrans(void) -{ - UINT8 *source; - UINT8 *dest; - INT32 count, yl; - const restrict INT32 stride = vid.width; - - while (--temp_dc.x >= 0) - { - yl = temp_dc.yl[temp_dc.x]; - source = &temp_dc.buf[temp_dc.x + (yl << 2)]; - dest = R_Address(temp_dc.startx + temp_dc.x, yl); - count = temp_dc.yh[temp_dc.x] - yl + 1; - - while (--count >= 0) - { - *dest = temp_dc.tranmap[(*dest << 8) + *source]; - source += 4; - dest += stride; - } +#define DEFINE_GETFLUSHWHOLE_FUNC(name, flags) \ + static inline void name(void) \ + { \ + constexpr ColumnFlushType opt = static_cast(flags); \ + R_FlushWhole(); \ } -} -static void R_FlushWholeColormap(void) -{ - UINT8 *source; - UINT8 *dest; - INT32 count, yl; - const restrict INT32 stride = vid.width; - - while (--temp_dc.x >= 0) - { - yl = temp_dc.yl[temp_dc.x]; - source = &temp_dc.buf[temp_dc.x + (yl << 2)]; - dest = R_Address(temp_dc.startx + temp_dc.x, yl); - count = temp_dc.yh[temp_dc.x] - yl + 1; - - while (--count >= 0) - { - *dest = temp_dc.translation[*source]; - source += 4; - dest += stride; - } - } -} - -static void R_FlushWholeColormapTrans(void) -{ - UINT8 *source; - UINT8 *dest; - INT32 count, yl; - const restrict INT32 stride = vid.width; - - while (--temp_dc.x >= 0) - { - yl = temp_dc.yl[temp_dc.x]; - source = &temp_dc.buf[temp_dc.x + (yl << 2)]; - dest = R_Address(temp_dc.startx + temp_dc.x, yl); - count = temp_dc.yh[temp_dc.x] - yl + 1; - - while (--count >= 0) - { - *dest = temp_dc.tranmap[(*dest << 8) + temp_dc.translation[*source]]; - source += 4; - dest += stride; - } - } -} +DEFINE_GETFLUSHWHOLE_FUNC(R_FlushWholeOpague, FLUSH_OPAQUE) +DEFINE_GETFLUSHWHOLE_FUNC(R_FlushWholeTrans, FLUSH_TRANS) +DEFINE_GETFLUSHWHOLE_FUNC(R_FlushWholeColormap, FLUSH_COLORMAP) +DEFINE_GETFLUSHWHOLE_FUNC(R_FlushWholeColormapTrans, FLUSH_COLORMAP_TRANS) // // R_FlushHT @@ -117,56 +77,11 @@ static void R_FlushWholeColormapTrans(void) // Flushes the head and tail of columns in the buffer in // preparation for a quad flush. // -static void R_FlushHTOpaque(void) +template +static void R_FlushHT(void) { - UINT8 *source; - UINT8 *dest; - INT32 count, colnum = 0; - INT32 yl, yh; - const restrict INT32 stride = vid.width; - - while (colnum < 4) - { - yl = temp_dc.yl[colnum]; - yh = temp_dc.yh[colnum]; - - // flush column head - if (yl < temp_dc.commontop) - { - source = &temp_dc.buf[colnum + (yl << 2)]; - dest = R_Address(temp_dc.startx + colnum, yl); - count = temp_dc.commontop - yl; - - while (--count >= 0) - { - *dest = *source; - source += 4; - dest += stride; - } - } - - // flush column tail - if (yh > temp_dc.commonbot) - { - source = &temp_dc.buf[colnum + ((temp_dc.commonbot + 1) << 2)]; - dest = R_Address(temp_dc.startx + colnum, temp_dc.commonbot + 1); - count = yh - temp_dc.commonbot; - - while (--count >= 0) - { - *dest = *source; - source += 4; - dest += stride; - } - } - ++colnum; - } -} - -static void R_FlushHTTrans(void) -{ - UINT8 *source; - UINT8 *dest; + UINT8 * restrict source; + UINT8 * restrict dest; INT32 count; INT32 colnum = 0, yl, yh; const restrict INT32 stride = vid.width; @@ -185,7 +100,23 @@ static void R_FlushHTTrans(void) while (--count >= 0) { - *dest = temp_dc.tranmap[(*dest << 8) + *source]; + if constexpr (Type & ColumnFlushType::FLUSH_OPAQUE) + { + *dest = *source; + } + else if constexpr (Type & ColumnFlushType::FLUSH_TRANS) + { + *dest = temp_dc.tranmap[(*dest << 8) + *source]; + } + else if constexpr (Type & ColumnFlushType::FLUSH_COLORMAP) + { + *dest = temp_dc.translation[*source]; + } + else if constexpr (Type & ColumnFlushType::FLUSH_COLORMAP_TRANS) + { + *dest = temp_dc.tranmap[(*dest << 8) + temp_dc.translation[*source]]; + } + source += 4; dest += stride; } @@ -200,7 +131,23 @@ static void R_FlushHTTrans(void) while (--count >= 0) { - *dest = temp_dc.tranmap[(*dest << 8) + *source]; + if constexpr (Type & ColumnFlushType::FLUSH_OPAQUE) + { + *dest = *source; + } + else if constexpr (Type & ColumnFlushType::FLUSH_TRANS) + { + *dest = temp_dc.tranmap[(*dest << 8) + *source]; + } + else if constexpr (Type & ColumnFlushType::FLUSH_COLORMAP) + { + *dest = temp_dc.translation[*source]; + } + else if constexpr (Type & ColumnFlushType::FLUSH_COLORMAP_TRANS) + { + *dest = temp_dc.tranmap[(*dest << 8) + temp_dc.translation[*source]]; + } + source += 4; dest += stride; } @@ -210,206 +157,107 @@ static void R_FlushHTTrans(void) } } -static void R_FlushHTColormap(void) -{ - UINT8 *source; - UINT8 *dest; - INT32 count; - INT32 colnum = 0, yl, yh; - const restrict INT32 stride = vid.width; - - while (colnum < 4) - { - yl = temp_dc.yl[colnum]; - yh = temp_dc.yh[colnum]; - - // flush column head - if (yl < temp_dc.commontop) - { - source = &temp_dc.buf[colnum + (yl << 2)]; - dest = R_Address(temp_dc.startx + colnum, yl); - count = temp_dc.commontop - yl; - - while (--count >= 0) - { - *dest = temp_dc.translation[*source]; - source += 4; - dest += stride; - } - } - - // flush column tail - if (yh > temp_dc.commonbot) - { - source = &temp_dc.buf[colnum + ((temp_dc.commonbot + 1) << 2)]; - dest = R_Address(temp_dc.startx + colnum, temp_dc.commonbot + 1); - count = yh - temp_dc.commonbot; - - while (--count >= 0) - { - *dest = temp_dc.translation[*source]; - source += 4; - dest += stride; - } - } - - ++colnum; +#define DEFINE_GETFLUSHHT_FUNC(name, flags) \ + static inline void name(void) \ + { \ + constexpr ColumnFlushType opt = static_cast(flags); \ + R_FlushHT(); \ } -} -static void R_FlushHTColormapTrans(void) +DEFINE_GETFLUSHHT_FUNC(R_FlushHTOpague, FLUSH_OPAQUE) +DEFINE_GETFLUSHHT_FUNC(R_FlushHTTrans, FLUSH_TRANS) +DEFINE_GETFLUSHHT_FUNC(R_FlushHTColormap, FLUSH_COLORMAP) +DEFINE_GETFLUSHHT_FUNC(R_FlushHTColormapTrans, FLUSH_COLORMAP_TRANS) + +template +static void R_FlushQuad(void) { - UINT8 *source; - UINT8 *dest; - INT32 count; - INT32 colnum = 0, yl, yh; - const restrict INT32 stride = vid.width; - - while (colnum < 4) - { - yl = temp_dc.yl[colnum]; - yh = temp_dc.yh[colnum]; - - // flush column head - if (yl < temp_dc.commontop) - { - source = &temp_dc.buf[colnum + (yl << 2)]; - dest = R_Address(temp_dc.startx + colnum, yl); - count = temp_dc.commontop - yl; - - while (--count >= 0) - { - *dest = temp_dc.tranmap[(*dest << 8) + temp_dc.translation[*source]]; - source += 4; - dest += stride; - } - } - - // flush column tail - if (yh > temp_dc.commonbot) - { - source = &temp_dc.buf[colnum + ((temp_dc.commonbot + 1) << 2)]; - dest = R_Address(temp_dc.startx + colnum, temp_dc.commonbot + 1); - count = yh - temp_dc.commonbot; - - while (--count >= 0) - { - *dest = temp_dc.tranmap[(*dest << 8) + temp_dc.translation[*source]]; - source += 4; - dest += stride; - } - } - - ++colnum; - } -} - -static void R_FlushQuadOpaque(void) -{ - UINT8 *source = &temp_dc.buf[temp_dc.commontop << 2]; - UINT8 *dest = R_Address(temp_dc.startx, temp_dc.commontop); + UINT8 * restrict source = &temp_dc.buf[temp_dc.commontop << 2]; + UINT8 * restrict dest = R_Address(temp_dc.startx, temp_dc.commontop); INT32 count; const restrict INT32 stride = vid.width; count = temp_dc.commonbot - temp_dc.commontop + 1; - if ((sizeof(int) == 4) && (((intptr_t)source % 4) == 0) && (((intptr_t)dest % 4) == 0)) + if constexpr (Type & ColumnFlushType::FLUSH_OPAQUE) { - while(--count >= 0) + if ((sizeof(int) == 4) && (((intptr_t)source % 4) == 0) && (((intptr_t)dest % 4) == 0)) { - *(int *)dest = *(int *)source; - source += 4 * sizeof(UINT8); - dest += stride * sizeof(UINT8); + while(--count >= 0) + { + *(int *)dest = *(int *)source; + source += 4 * sizeof(UINT8); + dest += stride * sizeof(UINT8); + } + } + else + { + while(--count >= 0) + { + dest[0] = source[0]; + dest[1] = source[1]; + dest[2] = source[2]; + dest[3] = source[3]; + source += 4 * sizeof(UINT8); + dest += stride * sizeof(UINT8); + } } } - else + else if constexpr (Type & ColumnFlushType::FLUSH_TRANS) { - while(--count >= 0) + while (--count >= 0) { - dest[0] = source[0]; - dest[1] = source[1]; - dest[2] = source[2]; - dest[3] = source[3]; - source += 4 * sizeof(UINT8); - dest += stride * sizeof(UINT8); + dest[0] = temp_dc.tranmap[(dest[0] << 8) + source[0]]; + dest[1] = temp_dc.tranmap[(dest[1] << 8) + source[1]]; + dest[2] = temp_dc.tranmap[(dest[2] << 8) + source[2]]; + dest[3] = temp_dc.tranmap[(dest[3] << 8) + source[3]]; + source += 4; + dest += stride; } } - - while(--count >= 0) + else if constexpr (Type & ColumnFlushType::FLUSH_COLORMAP) { - dest[0] = source[0]; - dest[1] = source[1]; - dest[2] = source[2]; - dest[3] = source[3]; - source += 4 * sizeof(UINT8); - dest += stride * sizeof(UINT8); + while (--count >= 0) + { + dest[0] = temp_dc.translation[source[0]]; + dest[1] = temp_dc.translation[source[1]]; + dest[2] = temp_dc.translation[source[2]]; + dest[3] = temp_dc.translation[source[3]]; + source += 4; + dest += stride; + } + } + else if constexpr (Type & ColumnFlushType::FLUSH_COLORMAP_TRANS) + { + while (--count >= 0) + { + dest[0] = temp_dc.tranmap[(dest[0] << 8) + temp_dc.translation[source[0]]]; + dest[1] = temp_dc.tranmap[(dest[1] << 8) + temp_dc.translation[source[1]]]; + dest[2] = temp_dc.tranmap[(dest[2] << 8) + temp_dc.translation[source[2]]]; + dest[3] = temp_dc.tranmap[(dest[3] << 8) + temp_dc.translation[source[3]]]; + source += 4; + dest += stride; + } } } -static void R_FlushQuadTrans(void) -{ - UINT8 *source = &temp_dc.buf[temp_dc.commontop << 2]; - UINT8 *dest = R_Address(temp_dc.startx, temp_dc.commontop); - INT32 count; - const restrict INT32 stride = vid.width; - - count = temp_dc.commonbot - temp_dc.commontop + 1; - - while (--count >= 0) - { - dest[0] = temp_dc.tranmap[(dest[0] << 8) + source[0]]; - dest[1] = temp_dc.tranmap[(dest[1] << 8) + source[1]]; - dest[2] = temp_dc.tranmap[(dest[2] << 8) + source[2]]; - dest[3] = temp_dc.tranmap[(dest[3] << 8) + source[3]]; - source += 4; - dest += stride; +#define DEFINE_GETFLUSHQUAD_FUNC(name, flags) \ + static inline void name(void) \ + { \ + constexpr ColumnFlushType opt = static_cast(flags); \ + R_FlushQuad(); \ } -} -static void R_FlushQuadColormap(void) -{ - UINT8 *source = &temp_dc.buf[temp_dc.commontop << 2]; - UINT8 *dest = R_Address(temp_dc.startx, temp_dc.commontop); - INT32 count; - const restrict INT32 stride = vid.width; +DEFINE_GETFLUSHQUAD_FUNC(R_FlushQuadOpague, FLUSH_OPAQUE) +DEFINE_GETFLUSHQUAD_FUNC(R_FlushQuadTrans, FLUSH_TRANS) +DEFINE_GETFLUSHQUAD_FUNC(R_FlushQuadColormap, FLUSH_COLORMAP) +DEFINE_GETFLUSHQUAD_FUNC(R_FlushQuadColormapTrans, FLUSH_COLORMAP_TRANS) - count = temp_dc.commonbot - temp_dc.commontop + 1; - - while (--count >= 0) - { - dest[0] = temp_dc.translation[source[0]]; - dest[1] = temp_dc.translation[source[1]]; - dest[2] = temp_dc.translation[source[2]]; - dest[3] = temp_dc.translation[source[3]]; - source += 4; - dest += stride; - } -} - -static void R_FlushQuadColormapTrans(void) -{ - UINT8 *source = &temp_dc.buf[temp_dc.commontop << 2]; - UINT8 *dest = R_Address(temp_dc.startx, temp_dc.commontop); - INT32 count; - const restrict INT32 stride = vid.width; - - count = temp_dc.commonbot - temp_dc.commontop + 1; - - while (--count >= 0) - { - dest[0] = temp_dc.tranmap[(dest[0] << 8) + temp_dc.translation[source[0]]]; - dest[1] = temp_dc.tranmap[(dest[1] << 8) + temp_dc.translation[source[1]]]; - dest[2] = temp_dc.tranmap[(dest[2] << 8) + temp_dc.translation[source[2]]]; - dest[3] = temp_dc.tranmap[(dest[3] << 8) + temp_dc.translation[source[3]]]; - source += 4; - dest += stride; - } -} - -static UINT8 *R_GetBufferOpaque(drawcolumndata_t *dc) +template +static UINT8 *R_GetBuffer(drawcolumndata_t *dc) { if (temp_dc.x == 4 || - (temp_dc.x && (temp_dc.type != FLUSH_OPAQUE || temp_dc.x + temp_dc.startx != dc->x))) + (temp_dc.x && (temp_dc.type != Type || temp_dc.x + temp_dc.startx != dc->x))) R_FlushColumns(); if (!temp_dc.x) @@ -417,10 +265,37 @@ static UINT8 *R_GetBufferOpaque(drawcolumndata_t *dc) temp_dc.startx = dc->x; temp_dc.yl[0] = temp_dc.commontop = dc->yl; temp_dc.yh[0] = temp_dc.commonbot = dc->yh; - temp_dc.type = FLUSH_OPAQUE; - R_FlushWholeColumns = R_FlushWholeOpaque; - R_FlushHTColumns = R_FlushHTOpaque; - R_FlushQuadColumn = R_FlushQuadOpaque; + temp_dc.type = Type; + + if constexpr (Type & ColumnFlushType::FLUSH_OPAQUE) + { + R_FlushWholeColumns = R_FlushWholeOpague; + R_FlushHTColumns = R_FlushHTOpague; + R_FlushQuadColumn = R_FlushQuadOpague; + } + else if constexpr (Type & ColumnFlushType::FLUSH_TRANS) + { + temp_dc.tranmap = dc->transmap; + R_FlushWholeColumns = R_FlushWholeTrans; + R_FlushHTColumns = R_FlushHTTrans; + R_FlushQuadColumn = R_FlushQuadTrans; + } + else if constexpr (Type & ColumnFlushType::FLUSH_COLORMAP) + { + temp_dc.translation = dc->translation; + R_FlushWholeColumns = R_FlushWholeColormap; + R_FlushHTColumns = R_FlushHTColormap; + R_FlushQuadColumn = R_FlushQuadColormap; + } + else if constexpr (Type & ColumnFlushType::FLUSH_COLORMAP_TRANS) + { + temp_dc.tranmap = dc->transmap; + temp_dc.translation = dc->translation; + R_FlushWholeColumns = R_FlushWholeColormapTrans; + R_FlushHTColumns = R_FlushHTColormapTrans; + R_FlushQuadColumn = R_FlushQuadColormapTrans; + } + temp_dc.x += 1; return &temp_dc.buf[dc->yl << 2]; } @@ -436,96 +311,15 @@ static UINT8 *R_GetBufferOpaque(drawcolumndata_t *dc) return &temp_dc.buf[(dc->yl << 2) + temp_dc.x++]; } -static UINT8 *R_GetBufferTrans(drawcolumndata_t *dc) -{ - if (temp_dc.x == 4 || - (temp_dc.x && (temp_dc.type != FLUSH_TRANS || temp_dc.x + temp_dc.startx != dc->x))) - R_FlushColumns(); - - if (!temp_dc.x) - { - temp_dc.startx = dc->x; - temp_dc.yl[0] = temp_dc.commontop = dc->yl; - temp_dc.yh[0] = temp_dc.commonbot = dc->yh; - temp_dc.type = FLUSH_TRANS; - temp_dc.tranmap = dc->transmap; - R_FlushWholeColumns = R_FlushWholeTrans; - R_FlushHTColumns = R_FlushHTTrans; - R_FlushQuadColumn = R_FlushQuadTrans; - temp_dc.x += 1; - return &temp_dc.buf[dc->yl << 2]; +#define DEFINE_GETBUF_FUNC(name, flags) \ + static UINT8 *name(drawcolumndata_t *dc) \ + { \ + constexpr ColumnFlushType opt = static_cast(flags); \ + return R_GetBuffer(dc); \ } - temp_dc.yl[temp_dc.x] = dc->yl; - temp_dc.yh[temp_dc.x] = dc->yh; +DEFINE_GETBUF_FUNC(R_GetBufferOpaque, FLUSH_OPAQUE) +DEFINE_GETBUF_FUNC(R_GetBufferTrans, FLUSH_TRANS) +DEFINE_GETBUF_FUNC(R_GetBufferColormap, FLUSH_COLORMAP) +DEFINE_GETBUF_FUNC(R_GetBufferColormapTrans, FLUSH_COLORMAP_TRANS) - if (dc->yl > temp_dc.commontop) - temp_dc.commontop = dc->yl; - if (dc->yh < temp_dc.commonbot) - temp_dc.commonbot = dc->yh; - - return &temp_dc.buf[(dc->yl << 2) + temp_dc.x++]; -} - -static UINT8 *R_GetBufferColormap(drawcolumndata_t *dc) -{ - if (temp_dc.x == 4 || - (temp_dc.x && (temp_dc.type != FLUSH_COLORMAP || temp_dc.x + temp_dc.startx != dc->x))) - R_FlushColumns(); - - if (!temp_dc.x) - { - temp_dc.startx = dc->x; - temp_dc.yl[0] = temp_dc.commontop = dc->yl; - temp_dc.yh[0] = temp_dc.commonbot = dc->yh; - temp_dc.type = FLUSH_COLORMAP; - temp_dc.translation = dc->translation; - R_FlushWholeColumns = R_FlushWholeColormap; - R_FlushHTColumns = R_FlushHTColormap; - R_FlushQuadColumn = R_FlushQuadColormap; - temp_dc.x += 1; - return &temp_dc.buf[dc->yl << 2]; - } - - temp_dc.yl[temp_dc.x] = dc->yl; - temp_dc.yh[temp_dc.x] = dc->yh; - - if (dc->yl > temp_dc.commontop) - temp_dc.commontop = dc->yl; - if (dc->yh < temp_dc.commonbot) - temp_dc.commonbot = dc->yh; - - return &temp_dc.buf[(dc->yl << 2) + temp_dc.x++]; -} - -static UINT8 *R_GetBufferColormapTrans(drawcolumndata_t *dc) -{ - if (temp_dc.x == 4 || - (temp_dc.x && (temp_dc.type != FLUSH_COLORMAP_TRANS || temp_dc.x + temp_dc.startx != dc->x))) - R_FlushColumns(); - - if (!temp_dc.x) - { - temp_dc.startx = dc->x; - temp_dc.yl[0] = temp_dc.commontop = dc->yl; - temp_dc.yh[0] = temp_dc.commonbot = dc->yh; - temp_dc.type = FLUSH_COLORMAP_TRANS; - temp_dc.translation = dc->translation; - temp_dc.tranmap = dc->transmap; - R_FlushWholeColumns = R_FlushWholeColormapTrans; - R_FlushHTColumns = R_FlushHTColormapTrans; - R_FlushQuadColumn = R_FlushQuadColormapTrans; - temp_dc.x += 1; - return &temp_dc.buf[dc->yl << 2]; - } - - temp_dc.yl[temp_dc.x] = dc->yl; - temp_dc.yh[temp_dc.x] = dc->yh; - - if (dc->yl > temp_dc.commontop) - temp_dc.commontop = dc->yl; - if (dc->yh < temp_dc.commonbot) - temp_dc.commonbot = dc->yh; - - return &temp_dc.buf[(dc->yl << 2) + temp_dc.x++]; -} From b44548b7acf2a9ea254d8a2765f351ec2c99f7ef Mon Sep 17 00:00:00 2001 From: Alug Date: Mon, 6 Oct 2025 22:43:49 +0200 Subject: [PATCH 09/27] dedupe those a bit --- src/r_draw_flush.cpp | 99 ++++++++++++++++---------------------------- 1 file changed, 36 insertions(+), 63 deletions(-) diff --git a/src/r_draw_flush.cpp b/src/r_draw_flush.cpp index 23fd4beb3..18bc207b9 100644 --- a/src/r_draw_flush.cpp +++ b/src/r_draw_flush.cpp @@ -13,6 +13,27 @@ /// \brief column flush functions /// \note no includes because this is included as part of r_draw.cpp +template +static inline UINT8 R_DrawFlushColumnPixel(UINT8 dest, UINT8 source) +{ + if constexpr (Type & ColumnFlushType::FLUSH_OPAQUE) + { + return source; + } + else if constexpr (Type & ColumnFlushType::FLUSH_TRANS) + { + return temp_dc.tranmap[(dest << 8) + source]; + } + else if constexpr (Type & ColumnFlushType::FLUSH_COLORMAP) + { + return temp_dc.translation[source]; + } + else if constexpr (Type & ColumnFlushType::FLUSH_COLORMAP_TRANS) + { + return temp_dc.tranmap[(dest << 8) + temp_dc.translation[source]]; + } +} + // // R_FlushWhole // @@ -24,8 +45,8 @@ static void R_FlushWhole(void) { UINT8 * restrict source; UINT8 * restrict dest; - INT32 count, yl; - const restrict INT32 stride = vid.width; + intptr_t count, yl; + const restrict intptr_t stride = vid.width; while (--temp_dc.x >= 0) { @@ -36,23 +57,7 @@ static void R_FlushWhole(void) while (--count >= 0) { - if constexpr (Type & ColumnFlushType::FLUSH_OPAQUE) - { - *dest = *source; - } - else if constexpr (Type & ColumnFlushType::FLUSH_TRANS) - { - *dest = temp_dc.tranmap[(*dest << 8) + *source]; - } - else if constexpr (Type & ColumnFlushType::FLUSH_COLORMAP) - { - *dest = temp_dc.translation[*source]; - } - else if constexpr (Type & ColumnFlushType::FLUSH_COLORMAP_TRANS) - { - *dest = temp_dc.tranmap[(*dest << 8) + temp_dc.translation[*source]]; - } - + *dest = R_DrawFlushColumnPixel(*dest, *source); source += 4; dest += stride; } @@ -82,9 +87,9 @@ static void R_FlushHT(void) { UINT8 * restrict source; UINT8 * restrict dest; - INT32 count; - INT32 colnum = 0, yl, yh; - const restrict INT32 stride = vid.width; + intptr_t count, colnum = 0; + intptr_t yl, yh; + const restrict intptr_t stride = vid.width; while (colnum < 4) { @@ -95,28 +100,12 @@ static void R_FlushHT(void) if (yl < temp_dc.commontop) { source = &temp_dc.buf[colnum + (yl << 2)]; - dest = R_Address(temp_dc.startx + colnum, yl); - count = temp_dc.commontop - yl; + dest = R_Address(temp_dc.startx + colnum, yl); + count = temp_dc.commontop - yl; while (--count >= 0) { - if constexpr (Type & ColumnFlushType::FLUSH_OPAQUE) - { - *dest = *source; - } - else if constexpr (Type & ColumnFlushType::FLUSH_TRANS) - { - *dest = temp_dc.tranmap[(*dest << 8) + *source]; - } - else if constexpr (Type & ColumnFlushType::FLUSH_COLORMAP) - { - *dest = temp_dc.translation[*source]; - } - else if constexpr (Type & ColumnFlushType::FLUSH_COLORMAP_TRANS) - { - *dest = temp_dc.tranmap[(*dest << 8) + temp_dc.translation[*source]]; - } - + *dest = R_DrawFlushColumnPixel(*dest, *source); source += 4; dest += stride; } @@ -126,28 +115,12 @@ static void R_FlushHT(void) if (yh > temp_dc.commonbot) { source = &temp_dc.buf[colnum + ((temp_dc.commonbot + 1) << 2)]; - dest = R_Address(temp_dc.startx + colnum, temp_dc.commonbot + 1); - count = yh - temp_dc.commonbot; + dest = R_Address(temp_dc.startx + colnum, temp_dc.commonbot + 1); + count = yh - temp_dc.commonbot; while (--count >= 0) { - if constexpr (Type & ColumnFlushType::FLUSH_OPAQUE) - { - *dest = *source; - } - else if constexpr (Type & ColumnFlushType::FLUSH_TRANS) - { - *dest = temp_dc.tranmap[(*dest << 8) + *source]; - } - else if constexpr (Type & ColumnFlushType::FLUSH_COLORMAP) - { - *dest = temp_dc.translation[*source]; - } - else if constexpr (Type & ColumnFlushType::FLUSH_COLORMAP_TRANS) - { - *dest = temp_dc.tranmap[(*dest << 8) + temp_dc.translation[*source]]; - } - + *dest = R_DrawFlushColumnPixel(*dest, *source); source += 4; dest += stride; } @@ -174,8 +147,8 @@ static void R_FlushQuad(void) { UINT8 * restrict source = &temp_dc.buf[temp_dc.commontop << 2]; UINT8 * restrict dest = R_Address(temp_dc.startx, temp_dc.commontop); - INT32 count; - const restrict INT32 stride = vid.width; + intptr_t count; + const restrict intptr_t stride = vid.width; count = temp_dc.commonbot - temp_dc.commontop + 1; @@ -312,7 +285,7 @@ static UINT8 *R_GetBuffer(drawcolumndata_t *dc) } #define DEFINE_GETBUF_FUNC(name, flags) \ - static UINT8 *name(drawcolumndata_t *dc) \ + static inline UINT8 *name(drawcolumndata_t *dc) \ { \ constexpr ColumnFlushType opt = static_cast(flags); \ return R_GetBuffer(dc); \ From 23512f0a6c102db4b6c97978e85f69e38f0f7a4f Mon Sep 17 00:00:00 2001 From: Alug Date: Mon, 6 Oct 2025 23:31:44 +0200 Subject: [PATCH 10/27] align our tempbuf --- src/r_draw.cpp | 19 +++++++++++++++++-- src/r_draw_flush.cpp | 8 ++++---- src/r_main.cpp | 10 +++++----- src/r_plane.cpp | 2 +- 4 files changed, 27 insertions(+), 12 deletions(-) diff --git a/src/r_draw.cpp b/src/r_draw.cpp index b2cad26e0..eb43404df 100644 --- a/src/r_draw.cpp +++ b/src/r_draw.cpp @@ -621,11 +621,26 @@ void R_InitViewBuffer(INT32 width, INT32 height) linesize = vid.width; // killough 11/98 renderscreen = vid.screens[0]; // haleyjd 07/02/14 + INT32 bufsize = (linesize * 4) * sizeof(*temp_dc.buf); + if (temp_dc.buf) - Z_Free(temp_dc.buf); + { +#if defined(__SSE__) + aligned_free(temp_dc.buf); +#else + free(temp_dc.buf); +#endif + } memset(&temp_dc, 0, sizeof(temp_dc)); - temp_dc.buf = static_cast(Z_Calloc((vid.height * 4) * sizeof(*temp_dc.buf), PU_STATIC, NULL)); + +#if defined(__SSE__) + while (bufsize & 15) + bufsize++; + temp_dc.buf = static_cast(aligned_alloc(16, bufsize)); +#else + temp_dc.buf = static_cast(Z_Calloc(bufsize, PU_STATIC, NULL)); +#endif } /** \brief viewborder patches lump numbers diff --git a/src/r_draw_flush.cpp b/src/r_draw_flush.cpp index 18bc207b9..d27fb8cd8 100644 --- a/src/r_draw_flush.cpp +++ b/src/r_draw_flush.cpp @@ -65,7 +65,7 @@ static void R_FlushWhole(void) } #define DEFINE_GETFLUSHWHOLE_FUNC(name, flags) \ - static inline void name(void) \ + FUNCINLINE static ATTRINLINE void name(void) \ { \ constexpr ColumnFlushType opt = static_cast(flags); \ R_FlushWhole(); \ @@ -131,7 +131,7 @@ static void R_FlushHT(void) } #define DEFINE_GETFLUSHHT_FUNC(name, flags) \ - static inline void name(void) \ + FUNCINLINE static ATTRINLINE void name(void) \ { \ constexpr ColumnFlushType opt = static_cast(flags); \ R_FlushHT(); \ @@ -215,7 +215,7 @@ static void R_FlushQuad(void) } #define DEFINE_GETFLUSHQUAD_FUNC(name, flags) \ - static inline void name(void) \ + FUNCINLINE static ATTRINLINE void name(void) \ { \ constexpr ColumnFlushType opt = static_cast(flags); \ R_FlushQuad(); \ @@ -285,7 +285,7 @@ static UINT8 *R_GetBuffer(drawcolumndata_t *dc) } #define DEFINE_GETBUF_FUNC(name, flags) \ - static inline UINT8 *name(drawcolumndata_t *dc) \ + FUNCINLINE static ATTRINLINE UINT8 *name(drawcolumndata_t *dc) \ { \ constexpr ColumnFlushType opt = static_cast(flags); \ return R_GetBuffer(dc); \ diff --git a/src/r_main.cpp b/src/r_main.cpp index 132349a82..dd98f747b 100644 --- a/src/r_main.cpp +++ b/src/r_main.cpp @@ -1409,9 +1409,9 @@ void R_RenderPlayerView(player_t *player) R_ClipSprites(drawsegs, NULL); R_DrawSkyPlanes(); // draw the fucker again to prevent some artifacts R_DrawPlanes(); - //R_ResetColumnBuffer(); + R_ResetColumnBuffer(); R_DrawMasked(masks, nummasks); - //R_ResetColumnBuffer(); + R_ResetColumnBuffer(); } PS_STOP_TIMING(ps_skyboxtime); @@ -1495,18 +1495,18 @@ void R_RenderPlayerView(player_t *player) PS_START_TIMING(ps_sw_planetime); if (!skybox) R_DrawSkyPlanes(); - R_ResetColumnBuffer(); R_DrawPlanes(); + R_ResetColumnBuffer(); PS_STOP_TIMING(ps_sw_planetime); // draw mid texture and sprite // And now 3D floors/sides! PS_START_TIMING(ps_sw_maskedtime); R_DrawMasked(masks, nummasks); PS_STOP_TIMING(ps_sw_maskedtime); - R_ResetColumnBuffer(); - free(masks); + R_ResetColumnBuffer(); + // Check for new console commands. NetUpdate(); diff --git a/src/r_plane.cpp b/src/r_plane.cpp index 16e344bdf..83508e16a 100644 --- a/src/r_plane.cpp +++ b/src/r_plane.cpp @@ -1158,7 +1158,7 @@ void R_DrawSinglePlane(drawspandata_t* ds, visplane_t *pl, boolean allow_paralle offset = (scry*vid.width) + scrx; // No idea if this works - VID_BlitLinearScreen(renderscreen + offset, + VID_BlitLinearScreen(vid.screens[0] + offset, vid.screens[1] + (top*vid.width), // intentionally not +offset viewwidth, bottom-top, vid.width, vid.width); From fa8901f6b06003a744080b493c5c179a61f7b26e Mon Sep 17 00:00:00 2001 From: Alug Date: Tue, 7 Oct 2025 00:25:27 +0200 Subject: [PATCH 11/27] fix ColumnFlushType enum --- src/r_draw.cpp | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/src/r_draw.cpp b/src/r_draw.cpp index eb43404df..5234267e8 100644 --- a/src/r_draw.cpp +++ b/src/r_draw.cpp @@ -491,11 +491,11 @@ void R_FlushTranslationColormapCache(void) enum ColumnFlushType { - FLUSH_NONE, - FLUSH_OPAQUE, - FLUSH_TRANS, - FLUSH_COLORMAP, - FLUSH_COLORMAP_TRANS + FLUSH_NONE = 0x0000, + FLUSH_OPAQUE = 0x0001, + FLUSH_TRANS = 0x0002, + FLUSH_COLORMAP = 0x0004, + FLUSH_COLORMAP_TRANS = 0x0008, }; typedef struct drawcolumndata_temp_s From 4deebf8912b6e7fc4bdeba81eef53529bc3c87d9 Mon Sep 17 00:00:00 2001 From: Alug Date: Tue, 7 Oct 2025 00:28:34 +0200 Subject: [PATCH 12/27] translucency is handled on the flush side! --- src/r_draw_column.cpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/r_draw_column.cpp b/src/r_draw_column.cpp index c2275fbd4..43107e721 100644 --- a/src/r_draw_column.cpp +++ b/src/r_draw_column.cpp @@ -48,11 +48,11 @@ static constexpr UINT8 R_GetColumnTranslucent(drawcolumndata_t* dc, UINT8 * rest { col = R_GetColumnTranslated(dc, col, colormap); - if constexpr (Type & DrawColumnType::DC_TRANSMAP) + /*if constexpr (Type & DrawColumnType::DC_TRANSMAP) { return *(dc->transmap + (col << 8) + (*dest)); } - else + else*/ { return col; } From e5a03dc3bb3a29ac41a481e7718e7254b2d50d19 Mon Sep 17 00:00:00 2001 From: Alug Date: Tue, 7 Oct 2025 01:01:13 +0200 Subject: [PATCH 13/27] fix translucency being only half as translucent oops lmao didnt notice in all of this doom uses the inverse of our blendlevels kek --- src/r_draw_column.cpp | 4 ++-- src/r_draw_flush.cpp | 20 ++++++++++---------- 2 files changed, 12 insertions(+), 12 deletions(-) diff --git a/src/r_draw_column.cpp b/src/r_draw_column.cpp index 43107e721..b15294c75 100644 --- a/src/r_draw_column.cpp +++ b/src/r_draw_column.cpp @@ -44,7 +44,7 @@ static constexpr UINT8 R_GetColumnTranslated(drawcolumndata_t* dc, UINT8 col, co } template -static constexpr UINT8 R_GetColumnTranslucent(drawcolumndata_t* dc, UINT8 * restrict dest, UINT8 col, const UINT8 * restrict colormap) +static constexpr UINT8 R_GetColumnTranslucent(drawcolumndata_t* dc, UINT8 col, const UINT8 * restrict colormap) { col = R_GetColumnTranslated(dc, col, colormap); @@ -71,7 +71,7 @@ static constexpr UINT8 R_DrawColumnPixel(drawcolumndata_t* dc, UINT8 * restrict } } - return R_GetColumnTranslucent(dc, dest, col, colormap); + return R_GetColumnTranslucent(dc, col, colormap); } /** \brief The R_DrawColumn function diff --git a/src/r_draw_flush.cpp b/src/r_draw_flush.cpp index d27fb8cd8..fcc94a767 100644 --- a/src/r_draw_flush.cpp +++ b/src/r_draw_flush.cpp @@ -22,7 +22,7 @@ static inline UINT8 R_DrawFlushColumnPixel(UINT8 dest, UINT8 source) } else if constexpr (Type & ColumnFlushType::FLUSH_TRANS) { - return temp_dc.tranmap[(dest << 8) + source]; + return temp_dc.tranmap[(source << 8) + dest]; } else if constexpr (Type & ColumnFlushType::FLUSH_COLORMAP) { @@ -30,7 +30,7 @@ static inline UINT8 R_DrawFlushColumnPixel(UINT8 dest, UINT8 source) } else if constexpr (Type & ColumnFlushType::FLUSH_COLORMAP_TRANS) { - return temp_dc.tranmap[(dest << 8) + temp_dc.translation[source]]; + return temp_dc.tranmap[(temp_dc.translation[source] << 8) + dest]; } } @@ -180,10 +180,10 @@ static void R_FlushQuad(void) { while (--count >= 0) { - dest[0] = temp_dc.tranmap[(dest[0] << 8) + source[0]]; - dest[1] = temp_dc.tranmap[(dest[1] << 8) + source[1]]; - dest[2] = temp_dc.tranmap[(dest[2] << 8) + source[2]]; - dest[3] = temp_dc.tranmap[(dest[3] << 8) + source[3]]; + dest[0] = temp_dc.tranmap[(source[0] << 8) + dest[0]]; + dest[1] = temp_dc.tranmap[(source[1] << 8) + dest[1]]; + dest[2] = temp_dc.tranmap[(source[2] << 8) + dest[2]]; + dest[3] = temp_dc.tranmap[(source[3] << 8) + dest[3]]; source += 4; dest += stride; } @@ -204,10 +204,10 @@ static void R_FlushQuad(void) { while (--count >= 0) { - dest[0] = temp_dc.tranmap[(dest[0] << 8) + temp_dc.translation[source[0]]]; - dest[1] = temp_dc.tranmap[(dest[1] << 8) + temp_dc.translation[source[1]]]; - dest[2] = temp_dc.tranmap[(dest[2] << 8) + temp_dc.translation[source[2]]]; - dest[3] = temp_dc.tranmap[(dest[3] << 8) + temp_dc.translation[source[3]]]; + dest[0] = temp_dc.tranmap[(temp_dc.translation[source[0]] << 8) + dest[0]]; + dest[1] = temp_dc.tranmap[(temp_dc.translation[source[1]] << 8) + dest[1]]; + dest[2] = temp_dc.tranmap[(temp_dc.translation[source[2]] << 8) + dest[2]]; + dest[3] = temp_dc.tranmap[(temp_dc.translation[source[3]] << 8) + dest[3]]; source += 4; dest += stride; } From 39a5165d919e333d23fcb8ada6bdecf033ca599b Mon Sep 17 00:00:00 2001 From: Alug Date: Tue, 7 Oct 2025 01:02:25 +0200 Subject: [PATCH 14/27] reset our column buffer directly after bsp traversal we do not need to wait for sky draw since the sky gets instantly drawn --- src/r_main.cpp | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) diff --git a/src/r_main.cpp b/src/r_main.cpp index dd98f747b..ac722dbdd 100644 --- a/src/r_main.cpp +++ b/src/r_main.cpp @@ -1405,11 +1405,11 @@ void R_RenderPlayerView(player_t *player) R_ClearSprites(); R_RenderViewpoint(&masks[nummasks - 1], false); + R_ResetColumnBuffer(); R_ClipSprites(drawsegs, NULL); R_DrawSkyPlanes(); // draw the fucker again to prevent some artifacts R_DrawPlanes(); - R_ResetColumnBuffer(); R_DrawMasked(masks, nummasks); R_ResetColumnBuffer(); } @@ -1447,6 +1447,7 @@ void R_RenderPlayerView(player_t *player) PS_START_TIMING(ps_bsptime); R_RenderViewpoint(&masks[nummasks - 1], true); PS_STOP_TIMING(ps_bsptime); + R_ResetColumnBuffer(); PS_START_TIMING(ps_sw_spritecliptime); R_ClipSprites(drawsegs, NULL); PS_STOP_TIMING(ps_sw_spritecliptime); @@ -1496,7 +1497,6 @@ void R_RenderPlayerView(player_t *player) if (!skybox) R_DrawSkyPlanes(); R_DrawPlanes(); - R_ResetColumnBuffer(); PS_STOP_TIMING(ps_sw_planetime); // draw mid texture and sprite // And now 3D floors/sides! @@ -1504,7 +1504,6 @@ void R_RenderPlayerView(player_t *player) R_DrawMasked(masks, nummasks); PS_STOP_TIMING(ps_sw_maskedtime); free(masks); - R_ResetColumnBuffer(); // Check for new console commands. From c9b6276a02aa46d662e6a66837bc90eb78d6259d Mon Sep 17 00:00:00 2001 From: Alug Date: Tue, 7 Oct 2025 01:31:27 +0200 Subject: [PATCH 15/27] merge sky column drawer back lets hope this is safe lulul --- src/r_draw_column.cpp | 174 +++++------------------------------------- src/r_plane.cpp | 6 +- 2 files changed, 23 insertions(+), 157 deletions(-) diff --git a/src/r_draw_column.cpp b/src/r_draw_column.cpp index b15294c75..8ec979cde 100644 --- a/src/r_draw_column.cpp +++ b/src/r_draw_column.cpp @@ -30,6 +30,7 @@ enum DrawColumnType DC_TRANSMAP = 0x0002, DC_HOLES = 0x0004, DC_LIGHTLIST = 0x0008, + DC_SKY = 0x0010, }; template @@ -208,8 +209,10 @@ static void R_DrawColumnTemplate(drawcolumndata_t *dc) // SoM: MAGIC UINT8 * restrict dest; - if constexpr ((Type & (DrawColumnType::DC_COLORMAP | DrawColumnType::DC_TRANSMAP)) - == (DrawColumnType::DC_COLORMAP | DrawColumnType::DC_TRANSMAP)) + if constexpr (Type & DrawColumnType::DC_SKY) + dest = R_Address(dc->x, dc->yl); + else if constexpr ((Type & (DrawColumnType::DC_COLORMAP | DrawColumnType::DC_TRANSMAP)) + == (DrawColumnType::DC_COLORMAP | DrawColumnType::DC_TRANSMAP)) dest = R_GetBufferColormapTrans(dc); else if constexpr (Type & DrawColumnType::DC_TRANSMAP) dest = R_GetBufferTrans(dc); @@ -218,6 +221,11 @@ static void R_DrawColumnTemplate(drawcolumndata_t *dc) else dest = R_GetBufferOpaque(dc); + restrict INT32 stride = 4; + + if constexpr (Type & DrawColumnType::DC_SKY) + stride = vid.width; + count++; // Determine scaling, which is the only mapping to be done. @@ -231,7 +239,8 @@ static void R_DrawColumnTemplate(drawcolumndata_t *dc) while (count--) { *dest = R_DrawColumnPixel(dc, dest, (frac>>FRACBITS) & heightmask, source, colormap); - dest += 4; + + dest += stride; frac += fracstep; } } @@ -246,7 +255,8 @@ static void R_DrawColumnTemplate(drawcolumndata_t *dc) while (--count >= 0) { *dest = R_DrawColumnPixel(dc, dest, frac>>FRACBITS, source, colormap); - dest += 4; + + dest += stride; frac += fracstep; } } @@ -258,11 +268,13 @@ static void R_DrawColumnTemplate(drawcolumndata_t *dc) while ((count -= 2) >= 0) // texture height is a power of 2 -- killough { *dest = R_DrawColumnPixel(dc, dest, (frac>>FRACBITS) & heightmask, source, colormap); - dest += 4; + + dest += stride; frac += fracstep; *dest = R_DrawColumnPixel(dc, dest, (frac>>FRACBITS) & heightmask, source, colormap); - dest += 4; + + dest += stride; frac += fracstep; } @@ -300,7 +312,7 @@ static void R_DrawColumnTemplate(drawcolumndata_t *dc) // and a few bytes after as well *dest = R_DrawColumnPixel(dc, dest, CLAMP((frac >> FRACBITS), npow2min, npow2max), source, colormap); - dest += 4; + dest += stride; #if __SIZEOF_POINTER__ < 8 // 64-bit systems have large enough numbers for this to be a non-issue // Avoid overflow. @@ -341,6 +353,7 @@ DEFINE_COLUMN_FUNC(R_DrawColumnShadowed, DC_LIGHTLIST) DEFINE_COLUMN_FUNC(R_DrawTranslatedTranslucentColumn, DC_COLORMAP|DC_TRANSMAP) DEFINE_COLUMN_FUNC(R_Draw2sMultiPatchColumn, DC_HOLES) DEFINE_COLUMN_FUNC(R_Draw2sMultiPatchTranslucentColumn, DC_HOLES|DC_TRANSMAP) +DEFINE_COLUMN_FUNC(R_DrawSkyColumn, DC_SKY) /** \brief The R_DrawFogColumn function Fog wall. @@ -377,150 +390,3 @@ void R_DrawFogColumn(drawcolumndata_t* dc) dest += stride; } while (count--); } - -// blunt copy paste for now -// cant share a global buffer between threads for obvious reasons lmao -void R_DrawSkyColumn(drawcolumndata_t *dc) -{ - INT32 count; - - count = dc->yh - dc->yl; - - if (count < 0) // Zero length, column does not exceed a pixel. - { - return; - } - - if ((unsigned)dc->x >= (unsigned)vid.width || dc->yl < 0 || dc->yh >= vid.height) - { - return; - } - - { - // Inner loop that does the actual texture mapping, - // e.g. a DDA-lile scaling. - // This is as fast as it gets. (Yeah, right!!! -- killough) - // - // killough 2/1/98: more performance tuning - - intptr_t frac; - const intptr_t fracstep = dc->iscale; - const intptr_t heightmask = dc->sourcelength-1; - constexpr INT32 npow2min = -1; - const INT32 npow2max = dc->sourcelength; - const INT32 stride = vid.width; - - const UINT8 * restrict source = dc->source; - const lighttable_t * restrict colormap = dc->colormap; - - // Framebuffer destination address. - UINT8 * restrict dest = R_Address(dc->x, dc->yl); - - count++; - - // Determine scaling, which is the only mapping to be done. - frac = (dc->texturemid + FixedMul((dc->yl << FRACBITS) - centeryfrac, fracstep)); - - switch (heightmask) - { - case 255: - case 127: - { - while(count--) - { - *dest = R_DrawColumnPixel(dc, dest, (frac>>FRACBITS) & heightmask, source, colormap); - dest += stride; - frac += fracstep; - } - } - break; - case -1: - { - if (frac < 0) - // adjust in case we underread - frac += fracstep; - - // texture has no height, so just go - while (--count >= 0) - { - *dest = R_DrawColumnPixel(dc, dest, frac>>FRACBITS, source, colormap); - dest += stride; - frac += fracstep; - } - } - break; - default: - { - if (!(dc->sourcelength & heightmask)) // power of 2 -- killough - { - while ((count -= 2) >= 0) // texture height is a power of 2 -- killough - { - *dest = R_DrawColumnPixel(dc, dest, (frac>>FRACBITS) & heightmask, source, colormap); - dest += stride; - frac += fracstep; - - *dest = R_DrawColumnPixel(dc, dest, (frac>>FRACBITS) & heightmask, source, colormap); - dest += stride; - frac += fracstep; - } - - if (count & 1) - { - *dest = R_DrawColumnPixel(dc, dest, (frac>>FRACBITS) & heightmask, source, colormap); - } - } - else - { - const intptr_t fixed_heightmask = dc->texheight << FRACBITS; - - if (frac < 0) - { - while ((frac += fixed_heightmask) < 0) - { - ; - } - } - else - { - while (frac >= fixed_heightmask) - { - frac -= fixed_heightmask; - } - } - - do - { - // Re-map color indices from wall texture column - // using a lighting/special effects LUT. - // heightmask is the Tutti-Frutti fix - - // -1 is the lower clamp bound because column posts have a "safe" byte before the real data - // and a few bytes after as well - *dest = R_DrawColumnPixel(dc, dest, CLAMP((frac >> FRACBITS), npow2min, npow2max), source, colormap); - - dest += stride; - -#if __SIZEOF_POINTER__ < 8 // 64-bit systems have large enough numbers for this to be a non-issue - // Avoid overflow. - if (fracstep > 0x7FFFFFFF - frac) - { - frac += fracstep - fixed_heightmask; - } - else -#endif - { - frac += fracstep; - } - - while (frac >= fixed_heightmask) - { - frac -= fixed_heightmask; - } - } - while (--count); - } - } - break; - } - } -} diff --git a/src/r_plane.cpp b/src/r_plane.cpp index 83508e16a..7c2ff271d 100644 --- a/src/r_plane.cpp +++ b/src/r_plane.cpp @@ -739,7 +739,7 @@ void R_DrawPlanes(void) #endif } -static void R_DrawSkyPlane(visplane_t *pl, void(*colfunc2)(drawcolumndata_t*), boolean allow_parallel); +static void R_DrawSkyPlane(visplane_t *pl, boolean allow_parallel); void R_DrawSkyPlanes(void) { @@ -757,7 +757,7 @@ void R_DrawSkyPlanes(void) if (pl->picnum != skyflatnum || pl->ffloor || pl->polyobj) continue; - R_DrawSkyPlane(pl, colfunc, cv_parallelsoftware.value); + R_DrawSkyPlane(pl, cv_parallelsoftware.value); } } #ifdef HAVE_THREADS @@ -767,7 +767,7 @@ void R_DrawSkyPlanes(void) #endif } -static void R_DrawSkyPlane(visplane_t *pl, void(*colfunc2)(drawcolumndata_t*), boolean allow_parallel) +static void R_DrawSkyPlane(visplane_t *pl, boolean allow_parallel) { INT32 x; From 41b78feef5b2e81382fb354dce7c095fc101bf64 Mon Sep 17 00:00:00 2001 From: Alug Date: Tue, 7 Oct 2025 01:38:00 +0200 Subject: [PATCH 16/27] remove R_GetColumnTranslucent --- src/r_draw_column.cpp | 12 +++++++----- src/r_draw_flush.cpp | 2 +- 2 files changed, 8 insertions(+), 6 deletions(-) diff --git a/src/r_draw_column.cpp b/src/r_draw_column.cpp index 8ec979cde..4102035d1 100644 --- a/src/r_draw_column.cpp +++ b/src/r_draw_column.cpp @@ -44,20 +44,21 @@ static constexpr UINT8 R_GetColumnTranslated(drawcolumndata_t* dc, UINT8 col, co return colormap[col]; } -template +// translucency is handled on flush side now! +/*template static constexpr UINT8 R_GetColumnTranslucent(drawcolumndata_t* dc, UINT8 col, const UINT8 * restrict colormap) { col = R_GetColumnTranslated(dc, col, colormap); - /*if constexpr (Type & DrawColumnType::DC_TRANSMAP) + if constexpr (Type & DrawColumnType::DC_TRANSMAP) { return *(dc->transmap + (col << 8) + (*dest)); } - else*/ + else { return col; } -} +}*/ template static constexpr UINT8 R_DrawColumnPixel(drawcolumndata_t* dc, UINT8 * restrict dest, UINT32 bit, const UINT8 * restrict source, const UINT8 * restrict colormap) @@ -72,7 +73,8 @@ static constexpr UINT8 R_DrawColumnPixel(drawcolumndata_t* dc, UINT8 * restrict } } - return R_GetColumnTranslucent(dc, col, colormap); + //return R_GetColumnTranslucent(dc, col, colormap); + return R_GetColumnTranslated(dc, col, colormap); } /** \brief The R_DrawColumn function diff --git a/src/r_draw_flush.cpp b/src/r_draw_flush.cpp index fcc94a767..53ce2f3f7 100644 --- a/src/r_draw_flush.cpp +++ b/src/r_draw_flush.cpp @@ -14,7 +14,7 @@ /// \note no includes because this is included as part of r_draw.cpp template -static inline UINT8 R_DrawFlushColumnPixel(UINT8 dest, UINT8 source) +FUNCINLINE static ATTRINLINE UINT8 R_DrawFlushColumnPixel(UINT8 restrict dest, UINT8 restrict source) { if constexpr (Type & ColumnFlushType::FLUSH_OPAQUE) { From b6943ce92ef7e8f0efc477344b856909748441bc Mon Sep 17 00:00:00 2001 From: Alug Date: Tue, 7 Oct 2025 01:48:34 +0200 Subject: [PATCH 17/27] can check on compile if sizeof int == 4 can prob remove it alltogether we dont support 16 bit cpus kek --- src/r_draw_flush.cpp | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/src/r_draw_flush.cpp b/src/r_draw_flush.cpp index 53ce2f3f7..ff85f351d 100644 --- a/src/r_draw_flush.cpp +++ b/src/r_draw_flush.cpp @@ -154,7 +154,8 @@ static void R_FlushQuad(void) if constexpr (Type & ColumnFlushType::FLUSH_OPAQUE) { - if ((sizeof(int) == 4) && (((intptr_t)source % 4) == 0) && (((intptr_t)dest % 4) == 0)) +#if __SIZEOF_INT__ == 4 + if ((((intptr_t)source % 4) == 0) && (((intptr_t)dest % 4) == 0)) { while(--count >= 0) { @@ -164,6 +165,7 @@ static void R_FlushQuad(void) } } else +#endif { while(--count >= 0) { From c9f50ca0c875a0c018052b375cf94acbaaf166ec Mon Sep 17 00:00:00 2001 From: Alug Date: Tue, 7 Oct 2025 01:59:24 +0200 Subject: [PATCH 18/27] sizeof(UINT8) is 1 lel --- src/r_draw_flush.cpp | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/src/r_draw_flush.cpp b/src/r_draw_flush.cpp index ff85f351d..96d58cccd 100644 --- a/src/r_draw_flush.cpp +++ b/src/r_draw_flush.cpp @@ -160,21 +160,21 @@ static void R_FlushQuad(void) while(--count >= 0) { *(int *)dest = *(int *)source; - source += 4 * sizeof(UINT8); - dest += stride * sizeof(UINT8); + source += 4; + dest += stride; } } else #endif { - while(--count >= 0) + while (--count >= 0) { dest[0] = source[0]; dest[1] = source[1]; dest[2] = source[2]; dest[3] = source[3]; - source += 4 * sizeof(UINT8); - dest += stride * sizeof(UINT8); + source += 4; + dest += stride; } } } From ba3404d823a9da695fdc24f59dc26c14942eff46 Mon Sep 17 00:00:00 2001 From: Alug Date: Tue, 7 Oct 2025 16:00:12 +0200 Subject: [PATCH 19/27] cleanup + type fixes --- src/r_draw.cpp | 14 +++++----- src/r_draw_flush.cpp | 61 ++++++++++++++++++++++++-------------------- 2 files changed, 40 insertions(+), 35 deletions(-) diff --git a/src/r_draw.cpp b/src/r_draw.cpp index 5234267e8..26184c158 100644 --- a/src/r_draw.cpp +++ b/src/r_draw.cpp @@ -500,18 +500,18 @@ enum ColumnFlushType typedef struct drawcolumndata_temp_s { - intptr_t x; - intptr_t yl[4], yh[4]; + INT32 x; + INT32 yl[4], yh[4]; // e6y: resolution limitation is removed UINT8 *buf; - intptr_t startx; + INT32 startx; ColumnFlushType type; - intptr_t commontop, commonbot; - const UINT8 *tranmap; + INT32 commontop, commonbot; + UINT8 *transmap; // SoM 7-28-04: Fix the fuzz problem. - const UINT8 *translation; + UINT8 *translation; } drawcolumndata_temp_t; drawcolumndata_temp_t temp_dc = {}; @@ -628,7 +628,7 @@ void R_InitViewBuffer(INT32 width, INT32 height) #if defined(__SSE__) aligned_free(temp_dc.buf); #else - free(temp_dc.buf); + Z_Free(temp_dc.buf); #endif } diff --git a/src/r_draw_flush.cpp b/src/r_draw_flush.cpp index 96d58cccd..bed7fd1fa 100644 --- a/src/r_draw_flush.cpp +++ b/src/r_draw_flush.cpp @@ -22,7 +22,7 @@ FUNCINLINE static ATTRINLINE UINT8 R_DrawFlushColumnPixel(UINT8 restrict dest, U } else if constexpr (Type & ColumnFlushType::FLUSH_TRANS) { - return temp_dc.tranmap[(source << 8) + dest]; + return temp_dc.transmap[(source << 8) + dest]; } else if constexpr (Type & ColumnFlushType::FLUSH_COLORMAP) { @@ -30,7 +30,7 @@ FUNCINLINE static ATTRINLINE UINT8 R_DrawFlushColumnPixel(UINT8 restrict dest, U } else if constexpr (Type & ColumnFlushType::FLUSH_COLORMAP_TRANS) { - return temp_dc.tranmap[(temp_dc.translation[source] << 8) + dest]; + return temp_dc.transmap[(temp_dc.translation[source] << 8) + dest]; } } @@ -45,8 +45,8 @@ static void R_FlushWhole(void) { UINT8 * restrict source; UINT8 * restrict dest; - intptr_t count, yl; - const restrict intptr_t stride = vid.width; + INT32 count, yl; + const INT32 stride = vid.width; while (--temp_dc.x >= 0) { @@ -87,9 +87,9 @@ static void R_FlushHT(void) { UINT8 * restrict source; UINT8 * restrict dest; - intptr_t count, colnum = 0; - intptr_t yl, yh; - const restrict intptr_t stride = vid.width; + INT32 count, colnum = 0; + INT32 yl, yh; + const INT32 stride = vid.width; while (colnum < 4) { @@ -147,19 +147,17 @@ static void R_FlushQuad(void) { UINT8 * restrict source = &temp_dc.buf[temp_dc.commontop << 2]; UINT8 * restrict dest = R_Address(temp_dc.startx, temp_dc.commontop); - intptr_t count; - const restrict intptr_t stride = vid.width; - - count = temp_dc.commonbot - temp_dc.commontop + 1; + INT32 count = temp_dc.commonbot - temp_dc.commontop + 1; + const INT32 stride = vid.width; if constexpr (Type & ColumnFlushType::FLUSH_OPAQUE) { #if __SIZEOF_INT__ == 4 - if ((((intptr_t)source % 4) == 0) && (((intptr_t)dest % 4) == 0)) + if ((((uintptr_t)source | (uintptr_t)dest) & 3) == 0) { - while(--count >= 0) + while (--count >= 0) { - *(int *)dest = *(int *)source; + *(UINT32 *)dest = *(UINT32 *)source; source += 4; dest += stride; } @@ -180,36 +178,43 @@ static void R_FlushQuad(void) } else if constexpr (Type & ColumnFlushType::FLUSH_TRANS) { + const UINT8 * restrict transmap = temp_dc.transmap; + while (--count >= 0) { - dest[0] = temp_dc.tranmap[(source[0] << 8) + dest[0]]; - dest[1] = temp_dc.tranmap[(source[1] << 8) + dest[1]]; - dest[2] = temp_dc.tranmap[(source[2] << 8) + dest[2]]; - dest[3] = temp_dc.tranmap[(source[3] << 8) + dest[3]]; + dest[0] = transmap[(source[0] << 8) + dest[0]]; + dest[1] = transmap[(source[1] << 8) + dest[1]]; + dest[2] = transmap[(source[2] << 8) + dest[2]]; + dest[3] = transmap[(source[3] << 8) + dest[3]]; source += 4; dest += stride; } } else if constexpr (Type & ColumnFlushType::FLUSH_COLORMAP) { + const UINT8 * restrict translation = temp_dc.translation; + while (--count >= 0) { - dest[0] = temp_dc.translation[source[0]]; - dest[1] = temp_dc.translation[source[1]]; - dest[2] = temp_dc.translation[source[2]]; - dest[3] = temp_dc.translation[source[3]]; + dest[0] = translation[source[0]]; + dest[1] = translation[source[1]]; + dest[2] = translation[source[2]]; + dest[3] = translation[source[3]]; source += 4; dest += stride; } } else if constexpr (Type & ColumnFlushType::FLUSH_COLORMAP_TRANS) { + const UINT8 * restrict transmap = temp_dc.transmap; + const UINT8 * restrict translation = temp_dc.translation; + while (--count >= 0) { - dest[0] = temp_dc.tranmap[(temp_dc.translation[source[0]] << 8) + dest[0]]; - dest[1] = temp_dc.tranmap[(temp_dc.translation[source[1]] << 8) + dest[1]]; - dest[2] = temp_dc.tranmap[(temp_dc.translation[source[2]] << 8) + dest[2]]; - dest[3] = temp_dc.tranmap[(temp_dc.translation[source[3]] << 8) + dest[3]]; + dest[0] = transmap[(translation[source[0]] << 8) + dest[0]]; + dest[1] = transmap[(translation[source[1]] << 8) + dest[1]]; + dest[2] = transmap[(translation[source[2]] << 8) + dest[2]]; + dest[3] = transmap[(translation[source[3]] << 8) + dest[3]]; source += 4; dest += stride; } @@ -250,7 +255,7 @@ static UINT8 *R_GetBuffer(drawcolumndata_t *dc) } else if constexpr (Type & ColumnFlushType::FLUSH_TRANS) { - temp_dc.tranmap = dc->transmap; + temp_dc.transmap = dc->transmap; R_FlushWholeColumns = R_FlushWholeTrans; R_FlushHTColumns = R_FlushHTTrans; R_FlushQuadColumn = R_FlushQuadTrans; @@ -264,7 +269,7 @@ static UINT8 *R_GetBuffer(drawcolumndata_t *dc) } else if constexpr (Type & ColumnFlushType::FLUSH_COLORMAP_TRANS) { - temp_dc.tranmap = dc->transmap; + temp_dc.transmap = dc->transmap; temp_dc.translation = dc->translation; R_FlushWholeColumns = R_FlushWholeColormapTrans; R_FlushHTColumns = R_FlushHTColormapTrans; From 32504b9e8ea568d13760b8dd6b51285f52d90930 Mon Sep 17 00:00:00 2001 From: Alug Date: Tue, 7 Oct 2025 16:50:43 +0200 Subject: [PATCH 20/27] speed up Opague quad flush from eternity engine --- src/r_draw_column.cpp | 7 ++++--- src/r_draw_flush.cpp | 41 ++++++++++++++++------------------------- 2 files changed, 20 insertions(+), 28 deletions(-) diff --git a/src/r_draw_column.cpp b/src/r_draw_column.cpp index 4102035d1..aa5d03d91 100644 --- a/src/r_draw_column.cpp +++ b/src/r_draw_column.cpp @@ -199,6 +199,7 @@ static void R_DrawColumnTemplate(drawcolumndata_t *dc) // killough 2/1/98: more performance tuning intptr_t frac; + // Looks familiar. const intptr_t fracstep = dc->iscale; const intptr_t heightmask = dc->sourcelength-1; // CPhipps - specify type constexpr INT32 npow2min = -1; @@ -223,12 +224,12 @@ static void R_DrawColumnTemplate(drawcolumndata_t *dc) else dest = R_GetBufferOpaque(dc); - restrict INT32 stride = 4; + restrict INT32 stride = 4; //SoM: Oh, Oh it's MAGIC! You know... if constexpr (Type & DrawColumnType::DC_SKY) - stride = vid.width; + stride = vid.width; // no MAGIC for the sky here X) - count++; + count++; // killough 1/99: minor tuning // Determine scaling, which is the only mapping to be done. frac = (dc->texturemid + FixedMul((dc->yl << FRACBITS) - centeryfrac, fracstep)); diff --git a/src/r_draw_flush.cpp b/src/r_draw_flush.cpp index bed7fd1fa..f0fa37f14 100644 --- a/src/r_draw_flush.cpp +++ b/src/r_draw_flush.cpp @@ -145,39 +145,25 @@ DEFINE_GETFLUSHHT_FUNC(R_FlushHTColormapTrans, FLUSH_COLORMAP_TRANS) template static void R_FlushQuad(void) { - UINT8 * restrict source = &temp_dc.buf[temp_dc.commontop << 2]; - UINT8 * restrict dest = R_Address(temp_dc.startx, temp_dc.commontop); - INT32 count = temp_dc.commonbot - temp_dc.commontop + 1; const INT32 stride = vid.width; + INT32 count = temp_dc.commonbot - temp_dc.commontop + 1; if constexpr (Type & ColumnFlushType::FLUSH_OPAQUE) { -#if __SIZEOF_INT__ == 4 - if ((((uintptr_t)source | (uintptr_t)dest) & 3) == 0) + const INT32 *source = reinterpret_cast(temp_dc.buf + (temp_dc.commontop << 2)); + INT32 *dest = reinterpret_cast(R_Address(temp_dc.startx, temp_dc.commontop)); + INT32 deststep = stride / 4; + + while(--count >= 0) { - while (--count >= 0) - { - *(UINT32 *)dest = *(UINT32 *)source; - source += 4; - dest += stride; - } - } - else -#endif - { - while (--count >= 0) - { - dest[0] = source[0]; - dest[1] = source[1]; - dest[2] = source[2]; - dest[3] = source[3]; - source += 4; - dest += stride; - } + *dest = *source++; + dest += deststep; } } else if constexpr (Type & ColumnFlushType::FLUSH_TRANS) { + const UINT8 * restrict source = temp_dc.buf + (temp_dc.commontop << 2); + UINT8 * restrict dest = R_Address(temp_dc.startx, temp_dc.commontop); const UINT8 * restrict transmap = temp_dc.transmap; while (--count >= 0) @@ -192,6 +178,8 @@ static void R_FlushQuad(void) } else if constexpr (Type & ColumnFlushType::FLUSH_COLORMAP) { + const UINT8 * restrict source = temp_dc.buf + (temp_dc.commontop << 2); + UINT8 * restrict dest = R_Address(temp_dc.startx, temp_dc.commontop); const UINT8 * restrict translation = temp_dc.translation; while (--count >= 0) @@ -206,6 +194,8 @@ static void R_FlushQuad(void) } else if constexpr (Type & ColumnFlushType::FLUSH_COLORMAP_TRANS) { + const UINT8 * restrict source = temp_dc.buf + (temp_dc.commontop << 2); + UINT8 * restrict dest = R_Address(temp_dc.startx, temp_dc.commontop); const UINT8 * restrict transmap = temp_dc.transmap; const UINT8 * restrict translation = temp_dc.translation; @@ -236,12 +226,14 @@ DEFINE_GETFLUSHQUAD_FUNC(R_FlushQuadColormapTrans, FLUSH_COLORMAP_TRANS) template static UINT8 *R_GetBuffer(drawcolumndata_t *dc) { + // haleyjd: reordered predicates if (temp_dc.x == 4 || (temp_dc.x && (temp_dc.type != Type || temp_dc.x + temp_dc.startx != dc->x))) R_FlushColumns(); if (!temp_dc.x) { + ++temp_dc.x; temp_dc.startx = dc->x; temp_dc.yl[0] = temp_dc.commontop = dc->yl; temp_dc.yh[0] = temp_dc.commonbot = dc->yh; @@ -276,7 +268,6 @@ static UINT8 *R_GetBuffer(drawcolumndata_t *dc) R_FlushQuadColumn = R_FlushQuadColormapTrans; } - temp_dc.x += 1; return &temp_dc.buf[dc->yl << 2]; } From 57990100c563f828848a4ec37e49a699174aa264 Mon Sep 17 00:00:00 2001 From: Alug Date: Tue, 7 Oct 2025 17:18:30 +0200 Subject: [PATCH 21/27] speed up masked sprites a bit thx eternity engine! --- src/r_things.cpp | 14 +++++++++----- 1 file changed, 9 insertions(+), 5 deletions(-) diff --git a/src/r_things.cpp b/src/r_things.cpp index 4713bc50e..60dba8a32 100644 --- a/src/r_things.cpp +++ b/src/r_things.cpp @@ -2810,6 +2810,11 @@ void R_ClipSprites(drawseg_t* dsstart, portal_t* portal) drawseg_t* ds; INT32 i; + if (visspritecount - clippedvissprites <= 0) + { + return; + } + // e6y // Reducing of cache misses in the following R_DrawSprite() // Makes sense for scenes with huge amount of drawsegs. @@ -2819,13 +2824,9 @@ void R_ClipSprites(drawseg_t* dsstart, portal_t* portal) drawsegs_xranges[i].count = 0; } - if (visspritecount - clippedvissprites <= 0) - { - return; - } - if (drawsegs_xrange_size < maxdrawsegs) { + // haleyjd: fix reallocation to track 2x size drawsegs_xrange_size = 2 * maxdrawsegs; for (i = 0; i < DS_RANGES_COUNT; i++) @@ -2865,6 +2866,9 @@ void R_ClipSprites(drawseg_t* dsstart, portal_t* portal) } } + // haleyjd: terminate with a nullptr user for faster loop - adds ~3 FPS + drawsegs_xranges[0].items[drawsegs_xranges[0].count].user = nullptr; + for (; clippedvissprites < visspritecount; clippedvissprites++) { vissprite_t *spr = R_GetVisSprite(clippedvissprites); From b12989f51ca3b0614bd16be9c427aaecabae5a54 Mon Sep 17 00:00:00 2001 From: Alug Date: Tue, 7 Oct 2025 17:19:07 +0200 Subject: [PATCH 22/27] lessen our manual column buffer resetting not really needed --- src/r_main.cpp | 2 -- 1 file changed, 2 deletions(-) diff --git a/src/r_main.cpp b/src/r_main.cpp index ac722dbdd..f2ee2bc96 100644 --- a/src/r_main.cpp +++ b/src/r_main.cpp @@ -1405,7 +1405,6 @@ void R_RenderPlayerView(player_t *player) R_ClearSprites(); R_RenderViewpoint(&masks[nummasks - 1], false); - R_ResetColumnBuffer(); R_ClipSprites(drawsegs, NULL); R_DrawSkyPlanes(); // draw the fucker again to prevent some artifacts @@ -1447,7 +1446,6 @@ void R_RenderPlayerView(player_t *player) PS_START_TIMING(ps_bsptime); R_RenderViewpoint(&masks[nummasks - 1], true); PS_STOP_TIMING(ps_bsptime); - R_ResetColumnBuffer(); PS_START_TIMING(ps_sw_spritecliptime); R_ClipSprites(drawsegs, NULL); PS_STOP_TIMING(ps_sw_spritecliptime); From fe54f2fba2af916f658aea75f54caf4f2c4191cc Mon Sep 17 00:00:00 2001 From: Alug Date: Tue, 7 Oct 2025 18:15:11 +0200 Subject: [PATCH 23/27] add Column drawer context switching reasoning explained in screen.c effectively, there are cases where drawing our columns directly to the screen is the better choice --- src/r_draw.cpp | 2 ++ src/r_draw.h | 21 ++++++++++++++++-- src/r_draw_column.cpp | 50 ++++++++++++++++++++++++++++--------------- src/r_main.cpp | 5 +++++ src/r_plane.cpp | 12 +++++------ src/screen.c | 43 +++++++++++++++++++++++++++++-------- src/screen.h | 1 + 7 files changed, 99 insertions(+), 35 deletions(-) diff --git a/src/r_draw.cpp b/src/r_draw.cpp index 26184c158..93638708b 100644 --- a/src/r_draw.cpp +++ b/src/r_draw.cpp @@ -489,6 +489,8 @@ void R_FlushTranslationColormapCache(void) // in reality, the few routines that can work for either mode, are // put here +enum columncontext_e columncontext = COLUMNCONTEXT_DIRECT; + enum ColumnFlushType { FLUSH_NONE = 0x0000, diff --git a/src/r_draw.h b/src/r_draw.h index 232e6c8ce..ae9d2ef40 100644 --- a/src/r_draw.h +++ b/src/r_draw.h @@ -102,6 +102,16 @@ extern floatv3_t *ds_su, *ds_sv, *ds_sz; extern float focallengthf; +enum columncontext_e +{ + COLUMNCONTEXT_DIRECT = 0, + COLUMNCONTEXT_FLUSH, +}; + +extern enum columncontext_e columncontext; +void R_SetColumnContext(enum columncontext_e _columncontext); + +void R_ResetColumnBuffer(void); typedef void (coldrawfunc_t)(drawcolumndata_t*); typedef void (spandrawfunc_t)(drawspandata_t*); @@ -250,10 +260,17 @@ void R_DrawTranslatedTranslucentColumn(drawcolumndata_t* dc); void R_Draw2sMultiPatchColumn(drawcolumndata_t* dc); void R_Draw2sMultiPatchTranslucentColumn(drawcolumndata_t* dc); +// column drawers which use buffered drawing with flush +void R_DrawColumnFlush(drawcolumndata_t* dc); +void R_DrawTranslucentColumnFlush(drawcolumndata_t* dc); +void R_DrawTranslatedColumnFlush(drawcolumndata_t* dc); +void R_DrawColumnShadowedFlush(drawcolumndata_t* dc); +void R_DrawTranslatedTranslucentColumnFlush(drawcolumndata_t* dc); +void R_Draw2sMultiPatchColumnFlush(drawcolumndata_t* dc); +void R_Draw2sMultiPatchTranslucentColumnFlush(drawcolumndata_t* dc); + void R_DrawFogColumn(drawcolumndata_t* dc); -void R_ResetColumnBuffer(void); -void R_DrawSkyColumn(drawcolumndata_t *dc); // span drawers void R_DrawSpan(drawspandata_t* ds); diff --git a/src/r_draw_column.cpp b/src/r_draw_column.cpp index aa5d03d91..27b570b0b 100644 --- a/src/r_draw_column.cpp +++ b/src/r_draw_column.cpp @@ -30,7 +30,7 @@ enum DrawColumnType DC_TRANSMAP = 0x0002, DC_HOLES = 0x0004, DC_LIGHTLIST = 0x0008, - DC_SKY = 0x0010, + DC_DIRECT = 0x0010, // draw our columns directly to screen! }; template @@ -45,8 +45,8 @@ static constexpr UINT8 R_GetColumnTranslated(drawcolumndata_t* dc, UINT8 col, co } // translucency is handled on flush side now! -/*template -static constexpr UINT8 R_GetColumnTranslucent(drawcolumndata_t* dc, UINT8 col, const UINT8 * restrict colormap) +template +static constexpr UINT8 R_GetColumnTranslucent(drawcolumndata_t* dc, UINT8 * restrict dest, UINT8 col, const UINT8 * restrict colormap) { col = R_GetColumnTranslated(dc, col, colormap); @@ -58,7 +58,7 @@ static constexpr UINT8 R_GetColumnTranslucent(drawcolumndata_t* dc, UINT8 col, c { return col; } -}*/ +} template static constexpr UINT8 R_DrawColumnPixel(drawcolumndata_t* dc, UINT8 * restrict dest, UINT32 bit, const UINT8 * restrict source, const UINT8 * restrict colormap) @@ -73,8 +73,14 @@ static constexpr UINT8 R_DrawColumnPixel(drawcolumndata_t* dc, UINT8 * restrict } } - //return R_GetColumnTranslucent(dc, col, colormap); - return R_GetColumnTranslated(dc, col, colormap); + if constexpr (Type & DrawColumnType::DC_DIRECT) + { // if we dont flush our columns, we need to handle translucency again + return R_GetColumnTranslucent(dc, dest, col, colormap); + } + else + { + return R_GetColumnTranslated(dc, col, colormap); + } } /** \brief The R_DrawColumn function @@ -212,7 +218,7 @@ static void R_DrawColumnTemplate(drawcolumndata_t *dc) // SoM: MAGIC UINT8 * restrict dest; - if constexpr (Type & DrawColumnType::DC_SKY) + if constexpr (Type & DrawColumnType::DC_DIRECT) dest = R_Address(dc->x, dc->yl); else if constexpr ((Type & (DrawColumnType::DC_COLORMAP | DrawColumnType::DC_TRANSMAP)) == (DrawColumnType::DC_COLORMAP | DrawColumnType::DC_TRANSMAP)) @@ -226,8 +232,8 @@ static void R_DrawColumnTemplate(drawcolumndata_t *dc) restrict INT32 stride = 4; //SoM: Oh, Oh it's MAGIC! You know... - if constexpr (Type & DrawColumnType::DC_SKY) - stride = vid.width; // no MAGIC for the sky here X) + if constexpr (Type & DrawColumnType::DC_DIRECT) + stride = vid.width; count++; // killough 1/99: minor tuning @@ -349,14 +355,24 @@ static void R_DrawColumnTemplate(drawcolumndata_t *dc) R_DrawColumnTemplate(dc); \ } -DEFINE_COLUMN_FUNC(R_DrawColumn, DC_BASIC) -DEFINE_COLUMN_FUNC(R_DrawTranslucentColumn, DC_TRANSMAP) -DEFINE_COLUMN_FUNC(R_DrawTranslatedColumn, DC_COLORMAP) -DEFINE_COLUMN_FUNC(R_DrawColumnShadowed, DC_LIGHTLIST) -DEFINE_COLUMN_FUNC(R_DrawTranslatedTranslucentColumn, DC_COLORMAP|DC_TRANSMAP) -DEFINE_COLUMN_FUNC(R_Draw2sMultiPatchColumn, DC_HOLES) -DEFINE_COLUMN_FUNC(R_Draw2sMultiPatchTranslucentColumn, DC_HOLES|DC_TRANSMAP) -DEFINE_COLUMN_FUNC(R_DrawSkyColumn, DC_SKY) +DEFINE_COLUMN_FUNC(R_DrawColumn, DC_DIRECT|DC_BASIC) +DEFINE_COLUMN_FUNC(R_DrawTranslucentColumn, DC_DIRECT|DC_TRANSMAP) +DEFINE_COLUMN_FUNC(R_DrawTranslatedColumn, DC_DIRECT|DC_COLORMAP) +DEFINE_COLUMN_FUNC(R_DrawColumnShadowed, DC_DIRECT|DC_LIGHTLIST) +DEFINE_COLUMN_FUNC(R_DrawTranslatedTranslucentColumn, DC_DIRECT|DC_COLORMAP|DC_TRANSMAP) +DEFINE_COLUMN_FUNC(R_Draw2sMultiPatchColumn, DC_DIRECT|DC_HOLES) +DEFINE_COLUMN_FUNC(R_Draw2sMultiPatchTranslucentColumn, DC_DIRECT|DC_HOLES|DC_TRANSMAP) + +DEFINE_COLUMN_FUNC(R_DrawColumnFlush, DC_BASIC) +DEFINE_COLUMN_FUNC(R_DrawTranslucentColumnFlush, DC_TRANSMAP) +DEFINE_COLUMN_FUNC(R_DrawTranslatedColumnFlush, DC_COLORMAP) +DEFINE_COLUMN_FUNC(R_DrawColumnShadowedFlush, DC_LIGHTLIST) +DEFINE_COLUMN_FUNC(R_DrawTranslatedTranslucentColumnFlush, DC_COLORMAP|DC_TRANSMAP) +DEFINE_COLUMN_FUNC(R_Draw2sMultiPatchColumnFlush, DC_HOLES) +DEFINE_COLUMN_FUNC(R_Draw2sMultiPatchTranslucentColumnFlush, DC_HOLES|DC_TRANSMAP) + +//skymyass +//DEFINE_COLUMN_FUNC(R_DrawSkyColumn, DC_SKY) /** \brief The R_DrawFogColumn function Fog wall. diff --git a/src/r_main.cpp b/src/r_main.cpp index f2ee2bc96..79e49438f 100644 --- a/src/r_main.cpp +++ b/src/r_main.cpp @@ -1391,6 +1391,8 @@ void R_RenderPlayerView(player_t *player) R_SetFov(fov); } + R_SetColumnContext(COLUMNCONTEXT_FLUSH); + Portal_InitList(); PS_START_TIMING(ps_skyboxtime); @@ -1407,6 +1409,7 @@ void R_RenderPlayerView(player_t *player) R_RenderViewpoint(&masks[nummasks - 1], false); R_ClipSprites(drawsegs, NULL); + R_SetColumnContext(COLUMNCONTEXT_DIRECT); R_DrawSkyPlanes(); // draw the fucker again to prevent some artifacts R_DrawPlanes(); R_DrawMasked(masks, nummasks); @@ -1442,6 +1445,7 @@ void R_RenderPlayerView(player_t *player) // check for new console commands. NetUpdate(); + R_SetColumnContext(COLUMNCONTEXT_FLUSH); ps_numbspcalls.value.i = ps_numpolyobjects.value.i = ps_numdrawnodes.value.i = 0; PS_START_TIMING(ps_bsptime); R_RenderViewpoint(&masks[nummasks - 1], true); @@ -1491,6 +1495,7 @@ void R_RenderPlayerView(player_t *player) } PS_STOP_TIMING(ps_sw_portaltime); + R_SetColumnContext(COLUMNCONTEXT_DIRECT); PS_START_TIMING(ps_sw_planetime); if (!skybox) R_DrawSkyPlanes(); diff --git a/src/r_plane.cpp b/src/r_plane.cpp index 7c2ff271d..71e6a4dca 100644 --- a/src/r_plane.cpp +++ b/src/r_plane.cpp @@ -739,7 +739,7 @@ void R_DrawPlanes(void) #endif } -static void R_DrawSkyPlane(visplane_t *pl, boolean allow_parallel); +static void R_DrawSkyPlane(visplane_t *pl, void(*colfunc2)(drawcolumndata_t*), boolean allow_parallel); void R_DrawSkyPlanes(void) { @@ -757,7 +757,7 @@ void R_DrawSkyPlanes(void) if (pl->picnum != skyflatnum || pl->ffloor || pl->polyobj) continue; - R_DrawSkyPlane(pl, cv_parallelsoftware.value); + R_DrawSkyPlane(pl, colfunc, cv_parallelsoftware.value); } } #ifdef HAVE_THREADS @@ -767,7 +767,7 @@ void R_DrawSkyPlanes(void) #endif } -static void R_DrawSkyPlane(visplane_t *pl, boolean allow_parallel) +static void R_DrawSkyPlane(visplane_t *pl, void(*colfunc2)(drawcolumndata_t*), boolean allow_parallel) { INT32 x; @@ -834,8 +834,7 @@ static void R_DrawSkyPlane(visplane_t *pl, boolean allow_parallel) dc.x = x + i; dc.source = R_GetColumn(texture, -angle); // get negative of angle for each column to display sky correct way round! --Monster Iestyn 27/01/18 - //colfunc2(&dc); - R_DrawSkyColumn(&dc); + colfunc2(&dc); } }; @@ -872,8 +871,7 @@ static void R_DrawSkyPlane(visplane_t *pl, boolean allow_parallel) R_GetColumn(texturetranslation[skytexture], -angle); // get negative of angle for each column to display sky correct way round! --Monster Iestyn 27/01/18 - //colfunc2(&dc); - R_DrawSkyColumn(&dc); + colfunc2(&dc); } #endif } diff --git a/src/screen.c b/src/screen.c index 21ec0ed52..735bb88c4 100644 --- a/src/screen.c +++ b/src/screen.c @@ -84,7 +84,7 @@ UINT8 *scr_borderpatch; // flat used to fill the reduced view borders set at ST_ // ========================================================================= -static void SCR_SetDrawFuncs(void) +static void SCR_SetDrawFuncs(enum columncontext_e _columncontext) { // // setup the right draw routines @@ -103,13 +103,27 @@ static void SCR_SetDrawFuncs(void) spanfuncs[SPANDRAWFUNC_FOG] = R_DrawFogSpan; spanfuncs[SPANDRAWFUNC_TILTEDFOG] = R_DrawFogSpan_Tilted; - colfuncs[BASEDRAWFUNC] = R_DrawColumn; - colfuncs[COLDRAWFUNC_FUZZY] = R_DrawTranslucentColumn; - colfuncs[COLDRAWFUNC_TRANS] = R_DrawTranslatedColumn; - colfuncs[COLDRAWFUNC_SHADOWED] = R_DrawColumnShadowed; - colfuncs[COLDRAWFUNC_TRANSTRANS] = R_DrawTranslatedTranslucentColumn; - colfuncs[COLDRAWFUNC_TWOSMULTIPATCH] = R_Draw2sMultiPatchColumn; - colfuncs[COLDRAWFUNC_TWOSMULTIPATCHTRANS] = R_Draw2sMultiPatchTranslucentColumn; + if (_columncontext == COLUMNCONTEXT_FLUSH) + { + colfuncs[BASEDRAWFUNC] = R_DrawColumnFlush; + colfuncs[COLDRAWFUNC_FUZZY] = R_DrawTranslucentColumnFlush; + colfuncs[COLDRAWFUNC_TRANS] = R_DrawTranslatedColumnFlush; + colfuncs[COLDRAWFUNC_SHADOWED] = R_DrawColumnShadowedFlush; + colfuncs[COLDRAWFUNC_TRANSTRANS] = R_DrawTranslatedTranslucentColumnFlush; + colfuncs[COLDRAWFUNC_TWOSMULTIPATCH] = R_Draw2sMultiPatchColumnFlush; + colfuncs[COLDRAWFUNC_TWOSMULTIPATCHTRANS] = R_Draw2sMultiPatchTranslucentColumnFlush; + } + else + { + colfuncs[BASEDRAWFUNC] = R_DrawColumn; + colfuncs[COLDRAWFUNC_FUZZY] = R_DrawTranslucentColumn; + colfuncs[COLDRAWFUNC_TRANS] = R_DrawTranslatedColumn; + colfuncs[COLDRAWFUNC_SHADOWED] = R_DrawColumnShadowed; + colfuncs[COLDRAWFUNC_TRANSTRANS] = R_DrawTranslatedTranslucentColumn; + colfuncs[COLDRAWFUNC_TWOSMULTIPATCH] = R_Draw2sMultiPatchColumn; + colfuncs[COLDRAWFUNC_TWOSMULTIPATCHTRANS] = R_Draw2sMultiPatchTranslucentColumn; + } + colfuncs[COLDRAWFUNC_FOG] = R_DrawFogColumn; R_SetColumnFunc(BASEDRAWFUNC); @@ -131,12 +145,23 @@ void SCR_SetMode(void) V_SetPalette(0); - SCR_SetDrawFuncs(); + SCR_SetDrawFuncs(COLUMNCONTEXT_DIRECT); // set the apprpriate drawer for the sky (tall or INT16) setmodeneeded = 0; } +// used to switch between column buffering and drawing them directly to screen +// our sky "plane" drawer cannot handle the buffer system due to multithreading +// (that would require alot of extra complexity for smth with massive diminishing results) +// Our masked drawing step draws things in a very particular order, which results in alot of flushing to screen +// effectively adding massive overhead during buffering, so we draw our masked thing directly to screen instead +void R_SetColumnContext(enum columncontext_e _columncontext) +{ + columncontext = _columncontext; + SCR_SetDrawFuncs(_columncontext); // set our column drawers +} + void R_SetColumnFunc(size_t id) { I_Assert(id < COLDRAWFUNC_MAX); diff --git a/src/screen.h b/src/screen.h index ecad24a64..8cd90c23a 100644 --- a/src/screen.h +++ b/src/screen.h @@ -96,6 +96,7 @@ extern consvar_t cv_vidwait; extern consvar_t cv_votebgscaling; +//void R_SetColumnContext(enum columncontext_e _columncontext); // declared in r_draw! void R_SetColumnFunc(size_t id); void R_SetSpanFunc(size_t id); boolean R_CheckColumnFunc(size_t id); From 55afe9be7e94967222a1ed3944c83850cfec1e74 Mon Sep 17 00:00:00 2001 From: Alug Date: Tue, 7 Oct 2025 20:47:47 +0200 Subject: [PATCH 24/27] update copyright header for draw flush stuff --- src/r_draw_flush.cpp | 14 +++++++++++++- 1 file changed, 13 insertions(+), 1 deletion(-) diff --git a/src/r_draw_flush.cpp b/src/r_draw_flush.cpp index f0fa37f14..1baf98f31 100644 --- a/src/r_draw_flush.cpp +++ b/src/r_draw_flush.cpp @@ -4,13 +4,17 @@ // Copyright (C) 2020 by Sonic Team Junior. // Copyright (C) 2000 by DooM Legacy Team. // Copyright (C) 1996 by id Software, Inc. +// Copyright (C) 1999 by Chi Hoang, Lee Killough, Jim Flynn, Rand Phares, Ty Halderman +// Copyright (C) 1999-2000 by Jess Haas, Nicolas Kalkhof, Colin Phipps, Florian Schulze +// Copyright (C) Copyright 2005, 2006 by Florian Schulze, Colin Phipps, Neil Stevens, Andrey Budko +// Copyright (C) 2013 by James Haley, Stephen McGranahan, et al. // // This program is free software distributed under the // terms of the GNU General Public License, version 2. // See the 'LICENSE' file for more details. //----------------------------------------------------------------------------- /// \file r_draw_flush.cpp -/// \brief column flush functions +/// \brief Optimized quad column buffer code. By SoM. /// \note no includes because this is included as part of r_draw.cpp template @@ -22,6 +26,7 @@ FUNCINLINE static ATTRINLINE UINT8 R_DrawFlushColumnPixel(UINT8 restrict dest, U } else if constexpr (Type & ColumnFlushType::FLUSH_TRANS) { + // haleyjd 09/11/04: use temptranmap here return temp_dc.transmap[(source << 8) + dest]; } else if constexpr (Type & ColumnFlushType::FLUSH_COLORMAP) @@ -30,6 +35,7 @@ FUNCINLINE static ATTRINLINE UINT8 R_DrawFlushColumnPixel(UINT8 restrict dest, U } else if constexpr (Type & ColumnFlushType::FLUSH_COLORMAP_TRANS) { + // haleyjd 09/11/04: use temptranmap here return temp_dc.transmap[(temp_dc.translation[source] << 8) + dest]; } } @@ -142,6 +148,7 @@ DEFINE_GETFLUSHHT_FUNC(R_FlushHTTrans, FLUSH_TRANS) DEFINE_GETFLUSHHT_FUNC(R_FlushHTColormap, FLUSH_COLORMAP) DEFINE_GETFLUSHHT_FUNC(R_FlushHTColormapTrans, FLUSH_COLORMAP_TRANS) +// Begin: Quad column flushing functions. template static void R_FlushQuad(void) { @@ -168,6 +175,7 @@ static void R_FlushQuad(void) while (--count >= 0) { + // haleyjd 09/11/04: use temptranmap here dest[0] = transmap[(source[0] << 8) + dest[0]]; dest[1] = transmap[(source[1] << 8) + dest[1]]; dest[2] = transmap[(source[2] << 8) + dest[2]]; @@ -201,6 +209,7 @@ static void R_FlushQuad(void) while (--count >= 0) { + // haleyjd 09/11/04: use temptranmap here dest[0] = transmap[(translation[source[0]] << 8) + dest[0]]; dest[1] = transmap[(translation[source[1]] << 8) + dest[1]]; dest[2] = transmap[(translation[source[2]] << 8) + dest[2]]; @@ -223,6 +232,9 @@ DEFINE_GETFLUSHQUAD_FUNC(R_FlushQuadTrans, FLUSH_TRANS) DEFINE_GETFLUSHQUAD_FUNC(R_FlushQuadColormap, FLUSH_COLORMAP) DEFINE_GETFLUSHQUAD_FUNC(R_FlushQuadColormapTrans, FLUSH_COLORMAP_TRANS) +// haleyjd 09/12/04: split up R_GetBuffer into various different +// functions to minimize the number of branches and take advantage +// of as much precalculated information as possible. template static UINT8 *R_GetBuffer(drawcolumndata_t *dc) { From 8c8f96cf49758cf254d48796bd8ca1931e7d28d6 Mon Sep 17 00:00:00 2001 From: Alug Date: Tue, 7 Oct 2025 21:53:01 +0200 Subject: [PATCH 25/27] force flush our column buffer directly after bsp traversal (again) TODO: actually check what portals do --- src/r_main.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/r_main.cpp b/src/r_main.cpp index 79e49438f..6dd5a8563 100644 --- a/src/r_main.cpp +++ b/src/r_main.cpp @@ -1453,6 +1453,7 @@ void R_RenderPlayerView(player_t *player) PS_START_TIMING(ps_sw_spritecliptime); R_ClipSprites(drawsegs, NULL); PS_STOP_TIMING(ps_sw_spritecliptime); + R_ResetColumnBuffer(); ps_numsprites.value.i = numvisiblesprites; @@ -1507,7 +1508,6 @@ void R_RenderPlayerView(player_t *player) R_DrawMasked(masks, nummasks); PS_STOP_TIMING(ps_sw_maskedtime); free(masks); - R_ResetColumnBuffer(); // Check for new console commands. NetUpdate(); From 0843a586f854b9fb99698c72b3b771e8c3a260e1 Mon Sep 17 00:00:00 2001 From: Alug Date: Tue, 7 Oct 2025 22:45:25 +0200 Subject: [PATCH 26/27] fuckit, lets buffer 8 columns instead of 4 improves performance across the board on my ryzen 5600 cpu between 10 -15fps + in best case and around 5fps+ in worst case will need to check how this affects older cpus and 32bit builds since we do 64bit copies now (if needed can always add 32bit specific code) effectively, we also reduce the amount of flushing needed in many cases, writing more things at once during flushes --- src/r_draw.cpp | 6 ++--- src/r_draw_column.cpp | 2 +- src/r_draw_flush.cpp | 52 ++++++++++++++++++++++++++----------------- src/r_main.cpp | 2 +- 4 files changed, 37 insertions(+), 25 deletions(-) diff --git a/src/r_draw.cpp b/src/r_draw.cpp index 93638708b..288cf462d 100644 --- a/src/r_draw.cpp +++ b/src/r_draw.cpp @@ -503,7 +503,7 @@ enum ColumnFlushType typedef struct drawcolumndata_temp_s { INT32 x; - INT32 yl[4], yh[4]; + INT32 yl[8], yh[8]; // e6y: resolution limitation is removed UINT8 *buf; @@ -543,7 +543,7 @@ static void (*R_FlushQuadColumn)(void) = R_QuadFlushError; static void R_FlushColumns(void) { - if (temp_dc.x != 4 || temp_dc.commontop >= temp_dc.commonbot) + if (temp_dc.x != 8 || temp_dc.commontop >= temp_dc.commonbot) R_FlushWholeColumns(); else { @@ -623,7 +623,7 @@ void R_InitViewBuffer(INT32 width, INT32 height) linesize = vid.width; // killough 11/98 renderscreen = vid.screens[0]; // haleyjd 07/02/14 - INT32 bufsize = (linesize * 4) * sizeof(*temp_dc.buf); + INT32 bufsize = (linesize * 8) * sizeof(*temp_dc.buf); if (temp_dc.buf) { diff --git a/src/r_draw_column.cpp b/src/r_draw_column.cpp index 27b570b0b..58de4eebd 100644 --- a/src/r_draw_column.cpp +++ b/src/r_draw_column.cpp @@ -230,7 +230,7 @@ static void R_DrawColumnTemplate(drawcolumndata_t *dc) else dest = R_GetBufferOpaque(dc); - restrict INT32 stride = 4; //SoM: Oh, Oh it's MAGIC! You know... + restrict INT32 stride = 8; //SoM: Oh, Oh it's MAGIC! You know... if constexpr (Type & DrawColumnType::DC_DIRECT) stride = vid.width; diff --git a/src/r_draw_flush.cpp b/src/r_draw_flush.cpp index 1baf98f31..3ef763a4e 100644 --- a/src/r_draw_flush.cpp +++ b/src/r_draw_flush.cpp @@ -57,14 +57,14 @@ static void R_FlushWhole(void) while (--temp_dc.x >= 0) { yl = temp_dc.yl[temp_dc.x]; - source = &temp_dc.buf[temp_dc.x + (yl << 2)]; + source = &temp_dc.buf[temp_dc.x + (yl << 3)]; dest = R_Address(temp_dc.startx + temp_dc.x, yl); count = temp_dc.yh[temp_dc.x] - yl + 1; while (--count >= 0) { *dest = R_DrawFlushColumnPixel(*dest, *source); - source += 4; + source += 8; dest += stride; } } @@ -97,7 +97,7 @@ static void R_FlushHT(void) INT32 yl, yh; const INT32 stride = vid.width; - while (colnum < 4) + while (colnum < 8) { yl = temp_dc.yl[colnum]; yh = temp_dc.yh[colnum]; @@ -105,14 +105,14 @@ static void R_FlushHT(void) // flush column head if (yl < temp_dc.commontop) { - source = &temp_dc.buf[colnum + (yl << 2)]; + source = &temp_dc.buf[colnum + (yl << 3)]; dest = R_Address(temp_dc.startx + colnum, yl); count = temp_dc.commontop - yl; while (--count >= 0) { *dest = R_DrawFlushColumnPixel(*dest, *source); - source += 4; + source += 8; dest += stride; } } @@ -120,14 +120,14 @@ static void R_FlushHT(void) // flush column tail if (yh > temp_dc.commonbot) { - source = &temp_dc.buf[colnum + ((temp_dc.commonbot + 1) << 2)]; + source = &temp_dc.buf[colnum + ((temp_dc.commonbot + 1) << 3)]; dest = R_Address(temp_dc.startx + colnum, temp_dc.commonbot + 1); count = yh - temp_dc.commonbot; while (--count >= 0) { *dest = R_DrawFlushColumnPixel(*dest, *source); - source += 4; + source += 8; dest += stride; } } @@ -157,11 +157,11 @@ static void R_FlushQuad(void) if constexpr (Type & ColumnFlushType::FLUSH_OPAQUE) { - const INT32 *source = reinterpret_cast(temp_dc.buf + (temp_dc.commontop << 2)); - INT32 *dest = reinterpret_cast(R_Address(temp_dc.startx, temp_dc.commontop)); - INT32 deststep = stride / 4; + const INT64 *source = reinterpret_cast(temp_dc.buf + (temp_dc.commontop << 3)); + INT64 *dest = reinterpret_cast(R_Address(temp_dc.startx, temp_dc.commontop)); + INT32 deststep = stride / 8; - while(--count >= 0) + while (--count >= 0) { *dest = *source++; dest += deststep; @@ -169,7 +169,7 @@ static void R_FlushQuad(void) } else if constexpr (Type & ColumnFlushType::FLUSH_TRANS) { - const UINT8 * restrict source = temp_dc.buf + (temp_dc.commontop << 2); + const UINT8 * restrict source = temp_dc.buf + (temp_dc.commontop << 3); UINT8 * restrict dest = R_Address(temp_dc.startx, temp_dc.commontop); const UINT8 * restrict transmap = temp_dc.transmap; @@ -180,13 +180,17 @@ static void R_FlushQuad(void) dest[1] = transmap[(source[1] << 8) + dest[1]]; dest[2] = transmap[(source[2] << 8) + dest[2]]; dest[3] = transmap[(source[3] << 8) + dest[3]]; - source += 4; + dest[4] = transmap[(source[4] << 8) + dest[4]]; + dest[5] = transmap[(source[5] << 8) + dest[5]]; + dest[6] = transmap[(source[6] << 8) + dest[6]]; + dest[7] = transmap[(source[7] << 8) + dest[7]]; + source += 8; dest += stride; } } else if constexpr (Type & ColumnFlushType::FLUSH_COLORMAP) { - const UINT8 * restrict source = temp_dc.buf + (temp_dc.commontop << 2); + const UINT8 * restrict source = temp_dc.buf + (temp_dc.commontop << 3); UINT8 * restrict dest = R_Address(temp_dc.startx, temp_dc.commontop); const UINT8 * restrict translation = temp_dc.translation; @@ -196,13 +200,17 @@ static void R_FlushQuad(void) dest[1] = translation[source[1]]; dest[2] = translation[source[2]]; dest[3] = translation[source[3]]; - source += 4; + dest[4] = translation[source[4]]; + dest[5] = translation[source[5]]; + dest[6] = translation[source[6]]; + dest[7] = translation[source[7]]; + source += 8; dest += stride; } } else if constexpr (Type & ColumnFlushType::FLUSH_COLORMAP_TRANS) { - const UINT8 * restrict source = temp_dc.buf + (temp_dc.commontop << 2); + const UINT8 * restrict source = temp_dc.buf + (temp_dc.commontop << 3); UINT8 * restrict dest = R_Address(temp_dc.startx, temp_dc.commontop); const UINT8 * restrict transmap = temp_dc.transmap; const UINT8 * restrict translation = temp_dc.translation; @@ -214,7 +222,11 @@ static void R_FlushQuad(void) dest[1] = transmap[(translation[source[1]] << 8) + dest[1]]; dest[2] = transmap[(translation[source[2]] << 8) + dest[2]]; dest[3] = transmap[(translation[source[3]] << 8) + dest[3]]; - source += 4; + dest[4] = transmap[(translation[source[4]] << 8) + dest[4]]; + dest[5] = transmap[(translation[source[5]] << 8) + dest[5]]; + dest[6] = transmap[(translation[source[6]] << 8) + dest[6]]; + dest[7] = transmap[(translation[source[7]] << 8) + dest[7]]; + source += 8; dest += stride; } } @@ -239,7 +251,7 @@ template static UINT8 *R_GetBuffer(drawcolumndata_t *dc) { // haleyjd: reordered predicates - if (temp_dc.x == 4 || + if (temp_dc.x == 8 || (temp_dc.x && (temp_dc.type != Type || temp_dc.x + temp_dc.startx != dc->x))) R_FlushColumns(); @@ -280,7 +292,7 @@ static UINT8 *R_GetBuffer(drawcolumndata_t *dc) R_FlushQuadColumn = R_FlushQuadColormapTrans; } - return &temp_dc.buf[dc->yl << 2]; + return &temp_dc.buf[dc->yl << 3]; } temp_dc.yl[temp_dc.x] = dc->yl; @@ -291,7 +303,7 @@ static UINT8 *R_GetBuffer(drawcolumndata_t *dc) if (dc->yh < temp_dc.commonbot) temp_dc.commonbot = dc->yh; - return &temp_dc.buf[(dc->yl << 2) + temp_dc.x++]; + return &temp_dc.buf[(dc->yl << 3) + temp_dc.x++]; } #define DEFINE_GETBUF_FUNC(name, flags) \ diff --git a/src/r_main.cpp b/src/r_main.cpp index 6dd5a8563..2a04c6600 100644 --- a/src/r_main.cpp +++ b/src/r_main.cpp @@ -1409,11 +1409,11 @@ void R_RenderPlayerView(player_t *player) R_RenderViewpoint(&masks[nummasks - 1], false); R_ClipSprites(drawsegs, NULL); + R_ResetColumnBuffer(); R_SetColumnContext(COLUMNCONTEXT_DIRECT); R_DrawSkyPlanes(); // draw the fucker again to prevent some artifacts R_DrawPlanes(); R_DrawMasked(masks, nummasks); - R_ResetColumnBuffer(); } PS_STOP_TIMING(ps_skyboxtime); From 48dc5461cdc9049e671ceb5dd99937f318bdfcb9 Mon Sep 17 00:00:00 2001 From: Alug Date: Wed, 8 Oct 2025 16:47:01 +0200 Subject: [PATCH 27/27] cleanup column flusher stuff - properly make use of templates!, reduce code dupe - inline the "DrawPixel" stuff - use local "const" pointers everywhere --- src/r_draw_column.cpp | 11 +- src/r_draw_flush.cpp | 269 +++++++++++++++--------------------------- src/r_draw_span.cpp | 9 +- src/screen.c | 2 +- 4 files changed, 112 insertions(+), 179 deletions(-) diff --git a/src/r_draw_column.cpp b/src/r_draw_column.cpp index 58de4eebd..08cfa00a1 100644 --- a/src/r_draw_column.cpp +++ b/src/r_draw_column.cpp @@ -34,7 +34,8 @@ enum DrawColumnType }; template -static constexpr UINT8 R_GetColumnTranslated(drawcolumndata_t* dc, UINT8 col, const UINT8 * restrict colormap) +FUNCINLINE static ATTRINLINE constexpr UINT8 +R_GetColumnTranslated(const drawcolumndata_t* dc, UINT8 col, const UINT8 * restrict colormap) { if constexpr (Type & DrawColumnType::DC_COLORMAP) { @@ -46,7 +47,8 @@ static constexpr UINT8 R_GetColumnTranslated(drawcolumndata_t* dc, UINT8 col, co // translucency is handled on flush side now! template -static constexpr UINT8 R_GetColumnTranslucent(drawcolumndata_t* dc, UINT8 * restrict dest, UINT8 col, const UINT8 * restrict colormap) +FUNCINLINE static ATTRINLINE constexpr UINT8 +R_GetColumnTranslucent(const drawcolumndata_t* dc, UINT8 * restrict dest, UINT8 col, const UINT8 * restrict colormap) { col = R_GetColumnTranslated(dc, col, colormap); @@ -61,7 +63,8 @@ static constexpr UINT8 R_GetColumnTranslucent(drawcolumndata_t* dc, UINT8 * rest } template -static constexpr UINT8 R_DrawColumnPixel(drawcolumndata_t* dc, UINT8 * restrict dest, UINT32 bit, const UINT8 * restrict source, const UINT8 * restrict colormap) +FUNCINLINE static ATTRINLINE constexpr UINT8 +R_DrawColumnPixel(const drawcolumndata_t* dc, UINT8 * restrict dest, UINT32 bit, const UINT8 * restrict source, const UINT8 * restrict colormap) { UINT8 col = source[bit]; @@ -74,7 +77,7 @@ static constexpr UINT8 R_DrawColumnPixel(drawcolumndata_t* dc, UINT8 * restrict } if constexpr (Type & DrawColumnType::DC_DIRECT) - { // if we dont flush our columns, we need to handle translucency again + { // if we dont buffer our columns, we need to handle translucency again return R_GetColumnTranslucent(dc, dest, col, colormap); } else diff --git a/src/r_draw_flush.cpp b/src/r_draw_flush.cpp index 3ef763a4e..80da61705 100644 --- a/src/r_draw_flush.cpp +++ b/src/r_draw_flush.cpp @@ -18,28 +18,42 @@ /// \note no includes because this is included as part of r_draw.cpp template -FUNCINLINE static ATTRINLINE UINT8 R_DrawFlushColumnPixel(UINT8 restrict dest, UINT8 restrict source) +FUNCINLINE static ATTRINLINE constexpr UINT8 +R_GetFlushPixelTranslated(const drawcolumndata_temp_t *t_dc, UINT8 col) { - if constexpr (Type & ColumnFlushType::FLUSH_OPAQUE) + if constexpr (Type & (ColumnFlushType::FLUSH_COLORMAP | ColumnFlushType::FLUSH_COLORMAP_TRANS)) { - return source; + col = t_dc->translation[col]; } - else if constexpr (Type & ColumnFlushType::FLUSH_TRANS) + + return col; +} + +template +FUNCINLINE static ATTRINLINE constexpr UINT8 +R_GetFlushPixelTranslucent(const drawcolumndata_temp_t *t_dc, UINT8 * restrict dest, UINT8 col) +{ + col = R_GetFlushPixelTranslated(t_dc, col); + + if constexpr (Type & (ColumnFlushType::FLUSH_TRANS | ColumnFlushType::FLUSH_COLORMAP_TRANS)) { // haleyjd 09/11/04: use temptranmap here - return temp_dc.transmap[(source << 8) + dest]; + return *(t_dc->transmap + (col << 8) + (*dest)); } - else if constexpr (Type & ColumnFlushType::FLUSH_COLORMAP) + else { - return temp_dc.translation[source]; - } - else if constexpr (Type & ColumnFlushType::FLUSH_COLORMAP_TRANS) - { - // haleyjd 09/11/04: use temptranmap here - return temp_dc.transmap[(temp_dc.translation[source] << 8) + dest]; + return col; } } +template +FUNCINLINE static ATTRINLINE constexpr UINT8 +R_DrawFlushPixel(const drawcolumndata_temp_t *t_dc, UINT8 * restrict dest, const UINT8 * restrict source) +{ + UINT8 col = *source; + return R_GetFlushPixelTranslucent(t_dc, dest, col); +} + // // R_FlushWhole // @@ -53,35 +67,25 @@ static void R_FlushWhole(void) UINT8 * restrict dest; INT32 count, yl; const INT32 stride = vid.width; + drawcolumndata_temp_t *t_dc = &temp_dc; + UINT8 *restrict buf = t_dc->buf; - while (--temp_dc.x >= 0) + while (--t_dc->x >= 0) { - yl = temp_dc.yl[temp_dc.x]; - source = &temp_dc.buf[temp_dc.x + (yl << 3)]; - dest = R_Address(temp_dc.startx + temp_dc.x, yl); - count = temp_dc.yh[temp_dc.x] - yl + 1; + yl = t_dc->yl[t_dc->x]; + source = &buf[t_dc->x + (yl << 3)]; + dest = R_Address(t_dc->startx + t_dc->x, yl); + count = t_dc->yh[t_dc->x] - yl + 1; while (--count >= 0) { - *dest = R_DrawFlushColumnPixel(*dest, *source); + *dest = R_DrawFlushPixel(t_dc, dest, source); source += 8; - dest += stride; + dest += stride; } } } -#define DEFINE_GETFLUSHWHOLE_FUNC(name, flags) \ - FUNCINLINE static ATTRINLINE void name(void) \ - { \ - constexpr ColumnFlushType opt = static_cast(flags); \ - R_FlushWhole(); \ - } - -DEFINE_GETFLUSHWHOLE_FUNC(R_FlushWholeOpague, FLUSH_OPAQUE) -DEFINE_GETFLUSHWHOLE_FUNC(R_FlushWholeTrans, FLUSH_TRANS) -DEFINE_GETFLUSHWHOLE_FUNC(R_FlushWholeColormap, FLUSH_COLORMAP) -DEFINE_GETFLUSHWHOLE_FUNC(R_FlushWholeColormapTrans, FLUSH_COLORMAP_TRANS) - // // R_FlushHT // @@ -96,39 +100,41 @@ static void R_FlushHT(void) INT32 count, colnum = 0; INT32 yl, yh; const INT32 stride = vid.width; + const drawcolumndata_temp_t *t_dc = &temp_dc; + UINT8 *restrict buf = t_dc->buf; while (colnum < 8) { - yl = temp_dc.yl[colnum]; - yh = temp_dc.yh[colnum]; + yl = t_dc->yl[colnum]; + yh = t_dc->yh[colnum]; // flush column head - if (yl < temp_dc.commontop) + if (yl < t_dc->commontop) { - source = &temp_dc.buf[colnum + (yl << 3)]; - dest = R_Address(temp_dc.startx + colnum, yl); - count = temp_dc.commontop - yl; + source = &buf[colnum + (yl << 3)]; + dest = R_Address(t_dc->startx + colnum, yl); + count = t_dc->commontop - yl; while (--count >= 0) { - *dest = R_DrawFlushColumnPixel(*dest, *source); + *dest = R_DrawFlushPixel(t_dc, dest, source); source += 8; - dest += stride; + dest += stride; } } // flush column tail - if (yh > temp_dc.commonbot) + if (yh > t_dc->commonbot) { - source = &temp_dc.buf[colnum + ((temp_dc.commonbot + 1) << 3)]; - dest = R_Address(temp_dc.startx + colnum, temp_dc.commonbot + 1); - count = yh - temp_dc.commonbot; + source = &buf[colnum + ((t_dc->commonbot + 1) << 3)]; + dest = R_Address(t_dc->startx + colnum, t_dc->commonbot + 1); + count = yh - t_dc->commonbot; while (--count >= 0) { - *dest = R_DrawFlushColumnPixel(*dest, *source); + *dest = R_DrawFlushPixel(t_dc, dest, source); source += 8; - dest += stride; + dest += stride; } } @@ -136,30 +142,20 @@ static void R_FlushHT(void) } } -#define DEFINE_GETFLUSHHT_FUNC(name, flags) \ - FUNCINLINE static ATTRINLINE void name(void) \ - { \ - constexpr ColumnFlushType opt = static_cast(flags); \ - R_FlushHT(); \ - } - -DEFINE_GETFLUSHHT_FUNC(R_FlushHTOpague, FLUSH_OPAQUE) -DEFINE_GETFLUSHHT_FUNC(R_FlushHTTrans, FLUSH_TRANS) -DEFINE_GETFLUSHHT_FUNC(R_FlushHTColormap, FLUSH_COLORMAP) -DEFINE_GETFLUSHHT_FUNC(R_FlushHTColormapTrans, FLUSH_COLORMAP_TRANS) - // Begin: Quad column flushing functions. template static void R_FlushQuad(void) { const INT32 stride = vid.width; - INT32 count = temp_dc.commonbot - temp_dc.commontop + 1; + const drawcolumndata_temp_t *t_dc = &temp_dc; + INT32 count = t_dc->commonbot - t_dc->commontop + 1; + const UINT8 *restrict buf = t_dc->buf; if constexpr (Type & ColumnFlushType::FLUSH_OPAQUE) { - const INT64 *source = reinterpret_cast(temp_dc.buf + (temp_dc.commontop << 3)); - INT64 *dest = reinterpret_cast(R_Address(temp_dc.startx, temp_dc.commontop)); - INT32 deststep = stride / 8; + const INT64 *source = reinterpret_cast(buf + (t_dc->commontop << 3)); + INT64 *dest = reinterpret_cast(R_Address(t_dc->startx, t_dc->commontop)); + const INT32 deststep = stride / 8; while (--count >= 0) { @@ -167,143 +163,74 @@ static void R_FlushQuad(void) dest += deststep; } } - else if constexpr (Type & ColumnFlushType::FLUSH_TRANS) + else { - const UINT8 * restrict source = temp_dc.buf + (temp_dc.commontop << 3); - UINT8 * restrict dest = R_Address(temp_dc.startx, temp_dc.commontop); - const UINT8 * restrict transmap = temp_dc.transmap; + const UINT8 * restrict source = buf + (t_dc->commontop << 3); + UINT8 * restrict dest = R_Address(t_dc->startx, t_dc->commontop); while (--count >= 0) { - // haleyjd 09/11/04: use temptranmap here - dest[0] = transmap[(source[0] << 8) + dest[0]]; - dest[1] = transmap[(source[1] << 8) + dest[1]]; - dest[2] = transmap[(source[2] << 8) + dest[2]]; - dest[3] = transmap[(source[3] << 8) + dest[3]]; - dest[4] = transmap[(source[4] << 8) + dest[4]]; - dest[5] = transmap[(source[5] << 8) + dest[5]]; - dest[6] = transmap[(source[6] << 8) + dest[6]]; - dest[7] = transmap[(source[7] << 8) + dest[7]]; + dest[0] = R_DrawFlushPixel(t_dc, &dest[0], &source[0]); + dest[1] = R_DrawFlushPixel(t_dc, &dest[1], &source[1]); + dest[2] = R_DrawFlushPixel(t_dc, &dest[2], &source[2]); + dest[3] = R_DrawFlushPixel(t_dc, &dest[3], &source[3]); + dest[4] = R_DrawFlushPixel(t_dc, &dest[4], &source[4]); + dest[5] = R_DrawFlushPixel(t_dc, &dest[5], &source[5]); + dest[6] = R_DrawFlushPixel(t_dc, &dest[6], &source[6]); + dest[7] = R_DrawFlushPixel(t_dc, &dest[7], &source[7]); source += 8; - dest += stride; - } - } - else if constexpr (Type & ColumnFlushType::FLUSH_COLORMAP) - { - const UINT8 * restrict source = temp_dc.buf + (temp_dc.commontop << 3); - UINT8 * restrict dest = R_Address(temp_dc.startx, temp_dc.commontop); - const UINT8 * restrict translation = temp_dc.translation; - - while (--count >= 0) - { - dest[0] = translation[source[0]]; - dest[1] = translation[source[1]]; - dest[2] = translation[source[2]]; - dest[3] = translation[source[3]]; - dest[4] = translation[source[4]]; - dest[5] = translation[source[5]]; - dest[6] = translation[source[6]]; - dest[7] = translation[source[7]]; - source += 8; - dest += stride; - } - } - else if constexpr (Type & ColumnFlushType::FLUSH_COLORMAP_TRANS) - { - const UINT8 * restrict source = temp_dc.buf + (temp_dc.commontop << 3); - UINT8 * restrict dest = R_Address(temp_dc.startx, temp_dc.commontop); - const UINT8 * restrict transmap = temp_dc.transmap; - const UINT8 * restrict translation = temp_dc.translation; - - while (--count >= 0) - { - // haleyjd 09/11/04: use temptranmap here - dest[0] = transmap[(translation[source[0]] << 8) + dest[0]]; - dest[1] = transmap[(translation[source[1]] << 8) + dest[1]]; - dest[2] = transmap[(translation[source[2]] << 8) + dest[2]]; - dest[3] = transmap[(translation[source[3]] << 8) + dest[3]]; - dest[4] = transmap[(translation[source[4]] << 8) + dest[4]]; - dest[5] = transmap[(translation[source[5]] << 8) + dest[5]]; - dest[6] = transmap[(translation[source[6]] << 8) + dest[6]]; - dest[7] = transmap[(translation[source[7]] << 8) + dest[7]]; - source += 8; - dest += stride; + dest += stride; } } } -#define DEFINE_GETFLUSHQUAD_FUNC(name, flags) \ - FUNCINLINE static ATTRINLINE void name(void) \ - { \ - constexpr ColumnFlushType opt = static_cast(flags); \ - R_FlushQuad(); \ - } - -DEFINE_GETFLUSHQUAD_FUNC(R_FlushQuadOpague, FLUSH_OPAQUE) -DEFINE_GETFLUSHQUAD_FUNC(R_FlushQuadTrans, FLUSH_TRANS) -DEFINE_GETFLUSHQUAD_FUNC(R_FlushQuadColormap, FLUSH_COLORMAP) -DEFINE_GETFLUSHQUAD_FUNC(R_FlushQuadColormapTrans, FLUSH_COLORMAP_TRANS) - // haleyjd 09/12/04: split up R_GetBuffer into various different // functions to minimize the number of branches and take advantage // of as much precalculated information as possible. template static UINT8 *R_GetBuffer(drawcolumndata_t *dc) { + drawcolumndata_temp_t *t_dc = &temp_dc; + // haleyjd: reordered predicates - if (temp_dc.x == 8 || - (temp_dc.x && (temp_dc.type != Type || temp_dc.x + temp_dc.startx != dc->x))) + if (t_dc->x == 8 || + (t_dc->x && (t_dc->type != Type || t_dc->x + t_dc->startx != dc->x))) R_FlushColumns(); - if (!temp_dc.x) + if (!t_dc->x) { - ++temp_dc.x; - temp_dc.startx = dc->x; - temp_dc.yl[0] = temp_dc.commontop = dc->yl; - temp_dc.yh[0] = temp_dc.commonbot = dc->yh; - temp_dc.type = Type; + ++t_dc->x; + t_dc->startx = dc->x; + t_dc->yl[0] = t_dc->commontop = dc->yl; + t_dc->yh[0] = t_dc->commonbot = dc->yh; + t_dc->type = Type; - if constexpr (Type & ColumnFlushType::FLUSH_OPAQUE) + if constexpr (Type & (ColumnFlushType::FLUSH_TRANS | ColumnFlushType::FLUSH_COLORMAP_TRANS)) { - R_FlushWholeColumns = R_FlushWholeOpague; - R_FlushHTColumns = R_FlushHTOpague; - R_FlushQuadColumn = R_FlushQuadOpague; - } - else if constexpr (Type & ColumnFlushType::FLUSH_TRANS) - { - temp_dc.transmap = dc->transmap; - R_FlushWholeColumns = R_FlushWholeTrans; - R_FlushHTColumns = R_FlushHTTrans; - R_FlushQuadColumn = R_FlushQuadTrans; - } - else if constexpr (Type & ColumnFlushType::FLUSH_COLORMAP) - { - temp_dc.translation = dc->translation; - R_FlushWholeColumns = R_FlushWholeColormap; - R_FlushHTColumns = R_FlushHTColormap; - R_FlushQuadColumn = R_FlushQuadColormap; - } - else if constexpr (Type & ColumnFlushType::FLUSH_COLORMAP_TRANS) - { - temp_dc.transmap = dc->transmap; - temp_dc.translation = dc->translation; - R_FlushWholeColumns = R_FlushWholeColormapTrans; - R_FlushHTColumns = R_FlushHTColormapTrans; - R_FlushQuadColumn = R_FlushQuadColormapTrans; + t_dc->transmap = dc->transmap; } - return &temp_dc.buf[dc->yl << 3]; + if constexpr (Type & (ColumnFlushType::FLUSH_COLORMAP | ColumnFlushType::FLUSH_COLORMAP_TRANS)) + { + t_dc->translation = dc->translation; + } + + R_FlushWholeColumns = R_FlushWhole; + R_FlushHTColumns = R_FlushHT; + R_FlushQuadColumn = R_FlushQuad; + + return &t_dc->buf[dc->yl << 3]; } - temp_dc.yl[temp_dc.x] = dc->yl; - temp_dc.yh[temp_dc.x] = dc->yh; + t_dc->yl[t_dc->x] = dc->yl; + t_dc->yh[t_dc->x] = dc->yh; - if (dc->yl > temp_dc.commontop) - temp_dc.commontop = dc->yl; - if (dc->yh < temp_dc.commonbot) - temp_dc.commonbot = dc->yh; + if (dc->yl > t_dc->commontop) + t_dc->commontop = dc->yl; + if (dc->yh < t_dc->commonbot) + t_dc->commonbot = dc->yh; - return &temp_dc.buf[(dc->yl << 3) + temp_dc.x++]; + return &t_dc->buf[(dc->yl << 3) + t_dc->x++]; } #define DEFINE_GETBUF_FUNC(name, flags) \ diff --git a/src/r_draw_span.cpp b/src/r_draw_span.cpp index cfa053382..bc18382a2 100644 --- a/src/r_draw_span.cpp +++ b/src/r_draw_span.cpp @@ -50,7 +50,8 @@ enum DrawSpanType }; template -static constexpr UINT8 R_GetSpanTranslated(drawspandata_t* ds, UINT8 col) +FUNCINLINE static ATTRINLINE constexpr UINT8 +R_GetSpanTranslated(const drawspandata_t* ds, UINT8 col) { if constexpr (Type & DrawSpanType::DS_COLORMAP) { @@ -63,7 +64,8 @@ static constexpr UINT8 R_GetSpanTranslated(drawspandata_t* ds, UINT8 col) } template -static constexpr UINT8 R_GetSpanTranslucent(drawspandata_t* ds, UINT8 *dsrc, const UINT8 *colormap, UINT8 col) +FUNCINLINE static ATTRINLINE constexpr UINT8 +R_GetSpanTranslucent(const drawspandata_t* ds, UINT8 *dsrc, const UINT8 *colormap, UINT8 col) { col = colormap[R_GetSpanTranslated(ds, col)]; @@ -78,7 +80,8 @@ static constexpr UINT8 R_GetSpanTranslucent(drawspandata_t* ds, UINT8 *dsrc, con } template -static constexpr UINT8 R_DrawSpanPixel(drawspandata_t* ds, UINT8 *dsrc, const UINT8 *colormap, UINT32 bit, const UINT8 *source) +FUNCINLINE static ATTRINLINE constexpr UINT8 +R_DrawSpanPixel(const drawspandata_t* ds, UINT8 *dsrc, const UINT8 *colormap, UINT32 bit, const UINT8 *source) { UINT8 col = source[bit]; diff --git a/src/screen.c b/src/screen.c index 735bb88c4..d67ac73eb 100644 --- a/src/screen.c +++ b/src/screen.c @@ -155,7 +155,7 @@ void SCR_SetMode(void) // our sky "plane" drawer cannot handle the buffer system due to multithreading // (that would require alot of extra complexity for smth with massive diminishing results) // Our masked drawing step draws things in a very particular order, which results in alot of flushing to screen -// effectively adding massive overhead during buffering, so we draw our masked thing directly to screen instead +// effectively adding massive overhead due to excessive flushing, so we draw our masked thing directly to screen instead void R_SetColumnContext(enum columncontext_e _columncontext) { columncontext = _columncontext;