zdoom/gzdoom-gles
0
0
Fork 0
mirror of https://github.com/ZDoom/gzdoom-gles.git synced 2024-12-01 16:41:22 +00:00
Code Issues Projects Releases Packages Wiki Activity

Rewrote the LLVM triangle drawer to use the data from the triangle setup function

Browse source
This commit is contained in:
Magnus Norddahl 2016-12-15 01:33:26 +01:00
parent 145c0a6d9e
commit c643238b86
7 changed files with 843 additions and 388 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

4
src/r_poly_sky.cpp
View file

@ -58,7 +58,7 @@ void PolySkyDome::Render(const TriMatrix &worldToClip)
args.uniforms.subsectorDepth = RenderPolyScene::SkySubsectorDepth; args.uniforms.subsectorDepth = RenderPolyScene::SkySubsectorDepth;
args.objectToClip = &objectToClip; args.objectToClip = &objectToClip;
args.stenciltestvalue = 255; args.stenciltestvalue = 255;
args.stencilwritevalue = 255; args.stencilwritevalue = 1;
args.SetTexture(frontskytex); args.SetTexture(frontskytex);
args.SetColormap(&NormalLight); args.SetColormap(&NormalLight);
args.SetClipPlane(0.0f, 0.0f, 0.0f, 0.0f); args.SetClipPlane(0.0f, 0.0f, 0.0f, 0.0f);
@ -84,6 +84,7 @@ void PolySkyDome::RenderRow(PolyDrawArgs &args, int row, uint32_t capcolor)
args.ccw = false; args.ccw = false;
args.uniforms.color = capcolor; args.uniforms.color = capcolor;
PolyTriangleDrawer::draw(args, TriDrawVariant::DrawNormal, TriBlendMode::Skycap); PolyTriangleDrawer::draw(args, TriDrawVariant::DrawNormal, TriBlendMode::Skycap);
PolyTriangleDrawer::draw(args, TriDrawVariant::Stencil, TriBlendMode::Skycap);
} }
void PolySkyDome::RenderCapColorRow(PolyDrawArgs &args, FTexture *skytex, int row, bool bottomCap) void PolySkyDome::RenderCapColorRow(PolyDrawArgs &args, FTexture *skytex, int row, bool bottomCap)
@ -98,6 +99,7 @@ void PolySkyDome::RenderCapColorRow(PolyDrawArgs &args, FTexture *skytex, int ro
args.ccw = bottomCap; args.ccw = bottomCap;
args.uniforms.color = solid; args.uniforms.color = solid;
PolyTriangleDrawer::draw(args, TriDrawVariant::FillNormal, TriBlendMode::Copy); PolyTriangleDrawer::draw(args, TriDrawVariant::FillNormal, TriBlendMode::Copy);
PolyTriangleDrawer::draw(args, TriDrawVariant::Stencil, TriBlendMode::Copy);
} }
void PolySkyDome::CreateDome() void PolySkyDome::CreateDome()

52
src/r_poly_triangle.cpp
View file

