From 67cd018aca39f64b9788dd8fb84d359ee799bfc0 Mon Sep 17 00:00:00 2001 From: Henrik Rydgard Date: Sat, 24 Oct 2015 23:09:28 +0200 Subject: [PATCH] Rename shader bits to not clash (this is preparation for other changes) --- GPU/GLES/FragmentShaderGenerator.cpp | 212 ++++++++++++------------- GPU/GLES/VertexShaderGenerator.cpp | 224 +++++++++++++-------------- 2 files changed, 218 insertions(+), 218 deletions(-) diff --git a/GPU/GLES/FragmentShaderGenerator.cpp b/GPU/GLES/FragmentShaderGenerator.cpp index 37f9d4fa87..b30a9e637c 100644 --- a/GPU/GLES/FragmentShaderGenerator.cpp +++ b/GPU/GLES/FragmentShaderGenerator.cpp @@ -303,33 +303,33 @@ static inline LogicOpReplaceType ReplaceLogicOpType() { // Local enum { - BIT_CLEARMODE = 0, - BIT_DO_TEXTURE = 1, - BIT_TEXFUNC = 2, // 3 bits - BIT_TEXALPHA = 5, - BIT_FLIP_TEXTURE = 6, - BIT_SHADER_TEX_CLAMP = 7, - BIT_CLAMP_S = 8, - BIT_CLAMP_T = 9, - BIT_TEXTURE_AT_OFFSET = 10, - BIT_LMODE = 11, - BIT_ALPHA_TEST = 12, - BIT_ALPHA_TEST_FUNC = 13, // 3 bits - BIT_ALPHA_AGAINST_ZERO = 16, - BIT_COLOR_TEST = 17, - BIT_COLOR_TEST_FUNC = 18, // 2 bits - BIT_COLOR_AGAINST_ZERO = 20, - BIT_ENABLE_FOG = 21, - BIT_DO_TEXTURE_PROJ = 22, - BIT_COLOR_DOUBLE = 23, - BIT_STENCIL_TO_ALPHA = 24, // 2 bits - BIT_REPLACE_ALPHA_WITH_STENCIL_TYPE = 26, // 4 bits - BIT_REPLACE_LOGIC_OP_TYPE = 30, // 2 bits - BIT_REPLACE_BLEND = 32, // 3 bits - BIT_BLENDEQ = 35, // 3 bits - BIT_BLENDFUNC_A = 38, // 4 bits - BIT_BLENDFUNC_B = 42, - BIT_FLATSHADE = 46, + FS_BIT_CLEARMODE = 0, + FS_BIT_DO_TEXTURE = 1, + FS_BIT_TEXFUNC = 2, // 3 bits + FS_BIT_TEXALPHA = 5, + FS_BIT_FLIP_TEXTURE = 6, + FS_BIT_SHADER_TEX_CLAMP = 7, + FS_BIT_CLAMP_S = 8, + FS_BIT_CLAMP_T = 9, + FS_BIT_TEXTURE_AT_OFFSET = 10, + FS_BIT_LMODE = 11, + FS_BIT_ALPHA_TEST = 12, + FS_BIT_ALPHA_TEST_FUNC = 13, // 3 bits + FS_BIT_ALPHA_AGAINST_ZERO = 16, + FS_BIT_COLOR_TEST = 17, + FS_BIT_COLOR_TEST_FUNC = 18, // 2 bits + FS_BIT_COLOR_AGAINST_ZERO = 20, + FS_BIT_ENABLE_FOG = 21, + FS_BIT_DO_TEXTURE_PROJ = 22, + FS_BIT_COLOR_DOUBLE = 23, + FS_BIT_STENCIL_TO_ALPHA = 24, // 2 bits + FS_BIT_REPLACE_ALPHA_WITH_STENCIL_TYPE = 26, // 4 bits + FS_BIT_REPLACE_LOGIC_OP_TYPE = 30, // 2 bits + FS_BIT_REPLACE_BLEND = 32, // 3 bits + FS_BIT_BLENDEQ = 35, // 3 bits + FS_BIT_BLENDFUNC_A = 38, // 4 bits + FS_BIT_BLENDFUNC_B = 42, + FS_BIT_FLATSHADE = 46, }; static const char *alphaTestFuncs[] = { "NEVER", "ALWAYS", "==", "!=", "<", "<=", ">", ">=" }; @@ -337,33 +337,33 @@ static const char *alphaTestFuncs[] = { "NEVER", "ALWAYS", "==", "!=", "<", "<=" std::string FragmentShaderDesc(const ShaderID &id) { std::stringstream desc; desc << StringFromFormat("%08x:%08x ", id.d[1], id.d[0]); - if (id.Bit(BIT_CLEARMODE)) desc << "Clear "; - if (id.Bit(BIT_DO_TEXTURE)) desc << "Tex "; - if (id.Bit(BIT_DO_TEXTURE_PROJ)) desc << "TexProj "; - if (id.Bit(BIT_FLIP_TEXTURE)) desc << "Flip "; - if (id.Bit(BIT_TEXALPHA)) desc << "TexAlpha "; - if (id.Bit(BIT_TEXTURE_AT_OFFSET)) desc << "TexOffs "; - if (id.Bit(BIT_LMODE)) desc << "LM "; - if (id.Bit(BIT_ENABLE_FOG)) desc << "Fog "; - if (id.Bit(BIT_COLOR_DOUBLE)) desc << "2x "; - if (id.Bit(BIT_FLATSHADE)) desc << "Flat "; - if (id.Bit(BIT_SHADER_TEX_CLAMP)) { + if (id.Bit(FS_BIT_CLEARMODE)) desc << "Clear "; + if (id.Bit(FS_BIT_DO_TEXTURE)) desc << "Tex "; + if (id.Bit(FS_BIT_DO_TEXTURE_PROJ)) desc << "TexProj "; + if (id.Bit(FS_BIT_FLIP_TEXTURE)) desc << "Flip "; + if (id.Bit(FS_BIT_TEXALPHA)) desc << "TexAlpha "; + if (id.Bit(FS_BIT_TEXTURE_AT_OFFSET)) desc << "TexOffs "; + if (id.Bit(FS_BIT_LMODE)) desc << "LM "; + if (id.Bit(FS_BIT_ENABLE_FOG)) desc << "Fog "; + if (id.Bit(FS_BIT_COLOR_DOUBLE)) desc << "2x "; + if (id.Bit(FS_BIT_FLATSHADE)) desc << "Flat "; + if (id.Bit(FS_BIT_SHADER_TEX_CLAMP)) { desc << "TClamp"; - if (id.Bit(BIT_CLAMP_S)) desc << "S"; - if (id.Bit(BIT_CLAMP_T)) desc << "T"; + if (id.Bit(FS_BIT_CLAMP_S)) desc << "S"; + if (id.Bit(FS_BIT_CLAMP_T)) desc << "T"; desc << " "; } - if (id.Bits(BIT_REPLACE_BLEND, 3)) { - desc << "ReplaceBlend_" << id.Bits(BIT_REPLACE_BLEND, 3) << ":" << id.Bits(38, 4) << "_B:" << id.Bits(42, 4) << "_Eq:" << id.Bits(35, 3) << " "; + if (id.Bits(FS_BIT_REPLACE_BLEND, 3)) { + desc << "ReplaceBlend_" << id.Bits(FS_BIT_REPLACE_BLEND, 3) << ":" << id.Bits(38, 4) << "_B:" << id.Bits(42, 4) << "_Eq:" << id.Bits(35, 3) << " "; } - switch (id.Bits(BIT_STENCIL_TO_ALPHA, 2)) { + switch (id.Bits(FS_BIT_STENCIL_TO_ALPHA, 2)) { case REPLACE_ALPHA_NO: break; case REPLACE_ALPHA_YES: desc << "StenToAlpha "; break; case REPLACE_ALPHA_DUALSOURCE: desc << "StenToAlphaDual "; break; } - if (id.Bits(BIT_STENCIL_TO_ALPHA, 2) != REPLACE_ALPHA_NO) { - switch (id.Bits(BIT_REPLACE_ALPHA_WITH_STENCIL_TYPE, 4)) { + if (id.Bits(FS_BIT_STENCIL_TO_ALPHA, 2) != REPLACE_ALPHA_NO) { + switch (id.Bits(FS_BIT_REPLACE_ALPHA_WITH_STENCIL_TYPE, 4)) { case STENCIL_VALUE_UNIFORM: desc << "StenUniform "; break; case STENCIL_VALUE_ZERO: desc << "Sten0 "; break; case STENCIL_VALUE_ONE: desc << "Sten1 "; break; @@ -376,8 +376,8 @@ std::string FragmentShaderDesc(const ShaderID &id) { default: desc << "StenUnknown"; break; } } - if (id.Bit(BIT_DO_TEXTURE)) { - switch (id.Bits(BIT_TEXFUNC, 3)) { + if (id.Bit(FS_BIT_DO_TEXTURE)) { + switch (id.Bits(FS_BIT_TEXFUNC, 3)) { case GE_TEXFUNC_ADD: desc << "TFuncAdd "; break; case GE_TEXFUNC_BLEND: desc << "TFuncBlend "; break; case GE_TEXFUNC_DECAL: desc << "TFuncDecal "; break; @@ -387,10 +387,10 @@ std::string FragmentShaderDesc(const ShaderID &id) { } } - if (id.Bit(BIT_ALPHA_AGAINST_ZERO)) desc << "AlphaTest0 " << alphaTestFuncs[id.Bits(BIT_ALPHA_TEST_FUNC, 3)] << " "; - else if (id.Bit(BIT_ALPHA_TEST)) desc << "AlphaTest " << alphaTestFuncs[id.Bits(BIT_ALPHA_TEST_FUNC, 3)] << " "; - if (id.Bit(BIT_COLOR_AGAINST_ZERO)) desc << "ColorTest0 " << alphaTestFuncs[id.Bits(BIT_COLOR_TEST_FUNC, 2)] << " "; // first 4 match; - else if (id.Bit(BIT_COLOR_TEST)) desc << "ColorTest " << alphaTestFuncs[id.Bits(BIT_COLOR_TEST_FUNC, 2)] << " "; // first 4 match + if (id.Bit(FS_BIT_ALPHA_AGAINST_ZERO)) desc << "AlphaTest0 " << alphaTestFuncs[id.Bits(FS_BIT_ALPHA_TEST_FUNC, 3)] << " "; + else if (id.Bit(FS_BIT_ALPHA_TEST)) desc << "AlphaTest " << alphaTestFuncs[id.Bits(FS_BIT_ALPHA_TEST_FUNC, 3)] << " "; + if (id.Bit(FS_BIT_COLOR_AGAINST_ZERO)) desc << "ColorTest0 " << alphaTestFuncs[id.Bits(FS_BIT_COLOR_TEST_FUNC, 2)] << " "; // first 4 match; + else if (id.Bit(FS_BIT_COLOR_TEST)) desc << "ColorTest " << alphaTestFuncs[id.Bits(FS_BIT_COLOR_TEST_FUNC, 2)] << " "; // first 4 match return desc.str(); } @@ -401,7 +401,7 @@ void ComputeFragmentShaderID(ShaderID *id_out, uint32_t vertType) { ShaderID id; if (gstate.isModeClear()) { // We only need one clear shader, so let's ignore the rest of the bits. - id.SetBit(BIT_CLEARMODE); + id.SetBit(FS_BIT_CLEARMODE); } else { bool isModeThrough = gstate.isModeThrough(); bool lmode = gstate.isUsingSecondaryColor() && gstate.isLightingEnabled() && !isModeThrough; @@ -421,46 +421,46 @@ void ComputeFragmentShaderID(ShaderID *id_out, uint32_t vertType) { doTextureAlpha = false; if (gstate.isTextureMapEnabled()) { - id.SetBit(BIT_DO_TEXTURE); - id.SetBits(BIT_TEXFUNC, 3, gstate.getTextureFunction()); - id.SetBit(BIT_TEXALPHA, doTextureAlpha & 1); // rgb or rgba - id.SetBit(BIT_FLIP_TEXTURE, gstate_c.flipTexture); + id.SetBit(FS_BIT_DO_TEXTURE); + id.SetBits(FS_BIT_TEXFUNC, 3, gstate.getTextureFunction()); + id.SetBit(FS_BIT_TEXALPHA, doTextureAlpha & 1); // rgb or rgba + id.SetBit(FS_BIT_FLIP_TEXTURE, gstate_c.flipTexture); if (gstate_c.needShaderTexClamp) { bool textureAtOffset = gstate_c.curTextureXOffset != 0 || gstate_c.curTextureYOffset != 0; // 4 bits total. - id.SetBit(BIT_SHADER_TEX_CLAMP); - id.SetBit(BIT_CLAMP_S, gstate.isTexCoordClampedS()); - id.SetBit(BIT_CLAMP_T, gstate.isTexCoordClampedT()); - id.SetBit(BIT_TEXTURE_AT_OFFSET, textureAtOffset); + id.SetBit(FS_BIT_SHADER_TEX_CLAMP); + id.SetBit(FS_BIT_CLAMP_S, gstate.isTexCoordClampedS()); + id.SetBit(FS_BIT_CLAMP_T, gstate.isTexCoordClampedT()); + id.SetBit(FS_BIT_TEXTURE_AT_OFFSET, textureAtOffset); } } - id.SetBit(BIT_LMODE, lmode); + id.SetBit(FS_BIT_LMODE, lmode); #if !defined(DX9_USE_HW_ALPHA_TEST) if (enableAlphaTest) { // 5 bits total. - id.SetBit(BIT_ALPHA_TEST); - id.SetBits(BIT_ALPHA_TEST_FUNC, 3, gstate.getAlphaTestFunction()); - id.SetBit(BIT_ALPHA_AGAINST_ZERO, IsAlphaTestAgainstZero()); + id.SetBit(FS_BIT_ALPHA_TEST); + id.SetBits(FS_BIT_ALPHA_TEST_FUNC, 3, gstate.getAlphaTestFunction()); + id.SetBit(FS_BIT_ALPHA_AGAINST_ZERO, IsAlphaTestAgainstZero()); } #endif if (enableColorTest) { // 4 bits total. - id.SetBit(BIT_COLOR_TEST); - id.SetBits(BIT_COLOR_TEST_FUNC, 2, gstate.getColorTestFunction()); - id.SetBit(BIT_COLOR_AGAINST_ZERO, IsColorTestAgainstZero()); + id.SetBit(FS_BIT_COLOR_TEST); + id.SetBits(FS_BIT_COLOR_TEST_FUNC, 2, gstate.getColorTestFunction()); + id.SetBit(FS_BIT_COLOR_AGAINST_ZERO, IsColorTestAgainstZero()); } - id.SetBit(BIT_ENABLE_FOG, enableFog); - id.SetBit(BIT_DO_TEXTURE_PROJ, doTextureProjection); - id.SetBit(BIT_COLOR_DOUBLE, enableColorDoubling); + id.SetBit(FS_BIT_ENABLE_FOG, enableFog); + id.SetBit(FS_BIT_DO_TEXTURE_PROJ, doTextureProjection); + id.SetBit(FS_BIT_COLOR_DOUBLE, enableColorDoubling); // 2 bits - id.SetBits(BIT_STENCIL_TO_ALPHA, 2, stencilToAlpha); + id.SetBits(FS_BIT_STENCIL_TO_ALPHA, 2, stencilToAlpha); if (stencilToAlpha != REPLACE_ALPHA_NO) { // 4 bits - id.SetBits(BIT_REPLACE_ALPHA_WITH_STENCIL_TYPE, 4, ReplaceAlphaWithStencilType()); + id.SetBits(FS_BIT_REPLACE_ALPHA_WITH_STENCIL_TYPE, 4, ReplaceAlphaWithStencilType()); } if (enableAlphaTest) @@ -469,18 +469,18 @@ void ComputeFragmentShaderID(ShaderID *id_out, uint32_t vertType) { gpuStats.numNonAlphaTestedDraws++; // 2 bits. - id.SetBits(BIT_REPLACE_LOGIC_OP_TYPE, 2, ReplaceLogicOpType()); + id.SetBits(FS_BIT_REPLACE_LOGIC_OP_TYPE, 2, ReplaceLogicOpType()); // If replaceBlend == REPLACE_BLEND_STANDARD (or REPLACE_BLEND_NO) nothing is done, so we kill these bits. if (replaceBlend > REPLACE_BLEND_STANDARD) { // 3 bits. - id.SetBits(BIT_REPLACE_BLEND, 3, replaceBlend); + id.SetBits(FS_BIT_REPLACE_BLEND, 3, replaceBlend); // 11 bits total. - id.SetBits(BIT_BLENDEQ, 3, gstate.getBlendEq()); - id.SetBits(BIT_BLENDFUNC_A, 4, gstate.getBlendFuncA()); - id.SetBits(BIT_BLENDFUNC_B, 4, gstate.getBlendFuncB()); + id.SetBits(FS_BIT_BLENDEQ, 3, gstate.getBlendEq()); + id.SetBits(FS_BIT_BLENDFUNC_A, 4, gstate.getBlendFuncA()); + id.SetBits(FS_BIT_BLENDFUNC_B, 4, gstate.getBlendFuncB()); } - id.SetBit(BIT_FLATSHADE, doFlatShading); + id.SetBit(FS_BIT_FLATSHADE, doFlatShading); } *id_out = id; @@ -578,35 +578,35 @@ bool GenerateFragmentShader(const ShaderID &id, char *buffer) { varying = "in"; } - bool lmode = id.Bit(BIT_LMODE); - bool doTexture = id.Bit(BIT_DO_TEXTURE); - bool enableFog = id.Bit(BIT_ENABLE_FOG); - bool enableAlphaTest = id.Bit(BIT_ALPHA_TEST); + bool lmode = id.Bit(FS_BIT_LMODE); + bool doTexture = id.Bit(FS_BIT_DO_TEXTURE); + bool enableFog = id.Bit(FS_BIT_ENABLE_FOG); + bool enableAlphaTest = id.Bit(FS_BIT_ALPHA_TEST); - bool alphaTestAgainstZero = id.Bit(BIT_ALPHA_AGAINST_ZERO); - bool enableColorTest = id.Bit(BIT_COLOR_TEST); - bool colorTestAgainstZero = id.Bit(BIT_COLOR_AGAINST_ZERO); - bool enableColorDoubling = id.Bit(BIT_COLOR_DOUBLE); - bool doTextureProjection = id.Bit(BIT_DO_TEXTURE_PROJ); - bool doTextureAlpha = id.Bit(BIT_TEXALPHA); - bool doFlatShading = id.Bit(BIT_FLATSHADE); - bool flipTexture = id.Bit(BIT_FLIP_TEXTURE); + bool alphaTestAgainstZero = id.Bit(FS_BIT_ALPHA_AGAINST_ZERO); + bool enableColorTest = id.Bit(FS_BIT_COLOR_TEST); + bool colorTestAgainstZero = id.Bit(FS_BIT_COLOR_AGAINST_ZERO); + bool enableColorDoubling = id.Bit(FS_BIT_COLOR_DOUBLE); + bool doTextureProjection = id.Bit(FS_BIT_DO_TEXTURE_PROJ); + bool doTextureAlpha = id.Bit(FS_BIT_TEXALPHA); + bool doFlatShading = id.Bit(FS_BIT_FLATSHADE); + bool flipTexture = id.Bit(FS_BIT_FLIP_TEXTURE); - GEComparison alphaTestFunc = (GEComparison)id.Bits(BIT_ALPHA_TEST_FUNC, 3); - GEComparison colorTestFunc = (GEComparison)id.Bits(BIT_COLOR_TEST_FUNC, 2); - bool needShaderTexClamp = id.Bit(BIT_SHADER_TEX_CLAMP); + GEComparison alphaTestFunc = (GEComparison)id.Bits(FS_BIT_ALPHA_TEST_FUNC, 3); + GEComparison colorTestFunc = (GEComparison)id.Bits(FS_BIT_COLOR_TEST_FUNC, 2); + bool needShaderTexClamp = id.Bit(FS_BIT_SHADER_TEX_CLAMP); - GETexFunc texFunc = (GETexFunc)id.Bits(BIT_TEXFUNC, 3); - bool textureAtOffset = id.Bit(BIT_TEXTURE_AT_OFFSET); + GETexFunc texFunc = (GETexFunc)id.Bits(FS_BIT_TEXFUNC, 3); + bool textureAtOffset = id.Bit(FS_BIT_TEXTURE_AT_OFFSET); - ReplaceBlendType replaceBlend = static_cast(id.Bits(BIT_REPLACE_BLEND, 3)); - ReplaceAlphaType stencilToAlpha = static_cast(id.Bits(BIT_STENCIL_TO_ALPHA, 2)); + ReplaceBlendType replaceBlend = static_cast(id.Bits(FS_BIT_REPLACE_BLEND, 3)); + ReplaceAlphaType stencilToAlpha = static_cast(id.Bits(FS_BIT_STENCIL_TO_ALPHA, 2)); - GEBlendSrcFactor replaceBlendFuncA = (GEBlendSrcFactor)id.Bits(BIT_BLENDFUNC_A, 4); - GEBlendDstFactor replaceBlendFuncB = (GEBlendDstFactor)id.Bits(BIT_BLENDFUNC_B, 4); - GEBlendMode replaceBlendEq = (GEBlendMode)id.Bits(BIT_BLENDEQ, 3); + GEBlendSrcFactor replaceBlendFuncA = (GEBlendSrcFactor)id.Bits(FS_BIT_BLENDFUNC_A, 4); + GEBlendDstFactor replaceBlendFuncB = (GEBlendDstFactor)id.Bits(FS_BIT_BLENDFUNC_B, 4); + GEBlendMode replaceBlendEq = (GEBlendMode)id.Bits(FS_BIT_BLENDEQ, 3); - bool isModeClear = id.Bit(BIT_CLEARMODE); + bool isModeClear = id.Bit(FS_BIT_CLEARMODE); const char *shading = ""; if (glslES30) @@ -632,7 +632,7 @@ bool GenerateFragmentShader(const ShaderID &id, char *buffer) { if (needShaderTexClamp && doTexture) { WRITE(p, "uniform vec4 u_texclamp;\n"); - if (id.Bit(BIT_TEXTURE_AT_OFFSET)) { + if (id.Bit(FS_BIT_TEXTURE_AT_OFFSET)) { WRITE(p, "uniform vec2 u_texclampoff;\n"); } } @@ -648,7 +648,7 @@ bool GenerateFragmentShader(const ShaderID &id, char *buffer) { } } - StencilValueType replaceAlphaWithStencilType = (StencilValueType)id.Bits(BIT_REPLACE_ALPHA_WITH_STENCIL_TYPE, 4); + StencilValueType replaceAlphaWithStencilType = (StencilValueType)id.Bits(FS_BIT_REPLACE_ALPHA_WITH_STENCIL_TYPE, 4); if (stencilToAlpha && replaceAlphaWithStencilType == STENCIL_VALUE_UNIFORM) { WRITE(p, "uniform float u_stencilReplaceValue;\n"); } @@ -737,12 +737,12 @@ bool GenerateFragmentShader(const ShaderID &id, char *buffer) { std::string modulo = (gl_extensions.bugs & BUG_PVR_SHADER_PRECISION_BAD) ? "mymod" : "mod"; - if (id.Bit(BIT_CLAMP_S)) { + if (id.Bit(FS_BIT_CLAMP_S)) { ucoord = "clamp(" + ucoord + ", u_texclamp.z, u_texclamp.x - u_texclamp.z)"; } else { ucoord = modulo + "(" + ucoord + ", u_texclamp.x)"; } - if (id.Bit(BIT_CLAMP_T)) { + if (id.Bit(FS_BIT_CLAMP_T)) { vcoord = "clamp(" + vcoord + ", u_texclamp.w, u_texclamp.y - u_texclamp.w)"; } else { vcoord = modulo + "(" + vcoord + ", u_texclamp.y)"; @@ -1086,7 +1086,7 @@ bool GenerateFragmentShader(const ShaderID &id, char *buffer) { return false; } - LogicOpReplaceType replaceLogicOpType = (LogicOpReplaceType)id.Bits(BIT_REPLACE_LOGIC_OP_TYPE, 2); + LogicOpReplaceType replaceLogicOpType = (LogicOpReplaceType)id.Bits(FS_BIT_REPLACE_LOGIC_OP_TYPE, 2); switch (replaceLogicOpType) { case LOGICOPTYPE_ONE: WRITE(p, " %s.rgb = vec3(1.0, 1.0, 1.0);\n", fragColor0); diff --git a/GPU/GLES/VertexShaderGenerator.cpp b/GPU/GLES/VertexShaderGenerator.cpp index a44e5e2791..5523ea073f 100644 --- a/GPU/GLES/VertexShaderGenerator.cpp +++ b/GPU/GLES/VertexShaderGenerator.cpp @@ -46,77 +46,77 @@ // TODO: There will be additional bits, indicating that groups of these will be // sent to the shader and processed there. This will cut down the number of shaders ("ubershader approach") enum { - BIT_LMODE = 0, - BIT_IS_THROUGH = 1, - BIT_ENABLE_FOG = 2, - BIT_HAS_COLOR = 3, - BIT_DO_TEXTURE = 4, - BIT_FLIP_TEXTURE = 5, - BIT_DO_TEXTURE_PROJ = 6, - BIT_USE_HW_TRANSFORM = 8, - BIT_HAS_NORMAL = 9, // conditioned on hw transform - BIT_NORM_REVERSE = 10, - BIT_HAS_TEXCOORD = 11, // 5 free after - BIT_UVGEN_MODE = 16, - BIT_UVPROJ_MODE = 18, // 2, can overlap with LS0 - BIT_LS0 = 18, // 2 - BIT_LS1 = 20, // 2 - BIT_BONES = 22, // 3 should be enough, not 8 - BIT_ENABLE_BONES = 30, - BIT_LIGHT0_COMP = 32, // 2 bits - BIT_LIGHT0_TYPE = 34, // 2 bits - BIT_LIGHT1_COMP = 36, // 2 bits - BIT_LIGHT1_TYPE = 38, // 2 bits - BIT_LIGHT2_COMP = 40, // 2 bits - BIT_LIGHT2_TYPE = 42, // 2 bits - BIT_LIGHT3_COMP = 44, // 2 bits - BIT_LIGHT3_TYPE = 46, // 2 bits - BIT_MATERIAL_UPDATE = 48, // 3 bits, 1 free after - BIT_LIGHT0_ENABLE = 52, - BIT_LIGHT1_ENABLE = 53, - BIT_LIGHT2_ENABLE = 54, - BIT_LIGHT3_ENABLE = 55, - BIT_LIGHTING_ENABLE = 56, - BIT_WEIGHT_FMTSCALE = 57, // only two bits, 1 free after - BIT_TEXCOORD_FMTSCALE = 60, - BIT_FLATSHADE = 62, // 1 free after + VS_BIT_LMODE = 0, + VS_BIT_IS_THROUGH = 1, + VS_BIT_ENABLE_FOG = 2, + VS_BIT_HAS_COLOR = 3, + VS_BIT_DO_TEXTURE = 4, + VS_BIT_FLIP_TEXTURE = 5, + VS_BIT_DO_TEXTURE_PROJ = 6, + VS_BIT_USE_HW_TRANSFORM = 8, + VS_BIT_HAS_NORMAL = 9, // conditioned on hw transform + VS_BIT_NORM_REVERSE = 10, + VS_BIT_HAS_TEXCOORD = 11, // 5 free after + VS_BIT_UVGEN_MODE = 16, + VS_BIT_UVPROJ_MODE = 18, // 2, can overlap with LS0 + VS_BIT_LS0 = 18, // 2 + VS_BIT_LS1 = 20, // 2 + VS_BIT_BONES = 22, // 3 should be enough, not 8 + VS_BIT_ENABLE_BONES = 30, + VS_BIT_LIGHT0_COMP = 32, // 2 bits + VS_BIT_LIGHT0_TYPE = 34, // 2 bits + VS_BIT_LIGHT1_COMP = 36, // 2 bits + VS_BIT_LIGHT1_TYPE = 38, // 2 bits + VS_BIT_LIGHT2_COMP = 40, // 2 bits + VS_BIT_LIGHT2_TYPE = 42, // 2 bits + VS_BIT_LIGHT3_COMP = 44, // 2 bits + VS_BIT_LIGHT3_TYPE = 46, // 2 bits + VS_BIT_MATERIAL_UPDATE = 48, // 3 bits, 1 free after + VS_BIT_LIGHT0_ENABLE = 52, + VS_BIT_LIGHT1_ENABLE = 53, + VS_BIT_LIGHT2_ENABLE = 54, + VS_BIT_LIGHT3_ENABLE = 55, + VS_BIT_LIGHTING_ENABLE = 56, + VS_BIT_WEIGHT_FMTSCALE = 57, // only two bits, 1 free after + VS_BIT_TEXCOORD_FMTSCALE = 60, + VS_BIT_FLATSHADE = 62, // 1 free after }; std::string VertexShaderDesc(const ShaderID &id) { std::stringstream desc; desc << StringFromFormat("%08x:%08x ", id.d[1], id.d[0]); - if (id.Bit(BIT_IS_THROUGH)) desc << "THR "; - if (id.Bit(BIT_USE_HW_TRANSFORM)) desc << "HWX "; - if (id.Bit(BIT_HAS_COLOR)) desc << "C "; - if (id.Bit(BIT_HAS_TEXCOORD)) desc << "T "; - if (id.Bit(BIT_HAS_NORMAL)) desc << "N "; - if (id.Bit(BIT_LMODE)) desc << "LM "; - if (id.Bit(BIT_ENABLE_FOG)) desc << "Fog "; - if (id.Bit(BIT_NORM_REVERSE)) desc << "RevN "; - if (id.Bit(BIT_DO_TEXTURE)) desc << "Tex "; - if (id.Bit(BIT_DO_TEXTURE_PROJ)) desc << "TexProj "; - if (id.Bit(BIT_FLIP_TEXTURE)) desc << "Flip "; - int uvgMode = id.Bits(BIT_UVGEN_MODE, 2); + if (id.Bit(VS_BIT_IS_THROUGH)) desc << "THR "; + if (id.Bit(VS_BIT_USE_HW_TRANSFORM)) desc << "HWX "; + if (id.Bit(VS_BIT_HAS_COLOR)) desc << "C "; + if (id.Bit(VS_BIT_HAS_TEXCOORD)) desc << "T "; + if (id.Bit(VS_BIT_HAS_NORMAL)) desc << "N "; + if (id.Bit(VS_BIT_LMODE)) desc << "LM "; + if (id.Bit(VS_BIT_ENABLE_FOG)) desc << "Fog "; + if (id.Bit(VS_BIT_NORM_REVERSE)) desc << "RevN "; + if (id.Bit(VS_BIT_DO_TEXTURE)) desc << "Tex "; + if (id.Bit(VS_BIT_DO_TEXTURE_PROJ)) desc << "TexProj "; + if (id.Bit(VS_BIT_FLIP_TEXTURE)) desc << "Flip "; + int uvgMode = id.Bits(VS_BIT_UVGEN_MODE, 2); const char *uvgModes[4] = { "UV ", "UVMtx ", "UVEnv ", "UVUnk " }; - int ls0 = id.Bits(BIT_LS0, 2); - int ls1 = id.Bits(BIT_LS1, 2); + int ls0 = id.Bits(VS_BIT_LS0, 2); + int ls1 = id.Bits(VS_BIT_LS1, 2); if (uvgMode) desc << uvgModes[uvgMode]; - if (id.Bit(BIT_ENABLE_BONES)) desc << "Bones:" << (id.Bits(BIT_BONES, 3) + 1) << " "; + if (id.Bit(VS_BIT_ENABLE_BONES)) desc << "Bones:" << (id.Bits(VS_BIT_BONES, 3) + 1) << " "; // Lights - if (id.Bit(BIT_LIGHTING_ENABLE)) { + if (id.Bit(VS_BIT_LIGHTING_ENABLE)) { desc << "Light: "; for (int i = 0; i < 4; i++) { - if (id.Bit(BIT_LIGHT0_ENABLE + i) || (uvgMode == GE_TEXMAP_ENVIRONMENT_MAP && (ls0 == i || ls1 == i))) { + if (id.Bit(VS_BIT_LIGHT0_ENABLE + i) || (uvgMode == GE_TEXMAP_ENVIRONMENT_MAP && (ls0 == i || ls1 == i))) { desc << i << ": "; - desc << "c:" << id.Bits(BIT_LIGHT0_COMP + 4 * i, 2) << " t:" << id.Bits(BIT_LIGHT0_TYPE + 4 * i, 2) << " "; + desc << "c:" << id.Bits(VS_BIT_LIGHT0_COMP + 4 * i, 2) << " t:" << id.Bits(VS_BIT_LIGHT0_TYPE + 4 * i, 2) << " "; } } } - if (id.Bits(BIT_MATERIAL_UPDATE, 3)) desc << "MatUp:" << id.Bits(BIT_MATERIAL_UPDATE, 3) << " "; - if (id.Bits(BIT_WEIGHT_FMTSCALE, 2)) desc << "WScale " << id.Bits(BIT_WEIGHT_FMTSCALE, 2) << " "; - if (id.Bits(BIT_TEXCOORD_FMTSCALE, 2)) desc << "TCScale " << id.Bits(BIT_TEXCOORD_FMTSCALE, 2) << " "; - if (id.Bit(BIT_FLATSHADE)) desc << "Flat "; + if (id.Bits(VS_BIT_MATERIAL_UPDATE, 3)) desc << "MatUp:" << id.Bits(VS_BIT_MATERIAL_UPDATE, 3) << " "; + if (id.Bits(VS_BIT_WEIGHT_FMTSCALE, 2)) desc << "WScale " << id.Bits(VS_BIT_WEIGHT_FMTSCALE, 2) << " "; + if (id.Bits(VS_BIT_TEXCOORD_FMTSCALE, 2)) desc << "TCScale " << id.Bits(VS_BIT_TEXCOORD_FMTSCALE, 2) << " "; + if (id.Bit(VS_BIT_FLATSHADE)) desc << "Flat "; // TODO: More... @@ -143,67 +143,67 @@ void ComputeVertexShaderID(ShaderID *id_out, u32 vertType, bool useHWTransform) // lmode: && !isModeThrough!? ShaderID id; - id.SetBit(BIT_LMODE, lmode); - id.SetBit(BIT_IS_THROUGH, gstate.isModeThrough()); - id.SetBit(BIT_ENABLE_FOG, enableFog); - id.SetBit(BIT_HAS_COLOR, hasColor); + id.SetBit(VS_BIT_LMODE, lmode); + id.SetBit(VS_BIT_IS_THROUGH, gstate.isModeThrough()); + id.SetBit(VS_BIT_ENABLE_FOG, enableFog); + id.SetBit(VS_BIT_HAS_COLOR, hasColor); if (doTexture) { - id.SetBit(BIT_DO_TEXTURE); - id.SetBit(BIT_FLIP_TEXTURE, gstate_c.flipTexture); - id.SetBit(BIT_DO_TEXTURE_PROJ, doTextureProjection); + id.SetBit(VS_BIT_DO_TEXTURE); + id.SetBit(VS_BIT_FLIP_TEXTURE, gstate_c.flipTexture); + id.SetBit(VS_BIT_DO_TEXTURE_PROJ, doTextureProjection); } if (useHWTransform) { - id.SetBit(BIT_USE_HW_TRANSFORM); - id.SetBit(BIT_HAS_NORMAL, hasNormal); + id.SetBit(VS_BIT_USE_HW_TRANSFORM); + id.SetBit(VS_BIT_HAS_NORMAL, hasNormal); // UV generation mode. doShadeMapping is implicitly stored here. - id.SetBits(BIT_UVGEN_MODE, 2, gstate.getUVGenMode()); + id.SetBits(VS_BIT_UVGEN_MODE, 2, gstate.getUVGenMode()); // The next bits are used differently depending on UVgen mode if (doTextureProjection) { - id.SetBits(BIT_UVPROJ_MODE, 2, gstate.getUVProjMode()); + id.SetBits(VS_BIT_UVPROJ_MODE, 2, gstate.getUVProjMode()); } else if (doShadeMapping) { - id.SetBits(BIT_LS0, 2, gstate.getUVLS0()); - id.SetBits(BIT_LS1, 2, gstate.getUVLS1()); + id.SetBits(VS_BIT_LS0, 2, gstate.getUVLS0()); + id.SetBits(VS_BIT_LS1, 2, gstate.getUVLS1()); } // Bones. bool enableBones = vertTypeIsSkinningEnabled(vertType); - id.SetBit(BIT_ENABLE_BONES, enableBones); + id.SetBit(VS_BIT_ENABLE_BONES, enableBones); if (enableBones) { - id.SetBits(BIT_BONES, 3, TranslateNumBones(vertTypeGetNumBoneWeights(vertType)) - 1); + id.SetBits(VS_BIT_BONES, 3, TranslateNumBones(vertTypeGetNumBoneWeights(vertType)) - 1); // 2 bits. We should probably send in the weight scalefactor as a uniform instead, // or simply preconvert all weights to floats. - id.SetBits(BIT_WEIGHT_FMTSCALE, 2, (vertType & GE_VTYPE_WEIGHT_MASK) >> GE_VTYPE_WEIGHT_SHIFT); + id.SetBits(VS_BIT_WEIGHT_FMTSCALE, 2, (vertType & GE_VTYPE_WEIGHT_MASK) >> GE_VTYPE_WEIGHT_SHIFT); } // Okay, d[1] coming up. ============== if (gstate.isLightingEnabled() || doShadeMapping) { // doShadeMapping is stored as UVGenMode, so this is enough for isLightingEnabled. if (gstate.isLightingEnabled()) - id.SetBit(BIT_LIGHTING_ENABLE); + id.SetBit(VS_BIT_LIGHTING_ENABLE); // Light bits for (int i = 0; i < 4; i++) { - id.SetBit(BIT_LIGHT0_ENABLE + i, gstate.isLightChanEnabled(i) != 0); + id.SetBit(VS_BIT_LIGHT0_ENABLE + i, gstate.isLightChanEnabled(i) != 0); if (gstate.isLightChanEnabled(i) || (doShadeMapping && (gstate.getUVLS0() == i || gstate.getUVLS1() == i))) { - id.SetBits(BIT_LIGHT0_COMP + 4 * i, 2, gstate.getLightComputation(i)); - id.SetBits(BIT_LIGHT0_TYPE + 4 * i, 2, gstate.getLightType(i)); + id.SetBits(VS_BIT_LIGHT0_COMP + 4 * i, 2, gstate.getLightComputation(i)); + id.SetBits(VS_BIT_LIGHT0_TYPE + 4 * i, 2, gstate.getLightType(i)); } } - id.SetBits(BIT_MATERIAL_UPDATE, 3, gstate.getMaterialUpdate() & 7); + id.SetBits(VS_BIT_MATERIAL_UPDATE, 3, gstate.getMaterialUpdate() & 7); } - id.SetBit(BIT_NORM_REVERSE, gstate.areNormalsReversed()); + id.SetBit(VS_BIT_NORM_REVERSE, gstate.areNormalsReversed()); if (doTextureProjection && gstate.getUVProjMode() == GE_PROJMAP_UV) { - id.SetBits(BIT_TEXCOORD_FMTSCALE, 2, (vertType & GE_VTYPE_TC_MASK) >> GE_VTYPE_TC_SHIFT); // two bits + id.SetBits(VS_BIT_TEXCOORD_FMTSCALE, 2, (vertType & GE_VTYPE_TC_MASK) >> GE_VTYPE_TC_SHIFT); // two bits } else { - id.SetBit(BIT_HAS_TEXCOORD, hasTexcoord); + id.SetBit(VS_BIT_HAS_TEXCOORD, hasTexcoord); } } - id.SetBit(BIT_FLATSHADE, doFlatShading); + id.SetBit(VS_BIT_FLATSHADE, doFlatShading); *id_out = id; } @@ -318,31 +318,31 @@ void GenerateVertexShader(const ShaderID &id, char *buffer) { boneWeightDecl = boneWeightInDecl; } - bool lmode = id.Bit(BIT_LMODE) && !gstate.isModeThrough(); // TODO: Different expression than in shaderIDgen - bool doTexture = id.Bit(BIT_DO_TEXTURE); - bool doTextureProjection = id.Bit(BIT_DO_TEXTURE_PROJ); + bool lmode = id.Bit(VS_BIT_LMODE) && !gstate.isModeThrough(); // TODO: Different expression than in shaderIDgen + bool doTexture = id.Bit(VS_BIT_DO_TEXTURE); + bool doTextureProjection = id.Bit(VS_BIT_DO_TEXTURE_PROJ); - GETexMapMode uvGenMode = static_cast(id.Bits(BIT_UVGEN_MODE, 2)); + GETexMapMode uvGenMode = static_cast(id.Bits(VS_BIT_UVGEN_MODE, 2)); // this is only valid for some settings of uvGenMode - GETexProjMapMode uvProjMode = static_cast(id.Bits(BIT_UVPROJ_MODE, 2)); + GETexProjMapMode uvProjMode = static_cast(id.Bits(VS_BIT_UVPROJ_MODE, 2)); bool doShadeMapping = uvGenMode == GE_TEXMAP_ENVIRONMENT_MAP; - bool doFlatShading = id.Bit(BIT_FLATSHADE); + bool doFlatShading = id.Bit(VS_BIT_FLATSHADE); - bool isModeThrough = id.Bit(BIT_IS_THROUGH); - bool useHWTransform = id.Bit(BIT_USE_HW_TRANSFORM); - bool hasColor = id.Bit(BIT_HAS_COLOR) || !useHWTransform; - bool hasNormal = id.Bit(BIT_HAS_NORMAL) && useHWTransform; - bool hasTexcoord = id.Bit(BIT_HAS_TEXCOORD) || !useHWTransform; - bool enableFog = id.Bit(BIT_ENABLE_FOG); - bool throughmode = id.Bit(BIT_IS_THROUGH); - bool flipV = id.Bit(BIT_FLIP_TEXTURE); // This also means that we are texturing from a render target - bool flipNormal = id.Bit(BIT_NORM_REVERSE); - int ls0 = id.Bits(BIT_LS0, 2); - int ls1 = id.Bits(BIT_LS1, 2); - bool enableBones = id.Bit(BIT_ENABLE_BONES); - bool enableLighting = id.Bit(BIT_LIGHTING_ENABLE); - int matUpdate = id.Bits(BIT_MATERIAL_UPDATE, 3); + bool isModeThrough = id.Bit(VS_BIT_IS_THROUGH); + bool useHWTransform = id.Bit(VS_BIT_USE_HW_TRANSFORM); + bool hasColor = id.Bit(VS_BIT_HAS_COLOR) || !useHWTransform; + bool hasNormal = id.Bit(VS_BIT_HAS_NORMAL) && useHWTransform; + bool hasTexcoord = id.Bit(VS_BIT_HAS_TEXCOORD) || !useHWTransform; + bool enableFog = id.Bit(VS_BIT_ENABLE_FOG); + bool throughmode = id.Bit(VS_BIT_IS_THROUGH); + bool flipV = id.Bit(VS_BIT_FLIP_TEXTURE); // This also means that we are texturing from a render target + bool flipNormal = id.Bit(VS_BIT_NORM_REVERSE); + int ls0 = id.Bits(VS_BIT_LS0, 2); + int ls1 = id.Bits(VS_BIT_LS1, 2); + bool enableBones = id.Bit(VS_BIT_ENABLE_BONES); + bool enableLighting = id.Bit(VS_BIT_LIGHTING_ENABLE); + int matUpdate = id.Bits(VS_BIT_MATERIAL_UPDATE, 3); const char *shading = ""; if (glslES30) @@ -355,18 +355,18 @@ void GenerateVertexShader(const ShaderID &id, char *buffer) { for (int i = 0; i < 4; i++) { if (i == shadeLight0 || i == shadeLight1) doLight[i] = LIGHT_SHADE; - if (id.Bit(BIT_LIGHTING_ENABLE) && id.Bit(BIT_LIGHT0_ENABLE + i)) + if (id.Bit(VS_BIT_LIGHTING_ENABLE) && id.Bit(VS_BIT_LIGHT0_ENABLE + i)) doLight[i] = LIGHT_FULL; } } int numBoneWeights = 0; - int boneWeightScale = id.Bits(BIT_WEIGHT_FMTSCALE, 2); + int boneWeightScale = id.Bits(VS_BIT_WEIGHT_FMTSCALE, 2); if (enableBones) { - numBoneWeights = 1 + id.Bits(BIT_BONES, 3); + numBoneWeights = 1 + id.Bits(VS_BIT_BONES, 3); WRITE(p, "%s", boneWeightDecl[numBoneWeights]); } - int texFmtScale = id.Bits(BIT_TEXCOORD_FMTSCALE, 2); + int texFmtScale = id.Bits(VS_BIT_TEXCOORD_FMTSCALE, 2); if (useHWTransform) WRITE(p, "%s vec3 position;\n", attribute); @@ -421,8 +421,8 @@ void GenerateVertexShader(const ShaderID &id, char *buffer) { WRITE(p, "uniform vec3 u_lightpos%i;\n", i); } if (doLight[i] == LIGHT_FULL) { - GELightType type = static_cast(id.Bits(BIT_LIGHT0_TYPE + 4*i, 2)); - GELightComputation comp = static_cast(id.Bits(BIT_LIGHT0_COMP + 4*i, 2)); + GELightType type = static_cast(id.Bits(VS_BIT_LIGHT0_TYPE + 4*i, 2)); + GELightComputation comp = static_cast(id.Bits(VS_BIT_LIGHT0_COMP + 4*i, 2)); if (type != GE_LIGHTTYPE_DIRECTIONAL) WRITE(p, "uniform mediump vec3 u_lightatt%i;\n", i); @@ -636,8 +636,8 @@ void GenerateVertexShader(const ShaderID &id, char *buffer) { WRITE(p, " lowp vec4 lightSum0 = u_ambient * %s + vec4(u_matemissive, 0.0);\n", ambientStr); for (int i = 0; i < 4; i++) { - GELightType type = static_cast(id.Bits(BIT_LIGHT0_TYPE + 4*i, 2)); - GELightComputation comp = static_cast(id.Bits(BIT_LIGHT0_COMP + 4*i, 2)); + GELightType type = static_cast(id.Bits(VS_BIT_LIGHT0_TYPE + 4*i, 2)); + GELightComputation comp = static_cast(id.Bits(VS_BIT_LIGHT0_COMP + 4*i, 2)); if (doLight[i] != LIGHT_FULL) continue; diffuseIsZero = false; @@ -666,8 +666,8 @@ void GenerateVertexShader(const ShaderID &id, char *buffer) { if (doLight[i] != LIGHT_FULL) continue; - GELightType type = static_cast(id.Bits(BIT_LIGHT0_TYPE + 4*i, 2)); - GELightComputation comp = static_cast(id.Bits(BIT_LIGHT0_COMP + 4*i, 2)); + GELightType type = static_cast(id.Bits(VS_BIT_LIGHT0_TYPE + 4*i, 2)); + GELightComputation comp = static_cast(id.Bits(VS_BIT_LIGHT0_COMP + 4*i, 2)); if (type == GE_LIGHTTYPE_DIRECTIONAL) { // We prenormalize light positions for directional lights. @@ -725,7 +725,7 @@ void GenerateVertexShader(const ShaderID &id, char *buffer) { WRITE(p, " lightSum0.rgb += (u_lightambient%i * %s.rgb + diffuse)%s;\n", i, ambientStr, timesLightScale); } - if (id.Bit(BIT_LIGHTING_ENABLE)) { + if (id.Bit(VS_BIT_LIGHTING_ENABLE)) { // Sum up ambient, emissive here. if (lmode) { WRITE(p, " v_color0 = clamp(lightSum0, 0.0, 1.0);\n");