Emulation/ppsspp
1
0
Fork 0
mirror of https://github.com/hrydgard/ppsspp.git synced 2025-04-02 11:01:50 -04:00
Code Issues Projects Releases Packages Wiki Activity

Rename shader bits to not clash (this is preparation for other changes)

Browse source
This commit is contained in:
Henrik Rydgard 2015-10-24 23:09:28 +02:00
parent 3c82dc1462
commit 67cd018aca
2 changed files with 218 additions and 218 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

212
GPU/GLES/FragmentShaderGenerator.cpp
View file

@ -303,33 +303,33 @@ static inline LogicOpReplaceType ReplaceLogicOpType() {
// Local // Local
enum { enum {
BIT_CLEARMODE = 0, FS_BIT_CLEARMODE = 0,
BIT_DO_TEXTURE = 1, FS_BIT_DO_TEXTURE = 1,
BIT_TEXFUNC = 2, // 3 bits FS_BIT_TEXFUNC = 2, // 3 bits
BIT_TEXALPHA = 5, FS_BIT_TEXALPHA = 5,
BIT_FLIP_TEXTURE = 6, FS_BIT_FLIP_TEXTURE = 6,
BIT_SHADER_TEX_CLAMP = 7, FS_BIT_SHADER_TEX_CLAMP = 7,
BIT_CLAMP_S = 8, FS_BIT_CLAMP_S = 8,
BIT_CLAMP_T = 9, FS_BIT_CLAMP_T = 9,
BIT_TEXTURE_AT_OFFSET = 10, FS_BIT_TEXTURE_AT_OFFSET = 10,
BIT_LMODE = 11, FS_BIT_LMODE = 11,
BIT_ALPHA_TEST = 12, FS_BIT_ALPHA_TEST = 12,
BIT_ALPHA_TEST_FUNC = 13, // 3 bits FS_BIT_ALPHA_TEST_FUNC = 13, // 3 bits
BIT_ALPHA_AGAINST_ZERO = 16, FS_BIT_ALPHA_AGAINST_ZERO = 16,
BIT_COLOR_TEST = 17, FS_BIT_COLOR_TEST = 17,
BIT_COLOR_TEST_FUNC = 18, // 2 bits FS_BIT_COLOR_TEST_FUNC = 18, // 2 bits
BIT_COLOR_AGAINST_ZERO = 20, FS_BIT_COLOR_AGAINST_ZERO = 20,
BIT_ENABLE_FOG = 21, FS_BIT_ENABLE_FOG = 21,
BIT_DO_TEXTURE_PROJ = 22, FS_BIT_DO_TEXTURE_PROJ = 22,
BIT_COLOR_DOUBLE = 23, FS_BIT_COLOR_DOUBLE = 23,
BIT_STENCIL_TO_ALPHA = 24, // 2 bits FS_BIT_STENCIL_TO_ALPHA = 24, // 2 bits
BIT_REPLACE_ALPHA_WITH_STENCIL_TYPE = 26, // 4 bits FS_BIT_REPLACE_ALPHA_WITH_STENCIL_TYPE = 26, // 4 bits
BIT_REPLACE_LOGIC_OP_TYPE = 30, // 2 bits FS_BIT_REPLACE_LOGIC_OP_TYPE = 30, // 2 bits
BIT_REPLACE_BLEND = 32, // 3 bits FS_BIT_REPLACE_BLEND = 32, // 3 bits
BIT_BLENDEQ = 35, // 3 bits FS_BIT_BLENDEQ = 35, // 3 bits
BIT_BLENDFUNC_A = 38, // 4 bits FS_BIT_BLENDFUNC_A = 38, // 4 bits
BIT_BLENDFUNC_B = 42, FS_BIT_BLENDFUNC_B = 42,
BIT_FLATSHADE = 46, FS_BIT_FLATSHADE = 46,
}; };
static const char *alphaTestFuncs[] = { "NEVER", "ALWAYS", "==", "!=", "<", "<=", ">", ">=" }; static const char *alphaTestFuncs[] = { "NEVER", "ALWAYS", "==", "!=", "<", "<=", ">", ">=" };
@ -337,33 +337,33 @@ static const char *alphaTestFuncs[] = { "NEVER", "ALWAYS", "==", "!=", "<", "<="
std::string FragmentShaderDesc(const ShaderID &id) { std::string FragmentShaderDesc(const ShaderID &id) {
std::stringstream desc; std::stringstream desc;
desc << StringFromFormat("%08x:%08x ", id.d[1], id.d[0]); desc << StringFromFormat("%08x:%08x ", id.d[1], id.d[0]);
if (id.Bit(BIT_CLEARMODE)) desc << "Clear "; if (id.Bit(FS_BIT_CLEARMODE)) desc << "Clear ";
if (id.Bit(BIT_DO_TEXTURE)) desc << "Tex "; if (id.Bit(FS_BIT_DO_TEXTURE)) desc << "Tex ";
if (id.Bit(BIT_DO_TEXTURE_PROJ)) desc << "TexProj "; if (id.Bit(FS_BIT_DO_TEXTURE_PROJ)) desc << "TexProj ";
if (id.Bit(BIT_FLIP_TEXTURE)) desc << "Flip "; if (id.Bit(FS_BIT_FLIP_TEXTURE)) desc << "Flip ";
if (id.Bit(BIT_TEXALPHA)) desc << "TexAlpha "; if (id.Bit(FS_BIT_TEXALPHA)) desc << "TexAlpha ";
if (id.Bit(BIT_TEXTURE_AT_OFFSET)) desc << "TexOffs "; if (id.Bit(FS_BIT_TEXTURE_AT_OFFSET)) desc << "TexOffs ";
if (id.Bit(BIT_LMODE)) desc << "LM "; if (id.Bit(FS_BIT_LMODE)) desc << "LM ";
if (id.Bit(BIT_ENABLE_FOG)) desc << "Fog "; if (id.Bit(FS_BIT_ENABLE_FOG)) desc << "Fog ";
if (id.Bit(BIT_COLOR_DOUBLE)) desc << "2x "; if (id.Bit(FS_BIT_COLOR_DOUBLE)) desc << "2x ";
if (id.Bit(BIT_FLATSHADE)) desc << "Flat "; if (id.Bit(FS_BIT_FLATSHADE)) desc << "Flat ";
if (id.Bit(BIT_SHADER_TEX_CLAMP)) { if (id.Bit(FS_BIT_SHADER_TEX_CLAMP)) {
desc << "TClamp"; desc << "TClamp";
if (id.Bit(BIT_CLAMP_S)) desc << "S"; if (id.Bit(FS_BIT_CLAMP_S)) desc << "S";
if (id.Bit(BIT_CLAMP_T)) desc << "T"; if (id.Bit(FS_BIT_CLAMP_T)) desc << "T";
desc << " "; desc << " ";
} }
if (id.Bits(BIT_REPLACE_BLEND, 3)) { if (id.Bits(FS_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) << " "; 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_NO: break;
case REPLACE_ALPHA_YES: desc << "StenToAlpha "; break; case REPLACE_ALPHA_YES: desc << "StenToAlpha "; break;
case REPLACE_ALPHA_DUALSOURCE: desc << "StenToAlphaDual "; break; case REPLACE_ALPHA_DUALSOURCE: desc << "StenToAlphaDual "; break;
} }
if (id.Bits(BIT_STENCIL_TO_ALPHA, 2) != REPLACE_ALPHA_NO) { if (id.Bits(FS_BIT_STENCIL_TO_ALPHA, 2) != REPLACE_ALPHA_NO) {
switch (id.Bits(BIT_REPLACE_ALPHA_WITH_STENCIL_TYPE, 4)) { switch (id.Bits(FS_BIT_REPLACE_ALPHA_WITH_STENCIL_TYPE, 4)) {
case STENCIL_VALUE_UNIFORM: desc << "StenUniform "; break; case STENCIL_VALUE_UNIFORM: desc << "StenUniform "; break;
case STENCIL_VALUE_ZERO: desc << "Sten0 "; break; case STENCIL_VALUE_ZERO: desc << "Sten0 "; break;
case STENCIL_VALUE_ONE: desc << "Sten1 "; break; case STENCIL_VALUE_ONE: desc << "Sten1 "; break;
@ -376,8 +376,8 @@ std::string FragmentShaderDesc(const ShaderID &id) {
default: desc << "StenUnknown"; break; default: desc << "StenUnknown"; break;
} }
} }
if (id.Bit(BIT_DO_TEXTURE)) { if (id.Bit(FS_BIT_DO_TEXTURE)) {
switch (id.Bits(BIT_TEXFUNC, 3)) { switch (id.Bits(FS_BIT_TEXFUNC, 3)) {
case GE_TEXFUNC_ADD: desc << "TFuncAdd "; break; case GE_TEXFUNC_ADD: desc << "TFuncAdd "; break;
case GE_TEXFUNC_BLEND: desc << "TFuncBlend "; break; case GE_TEXFUNC_BLEND: desc << "TFuncBlend "; break;
case GE_TEXFUNC_DECAL: desc << "TFuncDecal "; 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)] << " "; if (id.Bit(FS_BIT_ALPHA_AGAINST_ZERO)) desc << "AlphaTest0 " << alphaTestFuncs[id.Bits(FS_BIT_ALPHA_TEST_FUNC, 3)] << " ";
else if (id.Bit(BIT_ALPHA_TEST)) desc << "AlphaTest " << alphaTestFuncs[id.Bits(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(BIT_COLOR_AGAINST_ZERO)) desc << "ColorTest0 " << alphaTestFuncs[id.Bits(BIT_COLOR_TEST_FUNC, 2)] << " "; // first 4 match; 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(BIT_COLOR_TEST)) desc << "ColorTest " << alphaTestFuncs[id.Bits(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(); return desc.str();
} }
@ -401,7 +401,7 @@ void ComputeFragmentShaderID(ShaderID *id_out, uint32_t vertType) {
ShaderID id; ShaderID id;
if (gstate.isModeClear()) { if (gstate.isModeClear()) {
// We only need one clear shader, so let's ignore the rest of the bits. // 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 { } else {
bool isModeThrough = gstate.isModeThrough(); bool isModeThrough = gstate.isModeThrough();
bool lmode = gstate.isUsingSecondaryColor() && gstate.isLightingEnabled() && !isModeThrough; bool lmode = gstate.isUsingSecondaryColor() && gstate.isLightingEnabled() && !isModeThrough;
@ -421,46 +421,46 @@ void ComputeFragmentShaderID(ShaderID *id_out, uint32_t vertType) {
doTextureAlpha = false; doTextureAlpha = false;
if (gstate.isTextureMapEnabled()) { if (gstate.isTextureMapEnabled()) {
id.SetBit(BIT_DO_TEXTURE); id.SetBit(FS_BIT_DO_TEXTURE);
id.SetBits(BIT_TEXFUNC, 3, gstate.getTextureFunction()); id.SetBits(FS_BIT_TEXFUNC, 3, gstate.getTextureFunction());
id.SetBit(BIT_TEXALPHA, doTextureAlpha & 1); // rgb or rgba id.SetBit(FS_BIT_TEXALPHA, doTextureAlpha & 1); // rgb or rgba
id.SetBit(BIT_FLIP_TEXTURE, gstate_c.flipTexture); id.SetBit(FS_BIT_FLIP_TEXTURE, gstate_c.flipTexture);
if (gstate_c.needShaderTexClamp) { if (gstate_c.needShaderTexClamp) {
bool textureAtOffset = gstate_c.curTextureXOffset != 0 || gstate_c.curTextureYOffset != 0; bool textureAtOffset = gstate_c.curTextureXOffset != 0 || gstate_c.curTextureYOffset != 0;
// 4 bits total. // 4 bits total.
id.SetBit(BIT_SHADER_TEX_CLAMP); id.SetBit(FS_BIT_SHADER_TEX_CLAMP);
id.SetBit(BIT_CLAMP_S, gstate.isTexCoordClampedS()); id.SetBit(FS_BIT_CLAMP_S, gstate.isTexCoordClampedS());
id.SetBit(BIT_CLAMP_T, gstate.isTexCoordClampedT()); id.SetBit(FS_BIT_CLAMP_T, gstate.isTexCoordClampedT());
id.SetBit(BIT_TEXTURE_AT_OFFSET, textureAtOffset); 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 !defined(DX9_USE_HW_ALPHA_TEST)
if (enableAlphaTest) { if (enableAlphaTest) {
// 5 bits total. // 5 bits total.
id.SetBit(BIT_ALPHA_TEST); id.SetBit(FS_BIT_ALPHA_TEST);
id.SetBits(BIT_ALPHA_TEST_FUNC, 3, gstate.getAlphaTestFunction()); id.SetBits(FS_BIT_ALPHA_TEST_FUNC, 3, gstate.getAlphaTestFunction());
id.SetBit(BIT_ALPHA_AGAINST_ZERO, IsAlphaTestAgainstZero()); id.SetBit(FS_BIT_ALPHA_AGAINST_ZERO, IsAlphaTestAgainstZero());
} }
#endif #endif
if (enableColorTest) { if (enableColorTest) {
// 4 bits total. // 4 bits total.
id.SetBit(BIT_COLOR_TEST); id.SetBit(FS_BIT_COLOR_TEST);
id.SetBits(BIT_COLOR_TEST_FUNC, 2, gstate.getColorTestFunction()); id.SetBits(FS_BIT_COLOR_TEST_FUNC, 2, gstate.getColorTestFunction());
id.SetBit(BIT_COLOR_AGAINST_ZERO, IsColorTestAgainstZero()); id.SetBit(FS_BIT_COLOR_AGAINST_ZERO, IsColorTestAgainstZero());
} }
id.SetBit(BIT_ENABLE_FOG, enableFog); id.SetBit(FS_BIT_ENABLE_FOG, enableFog);
id.SetBit(BIT_DO_TEXTURE_PROJ, doTextureProjection); id.SetBit(FS_BIT_DO_TEXTURE_PROJ, doTextureProjection);
id.SetBit(BIT_COLOR_DOUBLE, enableColorDoubling); id.SetBit(FS_BIT_COLOR_DOUBLE, enableColorDoubling);
// 2 bits // 2 bits
id.SetBits(BIT_STENCIL_TO_ALPHA, 2, stencilToAlpha); id.SetBits(FS_BIT_STENCIL_TO_ALPHA, 2, stencilToAlpha);
if (stencilToAlpha != REPLACE_ALPHA_NO) { if (stencilToAlpha != REPLACE_ALPHA_NO) {
// 4 bits // 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) if (enableAlphaTest)
@ -469,18 +469,18 @@ void ComputeFragmentShaderID(ShaderID *id_out, uint32_t vertType) {
gpuStats.numNonAlphaTestedDraws++; gpuStats.numNonAlphaTestedDraws++;
// 2 bits. // 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 (or REPLACE_BLEND_NO) nothing is done, so we kill these bits.
if (replaceBlend > REPLACE_BLEND_STANDARD) { if (replaceBlend > REPLACE_BLEND_STANDARD) {
// 3 bits. // 3 bits.
id.SetBits(BIT_REPLACE_BLEND, 3, replaceBlend); id.SetBits(FS_BIT_REPLACE_BLEND, 3, replaceBlend);
// 11 bits total. // 11 bits total.
id.SetBits(BIT_BLENDEQ, 3, gstate.getBlendEq()); id.SetBits(FS_BIT_BLENDEQ, 3, gstate.getBlendEq());
id.SetBits(BIT_BLENDFUNC_A, 4, gstate.getBlendFuncA()); id.SetBits(FS_BIT_BLENDFUNC_A, 4, gstate.getBlendFuncA());
id.SetBits(BIT_BLENDFUNC_B, 4, gstate.getBlendFuncB()); id.SetBits(FS_BIT_BLENDFUNC_B, 4, gstate.getBlendFuncB());
} }
id.SetBit(BIT_FLATSHADE, doFlatShading); id.SetBit(FS_BIT_FLATSHADE, doFlatShading);
} }
*id_out = id; *id_out = id;
@ -578,35 +578,35 @@ bool GenerateFragmentShader(const ShaderID &id, char *buffer) {
varying = "in"; varying = "in";
} }
bool lmode = id.Bit(BIT_LMODE); bool lmode = id.Bit(FS_BIT_LMODE);
bool doTexture = id.Bit(BIT_DO_TEXTURE); bool doTexture = id.Bit(FS_BIT_DO_TEXTURE);
bool enableFog = id.Bit(BIT_ENABLE_FOG); bool enableFog = id.Bit(FS_BIT_ENABLE_FOG);
bool enableAlphaTest = id.Bit(BIT_ALPHA_TEST); bool enableAlphaTest = id.Bit(FS_BIT_ALPHA_TEST);
bool alphaTestAgainstZero = id.Bit(BIT_ALPHA_AGAINST_ZERO); bool alphaTestAgainstZero = id.Bit(FS_BIT_ALPHA_AGAINST_ZERO);
bool enableColorTest = id.Bit(BIT_COLOR_TEST); bool enableColorTest = id.Bit(FS_BIT_COLOR_TEST);
bool colorTestAgainstZero = id.Bit(BIT_COLOR_AGAINST_ZERO); bool colorTestAgainstZero = id.Bit(FS_BIT_COLOR_AGAINST_ZERO);
bool enableColorDoubling = id.Bit(BIT_COLOR_DOUBLE); bool enableColorDoubling = id.Bit(FS_BIT_COLOR_DOUBLE);
bool doTextureProjection = id.Bit(BIT_DO_TEXTURE_PROJ); bool doTextureProjection = id.Bit(FS_BIT_DO_TEXTURE_PROJ);
bool doTextureAlpha = id.Bit(BIT_TEXALPHA); bool doTextureAlpha = id.Bit(FS_BIT_TEXALPHA);
bool doFlatShading = id.Bit(BIT_FLATSHADE); bool doFlatShading = id.Bit(FS_BIT_FLATSHADE);
bool flipTexture = id.Bit(BIT_FLIP_TEXTURE); bool flipTexture = id.Bit(FS_BIT_FLIP_TEXTURE);
GEComparison alphaTestFunc = (GEComparison)id.Bits(BIT_ALPHA_TEST_FUNC, 3); GEComparison alphaTestFunc = (GEComparison)id.Bits(FS_BIT_ALPHA_TEST_FUNC, 3);
GEComparison colorTestFunc = (GEComparison)id.Bits(BIT_COLOR_TEST_FUNC, 2); GEComparison colorTestFunc = (GEComparison)id.Bits(FS_BIT_COLOR_TEST_FUNC, 2);
bool needShaderTexClamp = id.Bit(BIT_SHADER_TEX_CLAMP); bool needShaderTexClamp = id.Bit(FS_BIT_SHADER_TEX_CLAMP);
GETexFunc texFunc = (GETexFunc)id.Bits(BIT_TEXFUNC, 3); GETexFunc texFunc = (GETexFunc)id.Bits(FS_BIT_TEXFUNC, 3);
bool textureAtOffset = id.Bit(BIT_TEXTURE_AT_OFFSET); bool textureAtOffset = id.Bit(FS_BIT_TEXTURE_AT_OFFSET);
ReplaceBlendType replaceBlend = static_cast<ReplaceBlendType>(id.Bits(BIT_REPLACE_BLEND, 3)); ReplaceBlendType replaceBlend = static_cast<ReplaceBlendType>(id.Bits(FS_BIT_REPLACE_BLEND, 3));
ReplaceAlphaType stencilToAlpha = static_cast<ReplaceAlphaType>(id.Bits(BIT_STENCIL_TO_ALPHA, 2)); ReplaceAlphaType stencilToAlpha = static_cast<ReplaceAlphaType>(id.Bits(FS_BIT_STENCIL_TO_ALPHA, 2));
GEBlendSrcFactor replaceBlendFuncA = (GEBlendSrcFactor)id.Bits(BIT_BLENDFUNC_A, 4); GEBlendSrcFactor replaceBlendFuncA = (GEBlendSrcFactor)id.Bits(FS_BIT_BLENDFUNC_A, 4);
GEBlendDstFactor replaceBlendFuncB = (GEBlendDstFactor)id.Bits(BIT_BLENDFUNC_B, 4); GEBlendDstFactor replaceBlendFuncB = (GEBlendDstFactor)id.Bits(FS_BIT_BLENDFUNC_B, 4);
GEBlendMode replaceBlendEq = (GEBlendMode)id.Bits(BIT_BLENDEQ, 3); 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 = ""; const char *shading = "";
if (glslES30) if (glslES30)
@ -632,7 +632,7 @@ bool GenerateFragmentShader(const ShaderID &id, char *buffer) {
if (needShaderTexClamp && doTexture) { if (needShaderTexClamp && doTexture) {
WRITE(p, "uniform vec4 u_texclamp;\n"); 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"); 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) { if (stencilToAlpha && replaceAlphaWithStencilType == STENCIL_VALUE_UNIFORM) {
WRITE(p, "uniform float u_stencilReplaceValue;\n"); 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"; 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)"; ucoord = "clamp(" + ucoord + ", u_texclamp.z, u_texclamp.x - u_texclamp.z)";
} else { } else {
ucoord = modulo + "(" + ucoord + ", u_texclamp.x)"; 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)"; vcoord = "clamp(" + vcoord + ", u_texclamp.w, u_texclamp.y - u_texclamp.w)";
} else { } else {
vcoord = modulo + "(" + vcoord + ", u_texclamp.y)"; vcoord = modulo + "(" + vcoord + ", u_texclamp.y)";
@ -1086,7 +1086,7 @@ bool GenerateFragmentShader(const ShaderID &id, char *buffer) {
return false; 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) { switch (replaceLogicOpType) {
case LOGICOPTYPE_ONE: case LOGICOPTYPE_ONE:
WRITE(p, " %s.rgb = vec3(1.0, 1.0, 1.0);\n", fragColor0); WRITE(p, " %s.rgb = vec3(1.0, 1.0, 1.0);\n", fragColor0);

224
GPU/GLES/VertexShaderGenerator.cpp
View file

@ -46,77 +46,77 @@
// TODO: There will be additional bits, indicating that groups of these will be // 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") // sent to the shader and processed there. This will cut down the number of shaders ("ubershader approach")
enum { enum {
BIT_LMODE = 0, VS_BIT_LMODE = 0,
BIT_IS_THROUGH = 1, VS_BIT_IS_THROUGH = 1,
BIT_ENABLE_FOG = 2, VS_BIT_ENABLE_FOG = 2,
BIT_HAS_COLOR = 3, VS_BIT_HAS_COLOR = 3,
BIT_DO_TEXTURE = 4, VS_BIT_DO_TEXTURE = 4,
BIT_FLIP_TEXTURE = 5, VS_BIT_FLIP_TEXTURE = 5,
BIT_DO_TEXTURE_PROJ = 6, VS_BIT_DO_TEXTURE_PROJ = 6,
BIT_USE_HW_TRANSFORM = 8, VS_BIT_USE_HW_TRANSFORM = 8,
BIT_HAS_NORMAL = 9, // conditioned on hw transform VS_BIT_HAS_NORMAL = 9, // conditioned on hw transform
BIT_NORM_REVERSE = 10, VS_BIT_NORM_REVERSE = 10,
BIT_HAS_TEXCOORD = 11, // 5 free after VS_BIT_HAS_TEXCOORD = 11, // 5 free after
BIT_UVGEN_MODE = 16, VS_BIT_UVGEN_MODE = 16,
BIT_UVPROJ_MODE = 18, // 2, can overlap with LS0 VS_BIT_UVPROJ_MODE = 18, // 2, can overlap with LS0
BIT_LS0 = 18, // 2 VS_BIT_LS0 = 18, // 2
BIT_LS1 = 20, // 2 VS_BIT_LS1 = 20, // 2
BIT_BONES = 22, // 3 should be enough, not 8 VS_BIT_BONES = 22, // 3 should be enough, not 8
BIT_ENABLE_BONES = 30, VS_BIT_ENABLE_BONES = 30,
BIT_LIGHT0_COMP = 32, // 2 bits VS_BIT_LIGHT0_COMP = 32, // 2 bits
BIT_LIGHT0_TYPE = 34, // 2 bits VS_BIT_LIGHT0_TYPE = 34, // 2 bits
BIT_LIGHT1_COMP = 36, // 2 bits VS_BIT_LIGHT1_COMP = 36, // 2 bits
BIT_LIGHT1_TYPE = 38, // 2 bits VS_BIT_LIGHT1_TYPE = 38, // 2 bits
BIT_LIGHT2_COMP = 40, // 2 bits VS_BIT_LIGHT2_COMP = 40, // 2 bits
BIT_LIGHT2_TYPE = 42, // 2 bits VS_BIT_LIGHT2_TYPE = 42, // 2 bits
BIT_LIGHT3_COMP = 44, // 2 bits VS_BIT_LIGHT3_COMP = 44, // 2 bits
BIT_LIGHT3_TYPE = 46, // 2 bits VS_BIT_LIGHT3_TYPE = 46, // 2 bits
BIT_MATERIAL_UPDATE = 48, // 3 bits, 1 free after VS_BIT_MATERIAL_UPDATE = 48, // 3 bits, 1 free after
BIT_LIGHT0_ENABLE = 52, VS_BIT_LIGHT0_ENABLE = 52,
BIT_LIGHT1_ENABLE = 53, VS_BIT_LIGHT1_ENABLE = 53,
BIT_LIGHT2_ENABLE = 54, VS_BIT_LIGHT2_ENABLE = 54,
BIT_LIGHT3_ENABLE = 55, VS_BIT_LIGHT3_ENABLE = 55,
BIT_LIGHTING_ENABLE = 56, VS_BIT_LIGHTING_ENABLE = 56,
BIT_WEIGHT_FMTSCALE = 57, // only two bits, 1 free after VS_BIT_WEIGHT_FMTSCALE = 57, // only two bits, 1 free after
BIT_TEXCOORD_FMTSCALE = 60, VS_BIT_TEXCOORD_FMTSCALE = 60,
BIT_FLATSHADE = 62, // 1 free after VS_BIT_FLATSHADE = 62, // 1 free after
}; };
std::string VertexShaderDesc(const ShaderID &id) { std::string VertexShaderDesc(const ShaderID &id) {
std::stringstream desc; std::stringstream desc;
desc << StringFromFormat("%08x:%08x ", id.d[1], id.d[0]); desc << StringFromFormat("%08x:%08x ", id.d[1], id.d[0]);
if (id.Bit(BIT_IS_THROUGH)) desc << "THR "; if (id.Bit(VS_BIT_IS_THROUGH)) desc << "THR ";
if (id.Bit(BIT_USE_HW_TRANSFORM)) desc << "HWX "; if (id.Bit(VS_BIT_USE_HW_TRANSFORM)) desc << "HWX ";
if (id.Bit(BIT_HAS_COLOR)) desc << "C "; if (id.Bit(VS_BIT_HAS_COLOR)) desc << "C ";
if (id.Bit(BIT_HAS_TEXCOORD)) desc << "T "; if (id.Bit(VS_BIT_HAS_TEXCOORD)) desc << "T ";
if (id.Bit(BIT_HAS_NORMAL)) desc << "N "; if (id.Bit(VS_BIT_HAS_NORMAL)) desc << "N ";
if (id.Bit(BIT_LMODE)) desc << "LM "; if (id.Bit(VS_BIT_LMODE)) desc << "LM ";
if (id.Bit(BIT_ENABLE_FOG)) desc << "Fog "; if (id.Bit(VS_BIT_ENABLE_FOG)) desc << "Fog ";
if (id.Bit(BIT_NORM_REVERSE)) desc << "RevN "; if (id.Bit(VS_BIT_NORM_REVERSE)) desc << "RevN ";
if (id.Bit(BIT_DO_TEXTURE)) desc << "Tex "; if (id.Bit(VS_BIT_DO_TEXTURE)) desc << "Tex ";
if (id.Bit(BIT_DO_TEXTURE_PROJ)) desc << "TexProj "; if (id.Bit(VS_BIT_DO_TEXTURE_PROJ)) desc << "TexProj ";
if (id.Bit(BIT_FLIP_TEXTURE)) desc << "Flip "; if (id.Bit(VS_BIT_FLIP_TEXTURE)) desc << "Flip ";
int uvgMode = id.Bits(BIT_UVGEN_MODE, 2); int uvgMode = id.Bits(VS_BIT_UVGEN_MODE, 2);
const char *uvgModes[4] = { "UV ", "UVMtx ", "UVEnv ", "UVUnk " }; const char *uvgModes[4] = { "UV ", "UVMtx ", "UVEnv ", "UVUnk " };
int ls0 = id.Bits(BIT_LS0, 2); int ls0 = id.Bits(VS_BIT_LS0, 2);
int ls1 = id.Bits(BIT_LS1, 2); int ls1 = id.Bits(VS_BIT_LS1, 2);
if (uvgMode) desc << uvgModes[uvgMode]; 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 // Lights
if (id.Bit(BIT_LIGHTING_ENABLE)) { if (id.Bit(VS_BIT_LIGHTING_ENABLE)) {
desc << "Light: "; desc << "Light: ";
for (int i = 0; i < 4; i++) { 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 << 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(VS_BIT_MATERIAL_UPDATE, 3)) desc << "MatUp:" << id.Bits(VS_BIT_MATERIAL_UPDATE, 3) << " ";
if (id.Bits(BIT_WEIGHT_FMTSCALE, 2)) desc << "WScale " << id.Bits(BIT_WEIGHT_FMTSCALE, 2) << " "; if (id.Bits(VS_BIT_WEIGHT_FMTSCALE, 2)) desc << "WScale " << id.Bits(VS_BIT_WEIGHT_FMTSCALE, 2) << " ";
if (id.Bits(BIT_TEXCOORD_FMTSCALE, 2)) desc << "TCScale " << id.Bits(BIT_TEXCOORD_FMTSCALE, 2) << " "; if (id.Bits(VS_BIT_TEXCOORD_FMTSCALE, 2)) desc << "TCScale " << id.Bits(VS_BIT_TEXCOORD_FMTSCALE, 2) << " ";
if (id.Bit(BIT_FLATSHADE)) desc << "Flat "; if (id.Bit(VS_BIT_FLATSHADE)) desc << "Flat ";
// TODO: More... // TODO: More...
@ -143,67 +143,67 @@ void ComputeVertexShaderID(ShaderID *id_out, u32 vertType, bool useHWTransform)
// lmode: && !isModeThrough!? // lmode: && !isModeThrough!?
ShaderID id; ShaderID id;
id.SetBit(BIT_LMODE, lmode); id.SetBit(VS_BIT_LMODE, lmode);
id.SetBit(BIT_IS_THROUGH, gstate.isModeThrough()); id.SetBit(VS_BIT_IS_THROUGH, gstate.isModeThrough());
id.SetBit(BIT_ENABLE_FOG, enableFog); id.SetBit(VS_BIT_ENABLE_FOG, enableFog);
id.SetBit(BIT_HAS_COLOR, hasColor); id.SetBit(VS_BIT_HAS_COLOR, hasColor);
if (doTexture) { if (doTexture) {
id.SetBit(BIT_DO_TEXTURE); id.SetBit(VS_BIT_DO_TEXTURE);
id.SetBit(BIT_FLIP_TEXTURE, gstate_c.flipTexture); id.SetBit(VS_BIT_FLIP_TEXTURE, gstate_c.flipTexture);
id.SetBit(BIT_DO_TEXTURE_PROJ, doTextureProjection); id.SetBit(VS_BIT_DO_TEXTURE_PROJ, doTextureProjection);
} }
if (useHWTransform) { if (useHWTransform) {
id.SetBit(BIT_USE_HW_TRANSFORM); id.SetBit(VS_BIT_USE_HW_TRANSFORM);
id.SetBit(BIT_HAS_NORMAL, hasNormal); id.SetBit(VS_BIT_HAS_NORMAL, hasNormal);
// UV generation mode. doShadeMapping is implicitly stored here. // 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 // The next bits are used differently depending on UVgen mode
if (doTextureProjection) { if (doTextureProjection) {
id.SetBits(BIT_UVPROJ_MODE, 2, gstate.getUVProjMode()); id.SetBits(VS_BIT_UVPROJ_MODE, 2, gstate.getUVProjMode());
} else if (doShadeMapping) { } else if (doShadeMapping) {
id.SetBits(BIT_LS0, 2, gstate.getUVLS0()); id.SetBits(VS_BIT_LS0, 2, gstate.getUVLS0());
id.SetBits(BIT_LS1, 2, gstate.getUVLS1()); id.SetBits(VS_BIT_LS1, 2, gstate.getUVLS1());
} }
// Bones. // Bones.
bool enableBones = vertTypeIsSkinningEnabled(vertType); bool enableBones = vertTypeIsSkinningEnabled(vertType);
id.SetBit(BIT_ENABLE_BONES, enableBones); id.SetBit(VS_BIT_ENABLE_BONES, enableBones);
if (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, // 2 bits. We should probably send in the weight scalefactor as a uniform instead,
// or simply preconvert all weights to floats. // 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. ============== // Okay, d[1] coming up. ==============
if (gstate.isLightingEnabled() || doShadeMapping) { if (gstate.isLightingEnabled() || doShadeMapping) {
// doShadeMapping is stored as UVGenMode, so this is enough for isLightingEnabled. // doShadeMapping is stored as UVGenMode, so this is enough for isLightingEnabled.
if (gstate.isLightingEnabled()) if (gstate.isLightingEnabled())
id.SetBit(BIT_LIGHTING_ENABLE); id.SetBit(VS_BIT_LIGHTING_ENABLE);
// Light bits // Light bits
for (int i = 0; i < 4; i++) { 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))) { if (gstate.isLightChanEnabled(i) || (doShadeMapping && (gstate.getUVLS0() == i || gstate.getUVLS1() == i))) {
id.SetBits(BIT_LIGHT0_COMP + 4 * i, 2, gstate.getLightComputation(i)); id.SetBits(VS_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_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) { 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 { } 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; *id_out = id;
} }
@ -318,31 +318,31 @@ void GenerateVertexShader(const ShaderID &id, char *buffer) {
boneWeightDecl = boneWeightInDecl; boneWeightDecl = boneWeightInDecl;
} }
bool lmode = id.Bit(BIT_LMODE) && !gstate.isModeThrough(); // TODO: Different expression than in shaderIDgen bool lmode = id.Bit(VS_BIT_LMODE) && !gstate.isModeThrough(); // TODO: Different expression than in shaderIDgen
bool doTexture = id.Bit(BIT_DO_TEXTURE); bool doTexture = id.Bit(VS_BIT_DO_TEXTURE);
bool doTextureProjection = id.Bit(BIT_DO_TEXTURE_PROJ); bool doTextureProjection = id.Bit(VS_BIT_DO_TEXTURE_PROJ);
GETexMapMode uvGenMode = static_cast<GETexMapMode>(id.Bits(BIT_UVGEN_MODE, 2)); GETexMapMode uvGenMode = static_cast<GETexMapMode>(id.Bits(VS_BIT_UVGEN_MODE, 2));
// this is only valid for some settings of uvGenMode // this is only valid for some settings of uvGenMode
GETexProjMapMode uvProjMode = static_cast<GETexProjMapMode>(id.Bits(BIT_UVPROJ_MODE, 2)); GETexProjMapMode uvProjMode = static_cast<GETexProjMapMode>(id.Bits(VS_BIT_UVPROJ_MODE, 2));
bool doShadeMapping = uvGenMode == GE_TEXMAP_ENVIRONMENT_MAP; 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 isModeThrough = id.Bit(VS_BIT_IS_THROUGH);
bool useHWTransform = id.Bit(BIT_USE_HW_TRANSFORM); bool useHWTransform = id.Bit(VS_BIT_USE_HW_TRANSFORM);
bool hasColor = id.Bit(BIT_HAS_COLOR) || !useHWTransform; bool hasColor = id.Bit(VS_BIT_HAS_COLOR) || !useHWTransform;
bool hasNormal = id.Bit(BIT_HAS_NORMAL) && useHWTransform; bool hasNormal = id.Bit(VS_BIT_HAS_NORMAL) && useHWTransform;
bool hasTexcoord = id.Bit(BIT_HAS_TEXCOORD) || !useHWTransform; bool hasTexcoord = id.Bit(VS_BIT_HAS_TEXCOORD) || !useHWTransform;
bool enableFog = id.Bit(BIT_ENABLE_FOG); bool enableFog = id.Bit(VS_BIT_ENABLE_FOG);
bool throughmode = id.Bit(BIT_IS_THROUGH); bool throughmode = id.Bit(VS_BIT_IS_THROUGH);
bool flipV = id.Bit(BIT_FLIP_TEXTURE); // This also means that we are texturing from a render target bool flipV = id.Bit(VS_BIT_FLIP_TEXTURE); // This also means that we are texturing from a render target
bool flipNormal = id.Bit(BIT_NORM_REVERSE); bool flipNormal = id.Bit(VS_BIT_NORM_REVERSE);
int ls0 = id.Bits(BIT_LS0, 2); int ls0 = id.Bits(VS_BIT_LS0, 2);
int ls1 = id.Bits(BIT_LS1, 2); int ls1 = id.Bits(VS_BIT_LS1, 2);
bool enableBones = id.Bit(BIT_ENABLE_BONES); bool enableBones = id.Bit(VS_BIT_ENABLE_BONES);
bool enableLighting = id.Bit(BIT_LIGHTING_ENABLE); bool enableLighting = id.Bit(VS_BIT_LIGHTING_ENABLE);
int matUpdate = id.Bits(BIT_MATERIAL_UPDATE, 3); int matUpdate = id.Bits(VS_BIT_MATERIAL_UPDATE, 3);
const char *shading = ""; const char *shading = "";
if (glslES30) if (glslES30)
@ -355,18 +355,18 @@ void GenerateVertexShader(const ShaderID &id, char *buffer) {
for (int i = 0; i < 4; i++) { for (int i = 0; i < 4; i++) {
if (i == shadeLight0 || i == shadeLight1) if (i == shadeLight0 || i == shadeLight1)
doLight[i] = LIGHT_SHADE; 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; doLight[i] = LIGHT_FULL;
} }
} }
int numBoneWeights = 0; int numBoneWeights = 0;
int boneWeightScale = id.Bits(BIT_WEIGHT_FMTSCALE, 2); int boneWeightScale = id.Bits(VS_BIT_WEIGHT_FMTSCALE, 2);
if (enableBones) { if (enableBones) {
numBoneWeights = 1 + id.Bits(BIT_BONES, 3); numBoneWeights = 1 + id.Bits(VS_BIT_BONES, 3);
WRITE(p, "%s", boneWeightDecl[numBoneWeights]); WRITE(p, "%s", boneWeightDecl[numBoneWeights]);
} }
int texFmtScale = id.Bits(BIT_TEXCOORD_FMTSCALE, 2); int texFmtScale = id.Bits(VS_BIT_TEXCOORD_FMTSCALE, 2);
if (useHWTransform) if (useHWTransform)
WRITE(p, "%s vec3 position;\n", attribute); 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); WRITE(p, "uniform vec3 u_lightpos%i;\n", i);
} }
if (doLight[i] == LIGHT_FULL) { if (doLight[i] == LIGHT_FULL) {
GELightType type = static_cast<GELightType>(id.Bits(BIT_LIGHT0_TYPE + 4*i, 2)); GELightType type = static_cast<GELightType>(id.Bits(VS_BIT_LIGHT0_TYPE + 4*i, 2));
GELightComputation comp = static_cast<GELightComputation>(id.Bits(BIT_LIGHT0_COMP + 4*i, 2)); GELightComputation comp = static_cast<GELightComputation>(id.Bits(VS_BIT_LIGHT0_COMP + 4*i, 2));
if (type != GE_LIGHTTYPE_DIRECTIONAL) if (type != GE_LIGHTTYPE_DIRECTIONAL)
WRITE(p, "uniform mediump vec3 u_lightatt%i;\n", i); 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); WRITE(p, " lowp vec4 lightSum0 = u_ambient * %s + vec4(u_matemissive, 0.0);\n", ambientStr);
for (int i = 0; i < 4; i++) { for (int i = 0; i < 4; i++) {
GELightType type = static_cast<GELightType>(id.Bits(BIT_LIGHT0_TYPE + 4*i, 2)); GELightType type = static_cast<GELightType>(id.Bits(VS_BIT_LIGHT0_TYPE + 4*i, 2));
GELightComputation comp = static_cast<GELightComputation>(id.Bits(BIT_LIGHT0_COMP + 4*i, 2)); GELightComputation comp = static_cast<GELightComputation>(id.Bits(VS_BIT_LIGHT0_COMP + 4*i, 2));
if (doLight[i] != LIGHT_FULL) if (doLight[i] != LIGHT_FULL)
continue; continue;
diffuseIsZero = false; diffuseIsZero = false;
@ -666,8 +666,8 @@ void GenerateVertexShader(const ShaderID &id, char *buffer) {
if (doLight[i] != LIGHT_FULL) if (doLight[i] != LIGHT_FULL)
continue; continue;
GELightType type = static_cast<GELightType>(id.Bits(BIT_LIGHT0_TYPE + 4*i, 2)); GELightType type = static_cast<GELightType>(id.Bits(VS_BIT_LIGHT0_TYPE + 4*i, 2));
GELightComputation comp = static_cast<GELightComputation>(id.Bits(BIT_LIGHT0_COMP + 4*i, 2)); GELightComputation comp = static_cast<GELightComputation>(id.Bits(VS_BIT_LIGHT0_COMP + 4*i, 2));
if (type == GE_LIGHTTYPE_DIRECTIONAL) { if (type == GE_LIGHTTYPE_DIRECTIONAL) {
// We prenormalize light positions for directional lights. // 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); 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. // Sum up ambient, emissive here.
if (lmode) { if (lmode) {
WRITE(p, " v_color0 = clamp(lightSum0, 0.0, 1.0);\n"); WRITE(p, " v_color0 = clamp(lightSum0, 0.0, 1.0);\n");