mirror of
https://github.com/hrydgard/ppsspp.git
synced 2025-02-17 12:47:46 +00:00
Rename shader bits to not clash (this is preparation for other changes)
This commit is contained in:
Henrik Rydgard
parent
3c82dc1462
commit
67cd018aca
@ -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<ReplaceBlendType>(id.Bits(BIT_REPLACE_BLEND, 3));
|
||||
ReplaceAlphaType stencilToAlpha = static_cast<ReplaceAlphaType>(id.Bits(BIT_STENCIL_TO_ALPHA, 2));
|
||||
ReplaceBlendType replaceBlend = static_cast<ReplaceBlendType>(id.Bits(FS_BIT_REPLACE_BLEND, 3));
|
||||
ReplaceAlphaType stencilToAlpha = static_cast<ReplaceAlphaType>(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);
|
||||
|
||||
@ -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<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
|
||||
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 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<GELightType>(id.Bits(BIT_LIGHT0_TYPE + 4*i, 2));
|
||||
GELightComputation comp = static_cast<GELightComputation>(id.Bits(BIT_LIGHT0_COMP + 4*i, 2));
|
||||
GELightType type = static_cast<GELightType>(id.Bits(VS_BIT_LIGHT0_TYPE + 4*i, 2));
|
||||
GELightComputation comp = static_cast<GELightComputation>(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<GELightType>(id.Bits(BIT_LIGHT0_TYPE + 4*i, 2));
|
||||
GELightComputation comp = static_cast<GELightComputation>(id.Bits(BIT_LIGHT0_COMP + 4*i, 2));
|
||||
GELightType type = static_cast<GELightType>(id.Bits(VS_BIT_LIGHT0_TYPE + 4*i, 2));
|
||||
GELightComputation comp = static_cast<GELightComputation>(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<GELightType>(id.Bits(BIT_LIGHT0_TYPE + 4*i, 2));
|
||||
GELightComputation comp = static_cast<GELightComputation>(id.Bits(BIT_LIGHT0_COMP + 4*i, 2));
|
||||
GELightType type = static_cast<GELightType>(id.Bits(VS_BIT_LIGHT0_TYPE + 4*i, 2));
|
||||
GELightComputation comp = static_cast<GELightComputation>(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");
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user