ShuriZma
/
duckstation
mirror of https://github.com/stenzek/duckstation
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

GPU/Software: Eliminate branches in ShadePixel

This commit is contained in:
Connor McLaughlin 2020-10-27 22:57:40 +10:00
parent 950318ee43
commit 20401787a4
2 changed files with 138 additions and 62 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

185
src/core/gpu_sw_backend.cpp
View File

@ -31,9 +31,13 @@ void GPU_SW_Backend::DrawPolygon(const GPUBackendDrawPolygonCommand* cmd)
{ {
const GPURenderCommand rc{cmd->rc.bits}; const GPURenderCommand rc{cmd->rc.bits};
const bool dithering_enable = rc.IsDitheringEnabled() && cmd->draw_mode.dither_enable; const bool dithering_enable = rc.IsDitheringEnabled() && cmd->draw_mode.dither_enable;
const GPUTextureMode texture_mode =
rc.texture_enable ? (cmd->draw_mode.texture_mode |
(rc.raw_texture_enable ? GPUTextureMode::RawTextureBit : static_cast<GPUTextureMode>(0))) :
GPUTextureMode::Disabled;
const DrawTriangleFunction DrawFunction = GetDrawTriangleFunction( const DrawTriangleFunction DrawFunction =
rc.shading_enable, rc.texture_enable, rc.raw_texture_enable, rc.transparency_enable, dithering_enable); GetDrawTriangleFunction(rc.shading_enable, texture_mode, rc.transparency_enable, dithering_enable);
(this->*DrawFunction)(cmd, &cmd->vertices[0], &cmd->vertices[1], &cmd->vertices[2]); (this->*DrawFunction)(cmd, &cmd->vertices[0], &cmd->vertices[1], &cmd->vertices[2]);
if (rc.quad_polygon) if (rc.quad_polygon)
@ -44,9 +48,12 @@ void GPU_SW_Backend::DrawRectangle(const GPUBackendDrawRectangleCommand* cmd)
{ {
const GPURenderCommand rc{cmd->rc.bits}; const GPURenderCommand rc{cmd->rc.bits};
const bool dithering_enable = rc.IsDitheringEnabled() && cmd->draw_mode.dither_enable; const bool dithering_enable = rc.IsDitheringEnabled() && cmd->draw_mode.dither_enable;
const GPUTextureMode texture_mode =
rc.texture_enable ? (cmd->draw_mode.texture_mode |
(rc.raw_texture_enable ? GPUTextureMode::RawTextureBit : static_cast<GPUTextureMode>(0))) :
GPUTextureMode::Disabled;
const DrawRectangleFunction DrawFunction = const DrawRectangleFunction DrawFunction = GetDrawRectangleFunction(texture_mode, rc.transparency_enable);
GetDrawRectangleFunction(rc.texture_enable, rc.raw_texture_enable, rc.transparency_enable);
(this->*DrawFunction)(cmd); (this->*DrawFunction)(cmd);
} }
@ -79,13 +86,13 @@ constexpr GPU_SW_Backend::DitherLUT GPU_SW_Backend::ComputeDitherLUT()
static constexpr GPU_SW_Backend::DitherLUT s_dither_lut = GPU_SW_Backend::ComputeDitherLUT(); static constexpr GPU_SW_Backend::DitherLUT s_dither_lut = GPU_SW_Backend::ComputeDitherLUT();
template<bool texture_enable, bool raw_texture_enable, bool transparency_enable, bool dithering_enable> template<GPUTextureMode texture_mode, bool transparency_enable, bool dithering_enable>
void ALWAYS_INLINE_RELEASE GPU_SW_Backend::ShadePixel(const GPUBackendDrawCommand* cmd, u32 x, u32 y, u8 color_r, void ALWAYS_INLINE_RELEASE GPU_SW_Backend::ShadePixel(const GPUBackendDrawCommand* cmd, u32 x, u32 y, u8 color_r,
u8 color_g, u8 color_b, u8 texcoord_x, u8 texcoord_y) u8 color_g, u8 color_b, u8 texcoord_x, u8 texcoord_y)
{ {
VRAMPixel color; VRAMPixel color;
bool transparent; bool transparent;
if constexpr (texture_enable) if constexpr (texture_mode != GPUTextureMode::Disabled)
{ {
// Apply texture window // Apply texture window
// TODO: Precompute the second half // TODO: Precompute the second half
@ -96,6 +103,7 @@ void ALWAYS_INLINE_RELEASE GPU_SW_Backend::ShadePixel(const GPUBackendDrawComman
switch (cmd->draw_mode.texture_mode) switch (cmd->draw_mode.texture_mode)
{ {
case GPUTextureMode::Palette4Bit: case GPUTextureMode::Palette4Bit:
case GPUTextureMode::RawPalette4Bit:
{ {
const u16 palette_value = const u16 palette_value =
GetPixel((cmd->draw_mode.GetTexturePageBaseX() + ZeroExtend32(texcoord_x / 4)) % VRAM_WIDTH, GetPixel((cmd->draw_mode.GetTexturePageBaseX() + ZeroExtend32(texcoord_x / 4)) % VRAM_WIDTH,
@ -110,6 +118,7 @@ void ALWAYS_INLINE_RELEASE GPU_SW_Backend::ShadePixel(const GPUBackendDrawComman
break; break;
case GPUTextureMode::Palette8Bit: case GPUTextureMode::Palette8Bit:
case GPUTextureMode::RawPalette8Bit:
{ {
const u16 palette_value = const u16 palette_value =
GetPixel((cmd->draw_mode.GetTexturePageBaseX() + ZeroExtend32(texcoord_x / 2)) % VRAM_WIDTH, GetPixel((cmd->draw_mode.GetTexturePageBaseX() + ZeroExtend32(texcoord_x / 2)) % VRAM_WIDTH,
@ -133,7 +142,7 @@ void ALWAYS_INLINE_RELEASE GPU_SW_Backend::ShadePixel(const GPUBackendDrawComman
transparent = texture_color.c; transparent = texture_color.c;
if constexpr (raw_texture_enable) if constexpr (texture_mode >= GPUTextureMode::RawPalette4Bit)
{ {
color.bits = texture_color.bits; color.bits = texture_color.bits;
} }
@ -212,7 +221,7 @@ void ALWAYS_INLINE_RELEASE GPU_SW_Backend::ShadePixel(const GPUBackendDrawComman
SetPixel(static_cast<u32>(x), static_cast<u32>(y), color.bits | cmd->params.GetMaskOR()); SetPixel(static_cast<u32>(x), static_cast<u32>(y), color.bits | cmd->params.GetMaskOR());
} }
template<bool texture_enable, bool raw_texture_enable, bool transparency_enable> template<GPUTextureMode texture_mode, bool transparency_enable>
void GPU_SW_Backend::DrawRectangle(const GPUBackendDrawRectangleCommand* cmd) void GPU_SW_Backend::DrawRectangle(const GPUBackendDrawRectangleCommand* cmd)
{ {
const s32 origin_x = cmd->x; const s32 origin_x = cmd->x;
@ -239,8 +248,8 @@ void GPU_SW_Backend::DrawRectangle(const GPUBackendDrawRectangleCommand* cmd)
const u8 texcoord_x = Truncate8(ZeroExtend32(origin_texcoord_x) + offset_x); const u8 texcoord_x = Truncate8(ZeroExtend32(origin_texcoord_x) + offset_x);
ShadePixel<texture_enable, raw_texture_enable, transparency_enable, false>( ShadePixel<texture_mode, transparency_enable, false>(cmd, static_cast<u32>(x), static_cast<u32>(y), r, g, b,
cmd, static_cast<u32>(x), static_cast<u32>(y), r, g, b, texcoord_x, texcoord_y); texcoord_x, texcoord_y);
} }
} }
} }
@ -351,8 +360,7 @@ void ALWAYS_INLINE_RELEASE GPU_SW_Backend::AddIDeltas_DY(i_group& ig, const i_de
} }
} }
template<bool shading_enable, bool texture_enable, bool raw_texture_enable, bool transparency_enable, template<bool shading_enable, GPUTextureMode texture_mode, bool transparency_enable, bool dithering_enable>
bool dithering_enable>
void GPU_SW_Backend::DrawSpan(const GPUBackendDrawPolygonCommand* cmd, s32 y, s32 x_start, s32 x_bound, i_group ig, void GPU_SW_Backend::DrawSpan(const GPUBackendDrawPolygonCommand* cmd, s32 y, s32 x_start, s32 x_bound, i_group ig,
const i_deltas& idl) const i_deltas& idl)
{ {
@ -377,6 +385,7 @@ void GPU_SW_Backend::DrawSpan(const GPUBackendDrawPolygonCommand* cmd, s32 y, s3
if (w <= 0) if (w <= 0)
return; return;
constexpr bool texture_enable = (texture_mode != GPUTextureMode::Disabled);
AddIDeltas_DX<shading_enable, texture_enable>(ig, idl, x_ig_adjust); AddIDeltas_DX<shading_enable, texture_enable>(ig, idl, x_ig_adjust);
AddIDeltas_DY<shading_enable, texture_enable>(ig, idl, y); AddIDeltas_DY<shading_enable, texture_enable>(ig, idl, y);
@ -388,17 +397,16 @@ void GPU_SW_Backend::DrawSpan(const GPUBackendDrawPolygonCommand* cmd, s32 y, s3
const u32 u = ig.u >> (COORD_FBS + COORD_POST_PADDING); const u32 u = ig.u >> (COORD_FBS + COORD_POST_PADDING);
const u32 v = ig.v >> (COORD_FBS + COORD_POST_PADDING); const u32 v = ig.v >> (COORD_FBS + COORD_POST_PADDING);
ShadePixel<texture_enable, raw_texture_enable, transparency_enable, dithering_enable>( ShadePixel<texture_mode, transparency_enable, dithering_enable>(cmd, static_cast<u32>(x), static_cast<u32>(y),
cmd, static_cast<u32>(x), static_cast<u32>(y), Truncate8(r), Truncate8(g), Truncate8(b), Truncate8(u), Truncate8(r), Truncate8(g), Truncate8(b),
Truncate8(v)); Truncate8(u), Truncate8(v));
x++; x++;
AddIDeltas_DX<shading_enable, texture_enable>(ig, idl); AddIDeltas_DX<shading_enable, texture_enable>(ig, idl);
} while (--w > 0); } while (--w > 0);
} }
template<bool shading_enable, bool texture_enable, bool raw_texture_enable, bool transparency_enable, template<bool shading_enable, GPUTextureMode texture_mode, bool transparency_enable, bool dithering_enable>
bool dithering_enable>
void GPU_SW_Backend::DrawTriangle(const GPUBackendDrawPolygonCommand* cmd, void GPU_SW_Backend::DrawTriangle(const GPUBackendDrawPolygonCommand* cmd,
const GPUBackendDrawPolygonCommand::Vertex* v0, const GPUBackendDrawPolygonCommand::Vertex* v0,
const GPUBackendDrawPolygonCommand::Vertex* v1, const GPUBackendDrawPolygonCommand::Vertex* v1,
@ -475,6 +483,7 @@ void GPU_SW_Backend::DrawTriangle(const GPUBackendDrawPolygonCommand* cmd,
bound_coord_ls = MakePolyXFPStep((v2->x - v1->x), (v2->y - v1->y)); bound_coord_ls = MakePolyXFPStep((v2->x - v1->x), (v2->y - v1->y));
i_deltas idl; i_deltas idl;
constexpr bool texture_enable = (texture_mode != GPUTextureMode::Disabled);
if (!CalcIDeltas<shading_enable, texture_enable>(idl, v0, v1, v2)) if (!CalcIDeltas<shading_enable, texture_enable>(idl, v0, v1, v2))
return; return;
@ -563,8 +572,8 @@ void GPU_SW_Backend::DrawTriangle(const GPUBackendDrawPolygonCommand* cmd,
if (y > static_cast<s32>(m_drawing_area.bottom)) if (y > static_cast<s32>(m_drawing_area.bottom))
continue; continue;
DrawSpan<shading_enable, texture_enable, raw_texture_enable, transparency_enable, dithering_enable>( DrawSpan<shading_enable, texture_mode, transparency_enable, dithering_enable>(cmd, yi, GetPolyXFP_Int(lc),
cmd, yi, GetPolyXFP_Int(lc), GetPolyXFP_Int(rc), ig, idl); GetPolyXFP_Int(rc), ig, idl);
} }
} }
else else
@ -579,8 +588,8 @@ void GPU_SW_Backend::DrawTriangle(const GPUBackendDrawPolygonCommand* cmd,
if (y >= static_cast<s32>(m_drawing_area.top)) if (y >= static_cast<s32>(m_drawing_area.top))
{ {
DrawSpan<shading_enable, texture_enable, raw_texture_enable, transparency_enable, dithering_enable>( DrawSpan<shading_enable, texture_mode, transparency_enable, dithering_enable>(cmd, yi, GetPolyXFP_Int(lc),
cmd, yi, GetPolyXFP_Int(lc), GetPolyXFP_Int(rc), ig, idl); GetPolyXFP_Int(rc), ig, idl);
} }
yi++; yi++;
@ -591,36 +600,99 @@ void GPU_SW_Backend::DrawTriangle(const GPUBackendDrawPolygonCommand* cmd,
} }
} }
GPU_SW_Backend::DrawTriangleFunction GPU_SW_Backend::GetDrawTriangleFunction(bool shading_enable, bool texture_enable, GPU_SW_Backend::DrawTriangleFunction GPU_SW_Backend::GetDrawTriangleFunction(bool shading_enable,
bool raw_texture_enable, GPUTextureMode texture_mode,
bool transparency_enable, bool transparency_enable,
bool dithering_enable) bool dithering_enable)
{ {
#define F(SHADING, TEXTURE, RAW_TEXTURE, TRANSPARENCY, DITHERING) \ #define F(SHADING, TEXTURE, TRANSPARENCY, DITHERING) \
&GPU_SW_Backend::DrawTriangle<SHADING, TEXTURE, RAW_TEXTURE, TRANSPARENCY, DITHERING> &GPU_SW_Backend::DrawTriangle<SHADING, TEXTURE, TRANSPARENCY, DITHERING>
static constexpr DrawTriangleFunction funcs[2][2][2][2][2] = { static constexpr DrawTriangleFunction funcs[2][9][2][2] = {
{{{{F(false, false, false, false, false), F(false, false, false, false, true)}, {
{F(false, false, false, true, false), F(false, false, false, true, true)}}, {
{{F(false, false, true, false, false), F(false, false, true, false, true)}, {F(false, GPUTextureMode::Palette4Bit, false, false), F(false, GPUTextureMode::Palette4Bit, false, true)},
{F(false, false, true, true, false), F(false, false, true, true, true)}}}, {F(false, GPUTextureMode::Palette4Bit, true, false), F(false, GPUTextureMode::Palette4Bit, true, true)},
{{{F(false, true, false, false, false), F(false, true, false, false, true)}, },
{F(false, true, false, true, false), F(false, true, false, true, true)}}, {
{{F(false, true, true, false, false), F(false, true, true, false, true)}, {F(false, GPUTextureMode::Palette8Bit, false, false), F(false, GPUTextureMode::Palette8Bit, false, true)},
{F(false, true, true, true, false), F(false, true, true, true, true)}}}}, {F(false, GPUTextureMode::Palette8Bit, true, false), F(false, GPUTextureMode::Palette8Bit, true, true)},
{{{{F(true, false, false, false, false), F(true, false, false, false, true)}, },
{F(true, false, false, true, false), F(true, false, false, true, true)}}, {
{{F(true, false, true, false, false), F(true, false, true, false, true)}, {F(false, GPUTextureMode::Direct16Bit, false, false), F(false, GPUTextureMode::Direct16Bit, false, true)},
{F(true, false, true, true, false), F(true, false, true, true, true)}}}, {F(false, GPUTextureMode::Direct16Bit, true, false), F(false, GPUTextureMode::Direct16Bit, true, true)},
{{{F(true, true, false, false, false), F(true, true, false, false, true)}, },
{F(true, true, false, true, false), F(true, true, false, true, true)}}, {
{{F(true, true, true, false, false), F(true, true, true, false, true)}, {F(false, GPUTextureMode::Reserved_Direct16Bit, false, false),
{F(true, true, true, true, false), F(true, true, true, true, true)}}}}}; F(false, GPUTextureMode::Reserved_Direct16Bit, false, true)},
{F(false, GPUTextureMode::Reserved_Direct16Bit, true, false),
F(false, GPUTextureMode::Reserved_Direct16Bit, true, true)},
},
{
{F(false, GPUTextureMode::RawPalette4Bit, false, false), F(false, GPUTextureMode::RawPalette4Bit, false, true)},
{F(false, GPUTextureMode::RawPalette4Bit, true, false), F(false, GPUTextureMode::RawPalette4Bit, true, true)},
},
{
{F(false, GPUTextureMode::RawPalette8Bit, false, false), F(false, GPUTextureMode::RawPalette8Bit, false, true)},
{F(false, GPUTextureMode::RawPalette8Bit, true, false), F(false, GPUTextureMode::RawPalette8Bit, true, true)},
},
{
{F(false, GPUTextureMode::RawDirect16Bit, false, false), F(false, GPUTextureMode::RawDirect16Bit, false, true)},
{F(false, GPUTextureMode::RawDirect16Bit, true, false), F(false, GPUTextureMode::RawDirect16Bit, true, true)},
},
{
{F(false, GPUTextureMode::Reserved_RawDirect16Bit, false, false),
F(false, GPUTextureMode::Reserved_RawDirect16Bit, false, true)},
{F(false, GPUTextureMode::Reserved_RawDirect16Bit, true, false),
F(false, GPUTextureMode::Reserved_RawDirect16Bit, true, true)},
},
{
{F(false, GPUTextureMode::Disabled, false, false), F(false, GPUTextureMode::Disabled, false, true)},
{F(false, GPUTextureMode::Disabled, true, false), F(false, GPUTextureMode::Disabled, true, true)},
},
},
{{
{F(true, GPUTextureMode::Palette4Bit, false, false), F(true, GPUTextureMode::Palette4Bit, false, true)},
{F(true, GPUTextureMode::Palette4Bit, true, false), F(true, GPUTextureMode::Palette4Bit, true, true)},
},
{
{F(true, GPUTextureMode::Palette8Bit, false, false), F(true, GPUTextureMode::Palette8Bit, false, true)},
{F(true, GPUTextureMode::Palette8Bit, true, false), F(true, GPUTextureMode::Palette8Bit, true, true)},
},
{
{F(true, GPUTextureMode::Direct16Bit, false, false), F(true, GPUTextureMode::Direct16Bit, false, true)},
{F(true, GPUTextureMode::Direct16Bit, true, false), F(true, GPUTextureMode::Direct16Bit, true, true)},
},
{
{F(true, GPUTextureMode::Reserved_Direct16Bit, false, false),
F(true, GPUTextureMode::Reserved_Direct16Bit, false, true)},
{F(true, GPUTextureMode::Reserved_Direct16Bit, true, false),
F(true, GPUTextureMode::Reserved_Direct16Bit, true, true)},
},
{
{F(true, GPUTextureMode::RawPalette4Bit, false, false), F(true, GPUTextureMode::RawPalette4Bit, false, true)},
{F(true, GPUTextureMode::RawPalette4Bit, true, false), F(true, GPUTextureMode::RawPalette4Bit, true, true)},
},
{
{F(true, GPUTextureMode::RawPalette8Bit, false, false), F(true, GPUTextureMode::RawPalette8Bit, false, true)},
{F(true, GPUTextureMode::RawPalette8Bit, true, false), F(true, GPUTextureMode::RawPalette8Bit, true, true)},
},
{
{F(true, GPUTextureMode::RawDirect16Bit, false, false), F(true, GPUTextureMode::RawDirect16Bit, false, true)},
{F(true, GPUTextureMode::RawDirect16Bit, true, false), F(true, GPUTextureMode::RawDirect16Bit, true, true)},
},
{
{F(true, GPUTextureMode::Reserved_RawDirect16Bit, false, false),
F(true, GPUTextureMode::Reserved_RawDirect16Bit, false, true)},
{F(true, GPUTextureMode::Reserved_RawDirect16Bit, true, false),
F(true, GPUTextureMode::Reserved_RawDirect16Bit, true, true)},
},
{{F(true, GPUTextureMode::Disabled, false, false), F(true, GPUTextureMode::Disabled, false, true)},
{F(true, GPUTextureMode::Disabled, true, false), F(true, GPUTextureMode::Disabled, true, true)}}}};
#undef F #undef F
return funcs[u8(shading_enable)][u8(texture_enable)][u8(raw_texture_enable)][u8(transparency_enable)] return funcs[u8(shading_enable)][u8(texture_mode)][u8(transparency_enable)][u8(dithering_enable)];
[u8(dithering_enable)];
} }
enum enum
@ -725,8 +797,8 @@ void GPU_SW_Backend::DrawLine(const GPUBackendDrawLineCommand* cmd, const GPUBac
const u8 g = shading_enable ? static_cast<u8>(cur_point.g >> Line_RGB_FractBits) : p0->g; const u8 g = shading_enable ? static_cast<u8>(cur_point.g >> Line_RGB_FractBits) : p0->g;
const u8 b = shading_enable ? static_cast<u8>(cur_point.b >> Line_RGB_FractBits) : p0->b; const u8 b = shading_enable ? static_cast<u8>(cur_point.b >> Line_RGB_FractBits) : p0->b;
ShadePixel<false, false, transparency_enable, dithering_enable>(cmd, static_cast<u32>(x), static_cast<u32>(y), r, ShadePixel<GPUTextureMode::Disabled, transparency_enable, dithering_enable>(cmd, static_cast<u32>(x),
g, b, 0, 0); static_cast<u32>(y), r, g, b, 0, 0);
} }
cur_point.x += step.dx_dk; cur_point.x += step.dx_dk;
@ -755,18 +827,25 @@ GPU_SW_Backend::DrawLineFunction GPU_SW_Backend::GetDrawLineFunction(bool shadin
return funcs[u8(shading_enable)][u8(transparency_enable)][u8(dithering_enable)]; return funcs[u8(shading_enable)][u8(transparency_enable)][u8(dithering_enable)];
} }
GPU_SW_Backend::DrawRectangleFunction GPU_SW_Backend::DrawRectangleFunction GPU_SW_Backend::GetDrawRectangleFunction(GPUTextureMode texture_mode,
GPU_SW_Backend::GetDrawRectangleFunction(bool texture_enable, bool raw_texture_enable, bool transparency_enable) bool transparency_enable)
{ {
#define F(TEXTURE, RAW_TEXTURE, TRANSPARENCY) &GPU_SW_Backend::DrawRectangle<TEXTURE, RAW_TEXTURE, TRANSPARENCY> #define F(TEXTURE, TRANSPARENCY) &GPU_SW_Backend::DrawRectangle<TEXTURE, TRANSPARENCY>
static constexpr DrawRectangleFunction funcs[2][2][2] = { static constexpr DrawRectangleFunction funcs[9][2] = {
{{F(false, false, false), F(false, false, true)}, {F(false, true, false), F(false, true, true)}}, {F(GPUTextureMode::Palette4Bit, false), F(GPUTextureMode::Palette4Bit, true)},
{{F(true, false, false), F(true, false, true)}, {F(true, true, false), F(true, true, true)}}}; {F(GPUTextureMode::Palette8Bit, false), F(GPUTextureMode::Palette8Bit, true)},
{F(GPUTextureMode::Direct16Bit, false), F(GPUTextureMode::Direct16Bit, true)},
{F(GPUTextureMode::Reserved_Direct16Bit, false), F(GPUTextureMode::Reserved_Direct16Bit, true)},
{F(GPUTextureMode::RawPalette4Bit, false), F(GPUTextureMode::RawPalette4Bit, true)},
{F(GPUTextureMode::RawPalette8Bit, false), F(GPUTextureMode::RawPalette8Bit, true)},
{F(GPUTextureMode::RawDirect16Bit, false), F(GPUTextureMode::RawDirect16Bit, true)},
{F(GPUTextureMode::Reserved_RawDirect16Bit, false), F(GPUTextureMode::Reserved_RawDirect16Bit, true)},
{F(GPUTextureMode::Disabled, false), F(GPUTextureMode::Disabled, true)}};
#undef F #undef F
return funcs[u8(texture_enable)][u8(raw_texture_enable)][u8(transparency_enable)]; return funcs[u8(texture_mode)][u8(transparency_enable)];
} }
void GPU_SW_Backend::FillVRAM(u32 x, u32 y, u32 width, u32 height, u32 color, GPUBackendCommandParameters params) void GPU_SW_Backend::FillVRAM(u32 x, u32 y, u32 width, u32 height, u32 color, GPUBackendCommandParameters params)

15
src/core/gpu_sw_backend.h
View File

@ -105,16 +105,15 @@ protected:
////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////
// Rasterization // Rasterization
////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////
template<bool texture_enable, bool raw_texture_enable, bool transparency_enable, bool dithering_enable> template<GPUTextureMode texture_mode, bool transparency_enable, bool dithering_enable>
void ShadePixel(const GPUBackendDrawCommand* cmd, u32 x, u32 y, u8 color_r, u8 color_g, u8 color_b, u8 texcoord_x, void ShadePixel(const GPUBackendDrawCommand* cmd, u32 x, u32 y, u8 color_r, u8 color_g, u8 color_b, u8 texcoord_x,
u8 texcoord_y); u8 texcoord_y);
template<bool texture_enable, bool raw_texture_enable, bool transparency_enable> template<GPUTextureMode texture_mode, bool transparency_enable>
void DrawRectangle(const GPUBackendDrawRectangleCommand* cmd); void DrawRectangle(const GPUBackendDrawRectangleCommand* cmd);
using DrawRectangleFunction = void (GPU_SW_Backend::*)(const GPUBackendDrawRectangleCommand* cmd); using DrawRectangleFunction = void (GPU_SW_Backend::*)(const GPUBackendDrawRectangleCommand* cmd);
DrawRectangleFunction GetDrawRectangleFunction(bool texture_enable, bool raw_texture_enable, DrawRectangleFunction GetDrawRectangleFunction(GPUTextureMode texture_mode, bool transparency_enable);
bool transparency_enable);
////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////
// Polygon and line rasterization ported from Mednafen // Polygon and line rasterization ported from Mednafen
@ -144,13 +143,11 @@ protected:
template<bool shading_enable, bool texture_enable> template<bool shading_enable, bool texture_enable>
void AddIDeltas_DY(i_group& ig, const i_deltas& idl, u32 count = 1); void AddIDeltas_DY(i_group& ig, const i_deltas& idl, u32 count = 1);
template<bool shading_enable, bool texture_enable, bool raw_texture_enable, bool transparency_enable, template<bool shading_enable, GPUTextureMode texture_mode, bool transparency_enable, bool dithering_enable>
bool dithering_enable>
void DrawSpan(const GPUBackendDrawPolygonCommand* cmd, s32 y, s32 x_start, s32 x_bound, i_group ig, void DrawSpan(const GPUBackendDrawPolygonCommand* cmd, s32 y, s32 x_start, s32 x_bound, i_group ig,
const i_deltas& idl); const i_deltas& idl);
template<bool shading_enable, bool texture_enable, bool raw_texture_enable, bool transparency_enable, template<bool shading_enable, GPUTextureMode texture_mode, bool transparency_enable, bool dithering_enable>
bool dithering_enable>
void DrawTriangle(const GPUBackendDrawPolygonCommand* cmd, const GPUBackendDrawPolygonCommand::Vertex* v0, void DrawTriangle(const GPUBackendDrawPolygonCommand* cmd, const GPUBackendDrawPolygonCommand::Vertex* v0,
const GPUBackendDrawPolygonCommand::Vertex* v1, const GPUBackendDrawPolygonCommand::Vertex* v2); const GPUBackendDrawPolygonCommand::Vertex* v1, const GPUBackendDrawPolygonCommand::Vertex* v2);
@ -158,7 +155,7 @@ protected:
const GPUBackendDrawPolygonCommand::Vertex* v0, const GPUBackendDrawPolygonCommand::Vertex* v0,
const GPUBackendDrawPolygonCommand::Vertex* v1, const GPUBackendDrawPolygonCommand::Vertex* v1,
const GPUBackendDrawPolygonCommand::Vertex* v2); const GPUBackendDrawPolygonCommand::Vertex* v2);
DrawTriangleFunction GetDrawTriangleFunction(bool shading_enable, bool texture_enable, bool raw_texture_enable, DrawTriangleFunction GetDrawTriangleFunction(bool shading_enable, GPUTextureMode texture_mode,
bool transparency_enable, bool dithering_enable); bool transparency_enable, bool dithering_enable);
template<bool shading_enable, bool transparency_enable, bool dithering_enable> template<bool shading_enable, bool transparency_enable, bool dithering_enable>