cleanup column flusher stuff

- properly make use of templates!, reduce code dupe
- inline the "DrawPixel" stuff
- use local "const" pointers everywhere
This commit is contained in:
Alug committed 2025-10-08 16:50:17 +02:00
1 parent 0843a586f8
commit 48dc5461cd
4 files changed
+112 -179

No files matched your search

+7 -4
View File
@@ -34,7 +34,8 @@ enum DrawColumnType
};
template<DrawColumnType Type>
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<DrawColumnType Type>
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<Type>(dc, col, colormap);
@@ -61,7 +63,8 @@ static constexpr UINT8 R_GetColumnTranslucent(drawcolumndata_t* dc, UINT8 * rest
}
template<DrawColumnType Type>
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<Type>(dc, dest, col, colormap);
}
else
+98 -171
View File
@@ -18,28 +18,42 @@
/// \note no includes because this is included as part of r_draw.cpp
template<ColumnFlushType Type>
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<ColumnFlushType Type>
FUNCINLINE static ATTRINLINE constexpr UINT8
R_GetFlushPixelTranslucent(const drawcolumndata_temp_t *t_dc, UINT8 * restrict dest, UINT8 col)
{
col = R_GetFlushPixelTranslated<Type>(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<ColumnFlushType Type>
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<Type>(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<Type>(*dest, *source);
*dest = R_DrawFlushPixel<Type>(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<ColumnFlushType>(flags); \
R_FlushWhole<opt>(); \
}
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<Type>(*dest, *source);
*dest = R_DrawFlushPixel<Type>(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<Type>(*dest, *source);
*dest = R_DrawFlushPixel<Type>(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<ColumnFlushType>(flags); \
R_FlushHT<opt>(); \
}
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<ColumnFlushType Type>
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<const INT64 *>(temp_dc.buf + (temp_dc.commontop << 3));
INT64 *dest = reinterpret_cast<INT64 *>(R_Address(temp_dc.startx, temp_dc.commontop));
INT32 deststep = stride / 8;
const INT64 *source = reinterpret_cast<const INT64 *>(buf + (t_dc->commontop << 3));
INT64 *dest = reinterpret_cast<INT64 *>(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<Type>(t_dc, &dest[0], &source[0]);
dest[1] = R_DrawFlushPixel<Type>(t_dc, &dest[1], &source[1]);
dest[2] = R_DrawFlushPixel<Type>(t_dc, &dest[2], &source[2]);
dest[3] = R_DrawFlushPixel<Type>(t_dc, &dest[3], &source[3]);
dest[4] = R_DrawFlushPixel<Type>(t_dc, &dest[4], &source[4]);
dest[5] = R_DrawFlushPixel<Type>(t_dc, &dest[5], &source[5]);
dest[6] = R_DrawFlushPixel<Type>(t_dc, &dest[6], &source[6]);
dest[7] = R_DrawFlushPixel<Type>(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<ColumnFlushType>(flags); \
R_FlushQuad<opt>(); \
}
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<ColumnFlushType Type>
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<Type>;
R_FlushHTColumns = R_FlushHT<Type>;
R_FlushQuadColumn = R_FlushQuad<Type>;
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) \
+6 -3
View File
@@ -50,7 +50,8 @@ enum DrawSpanType
};
template<DrawSpanType Type>
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<DrawSpanType Type>
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<Type>(ds, col)];
@@ -78,7 +80,8 @@ static constexpr UINT8 R_GetSpanTranslucent(drawspandata_t* ds, UINT8 *dsrc, con
}
template<DrawSpanType Type>
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];
+1 -1
View File
@@ -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;