diff --git a/src/r_draw.cpp b/src/r_draw.cpp index a2bf412e8..9a79779d8 100644 --- a/src/r_draw.cpp +++ b/src/r_draw.cpp @@ -16,6 +16,7 @@ #include "r_data/colormaps.h" #include "r_plane.h" #include "r_draw.h" +#include "r_draw_rgba.h" #include "r_draw_pal.h" #include "r_thread.h" @@ -42,6 +43,9 @@ namespace swrenderer { int dc_pitch; lighttable_t *dc_colormap; + FSWColormap *dc_fcolormap; + ShadeConstants dc_shade_constants; + fixed_t dc_light; int dc_x; int dc_yl; int dc_yh; @@ -78,6 +82,8 @@ namespace swrenderer int ds_x1; int ds_x2; lighttable_t * ds_colormap; + FSWColormap *ds_fcolormap; + ShadeConstants ds_shade_constants; dsfixed_t ds_light; dsfixed_t ds_xfrac; dsfixed_t ds_yfrac; @@ -88,7 +94,9 @@ namespace swrenderer fixed_t ds_alpha; double ds_lod; const uint8_t *ds_source; + bool ds_source_mipmapped; int ds_color; + bool drawer_needs_pal_input; unsigned int dc_tspans[4][MAXHEIGHT]; unsigned int *dc_ctspan[4]; unsigned int *horizspan[4]; @@ -199,6 +207,7 @@ namespace swrenderer colfunc = transcolfunc; hcolfunc_post1 = rt_tlate1col; hcolfunc_post4 = rt_tlate4cols; + drawer_needs_pal_input = true; } return true; } @@ -249,6 +258,7 @@ namespace swrenderer colfunc = R_DrawTlatedAddColumn; hcolfunc_post1 = rt_tlateadd1col; hcolfunc_post4 = rt_tlateadd4cols; + drawer_needs_pal_input = true; } } else @@ -270,6 +280,7 @@ namespace swrenderer colfunc = R_DrawAddClampTranslatedColumn; hcolfunc_post1 = rt_tlateaddclamp1col; hcolfunc_post4 = rt_tlateaddclamp4cols; + drawer_needs_pal_input = true; } } return true; @@ -292,6 +303,7 @@ namespace swrenderer colfunc = R_DrawSubClampTranslatedColumn; hcolfunc_post1 = rt_tlatesubclamp1col; hcolfunc_post4 = rt_tlatesubclamp4cols; + drawer_needs_pal_input = true; } return true; @@ -317,6 +329,7 @@ namespace swrenderer colfunc = R_DrawRevSubClampTranslatedColumn; hcolfunc_post1 = rt_tlaterevsubclamp1col; hcolfunc_post4 = rt_tlaterevsubclamp4cols; + drawer_needs_pal_input = true; } return true; @@ -346,6 +359,8 @@ namespace swrenderer fixed_t fglevel, bglevel; + drawer_needs_pal_input = false; + style.CheckFuzz(); if (style.BlendOp == STYLEOP_Shadow) @@ -376,7 +391,10 @@ namespace swrenderer FRemapTable *table = TranslationToTable(translation); if (table != NULL && !table->Inactive) { - dc_translation = table->Remap; + if (r_swtruecolor) + dc_translation = (uint8_t*)table->Palette; + else + dc_translation = table->Remap; } } } @@ -397,13 +415,19 @@ namespace swrenderer colfunc = R_DrawShadedColumn; hcolfunc_post1 = rt_shaded1col; hcolfunc_post4 = rt_shaded4cols; - dc_color = fixedcolormap ? fixedcolormap[APART(color)] : basecolormap->Maps[APART(color)]; - dc_colormap = (basecolormap = &ShadeFakeColormap[16 - alpha])->Maps; + drawer_needs_pal_input = true; + dc_color = fixedcolormap ? fixedcolormap->Maps[APART(color)] : basecolormap->Maps[APART(color)]; + basecolormap = &ShadeFakeColormap[16 - alpha]; if (fixedlightlev >= 0 && fixedcolormap == NULL) { - dc_colormap += fixedlightlev; + R_SetColorMapLight(basecolormap, 0, FIXEDLIGHT2SHADE(fixedlightlev)); } - return r_columnmethod ? DoDraw1 : DoDraw0; + else + { + R_SetColorMapLight(basecolormap, 0, 0); + } + bool active_columnmethod = r_columnmethod && !r_swtruecolor; + return active_columnmethod ? DoDraw1 : DoDraw0; } fglevel = GetAlpha(style.SrcAlpha, alpha); @@ -429,14 +453,15 @@ namespace swrenderer // with the alpha. dc_srccolor = ((((r*x) >> 4) << 20) | ((g*x) >> 4) | ((((b)*x) >> 4) << 10)) & 0x3feffbff; hcolfunc_pre = R_FillColumnHoriz; - R_SetColorMapLight(identitycolormap.Maps, 0, 0); + R_SetColorMapLight(&identitycolormap, 0, 0); } if (!R_SetBlendFunc(style.BlendOp, fglevel, bglevel, style.Flags)) { return DontDraw; } - return r_columnmethod ? DoDraw1 : DoDraw0; + bool active_columnmethod = r_columnmethod && !r_swtruecolor; + return active_columnmethod ? DoDraw1 : DoDraw0; } ESPSResult R_SetPatchStyle(FRenderStyle style, float alpha, int translation, uint32_t color) @@ -460,7 +485,10 @@ namespace swrenderer col = width + (col % width); } - return tex->GetColumn(col, nullptr); + if (r_swtruecolor) + return (const uint8_t *)tex->GetColumnBgra(col, nullptr); + else + return tex->GetColumn(col, nullptr); } bool R_GetTransMaskDrawers(fixed_t(**tmvline1)(), void(**tmvline4)()) @@ -507,25 +535,84 @@ namespace swrenderer drawerargs::tmvlinebits = fracbits; } - void R_SetColorMapLight(lighttable_t *base_colormap, float light, int shade) + void R_SetColorMapLight(FSWColormap *base_colormap, float light, int shade) { using namespace drawerargs; - dc_colormap = base_colormap + (GETPALOOKUP(light, shade) << COLORMAPSHIFT); + dc_fcolormap = base_colormap; + if (r_swtruecolor) + { + dc_shade_constants.light_red = dc_fcolormap->Color.r * 256 / 255; + dc_shade_constants.light_green = dc_fcolormap->Color.g * 256 / 255; + dc_shade_constants.light_blue = dc_fcolormap->Color.b * 256 / 255; + dc_shade_constants.light_alpha = dc_fcolormap->Color.a * 256 / 255; + dc_shade_constants.fade_red = dc_fcolormap->Fade.r; + dc_shade_constants.fade_green = dc_fcolormap->Fade.g; + dc_shade_constants.fade_blue = dc_fcolormap->Fade.b; + dc_shade_constants.fade_alpha = dc_fcolormap->Fade.a; + dc_shade_constants.desaturate = MIN(abs(dc_fcolormap->Desaturate), 255) * 255 / 256; + dc_shade_constants.simple_shade = (dc_fcolormap->Color.d == 0x00ffffff && dc_fcolormap->Fade.d == 0x00000000 && dc_fcolormap->Desaturate == 0); + dc_colormap = base_colormap->Maps; + dc_light = LIGHTSCALE(light, shade); + } + else + { + dc_colormap = base_colormap->Maps + (GETPALOOKUP(light, shade) << COLORMAPSHIFT); + } } - void R_SetDSColorMapLight(lighttable_t *base_colormap, float light, int shade) + void R_SetDSColorMapLight(FSWColormap *base_colormap, float light, int shade) { using namespace drawerargs; - ds_colormap = base_colormap + (GETPALOOKUP(light, shade) << COLORMAPSHIFT); + ds_fcolormap = base_colormap; + if (r_swtruecolor) + { + ds_shade_constants.light_red = ds_fcolormap->Color.r * 256 / 255; + ds_shade_constants.light_green = ds_fcolormap->Color.g * 256 / 255; + ds_shade_constants.light_blue = ds_fcolormap->Color.b * 256 / 255; + ds_shade_constants.light_alpha = ds_fcolormap->Color.a * 256 / 255; + ds_shade_constants.fade_red = ds_fcolormap->Fade.r; + ds_shade_constants.fade_green = ds_fcolormap->Fade.g; + ds_shade_constants.fade_blue = ds_fcolormap->Fade.b; + ds_shade_constants.fade_alpha = ds_fcolormap->Fade.a; + ds_shade_constants.desaturate = MIN(abs(ds_fcolormap->Desaturate), 255) * 255 / 256; + ds_shade_constants.simple_shade = (ds_fcolormap->Color.d == 0x00ffffff && ds_fcolormap->Fade.d == 0x00000000 && ds_fcolormap->Desaturate == 0); + ds_colormap = base_colormap->Maps; + ds_light = LIGHTSCALE(light, shade); + } + else + { + ds_colormap = base_colormap->Maps + (GETPALOOKUP(light, shade) << COLORMAPSHIFT); + } } void R_SetTranslationMap(lighttable_t *translation) { using namespace drawerargs; - dc_colormap = translation; + if (r_swtruecolor) + { + dc_fcolormap = nullptr; + dc_colormap = nullptr; + dc_translation = translation; + dc_shade_constants.light_red = 256; + dc_shade_constants.light_green = 256; + dc_shade_constants.light_blue = 256; + dc_shade_constants.light_alpha = 256; + dc_shade_constants.fade_red = 0; + dc_shade_constants.fade_green = 0; + dc_shade_constants.fade_blue = 0; + dc_shade_constants.fade_alpha = 256; + dc_shade_constants.desaturate = 0; + dc_shade_constants.simple_shade = true; + dc_light = 0; + } + else + { + dc_fcolormap = nullptr; + dc_colormap = translation; + } } void rt_initcols(uint8_t *buffer) @@ -535,7 +622,10 @@ namespace swrenderer for (int y = 3; y >= 0; y--) horizspan[y] = dc_ctspan[y] = &dc_tspans[y][0]; - DrawerCommandQueue::QueueCommand(buffer); + if (r_swtruecolor) + DrawerCommandQueue::QueueCommand(buffer); + else + DrawerCommandQueue::QueueCommand(buffer); } void rt_span_coverage(int x, int start, int stop) @@ -727,18 +817,17 @@ namespace swrenderer } } - void R_SetSpanColormap(lighttable_t *colormap) + void R_SetSpanColormap(FDynamicColormap *colormap, int shade) { - using namespace drawerargs; - - ds_colormap = colormap; + R_SetDSColorMapLight(colormap, 0, shade); } void R_SetSpanSource(FTexture *tex) { using namespace drawerargs; - ds_source = tex->GetPixels(); + ds_source = r_swtruecolor ? (const uint8_t*)tex->GetPixelsBgra() : tex->GetPixels(); + ds_source_mipmapped = tex->Mipmapped() && tex->GetWidth() > 1 && tex->GetHeight() > 1; } ///////////////////////////////////////////////////////////////////////// @@ -756,7 +845,10 @@ namespace swrenderer (*span)[1] = dc_yh; *span += 2; - DrawerCommandQueue::QueueCommand(); + if (r_swtruecolor) + DrawerCommandQueue::QueueCommand(); + else + DrawerCommandQueue::QueueCommand(); } void R_DrawColumnHoriz() @@ -772,168 +864,301 @@ namespace swrenderer (*span)[1] = dc_yh; *span += 2; - DrawerCommandQueue::QueueCommand(); + if (r_swtruecolor) + { + if (drawer_needs_pal_input) + DrawerCommandQueue::QueueCommand>(); + else + DrawerCommandQueue::QueueCommand>(); + } + else + { + DrawerCommandQueue::QueueCommand(); + } } // Copies one span at hx to the screen at sx. void rt_copy1col(int hx, int sx, int yl, int yh) { - DrawerCommandQueue::QueueCommand(hx, sx, yl, yh); + if (r_swtruecolor) + DrawerCommandQueue::QueueCommand(hx, sx, yl, yh); + else + DrawerCommandQueue::QueueCommand(hx, sx, yl, yh); } // Copies all four spans to the screen starting at sx. void rt_copy4cols(int sx, int yl, int yh) { - DrawerCommandQueue::QueueCommand(0, sx, yl, yh); + if (r_swtruecolor) + { + // To do: we could do this with SSE using __m128i + rt_copy1col(0, sx, yl, yh); + rt_copy1col(1, sx + 1, yl, yh); + rt_copy1col(2, sx + 2, yl, yh); + rt_copy1col(3, sx + 3, yl, yh); + } + else + { + DrawerCommandQueue::QueueCommand(0, sx, yl, yh); + } } // Maps one span at hx to the screen at sx. void rt_map1col(int hx, int sx, int yl, int yh) { - DrawerCommandQueue::QueueCommand(hx, sx, yl, yh); + if (r_swtruecolor) + DrawerCommandQueue::QueueCommand(hx, sx, yl, yh); + else + DrawerCommandQueue::QueueCommand(hx, sx, yl, yh); } // Maps all four spans to the screen starting at sx. void rt_map4cols(int sx, int yl, int yh) { - DrawerCommandQueue::QueueCommand(0, sx, yl, yh); + if (r_swtruecolor) + DrawerCommandQueue::QueueCommand(0, sx, yl, yh); + else + DrawerCommandQueue::QueueCommand(0, sx, yl, yh); } // Translates one span at hx to the screen at sx. void rt_tlate1col(int hx, int sx, int yl, int yh) { - DrawerCommandQueue::QueueCommand(hx, sx, yl, yh); - rt_map1col(hx, sx, yl, yh); + if (r_swtruecolor) + { + DrawerCommandQueue::QueueCommand(hx, sx, yl, yh); + } + else + { + DrawerCommandQueue::QueueCommand(hx, sx, yl, yh); + rt_map1col(hx, sx, yl, yh); + } } // Translates all four spans to the screen starting at sx. void rt_tlate4cols(int sx, int yl, int yh) { - DrawerCommandQueue::QueueCommand(0, sx, yl, yh); - rt_map4cols(sx, yl, yh); + if (r_swtruecolor) + { + DrawerCommandQueue::QueueCommand(0, sx, yl, yh); + } + else + { + DrawerCommandQueue::QueueCommand(0, sx, yl, yh); + rt_map4cols(sx, yl, yh); + } } // Adds one span at hx to the screen at sx without clamping. void rt_add1col(int hx, int sx, int yl, int yh) { - DrawerCommandQueue::QueueCommand(hx, sx, yl, yh); + if (r_swtruecolor) + DrawerCommandQueue::QueueCommand(hx, sx, yl, yh); + else + DrawerCommandQueue::QueueCommand(hx, sx, yl, yh); } // Adds all four spans to the screen starting at sx without clamping. void rt_add4cols(int sx, int yl, int yh) { - DrawerCommandQueue::QueueCommand(0, sx, yl, yh); + if (r_swtruecolor) + DrawerCommandQueue::QueueCommand(0, sx, yl, yh); + else + DrawerCommandQueue::QueueCommand(0, sx, yl, yh); } // Translates and adds one span at hx to the screen at sx without clamping. void rt_tlateadd1col(int hx, int sx, int yl, int yh) { - DrawerCommandQueue::QueueCommand(hx, sx, yl, yh); - rt_add1col(hx, sx, yl, yh); + if (r_swtruecolor) + { + DrawerCommandQueue::QueueCommand(hx, sx, yl, yh); + } + else + { + DrawerCommandQueue::QueueCommand(hx, sx, yl, yh); + rt_add1col(hx, sx, yl, yh); + } } // Translates and adds all four spans to the screen starting at sx without clamping. void rt_tlateadd4cols(int sx, int yl, int yh) { - DrawerCommandQueue::QueueCommand(0, sx, yl, yh); - rt_add4cols(sx, yl, yh); + if (r_swtruecolor) + { + DrawerCommandQueue::QueueCommand(0, sx, yl, yh); + } + else + { + DrawerCommandQueue::QueueCommand(0, sx, yl, yh); + rt_add4cols(sx, yl, yh); + } } // Shades one span at hx to the screen at sx. void rt_shaded1col(int hx, int sx, int yl, int yh) { - DrawerCommandQueue::QueueCommand(hx, sx, yl, yh); + if (r_swtruecolor) + DrawerCommandQueue::QueueCommand(hx, sx, yl, yh); + else + DrawerCommandQueue::QueueCommand(hx, sx, yl, yh); } // Shades all four spans to the screen starting at sx. void rt_shaded4cols(int sx, int yl, int yh) { - DrawerCommandQueue::QueueCommand(0, sx, yl, yh); + if (r_swtruecolor) + DrawerCommandQueue::QueueCommand(0, sx, yl, yh); + else + DrawerCommandQueue::QueueCommand(0, sx, yl, yh); } // Adds one span at hx to the screen at sx with clamping. void rt_addclamp1col(int hx, int sx, int yl, int yh) { - DrawerCommandQueue::QueueCommand(hx, sx, yl, yh); + if (r_swtruecolor) + DrawerCommandQueue::QueueCommand(hx, sx, yl, yh); + else + DrawerCommandQueue::QueueCommand(hx, sx, yl, yh); } // Adds all four spans to the screen starting at sx with clamping. void rt_addclamp4cols(int sx, int yl, int yh) { - DrawerCommandQueue::QueueCommand(0, sx, yl, yh); + if (r_swtruecolor) + DrawerCommandQueue::QueueCommand(0, sx, yl, yh); + else + DrawerCommandQueue::QueueCommand(0, sx, yl, yh); } // Translates and adds one span at hx to the screen at sx with clamping. void rt_tlateaddclamp1col(int hx, int sx, int yl, int yh) { - DrawerCommandQueue::QueueCommand(hx, sx, yl, yh); - rt_addclamp1col(hx, sx, yl, yh); + if (r_swtruecolor) + { + DrawerCommandQueue::QueueCommand(hx, sx, yl, yh); + } + else + { + DrawerCommandQueue::QueueCommand(hx, sx, yl, yh); + rt_addclamp1col(hx, sx, yl, yh); + } } // Translates and adds all four spans to the screen starting at sx with clamping. void rt_tlateaddclamp4cols(int sx, int yl, int yh) { - DrawerCommandQueue::QueueCommand(0, sx, yl, yh); - rt_addclamp4cols(sx, yl, yh); + if (r_swtruecolor) + { + DrawerCommandQueue::QueueCommand(0, sx, yl, yh); + } + else + { + DrawerCommandQueue::QueueCommand(0, sx, yl, yh); + rt_addclamp4cols(sx, yl, yh); + } } // Subtracts one span at hx to the screen at sx with clamping. void rt_subclamp1col(int hx, int sx, int yl, int yh) { - DrawerCommandQueue::QueueCommand(hx, sx, yl, yh); + if (r_swtruecolor) + DrawerCommandQueue::QueueCommand(hx, sx, yl, yh); + else + DrawerCommandQueue::QueueCommand(hx, sx, yl, yh); } // Subtracts all four spans to the screen starting at sx with clamping. void rt_subclamp4cols(int sx, int yl, int yh) { - DrawerCommandQueue::QueueCommand(0, sx, yl, yh); + if (r_swtruecolor) + DrawerCommandQueue::QueueCommand(0, sx, yl, yh); + else + DrawerCommandQueue::QueueCommand(0, sx, yl, yh); } // Translates and subtracts one span at hx to the screen at sx with clamping. void rt_tlatesubclamp1col(int hx, int sx, int yl, int yh) { - DrawerCommandQueue::QueueCommand(hx, sx, yl, yh); - rt_subclamp1col(hx, sx, yl, yh); + if (r_swtruecolor) + { + DrawerCommandQueue::QueueCommand(hx, sx, yl, yh); + } + else + { + DrawerCommandQueue::QueueCommand(hx, sx, yl, yh); + rt_subclamp1col(hx, sx, yl, yh); + } } // Translates and subtracts all four spans to the screen starting at sx with clamping. void rt_tlatesubclamp4cols(int sx, int yl, int yh) { - DrawerCommandQueue::QueueCommand(0, sx, yl, yh); - rt_subclamp4cols(sx, yl, yh); + if (r_swtruecolor) + { + DrawerCommandQueue::QueueCommand(0, sx, yl, yh); + } + else + { + DrawerCommandQueue::QueueCommand(0, sx, yl, yh); + rt_subclamp4cols(sx, yl, yh); + } } // Subtracts one span at hx from the screen at sx with clamping. void rt_revsubclamp1col(int hx, int sx, int yl, int yh) { - DrawerCommandQueue::QueueCommand(hx, sx, yl, yh); + if (r_swtruecolor) + DrawerCommandQueue::QueueCommand(hx, sx, yl, yh); + else + DrawerCommandQueue::QueueCommand(hx, sx, yl, yh); } // Subtracts all four spans from the screen starting at sx with clamping. void rt_revsubclamp4cols(int sx, int yl, int yh) { - DrawerCommandQueue::QueueCommand(0, sx, yl, yh); + if (r_swtruecolor) + DrawerCommandQueue::QueueCommand(0, sx, yl, yh); + else + DrawerCommandQueue::QueueCommand(0, sx, yl, yh); } // Translates and subtracts one span at hx from the screen at sx with clamping. void rt_tlaterevsubclamp1col(int hx, int sx, int yl, int yh) { - DrawerCommandQueue::QueueCommand(hx, sx, yl, yh); - rt_revsubclamp1col(hx, sx, yl, yh); + if (r_swtruecolor) + { + DrawerCommandQueue::QueueCommand(hx, sx, yl, yh); + } + else + { + DrawerCommandQueue::QueueCommand(hx, sx, yl, yh); + rt_revsubclamp1col(hx, sx, yl, yh); + } } // Translates and subtracts all four spans from the screen starting at sx with clamping. void rt_tlaterevsubclamp4cols(int sx, int yl, int yh) { - DrawerCommandQueue::QueueCommand(0, sx, yl, yh); - rt_revsubclamp4cols(sx, yl, yh); + if (r_swtruecolor) + { + DrawerCommandQueue::QueueCommand(0, sx, yl, yh); + } + else + { + DrawerCommandQueue::QueueCommand(0, sx, yl, yh); + rt_revsubclamp4cols(sx, yl, yh); + } } uint32_t vlinec1() { using namespace drawerargs; - DrawerCommandQueue::QueueCommand(); + if (r_swtruecolor) + DrawerCommandQueue::QueueCommand(); + else + DrawerCommandQueue::QueueCommand(); return dc_texturefrac + dc_count * dc_iscale; } @@ -942,7 +1167,10 @@ namespace swrenderer { using namespace drawerargs; - DrawerCommandQueue::QueueCommand(); + if (r_swtruecolor) + DrawerCommandQueue::QueueCommand(); + else + DrawerCommandQueue::QueueCommand(); for (int i = 0; i < 4; i++) vplce[i] += vince[i] * dc_count; @@ -952,7 +1180,10 @@ namespace swrenderer { using namespace drawerargs; - DrawerCommandQueue::QueueCommand(); + if (r_swtruecolor) + DrawerCommandQueue::QueueCommand(); + else + DrawerCommandQueue::QueueCommand(); return dc_texturefrac + dc_count * dc_iscale; } @@ -961,7 +1192,10 @@ namespace swrenderer { using namespace drawerargs; - DrawerCommandQueue::QueueCommand(); + if (r_swtruecolor) + DrawerCommandQueue::QueueCommand(); + else + DrawerCommandQueue::QueueCommand(); for (int i = 0; i < 4; i++) vplce[i] += vince[i] * dc_count; @@ -971,7 +1205,10 @@ namespace swrenderer { using namespace drawerargs; - DrawerCommandQueue::QueueCommand(); + if (r_swtruecolor) + DrawerCommandQueue::QueueCommand(); + else + DrawerCommandQueue::QueueCommand(); return dc_texturefrac + dc_count * dc_iscale; } @@ -980,7 +1217,10 @@ namespace swrenderer { using namespace drawerargs; - DrawerCommandQueue::QueueCommand(); + if (r_swtruecolor) + DrawerCommandQueue::QueueCommand(); + else + DrawerCommandQueue::QueueCommand(); for (int i = 0; i < 4; i++) vplce[i] += vince[i] * dc_count; @@ -990,7 +1230,10 @@ namespace swrenderer { using namespace drawerargs; - DrawerCommandQueue::QueueCommand(); + if (r_swtruecolor) + DrawerCommandQueue::QueueCommand(); + else + DrawerCommandQueue::QueueCommand(); return dc_texturefrac + dc_count * dc_iscale; } @@ -999,7 +1242,10 @@ namespace swrenderer { using namespace drawerargs; - DrawerCommandQueue::QueueCommand(); + if (r_swtruecolor) + DrawerCommandQueue::QueueCommand(); + else + DrawerCommandQueue::QueueCommand(); for (int i = 0; i < 4; i++) vplce[i] += vince[i] * dc_count; @@ -1009,7 +1255,10 @@ namespace swrenderer { using namespace drawerargs; - DrawerCommandQueue::QueueCommand(); + if (r_swtruecolor) + DrawerCommandQueue::QueueCommand(); + else + DrawerCommandQueue::QueueCommand(); return dc_texturefrac + dc_count * dc_iscale; } @@ -1018,7 +1267,10 @@ namespace swrenderer { using namespace drawerargs; - DrawerCommandQueue::QueueCommand(); + if (r_swtruecolor) + DrawerCommandQueue::QueueCommand(); + else + DrawerCommandQueue::QueueCommand(); for (int i = 0; i < 4; i++) vplce[i] += vince[i] * dc_count; @@ -1028,7 +1280,10 @@ namespace swrenderer { using namespace drawerargs; - DrawerCommandQueue::QueueCommand(); + if (r_swtruecolor) + DrawerCommandQueue::QueueCommand(); + else + DrawerCommandQueue::QueueCommand(); return dc_texturefrac + dc_count * dc_iscale; } @@ -1037,7 +1292,10 @@ namespace swrenderer { using namespace drawerargs; - DrawerCommandQueue::QueueCommand(); + if (r_swtruecolor) + DrawerCommandQueue::QueueCommand(); + else + DrawerCommandQueue::QueueCommand(); for (int i = 0; i < 4; i++) vplce[i] += vince[i] * dc_count; @@ -1045,59 +1303,92 @@ namespace swrenderer void R_DrawSingleSkyCol1(uint32_t solid_top, uint32_t solid_bottom) { - DrawerCommandQueue::QueueCommand(solid_top, solid_bottom); + if (r_swtruecolor) + DrawerCommandQueue::QueueCommand(solid_top, solid_bottom); + else + DrawerCommandQueue::QueueCommand(solid_top, solid_bottom); } void R_DrawSingleSkyCol4(uint32_t solid_top, uint32_t solid_bottom) { - DrawerCommandQueue::QueueCommand(solid_top, solid_bottom); + if (r_swtruecolor) + DrawerCommandQueue::QueueCommand(solid_top, solid_bottom); + else + DrawerCommandQueue::QueueCommand(solid_top, solid_bottom); } void R_DrawDoubleSkyCol1(uint32_t solid_top, uint32_t solid_bottom) { - DrawerCommandQueue::QueueCommand(solid_top, solid_bottom); + if (r_swtruecolor) + DrawerCommandQueue::QueueCommand(solid_top, solid_bottom); + else + DrawerCommandQueue::QueueCommand(solid_top, solid_bottom); } void R_DrawDoubleSkyCol4(uint32_t solid_top, uint32_t solid_bottom) { - DrawerCommandQueue::QueueCommand(solid_top, solid_bottom); + if (r_swtruecolor) + DrawerCommandQueue::QueueCommand(solid_top, solid_bottom); + else + DrawerCommandQueue::QueueCommand(solid_top, solid_bottom); } void R_DrawColumn() { - DrawerCommandQueue::QueueCommand(); + if (r_swtruecolor) + DrawerCommandQueue::QueueCommand(); + else + DrawerCommandQueue::QueueCommand(); } void R_FillColumn() { - DrawerCommandQueue::QueueCommand(); + if (r_swtruecolor) + DrawerCommandQueue::QueueCommand(); + else + DrawerCommandQueue::QueueCommand(); } void R_FillAddColumn() { - DrawerCommandQueue::QueueCommand(); + if (r_swtruecolor) + DrawerCommandQueue::QueueCommand(); + else + DrawerCommandQueue::QueueCommand(); } void R_FillAddClampColumn() { - DrawerCommandQueue::QueueCommand(); + if (r_swtruecolor) + DrawerCommandQueue::QueueCommand(); + else + DrawerCommandQueue::QueueCommand(); } void R_FillSubClampColumn() { - DrawerCommandQueue::QueueCommand(); + if (r_swtruecolor) + DrawerCommandQueue::QueueCommand(); + else + DrawerCommandQueue::QueueCommand(); } void R_FillRevSubClampColumn() { - DrawerCommandQueue::QueueCommand(); + if (r_swtruecolor) + DrawerCommandQueue::QueueCommand(); + else + DrawerCommandQueue::QueueCommand(); } void R_DrawFuzzColumn() { using namespace drawerargs; - DrawerCommandQueue::QueueCommand(); + if (r_swtruecolor) + DrawerCommandQueue::QueueCommand(); + else + DrawerCommandQueue::QueueCommand(); dc_yl = MAX(dc_yl, 1); dc_yh = MIN(dc_yh, fuzzviewheight); @@ -1107,112 +1398,185 @@ namespace swrenderer void R_DrawAddColumn() { - DrawerCommandQueue::QueueCommand(); + if (r_swtruecolor) + DrawerCommandQueue::QueueCommand(); + else + DrawerCommandQueue::QueueCommand(); } void R_DrawTranslatedColumn() { - DrawerCommandQueue::QueueCommand(); + if (r_swtruecolor) + DrawerCommandQueue::QueueCommand(); + else + DrawerCommandQueue::QueueCommand(); } void R_DrawTlatedAddColumn() { - DrawerCommandQueue::QueueCommand(); + if (r_swtruecolor) + DrawerCommandQueue::QueueCommand(); + else + DrawerCommandQueue::QueueCommand(); } void R_DrawShadedColumn() { - DrawerCommandQueue::QueueCommand(); + if (r_swtruecolor) + DrawerCommandQueue::QueueCommand(); + else + DrawerCommandQueue::QueueCommand(); } void R_DrawAddClampColumn() { - DrawerCommandQueue::QueueCommand(); + if (r_swtruecolor) + DrawerCommandQueue::QueueCommand(); + else + DrawerCommandQueue::QueueCommand(); } void R_DrawAddClampTranslatedColumn() { - DrawerCommandQueue::QueueCommand(); + if (r_swtruecolor) + DrawerCommandQueue::QueueCommand(); + else + DrawerCommandQueue::QueueCommand(); } void R_DrawSubClampColumn() { - DrawerCommandQueue::QueueCommand(); + if (r_swtruecolor) + DrawerCommandQueue::QueueCommand(); + else + DrawerCommandQueue::QueueCommand(); } void R_DrawSubClampTranslatedColumn() { - DrawerCommandQueue::QueueCommand(); + if (r_swtruecolor) + DrawerCommandQueue::QueueCommand(); + else + DrawerCommandQueue::QueueCommand(); } void R_DrawRevSubClampColumn() { - DrawerCommandQueue::QueueCommand(); + if (r_swtruecolor) + DrawerCommandQueue::QueueCommand(); + else + DrawerCommandQueue::QueueCommand(); } void R_DrawRevSubClampTranslatedColumn() { - DrawerCommandQueue::QueueCommand(); + if (r_swtruecolor) + DrawerCommandQueue::QueueCommand(); + else + DrawerCommandQueue::QueueCommand(); } void R_DrawSpan() { - DrawerCommandQueue::QueueCommand(); + if (r_swtruecolor) + DrawerCommandQueue::QueueCommand(); + else + DrawerCommandQueue::QueueCommand(); } void R_DrawSpanMasked() { - DrawerCommandQueue::QueueCommand(); + if (r_swtruecolor) + DrawerCommandQueue::QueueCommand(); + else + DrawerCommandQueue::QueueCommand(); } void R_DrawSpanTranslucent() { - DrawerCommandQueue::QueueCommand(); + if (r_swtruecolor) + DrawerCommandQueue::QueueCommand(); + else + DrawerCommandQueue::QueueCommand(); } void R_DrawSpanMaskedTranslucent() { - DrawerCommandQueue::QueueCommand(); + if (r_swtruecolor) + DrawerCommandQueue::QueueCommand(); + else + DrawerCommandQueue::QueueCommand(); } void R_DrawSpanAddClamp() { - DrawerCommandQueue::QueueCommand(); + if (r_swtruecolor) + DrawerCommandQueue::QueueCommand(); + else + DrawerCommandQueue::QueueCommand(); } void R_DrawSpanMaskedAddClamp() { - DrawerCommandQueue::QueueCommand(); + if (r_swtruecolor) + DrawerCommandQueue::QueueCommand(); + else + DrawerCommandQueue::QueueCommand(); } void R_FillSpan() { - DrawerCommandQueue::QueueCommand(); + if (r_swtruecolor) + DrawerCommandQueue::QueueCommand(); + else + DrawerCommandQueue::QueueCommand(); } void R_DrawTiltedSpan(int y, int x1, int x2, const FVector3 &plane_sz, const FVector3 &plane_su, const FVector3 &plane_sv, bool plane_shade, int planeshade, float planelightfloat, fixed_t pviewx, fixed_t pviewy) { - DrawerCommandQueue::QueueCommand(y, x1, x2, plane_sz, plane_su, plane_sv, plane_shade, planeshade, planelightfloat, pviewx, pviewy); + if (r_swtruecolor) + DrawerCommandQueue::QueueCommand(y, x1, x2, plane_sz, plane_su, plane_sv, plane_shade, planeshade, planelightfloat, pviewx, pviewy); + else + DrawerCommandQueue::QueueCommand(y, x1, x2, plane_sz, plane_su, plane_sv, plane_shade, planeshade, planelightfloat, pviewx, pviewy); } void R_DrawColoredSpan(int y, int x1, int x2) { - DrawerCommandQueue::QueueCommand(y, x1, x2); + if (r_swtruecolor) + DrawerCommandQueue::QueueCommand(y, x1, x2); + else + DrawerCommandQueue::QueueCommand(y, x1, x2); } namespace { - const uint8_t *slab_colormap; + ShadeConstants slab_rgba_shade_constants; + const uint8_t *slab_rgba_colormap; + fixed_t slab_rgba_light; } - void R_SetupDrawSlab(uint8_t *colormap) + void R_SetupDrawSlab(FSWColormap *base_colormap, float light, int shade) { - slab_colormap = colormap; + slab_rgba_shade_constants.light_red = base_colormap->Color.r * 256 / 255; + slab_rgba_shade_constants.light_green = base_colormap->Color.g * 256 / 255; + slab_rgba_shade_constants.light_blue = base_colormap->Color.b * 256 / 255; + slab_rgba_shade_constants.light_alpha = base_colormap->Color.a * 256 / 255; + slab_rgba_shade_constants.fade_red = base_colormap->Fade.r; + slab_rgba_shade_constants.fade_green = base_colormap->Fade.g; + slab_rgba_shade_constants.fade_blue = base_colormap->Fade.b; + slab_rgba_shade_constants.fade_alpha = base_colormap->Fade.a; + slab_rgba_shade_constants.desaturate = MIN(abs(base_colormap->Desaturate), 255) * 255 / 256; + slab_rgba_shade_constants.simple_shade = (base_colormap->Color.d == 0x00ffffff && base_colormap->Fade.d == 0x00000000 && base_colormap->Desaturate == 0); + slab_rgba_colormap = base_colormap->Maps; + slab_rgba_light = LIGHTSCALE(light, shade); } void R_DrawSlab(int dx, fixed_t v, int dy, fixed_t vi, const uint8_t *vptr, uint8_t *p) { - DrawerCommandQueue::QueueCommand(dx, v, dy, vi, vptr, p, slab_colormap); + if (r_swtruecolor) + DrawerCommandQueue::QueueCommand(dx, v, dy, vi, vptr, p, slab_rgba_shade_constants, slab_rgba_colormap, slab_rgba_light); + else + DrawerCommandQueue::QueueCommand(dx, v, dy, vi, vptr, p, slab_rgba_colormap); } void R_DrawFogBoundarySection(int y, int y2, int x1) @@ -1220,7 +1584,10 @@ namespace swrenderer for (; y < y2; ++y) { int x2 = spanend[y]; - DrawerCommandQueue::QueueCommand(y, x1, x2); + if (r_swtruecolor) + DrawerCommandQueue::QueueCommand(y, x1, x2); + else + DrawerCommandQueue::QueueCommand(y, x1, x2); } } @@ -1244,7 +1611,7 @@ namespace swrenderer clearbufshort(spanend + t2, b2 - t2, x); } - R_SetColorMapLight(basecolormap->Maps, (float)light, wallshade); + R_SetColorMapLight(basecolormap, (float)light, wallshade); uint8_t *fake_dc_colormap = basecolormap->Maps + (GETPALOOKUP(light, wallshade) << COLORMAPSHIFT); @@ -1271,7 +1638,7 @@ namespace swrenderer clearbufshort(spanend + t2, b2 - t2, x); } rcolormap = lcolormap; - R_SetColorMapLight(basecolormap->Maps, (float)light, wallshade); + R_SetColorMapLight(basecolormap, (float)light, wallshade); fake_dc_colormap = basecolormap->Maps + (GETPALOOKUP(light, wallshade) << COLORMAPSHIFT); } else @@ -1282,13 +1649,19 @@ namespace swrenderer while (t2 < stop) { int y = t2++; - DrawerCommandQueue::QueueCommand(y, xr, spanend[y]); + if (r_swtruecolor) + DrawerCommandQueue::QueueCommand(y, xr, spanend[y]); + else + DrawerCommandQueue::QueueCommand(y, xr, spanend[y]); } stop = MAX(b1, t2); while (b2 > stop) { int y = --b2; - DrawerCommandQueue::QueueCommand(y, xr, spanend[y]); + if (r_swtruecolor) + DrawerCommandQueue::QueueCommand(y, xr, spanend[y]); + else + DrawerCommandQueue::QueueCommand(y, xr, spanend[y]); } } else @@ -1320,6 +1693,9 @@ namespace swrenderer void R_DrawParticle(vissprite_t *sprite) { - R_DrawParticle_C(sprite); + if (r_swtruecolor) + R_DrawParticle_rgba(sprite); + else + R_DrawParticle_C(sprite); } } diff --git a/src/r_draw.h b/src/r_draw.h index 40b332896..8c1af58fc 100644 --- a/src/r_draw.h +++ b/src/r_draw.h @@ -3,7 +3,13 @@ #include "r_defs.h" +struct FSWColormap; + EXTERN_CVAR(Bool, r_multithreaded); +EXTERN_CVAR(Bool, r_magfilter); +EXTERN_CVAR(Bool, r_minfilter); +EXTERN_CVAR(Bool, r_mipmap); +EXTERN_CVAR(Float, r_lod_bias); EXTERN_CVAR(Int, r_drawfuzz); EXTERN_CVAR(Bool, r_drawtrans); EXTERN_CVAR(Float, transsouls); @@ -13,12 +19,29 @@ namespace swrenderer { struct vissprite_t; + struct ShadeConstants + { + uint16_t light_alpha; + uint16_t light_red; + uint16_t light_green; + uint16_t light_blue; + uint16_t fade_alpha; + uint16_t fade_red; + uint16_t fade_green; + uint16_t fade_blue; + uint16_t desaturate; + bool simple_shade; + }; + extern double dc_texturemid; namespace drawerargs { extern int dc_pitch; extern lighttable_t *dc_colormap; + extern FSWColormap *dc_fcolormap; + extern ShadeConstants dc_shade_constants; + extern fixed_t dc_light; extern int dc_x; extern int dc_yl; extern int dc_yh; @@ -41,6 +64,8 @@ namespace swrenderer extern int dc_destheight; extern int dc_count; + extern bool drawer_needs_pal_input; + extern uint32_t vplce[4]; extern uint32_t vince[4]; extern uint8_t *palookupoffse[4]; @@ -57,6 +82,8 @@ namespace swrenderer extern int ds_x1; extern int ds_x2; extern lighttable_t * ds_colormap; + extern FSWColormap *ds_fcolormap; + extern ShadeConstants ds_shade_constants; extern dsfixed_t ds_light; extern dsfixed_t ds_xfrac; extern dsfixed_t ds_yfrac; @@ -67,6 +94,7 @@ namespace swrenderer extern fixed_t ds_alpha; extern double ds_lod; extern const uint8_t *ds_source; + extern bool ds_source_mipmapped; extern int ds_color; extern unsigned int dc_tspans[4][MAXHEIGHT]; @@ -86,6 +114,8 @@ namespace swrenderer extern int fuzzpos; extern int fuzzviewheight; + extern bool r_swtruecolor; + void R_InitColumnDrawers(); void R_InitShadeMaps(); void R_InitFuzzTable(int fuzzoff); @@ -162,7 +192,7 @@ namespace swrenderer void R_FillSpan(); void R_DrawTiltedSpan(int y, int x1, int x2, const FVector3 &plane_sz, const FVector3 &plane_su, const FVector3 &plane_sv, bool plane_shade, int planeshade, float planelightfloat, fixed_t pviewx, fixed_t pviewy); void R_DrawColoredSpan(int y, int x1, int x2); - void R_SetupDrawSlab(uint8_t *colormap); + void R_SetupDrawSlab(FSWColormap *base_colormap, float light, int shade); void R_DrawSlab(int dx, fixed_t v, int dy, fixed_t vi, const uint8_t *vptr, uint8_t *p); void R_DrawFogBoundary(int x1, int x2, short *uclip, short *dclip); uint32_t vlinec1(); @@ -194,12 +224,13 @@ namespace swrenderer void R_DrawDoubleSkyCol1(uint32_t solid_top, uint32_t solid_bottom); void R_DrawDoubleSkyCol4(uint32_t solid_top, uint32_t solid_bottom); - void R_SetColorMapLight(lighttable_t *base_colormap, float light, int shade); - void R_SetDSColorMapLight(lighttable_t *base_colormap, float light, int shade); + // Sets dc_colormap and dc_light to their appropriate values depending on the output format (pal vs true color) + void R_SetColorMapLight(FSWColormap *base_colormap, float light, int shade); + void R_SetDSColorMapLight(FSWColormap *base_colormap, float light, int shade); void R_SetTranslationMap(lighttable_t *translation); void R_SetupSpanBits(FTexture *tex); - void R_SetSpanColormap(lighttable_t *colormap); + void R_SetSpanColormap(FDynamicColormap *colormap, int shade); void R_SetSpanSource(FTexture *tex); void R_MapTiltedPlane(int y, int x1); diff --git a/src/r_draw_tc.cpp b/src/r_draw_tc.cpp deleted file mode 100644 index ec9129a89..000000000 --- a/src/r_draw_tc.cpp +++ /dev/null @@ -1,1701 +0,0 @@ - -#include - -#include "templates.h" -#include "doomdef.h" -#include "i_system.h" -#include "w_wad.h" -#include "r_local.h" -#include "v_video.h" -#include "doomstat.h" -#include "st_stuff.h" -#include "g_game.h" -#include "g_level.h" -#include "r_data/r_translate.h" -#include "v_palette.h" -#include "r_data/colormaps.h" -#include "r_plane.h" -#include "r_draw_tc.h" -#include "r_draw_rgba.h" -#include "r_draw_pal.h" -#include "r_thread.h" - -namespace swrenderer -{ - // Needed by R_DrawFogBoundary (which probably shouldn't be part of this file) - extern "C" short spanend[MAXHEIGHT]; - extern float rw_light; - extern float rw_lightstep; - extern int wallshade; - - double dc_texturemid; - - int ylookup[MAXHEIGHT]; - uint8_t shadetables[NUMCOLORMAPS * 16 * 256]; - FDynamicColormap ShadeFakeColormap[16]; - uint8_t identitymap[256]; - FDynamicColormap identitycolormap; - int fuzzoffset[FUZZTABLE + 1]; - int fuzzpos; - int fuzzviewheight; - - namespace drawerargs - { - int dc_pitch; - lighttable_t *dc_colormap; - FSWColormap *dc_fcolormap; - ShadeConstants dc_shade_constants; - fixed_t dc_light; - int dc_x; - int dc_yl; - int dc_yh; - fixed_t dc_iscale; - fixed_t dc_texturefrac; - uint32_t dc_textureheight; - int dc_color; - uint32_t dc_srccolor; - uint32_t dc_srccolor_bgra; - uint32_t *dc_srcblend; - uint32_t *dc_destblend; - fixed_t dc_srcalpha; - fixed_t dc_destalpha; - const uint8_t *dc_source; - const uint8_t *dc_source2; - uint32_t dc_texturefracx; - uint8_t *dc_translation; - uint8_t *dc_dest; - uint8_t *dc_destorg; - int dc_destheight; - int dc_count; - uint32_t vplce[4]; - uint32_t vince[4]; - uint8_t *palookupoffse[4]; - fixed_t palookuplight[4]; - const uint8_t *bufplce[4]; - const uint8_t *bufplce2[4]; - uint32_t buftexturefracx[4]; - uint32_t bufheight[4]; - int vlinebits; - int mvlinebits; - int tmvlinebits; - int ds_y; - int ds_x1; - int ds_x2; - lighttable_t * ds_colormap; - FSWColormap *ds_fcolormap; - ShadeConstants ds_shade_constants; - dsfixed_t ds_light; - dsfixed_t ds_xfrac; - dsfixed_t ds_yfrac; - dsfixed_t ds_xstep; - dsfixed_t ds_ystep; - int ds_xbits; - int ds_ybits; - fixed_t ds_alpha; - double ds_lod; - const uint8_t *ds_source; - bool ds_source_mipmapped; - int ds_color; - bool drawer_needs_pal_input; - unsigned int dc_tspans[4][MAXHEIGHT]; - unsigned int *dc_ctspan[4]; - unsigned int *horizspan[4]; - } - - void R_InitColumnDrawers() - { - colfunc = basecolfunc = R_DrawColumn; - fuzzcolfunc = R_DrawFuzzColumn; - transcolfunc = R_DrawTranslatedColumn; - spanfunc = R_DrawSpan; - hcolfunc_pre = R_DrawColumnHoriz; - hcolfunc_post1 = rt_map1col; - hcolfunc_post4 = rt_map4cols; - } - - void R_InitShadeMaps() - { - int i, j; - // set up shading tables for shaded columns - // 16 colormap sets, progressing from full alpha to minimum visible alpha - - uint8_t *table = shadetables; - - // Full alpha - for (i = 0; i < 16; ++i) - { - ShadeFakeColormap[i].Color = ~0u; - ShadeFakeColormap[i].Desaturate = ~0u; - ShadeFakeColormap[i].Next = NULL; - ShadeFakeColormap[i].Maps = table; - - for (j = 0; j < NUMCOLORMAPS; ++j) - { - int a = (NUMCOLORMAPS - j) * 256 / NUMCOLORMAPS * (16 - i); - for (int k = 0; k < 256; ++k) - { - uint8_t v = (((k + 2) * a) + 256) >> 14; - table[k] = MIN(v, 64); - } - table += 256; - } - } - for (i = 0; i < NUMCOLORMAPS * 16 * 256; ++i) - { - assert(shadetables[i] <= 64); - } - - // Set up a guaranteed identity map - for (i = 0; i < 256; ++i) - { - identitymap[i] = i; - } - } - - void R_InitFuzzTable(int fuzzoff) - { - /* - FUZZOFF,-FUZZOFF,FUZZOFF,-FUZZOFF,FUZZOFF,FUZZOFF,-FUZZOFF, - FUZZOFF,FUZZOFF,-FUZZOFF,FUZZOFF,FUZZOFF,FUZZOFF,-FUZZOFF, - FUZZOFF,FUZZOFF,FUZZOFF,-FUZZOFF,-FUZZOFF,-FUZZOFF,-FUZZOFF, - FUZZOFF,-FUZZOFF,-FUZZOFF,FUZZOFF,FUZZOFF,FUZZOFF,FUZZOFF,-FUZZOFF, - FUZZOFF,-FUZZOFF,FUZZOFF,FUZZOFF,-FUZZOFF,-FUZZOFF,FUZZOFF, - FUZZOFF,-FUZZOFF,-FUZZOFF,-FUZZOFF,-FUZZOFF,FUZZOFF,FUZZOFF, - FUZZOFF,FUZZOFF,-FUZZOFF,FUZZOFF,FUZZOFF,-FUZZOFF,FUZZOFF - */ - - static const int8_t fuzzinit[FUZZTABLE] = { - 1,-1, 1,-1, 1, 1,-1, - 1, 1,-1, 1, 1, 1,-1, - 1, 1, 1,-1,-1,-1,-1, - 1,-1,-1, 1, 1, 1, 1,-1, - 1,-1, 1, 1,-1,-1, 1, - 1,-1,-1,-1,-1, 1, 1, - 1, 1,-1, 1, 1,-1, 1 - }; - - for (int i = 0; i < FUZZTABLE; i++) - { - fuzzoffset[i] = fuzzinit[i] * fuzzoff; - } - } - - namespace - { - bool R_SetBlendFunc(int op, fixed_t fglevel, fixed_t bglevel, int flags) - { - using namespace drawerargs; - - // r_drawtrans is a seriously bad thing to turn off. I wonder if I should - // just remove it completely. - if (!r_drawtrans || (op == STYLEOP_Add && fglevel == FRACUNIT && bglevel == 0 && !(flags & STYLEF_InvertSource))) - { - if (flags & STYLEF_ColorIsFixed) - { - colfunc = R_FillColumn; - hcolfunc_post1 = rt_copy1col; - hcolfunc_post4 = rt_copy4cols; - } - else if (dc_translation == NULL) - { - colfunc = basecolfunc; - hcolfunc_post1 = rt_map1col; - hcolfunc_post4 = rt_map4cols; - } - else - { - colfunc = transcolfunc; - hcolfunc_post1 = rt_tlate1col; - hcolfunc_post4 = rt_tlate4cols; - drawer_needs_pal_input = true; - } - return true; - } - if (flags & STYLEF_InvertSource) - { - dc_srcblend = Col2RGB8_Inverse[fglevel >> 10]; - dc_destblend = Col2RGB8_LessPrecision[bglevel >> 10]; - dc_srcalpha = fglevel; - dc_destalpha = bglevel; - } - else if (op == STYLEOP_Add && fglevel + bglevel <= FRACUNIT) - { - dc_srcblend = Col2RGB8[fglevel >> 10]; - dc_destblend = Col2RGB8[bglevel >> 10]; - dc_srcalpha = fglevel; - dc_destalpha = bglevel; - } - else - { - dc_srcblend = Col2RGB8_LessPrecision[fglevel >> 10]; - dc_destblend = Col2RGB8_LessPrecision[bglevel >> 10]; - dc_srcalpha = fglevel; - dc_destalpha = bglevel; - } - switch (op) - { - case STYLEOP_Add: - if (fglevel == 0 && bglevel == FRACUNIT) - { - return false; - } - if (fglevel + bglevel <= FRACUNIT) - { // Colors won't overflow when added - if (flags & STYLEF_ColorIsFixed) - { - colfunc = R_FillAddColumn; - hcolfunc_post1 = rt_add1col; - hcolfunc_post4 = rt_add4cols; - } - else if (dc_translation == NULL) - { - colfunc = R_DrawAddColumn; - hcolfunc_post1 = rt_add1col; - hcolfunc_post4 = rt_add4cols; - } - else - { - colfunc = R_DrawTlatedAddColumn; - hcolfunc_post1 = rt_tlateadd1col; - hcolfunc_post4 = rt_tlateadd4cols; - drawer_needs_pal_input = true; - } - } - else - { // Colors might overflow when added - if (flags & STYLEF_ColorIsFixed) - { - colfunc = R_FillAddClampColumn; - hcolfunc_post1 = rt_addclamp1col; - hcolfunc_post4 = rt_addclamp4cols; - } - else if (dc_translation == NULL) - { - colfunc = R_DrawAddClampColumn; - hcolfunc_post1 = rt_addclamp1col; - hcolfunc_post4 = rt_addclamp4cols; - } - else - { - colfunc = R_DrawAddClampTranslatedColumn; - hcolfunc_post1 = rt_tlateaddclamp1col; - hcolfunc_post4 = rt_tlateaddclamp4cols; - drawer_needs_pal_input = true; - } - } - return true; - - case STYLEOP_Sub: - if (flags & STYLEF_ColorIsFixed) - { - colfunc = R_FillSubClampColumn; - hcolfunc_post1 = rt_subclamp1col; - hcolfunc_post4 = rt_subclamp4cols; - } - else if (dc_translation == NULL) - { - colfunc = R_DrawSubClampColumn; - hcolfunc_post1 = rt_subclamp1col; - hcolfunc_post4 = rt_subclamp4cols; - } - else - { - colfunc = R_DrawSubClampTranslatedColumn; - hcolfunc_post1 = rt_tlatesubclamp1col; - hcolfunc_post4 = rt_tlatesubclamp4cols; - drawer_needs_pal_input = true; - } - return true; - - case STYLEOP_RevSub: - if (fglevel == 0 && bglevel == FRACUNIT) - { - return false; - } - if (flags & STYLEF_ColorIsFixed) - { - colfunc = R_FillRevSubClampColumn; - hcolfunc_post1 = rt_subclamp1col; - hcolfunc_post4 = rt_subclamp4cols; - } - else if (dc_translation == NULL) - { - colfunc = R_DrawRevSubClampColumn; - hcolfunc_post1 = rt_revsubclamp1col; - hcolfunc_post4 = rt_revsubclamp4cols; - } - else - { - colfunc = R_DrawRevSubClampTranslatedColumn; - hcolfunc_post1 = rt_tlaterevsubclamp1col; - hcolfunc_post4 = rt_tlaterevsubclamp4cols; - drawer_needs_pal_input = true; - } - return true; - - default: - return false; - } - } - - fixed_t GetAlpha(int type, fixed_t alpha) - { - switch (type) - { - case STYLEALPHA_Zero: return 0; - case STYLEALPHA_One: return OPAQUE; - case STYLEALPHA_Src: return alpha; - case STYLEALPHA_InvSrc: return OPAQUE - alpha; - default: return 0; - } - } - - FDynamicColormap *basecolormapsave; - } - - ESPSResult R_SetPatchStyle(FRenderStyle style, fixed_t alpha, int translation, uint32_t color) - { - using namespace drawerargs; - - fixed_t fglevel, bglevel; - - drawer_needs_pal_input = false; - - style.CheckFuzz(); - - if (style.BlendOp == STYLEOP_Shadow) - { - style = LegacyRenderStyles[STYLE_TranslucentStencil]; - alpha = TRANSLUC33; - color = 0; - } - - if (style.Flags & STYLEF_TransSoulsAlpha) - { - alpha = fixed_t(transsouls * OPAQUE); - } - else if (style.Flags & STYLEF_Alpha1) - { - alpha = FRACUNIT; - } - else - { - alpha = clamp(alpha, 0, OPAQUE); - } - - if (translation != -1) - { - dc_translation = NULL; - if (translation != 0) - { - FRemapTable *table = TranslationToTable(translation); - if (table != NULL && !table->Inactive) - { - if (r_swtruecolor) - dc_translation = (uint8_t*)table->Palette; - else - dc_translation = table->Remap; - } - } - } - basecolormapsave = basecolormap; - hcolfunc_pre = R_DrawColumnHoriz; - - // Check for special modes - if (style.BlendOp == STYLEOP_Fuzz) - { - colfunc = fuzzcolfunc; - return DoDraw0; - } - else if (style == LegacyRenderStyles[STYLE_Shaded]) - { - // Shaded drawer only gets 16 levels of alpha because it saves memory. - if ((alpha >>= 12) == 0) - return DontDraw; - colfunc = R_DrawShadedColumn; - hcolfunc_post1 = rt_shaded1col; - hcolfunc_post4 = rt_shaded4cols; - drawer_needs_pal_input = true; - dc_color = fixedcolormap ? fixedcolormap->Maps[APART(color)] : basecolormap->Maps[APART(color)]; - basecolormap = &ShadeFakeColormap[16 - alpha]; - if (fixedlightlev >= 0 && fixedcolormap == NULL) - { - R_SetColorMapLight(basecolormap, 0, FIXEDLIGHT2SHADE(fixedlightlev)); - } - else - { - R_SetColorMapLight(basecolormap, 0, 0); - } - bool active_columnmethod = r_columnmethod && !r_swtruecolor; - return active_columnmethod ? DoDraw1 : DoDraw0; - } - - fglevel = GetAlpha(style.SrcAlpha, alpha); - bglevel = GetAlpha(style.DestAlpha, alpha); - - if (style.Flags & STYLEF_ColorIsFixed) - { - uint32_t x = fglevel >> 10; - uint32_t r = RPART(color); - uint32_t g = GPART(color); - uint32_t b = BPART(color); - // dc_color is used by the rt_* routines. It is indexed into dc_srcblend. - dc_color = RGB32k.RGB[r >> 3][g >> 3][b >> 3]; - if (style.Flags & STYLEF_InvertSource) - { - r = 255 - r; - g = 255 - g; - b = 255 - b; - } - uint32_t alpha = clamp(fglevel >> (FRACBITS - 8), 0, 255); - dc_srccolor_bgra = (alpha << 24) | (r << 16) | (g << 8) | b; - // dc_srccolor is used by the R_Fill* routines. It is premultiplied - // with the alpha. - dc_srccolor = ((((r*x) >> 4) << 20) | ((g*x) >> 4) | ((((b)*x) >> 4) << 10)) & 0x3feffbff; - hcolfunc_pre = R_FillColumnHoriz; - R_SetColorMapLight(&identitycolormap, 0, 0); - } - - if (!R_SetBlendFunc(style.BlendOp, fglevel, bglevel, style.Flags)) - { - return DontDraw; - } - bool active_columnmethod = r_columnmethod && !r_swtruecolor; - return active_columnmethod ? DoDraw1 : DoDraw0; - } - - ESPSResult R_SetPatchStyle(FRenderStyle style, float alpha, int translation, uint32_t color) - { - return R_SetPatchStyle(style, FLOAT2FIXED(alpha), translation, color); - } - - void R_FinishSetPatchStyle() - { - basecolormap = basecolormapsave; - } - - const uint8_t *R_GetColumn(FTexture *tex, int col) - { - int width; - - // If the texture's width isn't a power of 2, then we need to make it a - // positive offset for proper clamping. - if (col < 0 && (width = tex->GetWidth()) != (1 << tex->WidthBits)) - { - col = width + (col % width); - } - - if (r_swtruecolor) - return (const uint8_t *)tex->GetColumnBgra(col, nullptr); - else - return tex->GetColumn(col, nullptr); - } - - bool R_GetTransMaskDrawers(fixed_t(**tmvline1)(), void(**tmvline4)()) - { - if (colfunc == R_DrawAddColumn) - { - *tmvline1 = tmvline1_add; - *tmvline4 = tmvline4_add; - return true; - } - if (colfunc == R_DrawAddClampColumn) - { - *tmvline1 = tmvline1_addclamp; - *tmvline4 = tmvline4_addclamp; - return true; - } - if (colfunc == R_DrawSubClampColumn) - { - *tmvline1 = tmvline1_subclamp; - *tmvline4 = tmvline4_subclamp; - return true; - } - if (colfunc == R_DrawRevSubClampColumn) - { - *tmvline1 = tmvline1_revsubclamp; - *tmvline4 = tmvline4_revsubclamp; - return true; - } - return false; - } - - void setupvline(int fracbits) - { - drawerargs::vlinebits = fracbits; - } - - void setupmvline(int fracbits) - { - drawerargs::mvlinebits = fracbits; - } - - void setuptmvline(int fracbits) - { - drawerargs::tmvlinebits = fracbits; - } - - void R_SetColorMapLight(FSWColormap *base_colormap, float light, int shade) - { - using namespace drawerargs; - - dc_fcolormap = base_colormap; - if (r_swtruecolor) - { - dc_shade_constants.light_red = dc_fcolormap->Color.r * 256 / 255; - dc_shade_constants.light_green = dc_fcolormap->Color.g * 256 / 255; - dc_shade_constants.light_blue = dc_fcolormap->Color.b * 256 / 255; - dc_shade_constants.light_alpha = dc_fcolormap->Color.a * 256 / 255; - dc_shade_constants.fade_red = dc_fcolormap->Fade.r; - dc_shade_constants.fade_green = dc_fcolormap->Fade.g; - dc_shade_constants.fade_blue = dc_fcolormap->Fade.b; - dc_shade_constants.fade_alpha = dc_fcolormap->Fade.a; - dc_shade_constants.desaturate = MIN(abs(dc_fcolormap->Desaturate), 255) * 255 / 256; - dc_shade_constants.simple_shade = (dc_fcolormap->Color.d == 0x00ffffff && dc_fcolormap->Fade.d == 0x00000000 && dc_fcolormap->Desaturate == 0); - dc_colormap = base_colormap->Maps; - dc_light = LIGHTSCALE(light, shade); - } - else - { - dc_colormap = base_colormap->Maps + (GETPALOOKUP(light, shade) << COLORMAPSHIFT); - } - } - - void R_SetDSColorMapLight(FSWColormap *base_colormap, float light, int shade) - { - using namespace drawerargs; - - ds_fcolormap = base_colormap; - if (r_swtruecolor) - { - ds_shade_constants.light_red = ds_fcolormap->Color.r * 256 / 255; - ds_shade_constants.light_green = ds_fcolormap->Color.g * 256 / 255; - ds_shade_constants.light_blue = ds_fcolormap->Color.b * 256 / 255; - ds_shade_constants.light_alpha = ds_fcolormap->Color.a * 256 / 255; - ds_shade_constants.fade_red = ds_fcolormap->Fade.r; - ds_shade_constants.fade_green = ds_fcolormap->Fade.g; - ds_shade_constants.fade_blue = ds_fcolormap->Fade.b; - ds_shade_constants.fade_alpha = ds_fcolormap->Fade.a; - ds_shade_constants.desaturate = MIN(abs(ds_fcolormap->Desaturate), 255) * 255 / 256; - ds_shade_constants.simple_shade = (ds_fcolormap->Color.d == 0x00ffffff && ds_fcolormap->Fade.d == 0x00000000 && ds_fcolormap->Desaturate == 0); - ds_colormap = base_colormap->Maps; - ds_light = LIGHTSCALE(light, shade); - } - else - { - ds_colormap = base_colormap->Maps + (GETPALOOKUP(light, shade) << COLORMAPSHIFT); - } - } - - void R_SetTranslationMap(lighttable_t *translation) - { - using namespace drawerargs; - - if (r_swtruecolor) - { - dc_fcolormap = nullptr; - dc_colormap = nullptr; - dc_translation = translation; - dc_shade_constants.light_red = 256; - dc_shade_constants.light_green = 256; - dc_shade_constants.light_blue = 256; - dc_shade_constants.light_alpha = 256; - dc_shade_constants.fade_red = 0; - dc_shade_constants.fade_green = 0; - dc_shade_constants.fade_blue = 0; - dc_shade_constants.fade_alpha = 256; - dc_shade_constants.desaturate = 0; - dc_shade_constants.simple_shade = true; - dc_light = 0; - } - else - { - dc_fcolormap = nullptr; - dc_colormap = translation; - } - } - - void rt_initcols(uint8_t *buffer) - { - using namespace drawerargs; - - for (int y = 3; y >= 0; y--) - horizspan[y] = dc_ctspan[y] = &dc_tspans[y][0]; - - if (r_swtruecolor) - DrawerCommandQueue::QueueCommand(buffer); - else - DrawerCommandQueue::QueueCommand(buffer); - } - - void rt_span_coverage(int x, int start, int stop) - { - using namespace drawerargs; - - unsigned int **tspan = &dc_ctspan[x & 3]; - (*tspan)[0] = start; - (*tspan)[1] = stop; - *tspan += 2; - } - - void rt_flip_posts() - { - using namespace drawerargs; - - unsigned int *front = horizspan[dc_x & 3]; - unsigned int *back = dc_ctspan[dc_x & 3] - 2; - - while (front < back) - { - swapvalues(front[0], back[0]); - swapvalues(front[1], back[1]); - front += 2; - back -= 2; - } - } - - void rt_draw4cols(int sx) - { - using namespace drawerargs; - - int x, bad; - unsigned int maxtop, minbot, minnexttop; - - // Place a dummy "span" in each column. These don't get - // drawn. They're just here to avoid special cases in the - // max/min calculations below. - for (x = 0; x < 4; ++x) - { - dc_ctspan[x][0] = screen->GetHeight()+1; - dc_ctspan[x][1] = screen->GetHeight(); - } - - for (;;) - { - // If a column is out of spans, mark it as such - bad = 0; - minnexttop = 0xffffffff; - for (x = 0; x < 4; ++x) - { - if (horizspan[x] >= dc_ctspan[x]) - { - bad |= 1 << x; - } - else if ((horizspan[x]+2)[0] < minnexttop) - { - minnexttop = (horizspan[x]+2)[0]; - } - } - // Once all columns are out of spans, we're done - if (bad == 15) - { - return; - } - - // Find the largest shared area for the spans in each column - maxtop = MAX (MAX (horizspan[0][0], horizspan[1][0]), - MAX (horizspan[2][0], horizspan[3][0])); - minbot = MIN (MIN (horizspan[0][1], horizspan[1][1]), - MIN (horizspan[2][1], horizspan[3][1])); - - // If there is no shared area with these spans, draw each span - // individually and advance to the next spans until we reach a shared area. - // However, only draw spans down to the highest span in the next set of - // spans. If we allow the entire height of a span to be drawn, it could - // prevent any more shared areas from being drawn in these four columns. - // - // Example: Suppose we have the following arrangement: - // A CD - // A CD - // B D - // B D - // aB D - // aBcD - // aBcD - // aBc - // - // If we draw the entire height of the spans, we end up drawing this first: - // A CD - // A CD - // B D - // B D - // B D - // B D - // B D - // B D - // B - // - // This leaves only the "a" and "c" columns to be drawn, and they are not - // part of a shared area, but if we can include B and D with them, we can - // get a shared area. So we cut off everything in the first set just - // above the "a" column and end up drawing this first: - // A CD - // A CD - // B D - // B D - // - // Then the next time through, we have the following arrangement with an - // easily shared area to draw: - // aB D - // aBcD - // aBcD - // aBc - if (bad != 0 || maxtop > minbot) - { - int drawcount = 0; - for (x = 0; x < 4; ++x) - { - if (!(bad & 1)) - { - if (horizspan[x][1] < minnexttop) - { - hcolfunc_post1 (x, sx+x, horizspan[x][0], horizspan[x][1]); - horizspan[x] += 2; - drawcount++; - } - else if (minnexttop > horizspan[x][0]) - { - hcolfunc_post1 (x, sx+x, horizspan[x][0], minnexttop-1); - horizspan[x][0] = minnexttop; - drawcount++; - } - } - bad >>= 1; - } - // Drawcount *should* always be non-zero. The reality is that some situations - // can make this not true. Unfortunately, I'm not sure what those situations are. - if (drawcount == 0) - { - return; - } - continue; - } - - // Draw any span fragments above the shared area. - for (x = 0; x < 4; ++x) - { - if (maxtop > horizspan[x][0]) - { - hcolfunc_post1 (x, sx+x, horizspan[x][0], maxtop-1); - } - } - - // Draw the shared area. - hcolfunc_post4 (sx, maxtop, minbot); - - // For each column, if part of the span is past the shared area, - // set its top to just below the shared area. Otherwise, advance - // to the next span in that column. - for (x = 0; x < 4; ++x) - { - if (minbot < horizspan[x][1]) - { - horizspan[x][0] = minbot+1; - } - else - { - horizspan[x] += 2; - } - } - } - } - - void R_SetupSpanBits(FTexture *tex) - { - using namespace drawerargs; - - tex->GetWidth(); - ds_xbits = tex->WidthBits; - ds_ybits = tex->HeightBits; - if ((1 << ds_xbits) > tex->GetWidth()) - { - ds_xbits--; - } - if ((1 << ds_ybits) > tex->GetHeight()) - { - ds_ybits--; - } - } - - void R_SetSpanColormap(FDynamicColormap *colormap, int shade) - { - R_SetDSColorMapLight(colormap, 0, shade); - } - - void R_SetSpanSource(FTexture *tex) - { - using namespace drawerargs; - - ds_source = r_swtruecolor ? (const uint8_t*)tex->GetPixelsBgra() : tex->GetPixels(); - ds_source_mipmapped = tex->Mipmapped() && tex->GetWidth() > 1 && tex->GetHeight() > 1; - } - - ///////////////////////////////////////////////////////////////////////// - - void R_FillColumnHoriz() - { - using namespace drawerargs; - - if (dc_count <= 0) - return; - - int x = dc_x & 3; - unsigned int **span = &dc_ctspan[x]; - (*span)[0] = dc_yl; - (*span)[1] = dc_yh; - *span += 2; - - if (r_swtruecolor) - DrawerCommandQueue::QueueCommand(); - else - DrawerCommandQueue::QueueCommand(); - } - - void R_DrawColumnHoriz() - { - using namespace drawerargs; - - if (dc_count <= 0) - return; - - int x = dc_x & 3; - unsigned int **span = &dc_ctspan[x]; - (*span)[0] = dc_yl; - (*span)[1] = dc_yh; - *span += 2; - - if (r_swtruecolor) - { - if (drawer_needs_pal_input) - DrawerCommandQueue::QueueCommand>(); - else - DrawerCommandQueue::QueueCommand>(); - } - else - { - DrawerCommandQueue::QueueCommand(); - } - } - - // Copies one span at hx to the screen at sx. - void rt_copy1col(int hx, int sx, int yl, int yh) - { - if (r_swtruecolor) - DrawerCommandQueue::QueueCommand(hx, sx, yl, yh); - else - DrawerCommandQueue::QueueCommand(hx, sx, yl, yh); - } - - // Copies all four spans to the screen starting at sx. - void rt_copy4cols(int sx, int yl, int yh) - { - if (r_swtruecolor) - { - // To do: we could do this with SSE using __m128i - rt_copy1col(0, sx, yl, yh); - rt_copy1col(1, sx + 1, yl, yh); - rt_copy1col(2, sx + 2, yl, yh); - rt_copy1col(3, sx + 3, yl, yh); - } - else - { - DrawerCommandQueue::QueueCommand(0, sx, yl, yh); - } - } - - // Maps one span at hx to the screen at sx. - void rt_map1col(int hx, int sx, int yl, int yh) - { - if (r_swtruecolor) - DrawerCommandQueue::QueueCommand(hx, sx, yl, yh); - else - DrawerCommandQueue::QueueCommand(hx, sx, yl, yh); - } - - // Maps all four spans to the screen starting at sx. - void rt_map4cols(int sx, int yl, int yh) - { - if (r_swtruecolor) - DrawerCommandQueue::QueueCommand(0, sx, yl, yh); - else - DrawerCommandQueue::QueueCommand(0, sx, yl, yh); - } - - // Translates one span at hx to the screen at sx. - void rt_tlate1col(int hx, int sx, int yl, int yh) - { - if (r_swtruecolor) - { - DrawerCommandQueue::QueueCommand(hx, sx, yl, yh); - } - else - { - DrawerCommandQueue::QueueCommand(hx, sx, yl, yh); - rt_map1col(hx, sx, yl, yh); - } - } - - // Translates all four spans to the screen starting at sx. - void rt_tlate4cols(int sx, int yl, int yh) - { - if (r_swtruecolor) - { - DrawerCommandQueue::QueueCommand(0, sx, yl, yh); - } - else - { - DrawerCommandQueue::QueueCommand(0, sx, yl, yh); - rt_map4cols(sx, yl, yh); - } - } - - // Adds one span at hx to the screen at sx without clamping. - void rt_add1col(int hx, int sx, int yl, int yh) - { - if (r_swtruecolor) - DrawerCommandQueue::QueueCommand(hx, sx, yl, yh); - else - DrawerCommandQueue::QueueCommand(hx, sx, yl, yh); - } - - // Adds all four spans to the screen starting at sx without clamping. - void rt_add4cols(int sx, int yl, int yh) - { - if (r_swtruecolor) - DrawerCommandQueue::QueueCommand(0, sx, yl, yh); - else - DrawerCommandQueue::QueueCommand(0, sx, yl, yh); - } - - // Translates and adds one span at hx to the screen at sx without clamping. - void rt_tlateadd1col(int hx, int sx, int yl, int yh) - { - if (r_swtruecolor) - { - DrawerCommandQueue::QueueCommand(hx, sx, yl, yh); - } - else - { - DrawerCommandQueue::QueueCommand(hx, sx, yl, yh); - rt_add1col(hx, sx, yl, yh); - } - } - - // Translates and adds all four spans to the screen starting at sx without clamping. - void rt_tlateadd4cols(int sx, int yl, int yh) - { - if (r_swtruecolor) - { - DrawerCommandQueue::QueueCommand(0, sx, yl, yh); - } - else - { - DrawerCommandQueue::QueueCommand(0, sx, yl, yh); - rt_add4cols(sx, yl, yh); - } - } - - // Shades one span at hx to the screen at sx. - void rt_shaded1col(int hx, int sx, int yl, int yh) - { - if (r_swtruecolor) - DrawerCommandQueue::QueueCommand(hx, sx, yl, yh); - else - DrawerCommandQueue::QueueCommand(hx, sx, yl, yh); - } - - // Shades all four spans to the screen starting at sx. - void rt_shaded4cols(int sx, int yl, int yh) - { - if (r_swtruecolor) - DrawerCommandQueue::QueueCommand(0, sx, yl, yh); - else - DrawerCommandQueue::QueueCommand(0, sx, yl, yh); - } - - // Adds one span at hx to the screen at sx with clamping. - void rt_addclamp1col(int hx, int sx, int yl, int yh) - { - if (r_swtruecolor) - DrawerCommandQueue::QueueCommand(hx, sx, yl, yh); - else - DrawerCommandQueue::QueueCommand(hx, sx, yl, yh); - } - - // Adds all four spans to the screen starting at sx with clamping. - void rt_addclamp4cols(int sx, int yl, int yh) - { - if (r_swtruecolor) - DrawerCommandQueue::QueueCommand(0, sx, yl, yh); - else - DrawerCommandQueue::QueueCommand(0, sx, yl, yh); - } - - // Translates and adds one span at hx to the screen at sx with clamping. - void rt_tlateaddclamp1col(int hx, int sx, int yl, int yh) - { - if (r_swtruecolor) - { - DrawerCommandQueue::QueueCommand(hx, sx, yl, yh); - } - else - { - DrawerCommandQueue::QueueCommand(hx, sx, yl, yh); - rt_addclamp1col(hx, sx, yl, yh); - } - } - - // Translates and adds all four spans to the screen starting at sx with clamping. - void rt_tlateaddclamp4cols(int sx, int yl, int yh) - { - if (r_swtruecolor) - { - DrawerCommandQueue::QueueCommand(0, sx, yl, yh); - } - else - { - DrawerCommandQueue::QueueCommand(0, sx, yl, yh); - rt_addclamp4cols(sx, yl, yh); - } - } - - // Subtracts one span at hx to the screen at sx with clamping. - void rt_subclamp1col(int hx, int sx, int yl, int yh) - { - if (r_swtruecolor) - DrawerCommandQueue::QueueCommand(hx, sx, yl, yh); - else - DrawerCommandQueue::QueueCommand(hx, sx, yl, yh); - } - - // Subtracts all four spans to the screen starting at sx with clamping. - void rt_subclamp4cols(int sx, int yl, int yh) - { - if (r_swtruecolor) - DrawerCommandQueue::QueueCommand(0, sx, yl, yh); - else - DrawerCommandQueue::QueueCommand(0, sx, yl, yh); - } - - // Translates and subtracts one span at hx to the screen at sx with clamping. - void rt_tlatesubclamp1col(int hx, int sx, int yl, int yh) - { - if (r_swtruecolor) - { - DrawerCommandQueue::QueueCommand(hx, sx, yl, yh); - } - else - { - DrawerCommandQueue::QueueCommand(hx, sx, yl, yh); - rt_subclamp1col(hx, sx, yl, yh); - } - } - - // Translates and subtracts all four spans to the screen starting at sx with clamping. - void rt_tlatesubclamp4cols(int sx, int yl, int yh) - { - if (r_swtruecolor) - { - DrawerCommandQueue::QueueCommand(0, sx, yl, yh); - } - else - { - DrawerCommandQueue::QueueCommand(0, sx, yl, yh); - rt_subclamp4cols(sx, yl, yh); - } - } - - // Subtracts one span at hx from the screen at sx with clamping. - void rt_revsubclamp1col(int hx, int sx, int yl, int yh) - { - if (r_swtruecolor) - DrawerCommandQueue::QueueCommand(hx, sx, yl, yh); - else - DrawerCommandQueue::QueueCommand(hx, sx, yl, yh); - } - - // Subtracts all four spans from the screen starting at sx with clamping. - void rt_revsubclamp4cols(int sx, int yl, int yh) - { - if (r_swtruecolor) - DrawerCommandQueue::QueueCommand(0, sx, yl, yh); - else - DrawerCommandQueue::QueueCommand(0, sx, yl, yh); - } - - // Translates and subtracts one span at hx from the screen at sx with clamping. - void rt_tlaterevsubclamp1col(int hx, int sx, int yl, int yh) - { - if (r_swtruecolor) - { - DrawerCommandQueue::QueueCommand(hx, sx, yl, yh); - } - else - { - DrawerCommandQueue::QueueCommand(hx, sx, yl, yh); - rt_revsubclamp1col(hx, sx, yl, yh); - } - } - - // Translates and subtracts all four spans from the screen starting at sx with clamping. - void rt_tlaterevsubclamp4cols(int sx, int yl, int yh) - { - if (r_swtruecolor) - { - DrawerCommandQueue::QueueCommand(0, sx, yl, yh); - } - else - { - DrawerCommandQueue::QueueCommand(0, sx, yl, yh); - rt_revsubclamp4cols(sx, yl, yh); - } - } - - uint32_t vlinec1() - { - using namespace drawerargs; - - if (r_swtruecolor) - DrawerCommandQueue::QueueCommand(); - else - DrawerCommandQueue::QueueCommand(); - - return dc_texturefrac + dc_count * dc_iscale; - } - - void vlinec4() - { - using namespace drawerargs; - - if (r_swtruecolor) - DrawerCommandQueue::QueueCommand(); - else - DrawerCommandQueue::QueueCommand(); - - for (int i = 0; i < 4; i++) - vplce[i] += vince[i] * dc_count; - } - - uint32_t mvlinec1() - { - using namespace drawerargs; - - if (r_swtruecolor) - DrawerCommandQueue::QueueCommand(); - else - DrawerCommandQueue::QueueCommand(); - - return dc_texturefrac + dc_count * dc_iscale; - } - - void mvlinec4() - { - using namespace drawerargs; - - if (r_swtruecolor) - DrawerCommandQueue::QueueCommand(); - else - DrawerCommandQueue::QueueCommand(); - - for (int i = 0; i < 4; i++) - vplce[i] += vince[i] * dc_count; - } - - fixed_t tmvline1_add() - { - using namespace drawerargs; - - if (r_swtruecolor) - DrawerCommandQueue::QueueCommand(); - else - DrawerCommandQueue::QueueCommand(); - - return dc_texturefrac + dc_count * dc_iscale; - } - - void tmvline4_add() - { - using namespace drawerargs; - - if (r_swtruecolor) - DrawerCommandQueue::QueueCommand(); - else - DrawerCommandQueue::QueueCommand(); - - for (int i = 0; i < 4; i++) - vplce[i] += vince[i] * dc_count; - } - - fixed_t tmvline1_addclamp() - { - using namespace drawerargs; - - if (r_swtruecolor) - DrawerCommandQueue::QueueCommand(); - else - DrawerCommandQueue::QueueCommand(); - - return dc_texturefrac + dc_count * dc_iscale; - } - - void tmvline4_addclamp() - { - using namespace drawerargs; - - if (r_swtruecolor) - DrawerCommandQueue::QueueCommand(); - else - DrawerCommandQueue::QueueCommand(); - - for (int i = 0; i < 4; i++) - vplce[i] += vince[i] * dc_count; - } - - fixed_t tmvline1_subclamp() - { - using namespace drawerargs; - - if (r_swtruecolor) - DrawerCommandQueue::QueueCommand(); - else - DrawerCommandQueue::QueueCommand(); - - return dc_texturefrac + dc_count * dc_iscale; - } - - void tmvline4_subclamp() - { - using namespace drawerargs; - - if (r_swtruecolor) - DrawerCommandQueue::QueueCommand(); - else - DrawerCommandQueue::QueueCommand(); - - for (int i = 0; i < 4; i++) - vplce[i] += vince[i] * dc_count; - } - - fixed_t tmvline1_revsubclamp() - { - using namespace drawerargs; - - if (r_swtruecolor) - DrawerCommandQueue::QueueCommand(); - else - DrawerCommandQueue::QueueCommand(); - - return dc_texturefrac + dc_count * dc_iscale; - } - - void tmvline4_revsubclamp() - { - using namespace drawerargs; - - if (r_swtruecolor) - DrawerCommandQueue::QueueCommand(); - else - DrawerCommandQueue::QueueCommand(); - - for (int i = 0; i < 4; i++) - vplce[i] += vince[i] * dc_count; - } - - void R_DrawSingleSkyCol1(uint32_t solid_top, uint32_t solid_bottom) - { - if (r_swtruecolor) - DrawerCommandQueue::QueueCommand(solid_top, solid_bottom); - else - DrawerCommandQueue::QueueCommand(solid_top, solid_bottom); - } - - void R_DrawSingleSkyCol4(uint32_t solid_top, uint32_t solid_bottom) - { - if (r_swtruecolor) - DrawerCommandQueue::QueueCommand(solid_top, solid_bottom); - else - DrawerCommandQueue::QueueCommand(solid_top, solid_bottom); - } - - void R_DrawDoubleSkyCol1(uint32_t solid_top, uint32_t solid_bottom) - { - if (r_swtruecolor) - DrawerCommandQueue::QueueCommand(solid_top, solid_bottom); - else - DrawerCommandQueue::QueueCommand(solid_top, solid_bottom); - } - - void R_DrawDoubleSkyCol4(uint32_t solid_top, uint32_t solid_bottom) - { - if (r_swtruecolor) - DrawerCommandQueue::QueueCommand(solid_top, solid_bottom); - else - DrawerCommandQueue::QueueCommand(solid_top, solid_bottom); - } - - void R_DrawColumn() - { - if (r_swtruecolor) - DrawerCommandQueue::QueueCommand(); - else - DrawerCommandQueue::QueueCommand(); - } - - void R_FillColumn() - { - if (r_swtruecolor) - DrawerCommandQueue::QueueCommand(); - else - DrawerCommandQueue::QueueCommand(); - } - - void R_FillAddColumn() - { - if (r_swtruecolor) - DrawerCommandQueue::QueueCommand(); - else - DrawerCommandQueue::QueueCommand(); - } - - void R_FillAddClampColumn() - { - if (r_swtruecolor) - DrawerCommandQueue::QueueCommand(); - else - DrawerCommandQueue::QueueCommand(); - } - - void R_FillSubClampColumn() - { - if (r_swtruecolor) - DrawerCommandQueue::QueueCommand(); - else - DrawerCommandQueue::QueueCommand(); - } - - void R_FillRevSubClampColumn() - { - if (r_swtruecolor) - DrawerCommandQueue::QueueCommand(); - else - DrawerCommandQueue::QueueCommand(); - } - - void R_DrawFuzzColumn() - { - using namespace drawerargs; - - if (r_swtruecolor) - DrawerCommandQueue::QueueCommand(); - else - DrawerCommandQueue::QueueCommand(); - - dc_yl = MAX(dc_yl, 1); - dc_yh = MIN(dc_yh, fuzzviewheight); - if (dc_yl <= dc_yh) - fuzzpos = (fuzzpos + dc_yh - dc_yl + 1) % FUZZTABLE; - } - - void R_DrawAddColumn() - { - if (r_swtruecolor) - DrawerCommandQueue::QueueCommand(); - else - DrawerCommandQueue::QueueCommand(); - } - - void R_DrawTranslatedColumn() - { - if (r_swtruecolor) - DrawerCommandQueue::QueueCommand(); - else - DrawerCommandQueue::QueueCommand(); - } - - void R_DrawTlatedAddColumn() - { - if (r_swtruecolor) - DrawerCommandQueue::QueueCommand(); - else - DrawerCommandQueue::QueueCommand(); - } - - void R_DrawShadedColumn() - { - if (r_swtruecolor) - DrawerCommandQueue::QueueCommand(); - else - DrawerCommandQueue::QueueCommand(); - } - - void R_DrawAddClampColumn() - { - if (r_swtruecolor) - DrawerCommandQueue::QueueCommand(); - else - DrawerCommandQueue::QueueCommand(); - } - - void R_DrawAddClampTranslatedColumn() - { - if (r_swtruecolor) - DrawerCommandQueue::QueueCommand(); - else - DrawerCommandQueue::QueueCommand(); - } - - void R_DrawSubClampColumn() - { - if (r_swtruecolor) - DrawerCommandQueue::QueueCommand(); - else - DrawerCommandQueue::QueueCommand(); - } - - void R_DrawSubClampTranslatedColumn() - { - if (r_swtruecolor) - DrawerCommandQueue::QueueCommand(); - else - DrawerCommandQueue::QueueCommand(); - } - - void R_DrawRevSubClampColumn() - { - if (r_swtruecolor) - DrawerCommandQueue::QueueCommand(); - else - DrawerCommandQueue::QueueCommand(); - } - - void R_DrawRevSubClampTranslatedColumn() - { - if (r_swtruecolor) - DrawerCommandQueue::QueueCommand(); - else - DrawerCommandQueue::QueueCommand(); - } - - void R_DrawSpan() - { - if (r_swtruecolor) - DrawerCommandQueue::QueueCommand(); - else - DrawerCommandQueue::QueueCommand(); - } - - void R_DrawSpanMasked() - { - if (r_swtruecolor) - DrawerCommandQueue::QueueCommand(); - else - DrawerCommandQueue::QueueCommand(); - } - - void R_DrawSpanTranslucent() - { - if (r_swtruecolor) - DrawerCommandQueue::QueueCommand(); - else - DrawerCommandQueue::QueueCommand(); - } - - void R_DrawSpanMaskedTranslucent() - { - if (r_swtruecolor) - DrawerCommandQueue::QueueCommand(); - else - DrawerCommandQueue::QueueCommand(); - } - - void R_DrawSpanAddClamp() - { - if (r_swtruecolor) - DrawerCommandQueue::QueueCommand(); - else - DrawerCommandQueue::QueueCommand(); - } - - void R_DrawSpanMaskedAddClamp() - { - if (r_swtruecolor) - DrawerCommandQueue::QueueCommand(); - else - DrawerCommandQueue::QueueCommand(); - } - - void R_FillSpan() - { - if (r_swtruecolor) - DrawerCommandQueue::QueueCommand(); - else - DrawerCommandQueue::QueueCommand(); - } - - void R_DrawTiltedSpan(int y, int x1, int x2, const FVector3 &plane_sz, const FVector3 &plane_su, const FVector3 &plane_sv, bool plane_shade, int planeshade, float planelightfloat, fixed_t pviewx, fixed_t pviewy) - { - if (r_swtruecolor) - DrawerCommandQueue::QueueCommand(y, x1, x2, plane_sz, plane_su, plane_sv, plane_shade, planeshade, planelightfloat, pviewx, pviewy); - else - DrawerCommandQueue::QueueCommand(y, x1, x2, plane_sz, plane_su, plane_sv, plane_shade, planeshade, planelightfloat, pviewx, pviewy); - } - - void R_DrawColoredSpan(int y, int x1, int x2) - { - if (r_swtruecolor) - DrawerCommandQueue::QueueCommand(y, x1, x2); - else - DrawerCommandQueue::QueueCommand(y, x1, x2); - } - - namespace - { - ShadeConstants slab_rgba_shade_constants; - const uint8_t *slab_rgba_colormap; - fixed_t slab_rgba_light; - } - - void R_SetupDrawSlab(FSWColormap *base_colormap, float light, int shade) - { - slab_rgba_shade_constants.light_red = base_colormap->Color.r * 256 / 255; - slab_rgba_shade_constants.light_green = base_colormap->Color.g * 256 / 255; - slab_rgba_shade_constants.light_blue = base_colormap->Color.b * 256 / 255; - slab_rgba_shade_constants.light_alpha = base_colormap->Color.a * 256 / 255; - slab_rgba_shade_constants.fade_red = base_colormap->Fade.r; - slab_rgba_shade_constants.fade_green = base_colormap->Fade.g; - slab_rgba_shade_constants.fade_blue = base_colormap->Fade.b; - slab_rgba_shade_constants.fade_alpha = base_colormap->Fade.a; - slab_rgba_shade_constants.desaturate = MIN(abs(base_colormap->Desaturate), 255) * 255 / 256; - slab_rgba_shade_constants.simple_shade = (base_colormap->Color.d == 0x00ffffff && base_colormap->Fade.d == 0x00000000 && base_colormap->Desaturate == 0); - slab_rgba_colormap = base_colormap->Maps; - slab_rgba_light = LIGHTSCALE(light, shade); - } - - void R_DrawSlab(int dx, fixed_t v, int dy, fixed_t vi, const uint8_t *vptr, uint8_t *p) - { - if (r_swtruecolor) - DrawerCommandQueue::QueueCommand(dx, v, dy, vi, vptr, p, slab_rgba_shade_constants, slab_rgba_colormap, slab_rgba_light); - else - DrawerCommandQueue::QueueCommand(dx, v, dy, vi, vptr, p, slab_rgba_colormap); - } - - void R_DrawFogBoundarySection(int y, int y2, int x1) - { - for (; y < y2; ++y) - { - int x2 = spanend[y]; - if (r_swtruecolor) - DrawerCommandQueue::QueueCommand(y, x1, x2); - else - DrawerCommandQueue::QueueCommand(y, x1, x2); - } - } - - void R_DrawFogBoundary(int x1, int x2, short *uclip, short *dclip) - { - // This is essentially the same as R_MapVisPlane but with an extra step - // to create new horizontal spans whenever the light changes enough that - // we need to use a new colormap. - - double lightstep = rw_lightstep; - double light = rw_light + rw_lightstep*(x2 - x1 - 1); - int x = x2 - 1; - int t2 = uclip[x]; - int b2 = dclip[x]; - int rcolormap = GETPALOOKUP(light, wallshade); - int lcolormap; - uint8_t *basecolormapdata = basecolormap->Maps; - - if (b2 > t2) - { - clearbufshort(spanend + t2, b2 - t2, x); - } - - R_SetColorMapLight(basecolormap, (float)light, wallshade); - - uint8_t *fake_dc_colormap = basecolormap->Maps + (GETPALOOKUP(light, wallshade) << COLORMAPSHIFT); - - for (--x; x >= x1; --x) - { - int t1 = uclip[x]; - int b1 = dclip[x]; - const int xr = x + 1; - int stop; - - light -= rw_lightstep; - lcolormap = GETPALOOKUP(light, wallshade); - if (lcolormap != rcolormap) - { - if (t2 < b2 && rcolormap != 0) - { // Colormap 0 is always the identity map, so rendering it is - // just a waste of time. - R_DrawFogBoundarySection(t2, b2, xr); - } - if (t1 < t2) t2 = t1; - if (b1 > b2) b2 = b1; - if (t2 < b2) - { - clearbufshort(spanend + t2, b2 - t2, x); - } - rcolormap = lcolormap; - R_SetColorMapLight(basecolormap, (float)light, wallshade); - fake_dc_colormap = basecolormap->Maps + (GETPALOOKUP(light, wallshade) << COLORMAPSHIFT); - } - else - { - if (fake_dc_colormap != basecolormapdata) - { - stop = MIN(t1, b2); - while (t2 < stop) - { - int y = t2++; - if (r_swtruecolor) - DrawerCommandQueue::QueueCommand(y, xr, spanend[y]); - else - DrawerCommandQueue::QueueCommand(y, xr, spanend[y]); - } - stop = MAX(b1, t2); - while (b2 > stop) - { - int y = --b2; - if (r_swtruecolor) - DrawerCommandQueue::QueueCommand(y, xr, spanend[y]); - else - DrawerCommandQueue::QueueCommand(y, xr, spanend[y]); - } - } - else - { - t2 = MAX(t2, MIN(t1, b2)); - b2 = MIN(b2, MAX(b1, t2)); - } - - stop = MIN(t2, b1); - while (t1 < stop) - { - spanend[t1++] = x; - } - stop = MAX(b2, t2); - while (b1 > stop) - { - spanend[--b1] = x; - } - } - - t2 = uclip[x]; - b2 = dclip[x]; - } - if (t2 < b2 && rcolormap != 0) - { - R_DrawFogBoundarySection(t2, b2, x1); - } - } - - void R_DrawParticle(vissprite_t *sprite) - { - if (r_swtruecolor) - R_DrawParticle_rgba(sprite); - else - R_DrawParticle_C(sprite); - } -} diff --git a/src/r_draw_tc.h b/src/r_draw_tc.h deleted file mode 100644 index 8c1af58fc..000000000 --- a/src/r_draw_tc.h +++ /dev/null @@ -1,239 +0,0 @@ - -#pragma once - -#include "r_defs.h" - -struct FSWColormap; - -EXTERN_CVAR(Bool, r_multithreaded); -EXTERN_CVAR(Bool, r_magfilter); -EXTERN_CVAR(Bool, r_minfilter); -EXTERN_CVAR(Bool, r_mipmap); -EXTERN_CVAR(Float, r_lod_bias); -EXTERN_CVAR(Int, r_drawfuzz); -EXTERN_CVAR(Bool, r_drawtrans); -EXTERN_CVAR(Float, transsouls); -EXTERN_CVAR(Int, r_columnmethod); - -namespace swrenderer -{ - struct vissprite_t; - - struct ShadeConstants - { - uint16_t light_alpha; - uint16_t light_red; - uint16_t light_green; - uint16_t light_blue; - uint16_t fade_alpha; - uint16_t fade_red; - uint16_t fade_green; - uint16_t fade_blue; - uint16_t desaturate; - bool simple_shade; - }; - - extern double dc_texturemid; - - namespace drawerargs - { - extern int dc_pitch; - extern lighttable_t *dc_colormap; - extern FSWColormap *dc_fcolormap; - extern ShadeConstants dc_shade_constants; - extern fixed_t dc_light; - extern int dc_x; - extern int dc_yl; - extern int dc_yh; - extern fixed_t dc_iscale; - extern fixed_t dc_texturefrac; - extern uint32_t dc_textureheight; - extern int dc_color; - extern uint32_t dc_srccolor; - extern uint32_t dc_srccolor_bgra; - extern uint32_t *dc_srcblend; - extern uint32_t *dc_destblend; - extern fixed_t dc_srcalpha; - extern fixed_t dc_destalpha; - extern const uint8_t *dc_source; - extern const uint8_t *dc_source2; - extern uint32_t dc_texturefracx; - extern uint8_t *dc_translation; - extern uint8_t *dc_dest; - extern uint8_t *dc_destorg; - extern int dc_destheight; - extern int dc_count; - - extern bool drawer_needs_pal_input; - - extern uint32_t vplce[4]; - extern uint32_t vince[4]; - extern uint8_t *palookupoffse[4]; - extern fixed_t palookuplight[4]; - extern const uint8_t *bufplce[4]; - extern const uint8_t *bufplce2[4]; - extern uint32_t buftexturefracx[4]; - extern uint32_t bufheight[4]; - extern int vlinebits; - extern int mvlinebits; - extern int tmvlinebits; - - extern int ds_y; - extern int ds_x1; - extern int ds_x2; - extern lighttable_t * ds_colormap; - extern FSWColormap *ds_fcolormap; - extern ShadeConstants ds_shade_constants; - extern dsfixed_t ds_light; - extern dsfixed_t ds_xfrac; - extern dsfixed_t ds_yfrac; - extern dsfixed_t ds_xstep; - extern dsfixed_t ds_ystep; - extern int ds_xbits; - extern int ds_ybits; - extern fixed_t ds_alpha; - extern double ds_lod; - extern const uint8_t *ds_source; - extern bool ds_source_mipmapped; - extern int ds_color; - - extern unsigned int dc_tspans[4][MAXHEIGHT]; - extern unsigned int *dc_ctspan[4]; - extern unsigned int *horizspan[4]; - } - - extern int ylookup[MAXHEIGHT]; - extern uint8_t shadetables[/*NUMCOLORMAPS*16*256*/]; - extern FDynamicColormap ShadeFakeColormap[16]; - extern uint8_t identitymap[256]; - extern FDynamicColormap identitycolormap; - - // Spectre/Invisibility. - #define FUZZTABLE 50 - extern int fuzzoffset[FUZZTABLE + 1]; - extern int fuzzpos; - extern int fuzzviewheight; - - extern bool r_swtruecolor; - - void R_InitColumnDrawers(); - void R_InitShadeMaps(); - void R_InitFuzzTable(int fuzzoff); - - enum ESPSResult - { - DontDraw, // not useful to draw this - DoDraw0, // draw this as if r_columnmethod is 0 - DoDraw1, // draw this as if r_columnmethod is 1 - }; - - ESPSResult R_SetPatchStyle(FRenderStyle style, fixed_t alpha, int translation, uint32_t color); - ESPSResult R_SetPatchStyle(FRenderStyle style, float alpha, int translation, uint32_t color); - void R_FinishSetPatchStyle(); // Call this after finished drawing the current thing, in case its style was STYLE_Shade - bool R_GetTransMaskDrawers(fixed_t(**tmvline1)(), void(**tmvline4)()); - - const uint8_t *R_GetColumn(FTexture *tex, int col); - void wallscan(int x1, int x2, short *uwal, short *dwal, float *swal, fixed_t *lwal, double yrepeat, const uint8_t *(*getcol)(FTexture *tex, int col) = R_GetColumn); - void maskwallscan(int x1, int x2, short *uwal, short *dwal, float *swal, fixed_t *lwal, double yrepeat, const uint8_t *(*getcol)(FTexture *tex, int col) = R_GetColumn); - void transmaskwallscan(int x1, int x2, short *uwal, short *dwal, float *swal, fixed_t *lwal, double yrepeat, const uint8_t *(*getcol)(FTexture *tex, int col) = R_GetColumn); - - void rt_initcols(uint8_t *buffer = nullptr); - void rt_span_coverage(int x, int start, int stop); - void rt_draw4cols(int sx); - void rt_flip_posts(); - void rt_copy1col(int hx, int sx, int yl, int yh); - void rt_copy4cols(int sx, int yl, int yh); - void rt_shaded1col(int hx, int sx, int yl, int yh); - void rt_shaded4cols(int sx, int yl, int yh); - void rt_map1col(int hx, int sx, int yl, int yh); - void rt_add1col(int hx, int sx, int yl, int yh); - void rt_addclamp1col(int hx, int sx, int yl, int yh); - void rt_subclamp1col(int hx, int sx, int yl, int yh); - void rt_revsubclamp1col(int hx, int sx, int yl, int yh); - void rt_tlate1col(int hx, int sx, int yl, int yh); - void rt_tlateadd1col(int hx, int sx, int yl, int yh); - void rt_tlateaddclamp1col(int hx, int sx, int yl, int yh); - void rt_tlatesubclamp1col(int hx, int sx, int yl, int yh); - void rt_tlaterevsubclamp1col(int hx, int sx, int yl, int yh); - void rt_map4cols(int sx, int yl, int yh); - void rt_add4cols(int sx, int yl, int yh); - void rt_addclamp4cols(int sx, int yl, int yh); - void rt_subclamp4cols(int sx, int yl, int yh); - void rt_revsubclamp4cols(int sx, int yl, int yh); - void rt_tlate4cols(int sx, int yl, int yh); - void rt_tlateadd4cols(int sx, int yl, int yh); - void rt_tlateaddclamp4cols(int sx, int yl, int yh); - void rt_tlatesubclamp4cols(int sx, int yl, int yh); - void rt_tlaterevsubclamp4cols(int sx, int yl, int yh); - void R_DrawColumnHoriz(); - void R_DrawColumn(); - void R_DrawFuzzColumn(); - void R_DrawTranslatedColumn(); - void R_DrawShadedColumn(); - void R_FillColumn(); - void R_FillAddColumn(); - void R_FillAddClampColumn(); - void R_FillSubClampColumn(); - void R_FillRevSubClampColumn(); - void R_DrawAddColumn(); - void R_DrawTlatedAddColumn(); - void R_DrawAddClampColumn(); - void R_DrawAddClampTranslatedColumn(); - void R_DrawSubClampColumn(); - void R_DrawSubClampTranslatedColumn(); - void R_DrawRevSubClampColumn(); - void R_DrawRevSubClampTranslatedColumn(); - void R_DrawSpan(); - void R_DrawSpanMasked(); - void R_DrawSpanTranslucent(); - void R_DrawSpanMaskedTranslucent(); - void R_DrawSpanAddClamp(); - void R_DrawSpanMaskedAddClamp(); - void R_FillSpan(); - void R_DrawTiltedSpan(int y, int x1, int x2, const FVector3 &plane_sz, const FVector3 &plane_su, const FVector3 &plane_sv, bool plane_shade, int planeshade, float planelightfloat, fixed_t pviewx, fixed_t pviewy); - void R_DrawColoredSpan(int y, int x1, int x2); - void R_SetupDrawSlab(FSWColormap *base_colormap, float light, int shade); - void R_DrawSlab(int dx, fixed_t v, int dy, fixed_t vi, const uint8_t *vptr, uint8_t *p); - void R_DrawFogBoundary(int x1, int x2, short *uclip, short *dclip); - uint32_t vlinec1(); - void vlinec4(); - uint32_t mvlinec1(); - void mvlinec4(); - fixed_t tmvline1_add(); - void tmvline4_add(); - fixed_t tmvline1_addclamp(); - void tmvline4_addclamp(); - fixed_t tmvline1_subclamp(); - void tmvline4_subclamp(); - fixed_t tmvline1_revsubclamp(); - void tmvline4_revsubclamp(); - void R_FillColumnHoriz(); - void R_FillSpan(); - - inline uint32_t dovline1() { return vlinec1(); } - inline void dovline4() { vlinec4(); } - inline uint32_t domvline1() { return mvlinec1(); } - inline void domvline4() { mvlinec4(); } - - void setupvline(int fracbits); - void setupmvline(int fracbits); - void setuptmvline(int fracbits); - - void R_DrawSingleSkyCol1(uint32_t solid_top, uint32_t solid_bottom); - void R_DrawSingleSkyCol4(uint32_t solid_top, uint32_t solid_bottom); - void R_DrawDoubleSkyCol1(uint32_t solid_top, uint32_t solid_bottom); - void R_DrawDoubleSkyCol4(uint32_t solid_top, uint32_t solid_bottom); - - // Sets dc_colormap and dc_light to their appropriate values depending on the output format (pal vs true color) - void R_SetColorMapLight(FSWColormap *base_colormap, float light, int shade); - void R_SetDSColorMapLight(FSWColormap *base_colormap, float light, int shade); - void R_SetTranslationMap(lighttable_t *translation); - - void R_SetupSpanBits(FTexture *tex); - void R_SetSpanColormap(FDynamicColormap *colormap, int shade); - void R_SetSpanSource(FTexture *tex); - - void R_MapTiltedPlane(int y, int x1); - void R_MapColoredPlane(int y, int x1); - void R_DrawParticle(vissprite_t *); -}