@ -88,22 +88,19 @@ void PolyTriangleDrawer::draw_arrays(const PolyDrawArgs &drawargs, TriDrawVarian
return; return;
auto llvm = Drawers::Instance(); auto llvm = Drawers::Instance();
void(*drawfunc)(const TriDrawTriangleArgs *, WorkerThreadData *); PolyDrawFuncPtr setupfunc = nullptr;
PolyDrawFuncPtr drawfunc = nullptr;
int bmode = (int)blendmode; int bmode = (int)blendmode;
switch (variant) switch (variant)
{ {
default: default:
//case TriDrawVariant::DrawNormal: drawfunc = dest_bgra ? &ScreenTriangle::DrawFunc : llvm->TriDrawNormal8[bmode]; break; case TriDrawVariant::DrawNormal: setupfunc = &ScreenTriangle::SetupNormal; drawfunc = dest_bgra ? llvm->TriDrawNormal32[bmode] : llvm->TriDrawNormal8[bmode]; break;
//case TriDrawVariant::DrawSubsector: drawfunc = dest_bgra ? &ScreenTriangle::DrawSubsectorFunc : llvm->TriDrawSubsector8[bmode]; break; case TriDrawVariant::FillNormal: setupfunc = &ScreenTriangle::SetupNormal; drawfunc = dest_bgra ? llvm->TriFillNormal32[bmode] : llvm->TriFillNormal8[bmode]; break;
//case TriDrawVariant::Stencil: drawfunc = &ScreenTriangle::StencilFunc; break; case TriDrawVariant::DrawSubsector: setupfunc = &ScreenTriangle::SetupSubsector; drawfunc = dest_bgra ? llvm->TriDrawSubsector32[bmode] : llvm->TriDrawSubsector8[bmode]; break;
//case TriDrawVariant::StencilClose: drawfunc = &ScreenTriangle::StencilCloseFunc; break;
case TriDrawVariant::DrawNormal: drawfunc = dest_bgra ? llvm->TriDrawNormal32[bmode] : llvm->TriDrawNormal8[bmode]; break;
case TriDrawVariant::FillNormal: drawfunc = dest_bgra ? llvm->TriFillNormal32[bmode] : llvm->TriFillNormal8[bmode]; break;
case TriDrawVariant::DrawSubsector: drawfunc = dest_bgra ? llvm->TriDrawSubsector32[bmode] : llvm->TriDrawSubsector8[bmode]; break;
case TriDrawVariant::FuzzSubsector: case TriDrawVariant::FuzzSubsector:
case TriDrawVariant::FillSubsector: drawfunc = dest_bgra ? llvm->TriFillSubsector32[bmode] : llvm->TriFillSubsector8[bmode]; break; case TriDrawVariant::FillSubsector: setupfunc = &ScreenTriangle::SetupSubsector; drawfunc = dest_bgra ? llvm->TriFillSubsector32[bmode] : llvm->TriFillSubsector8[bmode]; break;
case TriDrawVariant::Stencil: drawfunc = llvm->TriStencil; break; case TriDrawVariant::Stencil: drawfunc = &ScreenTriangle::StencilFunc; break;
case TriDrawVariant::StencilClose: drawfunc = llvm->TriStencilClose; break; case TriDrawVariant::StencilClose: drawfunc = &ScreenTriangle::StencilCloseFunc; break;
} }
TriDrawTriangleArgs args; TriDrawTriangleArgs args;
@ -139,7 +136,7 @@ void PolyTriangleDrawer::draw_arrays(const PolyDrawArgs &drawargs, TriDrawVarian
{ {
for (int j = 0; j < 3; j++) for (int j = 0; j < 3; j++)
vert[j] = shade_vertex(*drawargs.objectToClip, drawargs.clipPlane, *(vinput++)); vert[j] = shade_vertex(*drawargs.objectToClip, drawargs.clipPlane, *(vinput++));
draw_shaded_triangle(vert, ccw, &args, thread, drawfunc); draw_shaded_triangle(vert, ccw, &args, thread, setupfunc, drawfunc);
} }
} }
else if (drawargs.mode == TriangleDrawMode::Fan) else if (drawargs.mode == TriangleDrawMode::Fan)
@ -149,7 +146,7 @@ void PolyTriangleDrawer::draw_arrays(const PolyDrawArgs &drawargs, TriDrawVarian
for (int i = 2; i < vcount; i++) for (int i = 2; i < vcount; i++)
{ {
vert[2] = shade_vertex(*drawargs.objectToClip, drawargs.clipPlane, *(vinput++)); vert[2] = shade_vertex(*drawargs.objectToClip, drawargs.clipPlane, *(vinput++));
draw_shaded_triangle(vert, ccw, &args, thread, drawfunc); draw_shaded_triangle(vert, ccw, &args, thread, setupfunc, drawfunc);
vert[1] = vert[2]; vert[1] = vert[2];
} }
} }
@ -160,7 +157,7 @@ void PolyTriangleDrawer::draw_arrays(const PolyDrawArgs &drawargs, TriDrawVarian
for (int i = 2; i < vcount; i++) for (int i = 2; i < vcount; i++)
{ {
vert[2] = shade_vertex(*drawargs.objectToClip, drawargs.clipPlane, *(vinput++)); vert[2] = shade_vertex(*drawargs.objectToClip, drawargs.clipPlane, *(vinput++));
draw_shaded_triangle(vert, ccw, &args, thread, drawfunc); draw_shaded_triangle(vert, ccw, &args, thread, setupfunc, drawfunc);
vert[0] = vert[1]; vert[0] = vert[1];
vert[1] = vert[2]; vert[1] = vert[2];
ccw = !ccw; ccw = !ccw;
@ -179,7 +176,7 @@ ShadedTriVertex PolyTriangleDrawer::shade_vertex(const TriMatrix &objectToClip,
return sv; return sv;
} }
void PolyTriangleDrawer::draw_shaded_triangle(const ShadedTriVertex *vert, bool ccw, TriDrawTriangleArgs *args, WorkerThreadData *thread, void(*drawfunc)(const TriDrawTriangleArgs *, WorkerThreadData *)) void PolyTriangleDrawer::draw_shaded_triangle(const ShadedTriVertex *vert, bool ccw, TriDrawTriangleArgs *args, WorkerThreadData *thread, PolyDrawFuncPtr setupfunc, PolyDrawFuncPtr drawfunc)
{ {
// Cull, clip and generate additional vertices as needed // Cull, clip and generate additional vertices as needed
TriVertex clippedvert[max_additional_vertices]; TriVertex clippedvert[max_additional_vertices];
@ -223,6 +220,7 @@ void PolyTriangleDrawer::draw_shaded_triangle(const ShadedTriVertex *vert, bool
args->v1 = &clippedvert[numclipvert - 1]; args->v1 = &clippedvert[numclipvert - 1];
args->v2 = &clippedvert[i - 1]; args->v2 = &clippedvert[i - 1];
args->v3 = &clippedvert[i - 2]; args->v3 = &clippedvert[i - 2];
if (setupfunc) setupfunc(args, thread);
drawfunc(args, thread); drawfunc(args, thread);
} }
} }
@ -233,6 +231,7 @@ void PolyTriangleDrawer::draw_shaded_triangle(const ShadedTriVertex *vert, bool
args->v1 = &clippedvert[0]; args->v1 = &clippedvert[0];
args->v2 = &clippedvert[i - 1]; args->v2 = &clippedvert[i - 1];
args->v3 = &clippedvert[i]; args->v3 = &clippedvert[i];
if (setupfunc) setupfunc(args, thread);
drawfunc(args, thread); drawfunc(args, thread);
} }
} }
@ -952,7 +951,7 @@ void ScreenTriangle::SetupSubsector(const TriDrawTriangleArgs *args, WorkerThrea
uint8_t *stencilBlock = &stencilValues[block * 64]; uint8_t *stencilBlock = &stencilValues[block * 64];
uint32_t *stencilBlockMask = &stencilMasks[block]; uint32_t *stencilBlockMask = &stencilMasks[block];
bool blockIsSingleStencil = ((*stencilBlockMask) & 0xffffff00) == 0xffffff00; bool blockIsSingleStencil = ((*stencilBlockMask) & 0xffffff00) == 0xffffff00;
bool skipBlock = blockIsSingleStencil && ((*stencilBlockMask) & 0xff) != stencilTestValue; bool skipBlock = blockIsSingleStencil && ((*stencilBlockMask) & 0xff) < stencilTestValue;
// Skip block when outside an edge // Skip block when outside an edge
if (a == 0 || b == 0 || c == 0 || skipBlock) if (a == 0 || b == 0 || c == 0 || skipBlock)
@ -1043,7 +1042,7 @@ void ScreenTriangle::SetupSubsector(const TriDrawTriangleArgs *args, WorkerThrea
for (int ix = 0; ix < q; ix++) for (int ix = 0; ix < q; ix++)
{ {
bool passStencilTest = blockIsSingleStencil || stencilBlock[ix + iy * q] == stencilTestValue; bool passStencilTest = blockIsSingleStencil || stencilBlock[ix + iy * q] >= stencilTestValue;
bool covered = (CX1 > 0 && CX2 > 0 && CX3 > 0 && (x + ix) < clipright && (y + iy) < clipbottom && passStencilTest && subsector[ix] >= subsectorDepth); bool covered = (CX1 > 0 && CX2 > 0 && CX3 > 0 && (x + ix) < clipright && (y + iy) < clipbottom && passStencilTest && subsector[ix] >= subsectorDepth);
mask0 <<= 1; mask0 <<= 1;
mask0 |= (uint32_t)covered; mask0 |= (uint32_t)covered;
@ -1067,7 +1066,7 @@ void ScreenTriangle::SetupSubsector(const TriDrawTriangleArgs *args, WorkerThrea
for (int ix = 0; ix < q; ix++) for (int ix = 0; ix < q; ix++)
{ {
bool passStencilTest = blockIsSingleStencil || stencilBlock[ix + iy * q] == stencilTestValue; bool passStencilTest = blockIsSingleStencil || stencilBlock[ix + iy * q] >= stencilTestValue;
bool covered = (CX1 > 0 && CX2 > 0 && CX3 > 0 && (x + ix) < clipright && (y + iy) < clipbottom && passStencilTest && subsector[ix] >= subsectorDepth); bool covered = (CX1 > 0 && CX2 > 0 && CX3 > 0 && (x + ix) < clipright && (y + iy) < clipbottom && passStencilTest && subsector[ix] >= subsectorDepth);
mask1 <<= 1; mask1 <<= 1;
mask1 |= (uint32_t)covered; mask1 |= (uint32_t)covered;
@ -1247,6 +1246,7 @@ void ScreenTriangle::SubsectorWrite(const TriDrawTriangleArgs *args, WorkerThrea
} }
} }
#if 0
float ScreenTriangle::FindGradientX(float x0, float y0, float x1, float y1, float x2, float y2, float c0, float c1, float c2) float ScreenTriangle::FindGradientX(float x0, float y0, float x1, float y1, float x2, float y2, float c0, float c1, float c2)
{ {
float top = (c1 - c2) * (y0 - y2) - (c0 - c2) * (y1 - y2); float top = (c1 - c2) * (y0 - y2) - (c0 - c2) * (y1 - y2);
@ -1323,11 +1323,10 @@ void ScreenTriangle::Draw(const TriDrawTriangleArgs *args, WorkerThreadData *thr
int32_t varyingPos[TriVertex::NumVarying]; int32_t varyingPos[TriVertex::NumVarying];
for (int j = 0; j < TriVertex::NumVarying; j++) for (int j = 0; j < TriVertex::NumVarying; j++)
varyingPos[j] = (int32_t)(blockPosX.Varying[j] * rcpW); varyingPos[j] = (int32_t)(blockPosX.Varying[j] * rcpW);
int lightpos = 256 - (int)(clamp(shade - MIN(24.0f, globVis * blockPosX.W) / 32.0f, 0.0f, 31.0f / 32.0f) * 256.0f);
for (int x = 0; x < width; x++) for (int x = 0; x < width; x++)
{ {
int lightpos = 256 - (int)(clamp(shade - MIN(24.0f, globVis * blockPosX.W) / 32.0f, 0.0f, 31.0f / 32.0f) * 256.0f);
blockPosX.W += gradientX.W * 8; blockPosX.W += gradientX.W * 8;
for (int j = 0; j < TriVertex::NumVarying; j++) for (int j = 0; j < TriVertex::NumVarying; j++)
blockPosX.Varying[j] += gradientX.Varying[j] * 8; blockPosX.Varying[j] += gradientX.Varying[j] * 8;
@ -1508,18 +1507,7 @@ void ScreenTriangle::Draw(const TriDrawTriangleArgs *args, WorkerThreadData *thr
} }
} }
} }
#endif
void ScreenTriangle::DrawFunc(const TriDrawTriangleArgs *args, WorkerThreadData *thread)
{
SetupNormal(args, thread);
Draw(args, thread);
}
void ScreenTriangle::DrawSubsectorFunc(const TriDrawTriangleArgs *args, WorkerThreadData *thread)
{
SetupSubsector(args, thread);
Draw(args, thread);
}
void ScreenTriangle::StencilFunc(const TriDrawTriangleArgs *args, WorkerThreadData *thread) void ScreenTriangle::StencilFunc(const TriDrawTriangleArgs *args, WorkerThreadData *thread)
{ {

11
src/r_poly_triangle.h
View file

@ -153,6 +153,8 @@ struct TriMatrix
float matrix[16]; float matrix[16];
}; };
typedef void(*PolyDrawFuncPtr)(const TriDrawTriangleArgs *, WorkerThreadData *);
class PolyTriangleDrawer class PolyTriangleDrawer
{ {
public: public:
@ -163,7 +165,7 @@ public:
private: private:
static ShadedTriVertex shade_vertex(const TriMatrix &objectToClip, const float *clipPlane, const TriVertex &v); static ShadedTriVertex shade_vertex(const TriMatrix &objectToClip, const float *clipPlane, const TriVertex &v);
static void draw_arrays(const PolyDrawArgs &args, TriDrawVariant variant, TriBlendMode blendmode, WorkerThreadData *thread); static void draw_arrays(const PolyDrawArgs &args, TriDrawVariant variant, TriBlendMode blendmode, WorkerThreadData *thread);
static void draw_shaded_triangle(const ShadedTriVertex *vertices, bool ccw, TriDrawTriangleArgs *args, WorkerThreadData *thread, void(*drawfunc)(const TriDrawTriangleArgs *, WorkerThreadData *)); static void draw_shaded_triangle(const ShadedTriVertex *vertices, bool ccw, TriDrawTriangleArgs *args, WorkerThreadData *thread, PolyDrawFuncPtr setupfunc, PolyDrawFuncPtr drawfunc);
static bool cullhalfspace(float clipdistance1, float clipdistance2, float &t1, float &t2); static bool cullhalfspace(float clipdistance1, float clipdistance2, float &t1, float &t2);
static void clipedge(const ShadedTriVertex *verts, TriVertex *clippedvert, int &numclipvert); static void clipedge(const ShadedTriVertex *verts, TriVertex *clippedvert, int &numclipvert);
@ -274,18 +276,11 @@ struct ScreenTriangleStepVariables
class ScreenTriangle class ScreenTriangle
{ {
public: public:
static void DrawFunc(const TriDrawTriangleArgs *args, WorkerThreadData *thread);
static void DrawSubsectorFunc(const TriDrawTriangleArgs *args, WorkerThreadData *thread);
static void StencilFunc(const TriDrawTriangleArgs *args, WorkerThreadData *thread); static void StencilFunc(const TriDrawTriangleArgs *args, WorkerThreadData *thread);
static void StencilCloseFunc(const TriDrawTriangleArgs *args, WorkerThreadData *thread); static void StencilCloseFunc(const TriDrawTriangleArgs *args, WorkerThreadData *thread);
private:
static void SetupNormal(const TriDrawTriangleArgs *args, WorkerThreadData *thread); static void SetupNormal(const TriDrawTriangleArgs *args, WorkerThreadData *thread);
static void SetupSubsector(const TriDrawTriangleArgs *args, WorkerThreadData *thread); static void SetupSubsector(const TriDrawTriangleArgs *args, WorkerThreadData *thread);
static void Draw(const TriDrawTriangleArgs *args, WorkerThreadData *thread);
static void StencilWrite(const TriDrawTriangleArgs *args, WorkerThreadData *thread); static void StencilWrite(const TriDrawTriangleArgs *args, WorkerThreadData *thread);
static void SubsectorWrite(const TriDrawTriangleArgs *args, WorkerThreadData *thread); static void SubsectorWrite(const TriDrawTriangleArgs *args, WorkerThreadData *thread);
static float FindGradientX(float x0, float y0, float x1, float y1, float x2, float y2, float c0, float c1, float c2);
static float FindGradientY(float x0, float y0, float x1, float y1, float x2, float y2, float c0, float c1, float c2);
}; };

960
tools/drawergen/fixedfunction/drawtrianglecodegen.cpp
View file

@ -32,6 +32,636 @@
#include "ssa/ssa_struct_type.h" #include "ssa/ssa_struct_type.h"
#include "ssa/ssa_value.h" #include "ssa/ssa_value.h"
void DrawTriangleCodegen::Generate(TriDrawVariant variant, TriBlendMode blendmode, bool truecolor, SSAValue args, SSAValue thread_data)
{
this->variant = variant;
this->blendmode = blendmode;
this->truecolor = truecolor;
pixelsize = truecolor ? 4 : 1;
LoadArgs(args, thread_data);
CalculateGradients();
DrawFullSpans();
DrawPartialBlocks();
}
void DrawTriangleCodegen::DrawFullSpans()
{
stack_i.store(SSAInt(0));
SSAForBlock loop;
SSAInt i = stack_i.load();
loop.loop_block(i < numSpans, 0);
{
SSAInt spanX = SSAShort(fullSpans[i][0].load(true).v).zext_int();
SSAInt spanY = SSAShort(fullSpans[i][1].load(true).v).zext_int();
SSAInt spanLength = fullSpans[i][2].load(true);
SSAInt width = spanLength;
SSAInt height = SSAInt(8);
stack_dest.store(destOrg[(spanX + spanY * pitch) * pixelsize]);
stack_subsector.store(subsectorGBuffer[spanX + spanY * pitch]);
stack_posYW.store(start.W + gradientX.W * (spanX - startX) + gradientY.W * (spanY - startY));
for (int j = 0; j < TriVertex::NumVarying; j++)
stack_posYVarying[j].store(start.Varying[j] + gradientX.Varying[j] * (spanX - startX) + gradientY.Varying[j] * (spanY - startY));
stack_y.store(SSAInt(0));
SSAForBlock loop_y;
SSAInt y = stack_y.load();
SSAUBytePtr dest = stack_dest.load();
SSAIntPtr subsector = stack_subsector.load();
SSAStepVariables blockPosY;
blockPosY.W = stack_posYW.load();
for (int j = 0; j < TriVertex::NumVarying; j++)
blockPosY.Varying[j] = stack_posYVarying[j].load();
loop_y.loop_block(y < height, 0);
{
stack_posXW.store(blockPosY.W);
for (int j = 0; j < TriVertex::NumVarying; j++)
stack_posXVarying[j].store(blockPosY.Varying[j]);
SSAFloat rcpW = SSAFloat((float)0x01000000) / blockPosY.W;
stack_lightpos.store(FRACUNIT - SSAInt(SSAFloat::clamp(shade - SSAFloat::MIN(SSAFloat(24.0f), globVis * blockPosY.W) / 32.0f, SSAFloat(0.0f), SSAFloat(31.0f / 32.0f)) * (float)FRACUNIT, true));
for (int j = 0; j < TriVertex::NumVarying; j++)
stack_varyingPos[j].store(SSAInt(blockPosY.Varying[j] * rcpW, false));
stack_x.store(SSAInt(0));
SSAForBlock loop_x;
SSAInt x = stack_x.load();
SSAStepVariables blockPosX;
blockPosX.W = stack_posXW.load();
for (int j = 0; j < TriVertex::NumVarying; j++)
blockPosX.Varying[j] = stack_posXVarying[j].load();
SSAInt lightpos = stack_lightpos.load();
SSAInt varyingPos[TriVertex::NumVarying];
for (int j = 0; j < TriVertex::NumVarying; j++)
varyingPos[j] = stack_varyingPos[j].load();
loop_x.loop_block(x < width, 0);
{
blockPosX.W = blockPosX.W + gradientX.W * 8.0f;
for (int j = 0; j < TriVertex::NumVarying; j++)
blockPosX.Varying[j] = blockPosX.Varying[j] + gradientX.Varying[j] * 8.0f;
rcpW = SSAFloat((float)0x01000000) / blockPosX.W;
SSAInt varyingStep[TriVertex::NumVarying];
for (int j = 0; j < TriVertex::NumVarying; j++)
{
SSAInt nextPos = SSAInt(blockPosX.Varying[j] * rcpW, false);
varyingStep[j] = (nextPos - varyingPos[j]) / 8;
}
SSAInt lightnext = FRACUNIT - SSAInt(SSAFloat::clamp(shade - SSAFloat::MIN(SSAFloat(24.0f), globVis * blockPosX.W) / 32.0f, SSAFloat(0.0f), SSAFloat(31.0f / 32.0f)) * (float)FRACUNIT, true);
SSAInt lightstep = (lightnext - lightpos) / 8;
for (int ix = 0; ix < 8; ix++)
{
if (truecolor)
{
currentlight = is_fixed_light.select(light, lightpos >> 8);
SSAUBytePtr destptr = dest[(x * 8 + ix) * 4];
destptr.store_vec4ub(ProcessPixel32(destptr.load_vec4ub(false), varyingPos));
if (variant != TriDrawVariant::DrawSubsector && variant != TriDrawVariant::FillSubsector && variant != TriDrawVariant::FuzzSubsector)
subsector[x * 8 + ix].store(subsectorDepth);
}
else
{
currentlight = is_fixed_light.select(light, lightpos >> 8);
SSAInt colormapindex = SSAInt::MIN((256 - currentlight) * 32 / 256, SSAInt(31));
currentcolormap = Colormaps[colormapindex << 8];
SSAUBytePtr destptr = dest[(x * 8 + ix)];
destptr.store(ProcessPixel8(destptr.load(false).zext_int(), varyingPos).trunc_ubyte());
if (variant != TriDrawVariant::DrawSubsector && variant != TriDrawVariant::FillSubsector && variant != TriDrawVariant::FuzzSubsector)
subsector[x * 8 + ix].store(subsectorDepth);
}
for (int j = 0; j < TriVertex::NumVarying; j++)
varyingPos[j] = varyingPos[j] + varyingStep[j];
lightpos = lightpos + lightstep;
}
for (int j = 0; j < TriVertex::NumVarying; j++)
stack_varyingPos[j].store(varyingPos[j]);
stack_lightpos.store(lightpos);
stack_posXW.store(blockPosX.W);
for (int j = 0; j < TriVertex::NumVarying; j++)
stack_posXVarying[j].store(blockPosX.Varying[j]);
stack_x.store(x + 1);
}
loop_x.end_block();
stack_posYW.store(blockPosY.W + gradientY.W);
for (int j = 0; j < TriVertex::NumVarying; j++)
stack_posYVarying[j].store(blockPosY.Varying[j] + gradientY.Varying[j]);
stack_dest.store(dest[pitch * pixelsize]);
stack_subsector.store(subsector[pitch]);
stack_y.store(y + 1);
}
loop_y.end_block();
stack_i.store(i + 1);
}
loop.end_block();
}
void DrawTriangleCodegen::DrawPartialBlocks()
{
stack_i.store(SSAInt(0));
SSAForBlock loop;
SSAInt i = stack_i.load();
loop.loop_block(i < numBlocks, 0);
{
SSAInt blockX = SSAShort(partialBlocks[i][0].load(true).v).zext_int();
SSAInt blockY = SSAShort(partialBlocks[i][1].load(true).v).zext_int();
SSAInt mask0 = partialBlocks[i][2].load(true);
SSAInt mask1 = partialBlocks[i][3].load(true);
SSAUBytePtr dest = destOrg[(blockX + blockY * pitch) * pixelsize];
SSAIntPtr subsector = subsectorGBuffer[blockX + blockY * pitch];
SSAStepVariables blockPosY;
blockPosY.W = start.W + gradientX.W * (blockX - startX) + gradientY.W * (blockY - startY);
for (int j = 0; j < TriVertex::NumVarying; j++)
blockPosY.Varying[j] = start.Varying[j] + gradientX.Varying[j] * (blockX - startX) + gradientY.Varying[j] * (blockY - startY);
for (int maskNum = 0; maskNum < 2; maskNum++)
{
SSAInt mask = (maskNum == 0) ? mask0 : mask1;
for (int y = 0; y < 4; y++)
{
SSAStepVariables blockPosX = blockPosY;
SSAFloat rcpW = SSAFloat((float)0x01000000) / blockPosX.W;
SSAInt varyingPos[TriVertex::NumVarying];
for (int j = 0; j < TriVertex::NumVarying; j++)
varyingPos[j] = SSAInt(blockPosX.Varying[j] * rcpW, false);
SSAInt lightpos = FRACUNIT - SSAInt(SSAFloat::clamp(shade - SSAFloat::MIN(SSAFloat(24.0f), globVis * blockPosX.W) / 32.0f, SSAFloat(0.0f), SSAFloat(31.0f / 32.0f)) * (float)FRACUNIT, true);
blockPosX.W = blockPosX.W + gradientX.W * 8.0f;
for (int j = 0; j < TriVertex::NumVarying; j++)
blockPosX.Varying[j] = blockPosX.Varying[j] + gradientX.Varying[j] * 8.0f;
rcpW = SSAFloat((float)0x01000000) / blockPosX.W;
SSAInt varyingStep[TriVertex::NumVarying];
for (int j = 0; j < TriVertex::NumVarying; j++)
{
SSAInt nextPos = SSAInt(blockPosX.Varying[j] * rcpW, false);
varyingStep[j] = (nextPos - varyingPos[j]) / 8;
}
SSAInt lightnext = FRACUNIT - SSAInt(SSAFloat::clamp(shade - SSAFloat::MIN(SSAFloat(24.0f), globVis * blockPosX.W) / 32.0f, SSAFloat(0.0f), SSAFloat(31.0f / 32.0f)) * (float)FRACUNIT, true);
SSAInt lightstep = (lightnext - lightpos) / 8;
for (int x = 0; x < 8; x++)
{
SSABool covered = !((mask & (1 << (31 - y * 8 - x))) == SSAInt(0));
SSAIfBlock branch;
branch.if_block(covered);
{
if (truecolor)
{
currentlight = is_fixed_light.select(light, lightpos >> 8);
SSAUBytePtr destptr = dest[x * 4];
destptr.store_vec4ub(ProcessPixel32(destptr.load_vec4ub(false), varyingPos));
if (variant != TriDrawVariant::DrawSubsector && variant != TriDrawVariant::FillSubsector && variant != TriDrawVariant::FuzzSubsector)
subsector[x].store(subsectorDepth);
}
else
{
currentlight = is_fixed_light.select(light, lightpos >> 8);
SSAInt colormapindex = SSAInt::MIN((256 - currentlight) * 32 / 256, SSAInt(31));
currentcolormap = Colormaps[colormapindex << 8];
SSAUBytePtr destptr = dest[x];
destptr.store(ProcessPixel8(destptr.load(false).zext_int(), varyingPos).trunc_ubyte());
if (variant != TriDrawVariant::DrawSubsector && variant != TriDrawVariant::FillSubsector && variant != TriDrawVariant::FuzzSubsector)
subsector[x].store(subsectorDepth);
}
}
branch.end_block();
for (int j = 0; j < TriVertex::NumVarying; j++)
varyingPos[j] = varyingPos[j] + varyingStep[j];
lightpos = lightpos + lightstep;
}
blockPosY.W = blockPosY.W + gradientY.W;
for (int j = 0; j < TriVertex::NumVarying; j++)
blockPosY.Varying[j] = blockPosY.Varying[j] + gradientY.Varying[j];
dest = dest[pitch * pixelsize];
subsector = subsector[pitch];
}
}
stack_i.store(i + 1);
}
loop.end_block();
}
SSAVec4i DrawTriangleCodegen::TranslateSample32(SSAInt *varying)
{
SSAInt ufrac = varying[0] << 8;
SSAInt vfrac = varying[1] << 8;
SSAInt upos = ((ufrac >> 16) * textureWidth) >> 16;
SSAInt vpos = ((vfrac >> 16) * textureHeight) >> 16;
SSAInt uvoffset = upos * textureHeight + vpos;
if (variant == TriDrawVariant::FillNormal || variant == TriDrawVariant::FillSubsector || variant == TriDrawVariant::FuzzSubsector)
return translation[color * 4].load_vec4ub(true);
else
return translation[texturePixels[uvoffset].load(true).zext_int() * 4].load_vec4ub(true);
}
SSAInt DrawTriangleCodegen::TranslateSample8(SSAInt *varying)
{
SSAInt ufrac = varying[0] << 8;
SSAInt vfrac = varying[1] << 8;
SSAInt upos = ((ufrac >> 16) * textureWidth) >> 16;
SSAInt vpos = ((vfrac >> 16) * textureHeight) >> 16;
SSAInt uvoffset = upos * textureHeight + vpos;
if (variant == TriDrawVariant::FillNormal || variant == TriDrawVariant::FillSubsector || variant == TriDrawVariant::FuzzSubsector)
return translation[color].load(true).zext_int();
else
return translation[texturePixels[uvoffset].load(true).zext_int()].load(true).zext_int();
}
SSAVec4i DrawTriangleCodegen::Sample32(SSAInt *varying)
{
if (variant == TriDrawVariant::FillNormal || variant == TriDrawVariant::FillSubsector || variant == TriDrawVariant::FuzzSubsector)
return SSAVec4i::unpack(color);
SSAInt ufrac = varying[0] << 8;
SSAInt vfrac = varying[1] << 8;
SSAVec4i nearest;
SSAVec4i linear;
{
SSAInt upos = ((ufrac >> 16) * textureWidth) >> 16;
SSAInt vpos = ((vfrac >> 16) * textureHeight) >> 16;
SSAInt uvoffset = upos * textureHeight + vpos;
nearest = texturePixels[uvoffset * 4].load_vec4ub(true);
}
return nearest;
/*
{
SSAInt uone = (SSAInt(0x01000000) / textureWidth) << 8;
SSAInt vone = (SSAInt(0x01000000) / textureHeight) << 8;
ufrac = ufrac - (uone >> 1);
vfrac = vfrac - (vone >> 1);
SSAInt frac_x0 = (ufrac >> FRACBITS) * textureWidth;
SSAInt frac_x1 = ((ufrac + uone) >> FRACBITS) * textureWidth;
SSAInt frac_y0 = (vfrac >> FRACBITS) * textureHeight;
SSAInt frac_y1 = ((vfrac + vone) >> FRACBITS) * textureHeight;
SSAInt x0 = frac_x0 >> FRACBITS;
SSAInt x1 = frac_x1 >> FRACBITS;
SSAInt y0 = frac_y0 >> FRACBITS;
SSAInt y1 = frac_y1 >> FRACBITS;
SSAVec4i p00 = texturePixels[(x0 * textureHeight + y0) * 4].load_vec4ub(true);
SSAVec4i p01 = texturePixels[(x0 * textureHeight + y1) * 4].load_vec4ub(true);
SSAVec4i p10 = texturePixels[(x1 * textureHeight + y0) * 4].load_vec4ub(true);
SSAVec4i p11 = texturePixels[(x1 * textureHeight + y1) * 4].load_vec4ub(true);
SSAInt inv_b = (frac_x1 >> (FRACBITS - 4)) & 15;
SSAInt inv_a = (frac_y1 >> (FRACBITS - 4)) & 15;
SSAInt a = 16 - inv_a;
SSAInt b = 16 - inv_b;
linear = (p00 * (a * b) + p01 * (inv_a * b) + p10 * (a * inv_b) + p11 * (inv_a * inv_b) + 127) >> 8;
}
return AffineLinear.select(linear, nearest);
*/
}
SSAInt DrawTriangleCodegen::Sample8(SSAInt *varying)
{
SSAInt ufrac = varying[0] << 8;
SSAInt vfrac = varying[1] << 8;
SSAInt upos = ((ufrac >> 16) * textureWidth) >> 16;
SSAInt vpos = ((vfrac >> 16) * textureHeight) >> 16;
SSAInt uvoffset = upos * textureHeight + vpos;
if (variant == TriDrawVariant::FillNormal || variant == TriDrawVariant::FillSubsector || variant == TriDrawVariant::FuzzSubsector)
return color;
else
return texturePixels[uvoffset].load(true).zext_int();
}
SSAInt DrawTriangleCodegen::Shade8(SSAInt c)
{
return currentcolormap[c].load(true).zext_int();
}
SSAVec4i DrawTriangleCodegen::ProcessPixel32(SSAVec4i bg, SSAInt *varying)
{
SSAVec4i fg;
SSAVec4i output;
switch (blendmode)
{
default:
case TriBlendMode::Copy:
fg = Sample32(varying);
output = blend_copy(shade_bgra_simple(fg, currentlight));
break;
case TriBlendMode::AlphaBlend:
fg = Sample32(varying);
output = blend_alpha_blend(shade_bgra_simple(fg, currentlight), bg);
break;
case TriBlendMode::AddSolid:
fg = Sample32(varying);
output = blend_add(shade_bgra_simple(fg, currentlight), bg, srcalpha, destalpha);
break;
case TriBlendMode::Add:
fg = Sample32(varying);
output = blend_add(shade_bgra_simple(fg, currentlight), bg, srcalpha, calc_blend_bgalpha(fg, destalpha));
break;
case TriBlendMode::Sub:
fg = Sample32(varying);
output = blend_sub(shade_bgra_simple(fg, currentlight), bg, srcalpha, calc_blend_bgalpha(fg, destalpha));
break;
case TriBlendMode::RevSub:
fg = Sample32(varying);
output = blend_revsub(shade_bgra_simple(fg, currentlight), bg, srcalpha, calc_blend_bgalpha(fg, destalpha));
break;
case TriBlendMode::Stencil:
fg = Sample32(varying);
output = blend_stencil(shade_bgra_simple(SSAVec4i::unpack(color), currentlight), fg[3], bg, srcalpha, destalpha);
break;
case TriBlendMode::Shaded:
output = blend_stencil(shade_bgra_simple(SSAVec4i::unpack(color), currentlight), Sample8(varying), bg, srcalpha, destalpha);
break;
case TriBlendMode::TranslateCopy:
fg = TranslateSample32(varying);
output = blend_copy(shade_bgra_simple(fg, currentlight));
break;
case TriBlendMode::TranslateAlphaBlend:
fg = TranslateSample32(varying);
output = blend_alpha_blend(shade_bgra_simple(fg, currentlight), bg);
break;
case TriBlendMode::TranslateAdd:
fg = TranslateSample32(varying);
output = blend_add(shade_bgra_simple(fg, currentlight), bg, srcalpha, calc_blend_bgalpha(fg, destalpha));
break;
case TriBlendMode::TranslateSub:
fg = TranslateSample32(varying);
output = blend_sub(shade_bgra_simple(fg, currentlight), bg, srcalpha, calc_blend_bgalpha(fg, destalpha));
break;
case TriBlendMode::TranslateRevSub:
fg = TranslateSample32(varying);
output = blend_revsub(shade_bgra_simple(fg, currentlight), bg, srcalpha, calc_blend_bgalpha(fg, destalpha));
break;
case TriBlendMode::AddSrcColorOneMinusSrcColor:
fg = Sample32(varying);
output = blend_add_srccolor_oneminussrccolor(shade_bgra_simple(fg, currentlight), bg);
break;
case TriBlendMode::Skycap:
fg = Sample32(varying);
output = FadeOut(varying[1], fg);
break;
}
return output;
}
SSAVec4i DrawTriangleCodegen::ToBgra(SSAInt index)
{
SSAVec4i c = BaseColors[index * 4].load_vec4ub(true);
c = c.insert(3, 255);
return c;
}
SSAInt DrawTriangleCodegen::ToPal8(SSAVec4i c)
{
return RGB32k[((c[2] >> 3) * 32 + (c[1] >> 3)) * 32 + (c[0] >> 3)].load(true).zext_int();
}
SSAInt DrawTriangleCodegen::ProcessPixel8(SSAInt bg, SSAInt *varying)
{
SSAVec4i fg;
SSAInt alpha, inv_alpha;
SSAInt output;
SSAInt palindex;
switch (blendmode)
{
default:
case TriBlendMode::Copy:
output = Shade8(Sample8(varying));
break;
case TriBlendMode::AlphaBlend:
palindex = Sample8(varying);
output = Shade8(palindex);
output = (palindex == SSAInt(0)).select(bg, output);
break;
case TriBlendMode::AddSolid:
palindex = Sample8(varying);
fg = ToBgra(Shade8(palindex));
output = ToPal8(blend_add(fg, ToBgra(bg), srcalpha, destalpha));
output = (palindex == SSAInt(0)).select(bg, output);
break;
case TriBlendMode::Add:
palindex = Sample8(varying);
fg = ToBgra(Shade8(palindex));
output = ToPal8(blend_add(fg, ToBgra(bg), srcalpha, calc_blend_bgalpha(fg, destalpha)));
output = (palindex == SSAInt(0)).select(bg, output);
break;
case TriBlendMode::Sub:
palindex = Sample8(varying);
fg = ToBgra(Shade8(palindex));
output = ToPal8(blend_sub(fg, ToBgra(bg), srcalpha, calc_blend_bgalpha(fg, destalpha)));
output = (palindex == SSAInt(0)).select(bg, output);
break;
case TriBlendMode::RevSub:
palindex = Sample8(varying);
fg = ToBgra(Shade8(palindex));
output = ToPal8(blend_revsub(fg, ToBgra(bg), srcalpha, calc_blend_bgalpha(fg, destalpha)));
output = (palindex == SSAInt(0)).select(bg, output);
break;
case TriBlendMode::Stencil:
output = ToPal8(blend_stencil(ToBgra(Shade8(color)), (Sample8(varying) == SSAInt(0)).select(SSAInt(0), SSAInt(256)), ToBgra(bg), srcalpha, destalpha));
break;
case TriBlendMode::Shaded:
palindex = Sample8(varying);
output = ToPal8(blend_stencil(ToBgra(Shade8(color)), palindex, ToBgra(bg), srcalpha, destalpha));
break;
case TriBlendMode::TranslateCopy:
palindex = TranslateSample8(varying);
output = Shade8(palindex);
output = (palindex == SSAInt(0)).select(bg, output);
break;
case TriBlendMode::TranslateAlphaBlend:
palindex = TranslateSample8(varying);
output = Shade8(palindex);
output = (palindex == SSAInt(0)).select(bg, output);
break;
case TriBlendMode::TranslateAdd:
palindex = TranslateSample8(varying);
fg = ToBgra(Shade8(palindex));
output = ToPal8(blend_add(fg, ToBgra(bg), srcalpha, calc_blend_bgalpha(fg, destalpha)));
output = (palindex == SSAInt(0)).select(bg, output);
break;
case TriBlendMode::TranslateSub:
palindex = TranslateSample8(varying);
fg = ToBgra(Shade8(palindex));
output = ToPal8(blend_sub(fg, ToBgra(bg), srcalpha, calc_blend_bgalpha(fg, destalpha)));
output = (palindex == SSAInt(0)).select(bg, output);
break;
case TriBlendMode::TranslateRevSub:
palindex = TranslateSample8(varying);
fg = ToBgra(Shade8(palindex));
output = ToPal8(blend_revsub(fg, ToBgra(bg), srcalpha, calc_blend_bgalpha(fg, destalpha)));
output = (palindex == SSAInt(0)).select(bg, output);
break;
case TriBlendMode::AddSrcColorOneMinusSrcColor:
palindex = Sample8(varying);
fg = ToBgra(Shade8(palindex));
output = ToPal8(blend_add_srccolor_oneminussrccolor(fg, ToBgra(bg)));
output = (palindex == SSAInt(0)).select(bg, output);
break;
case TriBlendMode::Skycap:
fg = ToBgra(Sample8(varying));
output = ToPal8(FadeOut(varying[1], fg));
break;
}
return output;
}
SSAVec4i DrawTriangleCodegen::FadeOut(SSAInt frac, SSAVec4i fg)
{
int start_fade = 2; // How fast it should fade out
SSAInt alpha_top = SSAInt::MAX(SSAInt::MIN(frac.ashr(16 - start_fade), SSAInt(256)), SSAInt(0));
SSAInt alpha_bottom = SSAInt::MAX(SSAInt::MIN(((2 << 24) - frac).ashr(16 - start_fade), SSAInt(256)), SSAInt(0));
SSAInt alpha = SSAInt::MIN(alpha_top, alpha_bottom);
SSAInt inv_alpha = 256 - alpha;
fg = (fg * alpha + SSAVec4i::unpack(color) * inv_alpha) / 256;
return fg.insert(3, 255);
}
void DrawTriangleCodegen::CalculateGradients()
{
gradientX.W = FindGradientX(v1.x, v1.y, v2.x, v2.y, v3.x, v3.y, v1.w, v2.w, v3.w);
gradientY.W = FindGradientY(v1.x, v1.y, v2.x, v2.y, v3.x, v3.y, v1.w, v2.w, v3.w);
start.W = v1.w + gradientX.W * (SSAFloat(startX) - v1.x) + gradientY.W * (SSAFloat(startY) - v1.y);
for (int i = 0; i < TriVertex::NumVarying; i++)
{
gradientX.Varying[i] = FindGradientX(v1.x, v1.y, v2.x, v2.y, v3.x, v3.y, v1.varying[i] * v1.w, v2.varying[i] * v2.w, v3.varying[i] * v3.w);
gradientY.Varying[i] = FindGradientY(v1.x, v1.y, v2.x, v2.y, v3.x, v3.y, v1.varying[i] * v1.w, v2.varying[i] * v2.w, v3.varying[i] * v3.w);
start.Varying[i] = v1.varying[i] * v1.w + gradientX.Varying[i] * (SSAFloat(startX) - v1.x) + gradientY.Varying[i] * (SSAFloat(startY) - v1.y);
}
shade = (64.0f - (SSAFloat(light * 255 / 256) + 12.0f) * 32.0f / 128.0f) / 32.0f;
globVis = SSAFloat(1706.0f);
}
void DrawTriangleCodegen::LoadArgs(SSAValue args, SSAValue thread_data)
{
destOrg = args[0][0].load(true);
pitch = args[0][1].load(true);
v1 = LoadTriVertex(args[0][2].load(true));
v2 = LoadTriVertex(args[0][3].load(true));
v3 = LoadTriVertex(args[0][4].load(true));
texturePixels = args[0][9].load(true);
textureWidth = args[0][10].load(true);
textureHeight = args[0][11].load(true);
translation = args[0][12].load(true);
LoadUniforms(args[0][13].load(true));
subsectorGBuffer = args[0][19].load(true);
if (!truecolor)
{
Colormaps = args[0][20].load(true);
RGB32k = args[0][21].load(true);
BaseColors = args[0][22].load(true);
}
fullSpans = thread_data[0][5].load(true);
partialBlocks = thread_data[0][6].load(true);
numSpans = thread_data[0][7].load(true);
numBlocks = thread_data[0][8].load(true);
startX = thread_data[0][9].load(true);
startY = thread_data[0][10].load(true);
}
SSATriVertex DrawTriangleCodegen::LoadTriVertex(SSAValue ptr)
{
SSATriVertex v;
v.x = ptr[0][0].load(true);
v.y = ptr[0][1].load(true);
v.z = ptr[0][2].load(true);
v.w = ptr[0][3].load(true);
for (int i = 0; i < TriVertex::NumVarying; i++)
v.varying[i] = ptr[0][4 + i].load(true);
return v;
}
void DrawTriangleCodegen::LoadUniforms(SSAValue uniforms)
{
light = uniforms[0][0].load(true);
subsectorDepth = uniforms[0][1].load(true);
color = uniforms[0][2].load(true);
srcalpha = uniforms[0][3].load(true);
destalpha = uniforms[0][4].load(true);
SSAShort light_alpha = uniforms[0][5].load(true);
SSAShort light_red = uniforms[0][6].load(true);
SSAShort light_green = uniforms[0][7].load(true);
SSAShort light_blue = uniforms[0][8].load(true);
SSAShort fade_alpha = uniforms[0][9].load(true);
SSAShort fade_red = uniforms[0][10].load(true);
SSAShort fade_green = uniforms[0][11].load(true);
SSAShort fade_blue = uniforms[0][12].load(true);
SSAShort desaturate = uniforms[0][13].load(true);
SSAInt flags = uniforms[0][14].load(true);
shade_constants.light = SSAVec4i(light_blue.zext_int(), light_green.zext_int(), light_red.zext_int(), light_alpha.zext_int());
shade_constants.fade = SSAVec4i(fade_blue.zext_int(), fade_green.zext_int(), fade_red.zext_int(), fade_alpha.zext_int());
shade_constants.desaturate = desaturate.zext_int();
is_simple_shade = (flags & TriUniforms::simple_shade) == SSAInt(TriUniforms::simple_shade);
is_nearest_filter = (flags & TriUniforms::nearest_filter) == SSAInt(TriUniforms::nearest_filter);
is_fixed_light = (flags & TriUniforms::fixed_light) == SSAInt(TriUniforms::fixed_light);
}
SSAFloat DrawTriangleCodegen::FindGradientX(SSAFloat x0, SSAFloat y0, SSAFloat x1, SSAFloat y1, SSAFloat x2, SSAFloat y2, SSAFloat c0, SSAFloat c1, SSAFloat c2)
{
SSAFloat top = (c1 - c2) * (y0 - y2) - (c0 - c2) * (y1 - y2);
SSAFloat bottom = (x1 - x2) * (y0 - y2) - (x0 - x2) * (y1 - y2);
return top / bottom;
}
SSAFloat DrawTriangleCodegen::FindGradientY(SSAFloat x0, SSAFloat y0, SSAFloat x1, SSAFloat y1, SSAFloat x2, SSAFloat y2, SSAFloat c0, SSAFloat c1, SSAFloat c2)
{
SSAFloat top = (c1 - c2) * (x0 - x2) - (c0 - c2) * (x1 - x2);
SSAFloat bottom = (x0 - x2) * (y1 - y2) - (x1 - x2) * (y0 - y2);
return top / bottom;
}
#if 0
void DrawTriangleCodegen::Generate(TriDrawVariant variant, TriBlendMode blendmode, bool truecolor, SSAValue args, SSAValue thread_data) void DrawTriangleCodegen::Generate(TriDrawVariant variant, TriBlendMode blendmode, bool truecolor, SSAValue args, SSAValue thread_data)
{ {
this->variant = variant; this->variant = variant;
@ -742,297 +1372,6 @@ void DrawTriangleCodegen::LoopMaskedStoreBlock()
} }
#endif #endif
SSAVec4i DrawTriangleCodegen::TranslateSample32(SSAInt *varying)
{
SSAInt ufrac = varying[0] << 8;
SSAInt vfrac = varying[1] << 8;
SSAInt upos = ((ufrac >> 16) * textureWidth) >> 16;
SSAInt vpos = ((vfrac >> 16) * textureHeight) >> 16;
SSAInt uvoffset = upos * textureHeight + vpos;
if (variant == TriDrawVariant::FillNormal || variant == TriDrawVariant::FillSubsector || variant == TriDrawVariant::FuzzSubsector)
return translation[color * 4].load_vec4ub(true);
else
return translation[texturePixels[uvoffset].load(true).zext_int() * 4].load_vec4ub(true);
}
SSAInt DrawTriangleCodegen::TranslateSample8(SSAInt *varying)
{
SSAInt ufrac = varying[0] << 8;
SSAInt vfrac = varying[1] << 8;
SSAInt upos = ((ufrac >> 16) * textureWidth) >> 16;
SSAInt vpos = ((vfrac >> 16) * textureHeight) >> 16;
SSAInt uvoffset = upos * textureHeight + vpos;
if (variant == TriDrawVariant::FillNormal || variant == TriDrawVariant::FillSubsector || variant == TriDrawVariant::FuzzSubsector)
return translation[color].load(true).zext_int();
else
return translation[texturePixels[uvoffset].load(true).zext_int()].load(true).zext_int();
}
SSAVec4i DrawTriangleCodegen::Sample32(SSAInt *varying)
{
if (variant == TriDrawVariant::FillNormal || variant == TriDrawVariant::FillSubsector || variant == TriDrawVariant::FuzzSubsector)
return SSAVec4i::unpack(color);
SSAInt ufrac = varying[0] << 8;
SSAInt vfrac = varying[1] << 8;
SSAVec4i nearest;
SSAVec4i linear;
{
SSAInt upos = ((ufrac >> 16) * textureWidth) >> 16;
SSAInt vpos = ((vfrac >> 16) * textureHeight) >> 16;
SSAInt uvoffset = upos * textureHeight + vpos;
nearest = texturePixels[uvoffset * 4].load_vec4ub(true);
}
{
SSAInt uone = (SSAInt(0x01000000) / textureWidth) << 8;
SSAInt vone = (SSAInt(0x01000000) / textureHeight) << 8;
ufrac = ufrac - (uone >> 1);
vfrac = vfrac - (vone >> 1);
SSAInt frac_x0 = (ufrac >> FRACBITS) * textureWidth;
SSAInt frac_x1 = ((ufrac + uone) >> FRACBITS) * textureWidth;
SSAInt frac_y0 = (vfrac >> FRACBITS) * textureHeight;
SSAInt frac_y1 = ((vfrac + vone) >> FRACBITS) * textureHeight;
SSAInt x0 = frac_x0 >> FRACBITS;
SSAInt x1 = frac_x1 >> FRACBITS;
SSAInt y0 = frac_y0 >> FRACBITS;
SSAInt y1 = frac_y1 >> FRACBITS;
SSAVec4i p00 = texturePixels[(x0 * textureHeight + y0) * 4].load_vec4ub(true);
SSAVec4i p01 = texturePixels[(x0 * textureHeight + y1) * 4].load_vec4ub(true);
SSAVec4i p10 = texturePixels[(x1 * textureHeight + y0) * 4].load_vec4ub(true);
SSAVec4i p11 = texturePixels[(x1 * textureHeight + y1) * 4].load_vec4ub(true);
SSAInt inv_b = (frac_x1 >> (FRACBITS - 4)) & 15;
SSAInt inv_a = (frac_y1 >> (FRACBITS - 4)) & 15;
SSAInt a = 16 - inv_a;
SSAInt b = 16 - inv_b;
linear = (p00 * (a * b) + p01 * (inv_a * b) + p10 * (a * inv_b) + p11 * (inv_a * inv_b) + 127) >> 8;
}
return AffineLinear.select(linear, nearest);
}
SSAInt DrawTriangleCodegen::Sample8(SSAInt *varying)
{
SSAInt ufrac = varying[0] << 8;
SSAInt vfrac = varying[1] << 8;
SSAInt upos = ((ufrac >> 16) * textureWidth) >> 16;
SSAInt vpos = ((vfrac >> 16) * textureHeight) >> 16;
SSAInt uvoffset = upos * textureHeight + vpos;
if (variant == TriDrawVariant::FillNormal || variant == TriDrawVariant::FillSubsector || variant == TriDrawVariant::FuzzSubsector)
return color;
else
return texturePixels[uvoffset].load(true).zext_int();
}
SSAInt DrawTriangleCodegen::Shade8(SSAInt c)
{
return currentcolormap[c].load(true).zext_int();
}
SSAVec4i DrawTriangleCodegen::ProcessPixel32(SSAVec4i bg, SSAInt *varying)
{
SSAVec4i fg;
SSAVec4i output;
switch (blendmode)
{
default:
case TriBlendMode::Copy:
fg = Sample32(varying);
output = blend_copy(shade_bgra_simple(fg, currentlight));
break;
case TriBlendMode::AlphaBlend:
fg = Sample32(varying);
output = blend_alpha_blend(shade_bgra_simple(fg, currentlight), bg);
break;
case TriBlendMode::AddSolid:
fg = Sample32(varying);
output = blend_add(shade_bgra_simple(fg, currentlight), bg, srcalpha, destalpha);
break;
case TriBlendMode::Add:
fg = Sample32(varying);
output = blend_add(shade_bgra_simple(fg, currentlight), bg, srcalpha, calc_blend_bgalpha(fg, destalpha));
break;
case TriBlendMode::Sub:
fg = Sample32(varying);
output = blend_sub(shade_bgra_simple(fg, currentlight), bg, srcalpha, calc_blend_bgalpha(fg, destalpha));
break;
case TriBlendMode::RevSub:
fg = Sample32(varying);
output = blend_revsub(shade_bgra_simple(fg, currentlight), bg, srcalpha, calc_blend_bgalpha(fg, destalpha));
break;
case TriBlendMode::Stencil:
fg = Sample32(varying);
output = blend_stencil(shade_bgra_simple(SSAVec4i::unpack(color), currentlight), fg[3], bg, srcalpha, destalpha);
break;
case TriBlendMode::Shaded:
output = blend_stencil(shade_bgra_simple(SSAVec4i::unpack(color), currentlight), Sample8(varying), bg, srcalpha, destalpha);
break;
case TriBlendMode::TranslateCopy:
fg = TranslateSample32(varying);
output = blend_copy(shade_bgra_simple(fg, currentlight));
break;
case TriBlendMode::TranslateAlphaBlend:
fg = TranslateSample32(varying);
output = blend_alpha_blend(shade_bgra_simple(fg, currentlight), bg);
break;
case TriBlendMode::TranslateAdd:
fg = TranslateSample32(varying);
output = blend_add(shade_bgra_simple(fg, currentlight), bg, srcalpha, calc_blend_bgalpha(fg, destalpha));
break;
case TriBlendMode::TranslateSub:
fg = TranslateSample32(varying);
output = blend_sub(shade_bgra_simple(fg, currentlight), bg, srcalpha, calc_blend_bgalpha(fg, destalpha));
break;
case TriBlendMode::TranslateRevSub:
fg = TranslateSample32(varying);
output = blend_revsub(shade_bgra_simple(fg, currentlight), bg, srcalpha, calc_blend_bgalpha(fg, destalpha));
break;
case TriBlendMode::AddSrcColorOneMinusSrcColor:
fg = Sample32(varying);
output = blend_add_srccolor_oneminussrccolor(shade_bgra_simple(fg, currentlight), bg);
break;
case TriBlendMode::Skycap:
fg = Sample32(varying);
output = FadeOut(varying[1], fg);
break;
}
return output;
}
SSAVec4i DrawTriangleCodegen::ToBgra(SSAInt index)
{
SSAVec4i c = BaseColors[index * 4].load_vec4ub(true);
c = c.insert(3, 255);
return c;
}
SSAInt DrawTriangleCodegen::ToPal8(SSAVec4i c)
{
return RGB32k[((c[2] >> 3) * 32 + (c[1] >> 3)) * 32 + (c[0] >> 3)].load(true).zext_int();
}
SSAInt DrawTriangleCodegen::ProcessPixel8(SSAInt bg, SSAInt *varying)
{
SSAVec4i fg;
SSAInt alpha, inv_alpha;
SSAInt output;
SSAInt palindex;
switch (blendmode)
{
default:
case TriBlendMode::Copy:
output = Shade8(Sample8(varying));
break;
case TriBlendMode::AlphaBlend:
palindex = Sample8(varying);
output = Shade8(palindex);
output = (palindex == SSAInt(0)).select(bg, output);
break;
case TriBlendMode::AddSolid:
palindex = Sample8(varying);
fg = ToBgra(Shade8(palindex));
output = ToPal8(blend_add(fg, ToBgra(bg), srcalpha, destalpha));
output = (palindex == SSAInt(0)).select(bg, output);
break;
case TriBlendMode::Add:
palindex = Sample8(varying);
fg = ToBgra(Shade8(palindex));
output = ToPal8(blend_add(fg, ToBgra(bg), srcalpha, calc_blend_bgalpha(fg, destalpha)));
output = (palindex == SSAInt(0)).select(bg, output);
break;
case TriBlendMode::Sub:
palindex = Sample8(varying);
fg = ToBgra(Shade8(palindex));
output = ToPal8(blend_sub(fg, ToBgra(bg), srcalpha, calc_blend_bgalpha(fg, destalpha)));
output = (palindex == SSAInt(0)).select(bg, output);
break;
case TriBlendMode::RevSub:
palindex = Sample8(varying);
fg = ToBgra(Shade8(palindex));
output = ToPal8(blend_revsub(fg, ToBgra(bg), srcalpha, calc_blend_bgalpha(fg, destalpha)));
output = (palindex == SSAInt(0)).select(bg, output);
break;
case TriBlendMode::Stencil:
output = ToPal8(blend_stencil(ToBgra(Shade8(color)), (Sample8(varying) == SSAInt(0)).select(SSAInt(0), SSAInt(256)), ToBgra(bg), srcalpha, destalpha));
break;
case TriBlendMode::Shaded:
palindex = Sample8(varying);
output = ToPal8(blend_stencil(ToBgra(Shade8(color)), palindex, ToBgra(bg), srcalpha, destalpha));
break;
case TriBlendMode::TranslateCopy:
palindex = TranslateSample8(varying);
output = Shade8(palindex);
output = (palindex == SSAInt(0)).select(bg, output);
break;
case TriBlendMode::TranslateAlphaBlend:
palindex = TranslateSample8(varying);
output = Shade8(palindex);
output = (palindex == SSAInt(0)).select(bg, output);
break;
case TriBlendMode::TranslateAdd:
palindex = TranslateSample8(varying);
fg = ToBgra(Shade8(palindex));
output = ToPal8(blend_add(fg, ToBgra(bg), srcalpha, calc_blend_bgalpha(fg, destalpha)));
output = (palindex == SSAInt(0)).select(bg, output);
break;
case TriBlendMode::TranslateSub:
palindex = TranslateSample8(varying);
fg = ToBgra(Shade8(palindex));
output = ToPal8(blend_sub(fg, ToBgra(bg), srcalpha, calc_blend_bgalpha(fg, destalpha)));
output = (palindex == SSAInt(0)).select(bg, output);
break;
case TriBlendMode::TranslateRevSub:
palindex = TranslateSample8(varying);
fg = ToBgra(Shade8(palindex));
output = ToPal8(blend_revsub(fg, ToBgra(bg), srcalpha, calc_blend_bgalpha(fg, destalpha)));
output = (palindex == SSAInt(0)).select(bg, output);
break;
case TriBlendMode::AddSrcColorOneMinusSrcColor:
palindex = Sample8(varying);
fg = ToBgra(Shade8(palindex));
output = ToPal8(blend_add_srccolor_oneminussrccolor(fg, ToBgra(bg)));
output = (palindex == SSAInt(0)).select(bg, output);
break;
case TriBlendMode::Skycap:
fg = ToBgra(Sample8(varying));
output = ToPal8(FadeOut(varying[1], fg));
break;
}
return output;
}
SSAVec4i DrawTriangleCodegen::FadeOut(SSAInt frac, SSAVec4i fg)
{
int start_fade = 2; // How fast it should fade out
SSAInt alpha_top = SSAInt::MAX(SSAInt::MIN(frac.ashr(16 - start_fade), SSAInt(256)), SSAInt(0));
SSAInt alpha_bottom = SSAInt::MAX(SSAInt::MIN(((2 << 24) - frac).ashr(16 - start_fade), SSAInt(256)), SSAInt(0));
SSAInt alpha = SSAInt::MIN(alpha_top, alpha_bottom);
SSAInt inv_alpha = 256 - alpha;
fg = (fg * alpha + SSAVec4i::unpack(color) * inv_alpha) / 256;
return fg.insert(3, 255);
}
void DrawTriangleCodegen::SetStencilBlock(SSAInt block) void DrawTriangleCodegen::SetStencilBlock(SSAInt block)
{ {
StencilBlock = stencilValues[block * 64]; StencilBlock = stencilValues[block * 64];
@ -1087,41 +1426,4 @@ void DrawTriangleCodegen::LoadArgs(SSAValue args, SSAValue thread_data)
thread.pass_end_y = SSAInt(32000); thread.pass_end_y = SSAInt(32000);
} }
SSATriVertex DrawTriangleCodegen::LoadTriVertex(SSAValue ptr) #endif
{
SSATriVertex v;
v.x = ptr[0][0].load(true);
v.y = ptr[0][1].load(true);
v.z = ptr[0][2].load(true);
v.w = ptr[0][3].load(true);
for (int i = 0; i < TriVertex::NumVarying; i++)
v.varying[i] = ptr[0][4 + i].load(true);
return v;
}
void DrawTriangleCodegen::LoadUniforms(SSAValue uniforms)
{
light = uniforms[0][0].load(true);
subsectorDepth = uniforms[0][1].load(true);
color = uniforms[0][2].load(true);
srcalpha = uniforms[0][3].load(true);
destalpha = uniforms[0][4].load(true);
SSAShort light_alpha = uniforms[0][5].load(true);
SSAShort light_red = uniforms[0][6].load(true);
SSAShort light_green = uniforms[0][7].load(true);
SSAShort light_blue = uniforms[0][8].load(true);
SSAShort fade_alpha = uniforms[0][9].load(true);
SSAShort fade_red = uniforms[0][10].load(true);
SSAShort fade_green = uniforms[0][11].load(true);
SSAShort fade_blue = uniforms[0][12].load(true);
SSAShort desaturate = uniforms[0][13].load(true);
SSAInt flags = uniforms[0][14].load(true);
shade_constants.light = SSAVec4i(light_blue.zext_int(), light_green.zext_int(), light_red.zext_int(), light_alpha.zext_int());
shade_constants.fade = SSAVec4i(fade_blue.zext_int(), fade_green.zext_int(), fade_red.zext_int(), fade_alpha.zext_int());
shade_constants.desaturate = desaturate.zext_int();
is_simple_shade = (flags & TriUniforms::simple_shade) == SSAInt(TriUniforms::simple_shade);
is_nearest_filter = (flags & TriUniforms::nearest_filter) == SSAInt(TriUniforms::nearest_filter);
is_fixed_light = (flags & TriUniforms::fixed_light) == SSAInt(TriUniforms::fixed_light);
}

87
tools/drawergen/fixedfunction/drawtrianglecodegen.h
View file

@ -30,6 +30,91 @@ struct SSATriVertex
SSAFloat varying[TriVertex::NumVarying]; SSAFloat varying[TriVertex::NumVarying];
}; };
struct SSAStepVariables
{
SSAFloat W;
SSAFloat Varying[TriVertex::NumVarying];
};
class DrawTriangleCodegen : public DrawerCodegen
{
public:
void Generate(TriDrawVariant variant, TriBlendMode blendmode, bool truecolor, SSAValue args, SSAValue thread_data);
private:
void LoadArgs(SSAValue args, SSAValue thread_data);
SSATriVertex LoadTriVertex(SSAValue v);
void LoadUniforms(SSAValue uniforms);
void CalculateGradients();
SSAFloat FindGradientX(SSAFloat x0, SSAFloat y0, SSAFloat x1, SSAFloat y1, SSAFloat x2, SSAFloat y2, SSAFloat c0, SSAFloat c1, SSAFloat c2);
SSAFloat FindGradientY(SSAFloat x0, SSAFloat y0, SSAFloat x1, SSAFloat y1, SSAFloat x2, SSAFloat y2, SSAFloat c0, SSAFloat c1, SSAFloat c2);
void DrawFullSpans();
void DrawPartialBlocks();
SSAVec4i ProcessPixel32(SSAVec4i bg, SSAInt *varying);
SSAInt ProcessPixel8(SSAInt bg, SSAInt *varying);
SSAVec4i TranslateSample32(SSAInt *varying);
SSAInt TranslateSample8(SSAInt *varying);
SSAVec4i Sample32(SSAInt *varying);
SSAInt Sample8(SSAInt *varying);
SSAInt Shade8(SSAInt c);
SSAVec4i ToBgra(SSAInt index);
SSAInt ToPal8(SSAVec4i c);
SSAVec4i FadeOut(SSAInt frac, SSAVec4i color);
SSAStack<SSAInt> stack_i, stack_y, stack_x;
SSAStack<SSAFloat> stack_posYW, stack_posXW;
SSAStack<SSAFloat> stack_posYVarying[TriVertex::NumVarying];
SSAStack<SSAFloat> stack_posXVarying[TriVertex::NumVarying];
SSAStack<SSAInt> stack_varyingPos[TriVertex::NumVarying];
SSAStack<SSAInt> stack_lightpos;
SSAStack<SSAUBytePtr> stack_dest;
SSAStack<SSAIntPtr> stack_subsector;
SSAStepVariables gradientX, gradientY, start;
SSAFloat shade, globVis;
SSAInt currentlight;
SSAUBytePtr currentcolormap;
SSAUBytePtr destOrg;
SSAIntPtr subsectorGBuffer;
SSAInt pitch;
SSATriVertex v1;
SSATriVertex v2;
SSATriVertex v3;
SSAUBytePtr texturePixels;
SSAInt textureWidth;
SSAInt textureHeight;
SSAUBytePtr translation;
SSAInt color, srcalpha, destalpha;
SSAInt light;
SSAInt subsectorDepth;
SSAShadeConstants shade_constants;
SSABool is_simple_shade;
SSABool is_nearest_filter;
SSABool is_fixed_light;
SSAUBytePtr Colormaps;
SSAUBytePtr RGB32k;
SSAUBytePtr BaseColors;
SSAInt numSpans;
SSAInt numBlocks;
SSAInt startX;
SSAInt startY;
SSAValue fullSpans; // TriFullSpan[]
SSAValue partialBlocks; // TriPartialBlock[]
TriDrawVariant variant;
TriBlendMode blendmode;
bool truecolor;
int pixelsize;
};
#if 0
class DrawTriangleCodegen : public DrawerCodegen class DrawTriangleCodegen : public DrawerCodegen
{ {
public: public:
@ -154,3 +239,5 @@ private:
SSAUBytePtr StencilBlock; SSAUBytePtr StencilBlock;
SSAIntPtr StencilBlockMask; SSAIntPtr StencilBlockMask;
}; };
#endif

85
tools/drawergen/llvmdrawers.cpp
View file

@ -204,6 +204,9 @@ void LLVMDrawers::CodegenDrawTriangle(const std::string &name, TriDrawVariant va
llvm::Type *LLVMDrawers::GetDrawColumnArgsStruct(llvm::LLVMContext &context) llvm::Type *LLVMDrawers::GetDrawColumnArgsStruct(llvm::LLVMContext &context)
{ {
if (DrawColumnArgsStruct)
return DrawColumnArgsStruct;
std::vector<llvm::Type *> elements; std::vector<llvm::Type *> elements;
elements.push_back(llvm::Type::getInt8PtrTy(context)); // uint32_t *dest; elements.push_back(llvm::Type::getInt8PtrTy(context)); // uint32_t *dest;
elements.push_back(llvm::Type::getInt8PtrTy(context)); // const uint32_t *source; elements.push_back(llvm::Type::getInt8PtrTy(context)); // const uint32_t *source;
@ -233,11 +236,15 @@ llvm::Type *LLVMDrawers::GetDrawColumnArgsStruct(llvm::LLVMContext &context)
elements.push_back(llvm::Type::getInt16Ty(context)); // uint16_t fade_blue; elements.push_back(llvm::Type::getInt16Ty(context)); // uint16_t fade_blue;
elements.push_back(llvm::Type::getInt16Ty(context)); // uint16_t desaturate; elements.push_back(llvm::Type::getInt16Ty(context)); // uint16_t desaturate;
elements.push_back(llvm::Type::getInt32Ty(context)); // uint32_t flags; elements.push_back(llvm::Type::getInt32Ty(context)); // uint32_t flags;
return llvm::StructType::create(context, elements, "DrawColumnArgs", false)->getPointerTo(); DrawColumnArgsStruct = llvm::StructType::create(context, elements, "DrawColumnArgs", false)->getPointerTo();
return DrawColumnArgsStruct;
} }
llvm::Type *LLVMDrawers::GetDrawSpanArgsStruct(llvm::LLVMContext &context) llvm::Type *LLVMDrawers::GetDrawSpanArgsStruct(llvm::LLVMContext &context)
{ {
if (DrawSpanArgsStruct)
return DrawSpanArgsStruct;
std::vector<llvm::Type *> elements; std::vector<llvm::Type *> elements;
elements.push_back(llvm::Type::getInt8PtrTy(context)); // uint8_t *destorg; elements.push_back(llvm::Type::getInt8PtrTy(context)); // uint8_t *destorg;
elements.push_back(llvm::Type::getInt8PtrTy(context)); // const uint32_t *source; elements.push_back(llvm::Type::getInt8PtrTy(context)); // const uint32_t *source;
@ -264,11 +271,15 @@ llvm::Type *LLVMDrawers::GetDrawSpanArgsStruct(llvm::LLVMContext &context)
elements.push_back(llvm::Type::getInt16Ty(context)); // uint16_t fade_blue; elements.push_back(llvm::Type::getInt16Ty(context)); // uint16_t fade_blue;
elements.push_back(llvm::Type::getInt16Ty(context)); // uint16_t desaturate; elements.push_back(llvm::Type::getInt16Ty(context)); // uint16_t desaturate;
elements.push_back(llvm::Type::getInt32Ty(context)); // uint32_t flags; elements.push_back(llvm::Type::getInt32Ty(context)); // uint32_t flags;
return llvm::StructType::create(context, elements, "DrawSpanArgs", false)->getPointerTo(); DrawSpanArgsStruct = llvm::StructType::create(context, elements, "DrawSpanArgs", false)->getPointerTo();
return DrawSpanArgsStruct;
} }
llvm::Type *LLVMDrawers::GetDrawWallArgsStruct(llvm::LLVMContext &context) llvm::Type *LLVMDrawers::GetDrawWallArgsStruct(llvm::LLVMContext &context)
{ {
if (DrawWallArgsStruct)
return DrawWallArgsStruct;
std::vector<llvm::Type *> elements; std::vector<llvm::Type *> elements;
elements.push_back(llvm::Type::getInt8PtrTy(context)); elements.push_back(llvm::Type::getInt8PtrTy(context));
for (int i = 0; i < 8; i++) for (int i = 0; i < 8; i++)
@ -285,47 +296,71 @@ llvm::Type *LLVMDrawers::GetDrawWallArgsStruct(llvm::LLVMContext &context)
elements.push_back(llvm::Type::getInt16Ty(context)); // uint16_t fade_blue; elements.push_back(llvm::Type::getInt16Ty(context)); // uint16_t fade_blue;
elements.push_back(llvm::Type::getInt16Ty(context)); // uint16_t desaturate; elements.push_back(llvm::Type::getInt16Ty(context)); // uint16_t desaturate;
elements.push_back(llvm::Type::getInt32Ty(context)); // uint32_t flags; elements.push_back(llvm::Type::getInt32Ty(context)); // uint32_t flags;
return llvm::StructType::create(context, elements, "DrawWallArgs", false)->getPointerTo(); DrawWallArgsStruct = llvm::StructType::create(context, elements, "DrawWallArgs", false)->getPointerTo();
return DrawWallArgsStruct;
} }
llvm::Type *LLVMDrawers::GetDrawSkyArgsStruct(llvm::LLVMContext &context) llvm::Type *LLVMDrawers::GetDrawSkyArgsStruct(llvm::LLVMContext &context)
{ {
if (DrawSkyArgsStruct)
return DrawSkyArgsStruct;
std::vector<llvm::Type *> elements; std::vector<llvm::Type *> elements;
elements.push_back(llvm::Type::getInt8PtrTy(context)); elements.push_back(llvm::Type::getInt8PtrTy(context));
for (int i = 0; i < 8; i++) for (int i = 0; i < 8; i++)
elements.push_back(llvm::Type::getInt8PtrTy(context)); elements.push_back(llvm::Type::getInt8PtrTy(context));
for (int i = 0; i < 15; i++) for (int i = 0; i < 15; i++)
elements.push_back(llvm::Type::getInt32Ty(context)); elements.push_back(llvm::Type::getInt32Ty(context));
return llvm::StructType::create(context, elements, "DrawSkyArgs", false)->getPointerTo(); DrawSkyArgsStruct = llvm::StructType::create(context, elements, "DrawSkyArgs", false)->getPointerTo();
return DrawSkyArgsStruct;
} }
llvm::Type *LLVMDrawers::GetWorkerThreadDataStruct(llvm::LLVMContext &context) llvm::Type *LLVMDrawers::GetWorkerThreadDataStruct(llvm::LLVMContext &context)
{ {
if (WorkerThreadDataStruct)
return WorkerThreadDataStruct;
std::vector<llvm::Type *> elements; std::vector<llvm::Type *> elements;
for (int i = 0; i < 4; i++) for (int i = 0; i < 4; i++)
elements.push_back(llvm::Type::getInt32Ty(context)); elements.push_back(llvm::Type::getInt32Ty(context));
elements.push_back(llvm::Type::getInt8PtrTy(context)); elements.push_back(llvm::Type::getInt8PtrTy(context));
return llvm::StructType::create(context, elements, "ThreadData", false)->getPointerTo(); elements.push_back(GetTriFullSpanStruct(context));
elements.push_back(GetTriPartialBlockStruct(context));
for (int i = 0; i < 4; i++)
elements.push_back(llvm::Type::getInt32Ty(context));
WorkerThreadDataStruct = llvm::StructType::create(context, elements, "ThreadData", false)->getPointerTo();
return WorkerThreadDataStruct;
} }
llvm::Type *LLVMDrawers::GetTriVertexStruct(llvm::LLVMContext &context) llvm::Type *LLVMDrawers::GetTriVertexStruct(llvm::LLVMContext &context)
{ {
if (TriVertexStruct)
return TriVertexStruct;
std::vector<llvm::Type *> elements; std::vector<llvm::Type *> elements;
for (int i = 0; i < 4 + TriVertex::NumVarying; i++) for (int i = 0; i < 4 + TriVertex::NumVarying; i++)
elements.push_back(llvm::Type::getFloatTy(context)); elements.push_back(llvm::Type::getFloatTy(context));
return llvm::StructType::create(context, elements, "TriVertex", false)->getPointerTo(); TriVertexStruct = llvm::StructType::create(context, elements, "TriVertex", false)->getPointerTo();
return TriVertexStruct;
} }
llvm::Type *LLVMDrawers::GetTriMatrixStruct(llvm::LLVMContext &context) llvm::Type *LLVMDrawers::GetTriMatrixStruct(llvm::LLVMContext &context)
{ {
if (TriMatrixStruct)
return TriMatrixStruct;
std::vector<llvm::Type *> elements; std::vector<llvm::Type *> elements;
for (int i = 0; i < 4 * 4; i++) for (int i = 0; i < 4 * 4; i++)
elements.push_back(llvm::Type::getFloatTy(context)); elements.push_back(llvm::Type::getFloatTy(context));
return llvm::StructType::create(context, elements, "TriMatrix", false)->getPointerTo(); TriMatrixStruct = llvm::StructType::create(context, elements, "TriMatrix", false)->getPointerTo();
return TriMatrixStruct;
} }
llvm::Type *LLVMDrawers::GetTriUniformsStruct(llvm::LLVMContext &context) llvm::Type *LLVMDrawers::GetTriUniformsStruct(llvm::LLVMContext &context)
{ {
if (TriUniformsStruct)
return TriUniformsStruct;
std::vector<llvm::Type *> elements; std::vector<llvm::Type *> elements;
elements.push_back(llvm::Type::getInt32Ty(context)); // uint32_t light; elements.push_back(llvm::Type::getInt32Ty(context)); // uint32_t light;
elements.push_back(llvm::Type::getInt32Ty(context)); // uint32_t subsectorDepth; elements.push_back(llvm::Type::getInt32Ty(context)); // uint32_t subsectorDepth;
@ -343,11 +378,42 @@ llvm::Type *LLVMDrawers::GetTriUniformsStruct(llvm::LLVMContext &context)
elements.push_back(llvm::Type::getInt16Ty(context)); // uint16_t desaturate; elements.push_back(llvm::Type::getInt16Ty(context)); // uint16_t desaturate;
elements.push_back(llvm::Type::getInt32Ty(context)); // uint32_t flags; elements.push_back(llvm::Type::getInt32Ty(context)); // uint32_t flags;
elements.push_back(GetTriMatrixStruct(context)); // TriMatrix objectToClip elements.push_back(GetTriMatrixStruct(context)); // TriMatrix objectToClip
return llvm::StructType::create(context, elements, "TriUniforms", false)->getPointerTo(); TriUniformsStruct = llvm::StructType::create(context, elements, "TriUniforms", false)->getPointerTo();
return TriUniformsStruct;
}
llvm::Type *LLVMDrawers::GetTriFullSpanStruct(llvm::LLVMContext &context)
{
if (TriFullSpanStruct)
return TriFullSpanStruct;
std::vector<llvm::Type *> elements;
elements.push_back(llvm::Type::getInt16Ty(context)); // uint32_t X;
elements.push_back(llvm::Type::getInt16Ty(context)); // uint32_t Y;
elements.push_back(llvm::Type::getInt32Ty(context)); // uint32_t Length;
TriFullSpanStruct = llvm::StructType::create(context, elements, "TriFullSpan", false)->getPointerTo();
return TriFullSpanStruct;
}
llvm::Type *LLVMDrawers::GetTriPartialBlockStruct(llvm::LLVMContext &context)
{
if (TriPartialBlockStruct)
return TriPartialBlockStruct;
std::vector<llvm::Type *> elements;
elements.push_back(llvm::Type::getInt16Ty(context)); // uint32_t X;
elements.push_back(llvm::Type::getInt16Ty(context)); // uint32_t Y;
elements.push_back(llvm::Type::getInt32Ty(context)); // uint32_t Mask0;
elements.push_back(llvm::Type::getInt32Ty(context)); // uint32_t Mask1;
TriPartialBlockStruct = llvm::StructType::create(context, elements, "TriPartialBlock", false)->getPointerTo();
return TriPartialBlockStruct;
} }
llvm::Type *LLVMDrawers::GetTriDrawTriangleArgs(llvm::LLVMContext &context) llvm::Type *LLVMDrawers::GetTriDrawTriangleArgs(llvm::LLVMContext &context)
{ {
if (TriDrawTriangleArgs)
return TriDrawTriangleArgs;
std::vector<llvm::Type *> elements; std::vector<llvm::Type *> elements;
elements.push_back(llvm::Type::getInt8PtrTy(context)); // uint8_t *dest; elements.push_back(llvm::Type::getInt8PtrTy(context)); // uint8_t *dest;
elements.push_back(llvm::Type::getInt32Ty(context)); // int32_t pitch; elements.push_back(llvm::Type::getInt32Ty(context)); // int32_t pitch;
@ -372,5 +438,6 @@ llvm::Type *LLVMDrawers::GetTriDrawTriangleArgs(llvm::LLVMContext &context)
elements.push_back(llvm::Type::getInt8PtrTy(context)); // const uint8_t *colormaps; elements.push_back(llvm::Type::getInt8PtrTy(context)); // const uint8_t *colormaps;
elements.push_back(llvm::Type::getInt8PtrTy(context)); // const uint8_t *RGB32k; elements.push_back(llvm::Type::getInt8PtrTy(context)); // const uint8_t *RGB32k;
elements.push_back(llvm::Type::getInt8PtrTy(context)); // const uint8_t *BaseColors; elements.push_back(llvm::Type::getInt8PtrTy(context)); // const uint8_t *BaseColors;
return llvm::StructType::create(context, elements, "TriDrawTriangle", false)->getPointerTo(); TriDrawTriangleArgs = llvm::StructType::create(context, elements, "TriDrawTriangle", false)->getPointerTo();
return TriDrawTriangleArgs;
} }

32
tools/drawergen/llvmdrawers.h
View file

@ -53,15 +53,29 @@ private:
void CodegenDrawSky(const char *name, DrawSkyVariant variant, int columns); void CodegenDrawSky(const char *name, DrawSkyVariant variant, int columns);
void CodegenDrawTriangle(const std::string &name, TriDrawVariant variant, TriBlendMode blendmode, bool truecolor); void CodegenDrawTriangle(const std::string &name, TriDrawVariant variant, TriBlendMode blendmode, bool truecolor);
static llvm::Type *GetDrawColumnArgsStruct(llvm::LLVMContext &context); llvm::Type *GetDrawColumnArgsStruct(llvm::LLVMContext &context);
static llvm::Type *GetDrawSpanArgsStruct(llvm::LLVMContext &context); llvm::Type *GetDrawSpanArgsStruct(llvm::LLVMContext &context);
static llvm::Type *GetDrawWallArgsStruct(llvm::LLVMContext &context); llvm::Type *GetDrawWallArgsStruct(llvm::LLVMContext &context);
static llvm::Type *GetDrawSkyArgsStruct(llvm::LLVMContext &context); llvm::Type *GetDrawSkyArgsStruct(llvm::LLVMContext &context);
static llvm::Type *GetWorkerThreadDataStruct(llvm::LLVMContext &context); llvm::Type *GetWorkerThreadDataStruct(llvm::LLVMContext &context);
static llvm::Type *GetTriVertexStruct(llvm::LLVMContext &context); llvm::Type *GetTriVertexStruct(llvm::LLVMContext &context);
static llvm::Type *GetTriMatrixStruct(llvm::LLVMContext &context); llvm::Type *GetTriMatrixStruct(llvm::LLVMContext &context);
static llvm::Type *GetTriUniformsStruct(llvm::LLVMContext &context); llvm::Type *GetTriUniformsStruct(llvm::LLVMContext &context);
static llvm::Type *GetTriDrawTriangleArgs(llvm::LLVMContext &context); llvm::Type *GetTriFullSpanStruct(llvm::LLVMContext &context);
llvm::Type *GetTriPartialBlockStruct(llvm::LLVMContext &context);
llvm::Type *GetTriDrawTriangleArgs(llvm::LLVMContext &context);
llvm::Type *DrawColumnArgsStruct = nullptr;
llvm::Type *DrawSpanArgsStruct = nullptr;
llvm::Type *DrawWallArgsStruct = nullptr;
llvm::Type *DrawSkyArgsStruct = nullptr;
llvm::Type *WorkerThreadDataStruct = nullptr;
llvm::Type *TriVertexStruct = nullptr;
llvm::Type *TriMatrixStruct = nullptr;
llvm::Type *TriUniformsStruct = nullptr;
llvm::Type *TriFullSpanStruct = nullptr;
llvm::Type *TriPartialBlockStruct = nullptr;
llvm::Type *TriDrawTriangleArgs = nullptr;
LLVMProgram mProgram; LLVMProgram mProgram;
std::string mNamePostfix; std::string mNamePostfix;