From 276ac82ddf0612ea604c979726856472b86ac983 Mon Sep 17 00:00:00 2001 From: aap Date: Fri, 19 Feb 2021 23:32:15 +0100 Subject: [PATCH] implement new gl uniform system --- src/gl/gl3device.cpp | 191 +++++++++++++--------------------- src/gl/gl3immed.cpp | 5 +- src/gl/gl3matfx.cpp | 19 ++-- src/gl/gl3shader.cpp | 74 ++++++++++++- src/gl/gl3skin.cpp | 7 +- src/gl/rwgl3.h | 2 + src/gl/rwgl3shader.h | 26 ++++- src/gl/shaders/header.frag | 2 +- src/gl/shaders/header.vert | 2 +- src/gl/shaders/header_fs.inc | 2 +- src/gl/shaders/header_vs.inc | 2 +- src/gl/shaders/matfx_env.frag | 2 +- src/gl/shaders/matfx_gl.inc | 2 +- 13 files changed, 190 insertions(+), 146 deletions(-) diff --git a/src/gl/gl3device.cpp b/src/gl/gl3device.cpp index b1036c0..1e511bb 100644 --- a/src/gl/gl3device.cpp +++ b/src/gl/gl3device.cpp @@ -67,13 +67,6 @@ struct UniformObject RGBAf lightColor[MAX_LIGHTS]; }; -struct GLShaderState -{ - RGBA matColor; - SurfaceProperties surfProps; - float extraSurfProp; -}; - const char *shaderDecl120 = "#version 120\n" "#define GL2\n" @@ -120,16 +113,11 @@ static GLuint whitetex; static UniformState uniformState; static UniformScene uniformScene; static UniformObject uniformObject; -static GLShaderState shaderState; #ifndef RW_GL_USE_UBOS // State int32 u_alphaRef; int32 u_fogData; -//int32 u_fogStart; -//int32 u_fogEnd; -//int32 u_fogRange; -//int32 u_fogDisable; int32 u_fogColor; // Scene @@ -405,6 +393,8 @@ getAlphaBlend(void) return rwStateCache.blendEnable; } +bool32 getAlphaTest(void) { return rwStateCache.alphaTestEnable; } + static void setDepthTest(bool32 enable) { @@ -980,6 +970,7 @@ void setWorldMatrix(Matrix *mat) { convMatrix(&uniformObject.world, mat); + setUniform(u_world, &uniformObject.world); objectDirty = 1; } @@ -1045,6 +1036,12 @@ setLights(WorldLights *lightData) } uniformObject.lightParams[n].type = 0.0f; + + setUniform(u_ambLight, &uniformObject.ambLight); + setUniform(u_lightParams, uniformObject.lightParams); + setUniform(u_lightPosition, uniformObject.lightPosition); + setUniform(u_lightDirection, uniformObject.lightDirection); + setUniform(u_lightColor, uniformObject.lightColor); out: objectDirty = 1; return bits; @@ -1054,6 +1051,7 @@ void setProjectionMatrix(float32 *mat) { memcpy(&uniformScene.proj, mat, 64); + setUniform(u_proj, uniformScene.proj); sceneDirty = 1; } @@ -1061,6 +1059,7 @@ void setViewMatrix(float32 *mat) { memcpy(&uniformScene.view, mat, 64); + setUniform(u_view, uniformScene.view); sceneDirty = 1; } @@ -1071,27 +1070,16 @@ Shader *lastShaderUploaded; void setMaterial(const RGBA &color, const SurfaceProperties &surfaceprops, float extraSurfProp) { - bool force = lastShaderUploaded != currentShader; - if(force || !equal(shaderState.matColor, color)){ - rw::RGBAf col; - convColor(&col, &color); - glUniform4fv(U(u_matColor), 1, (GLfloat*)&col); - shaderState.matColor = color; - } + rw::RGBAf col; + convColor(&col, &color); + setUniform(u_matColor, &col); - if(force || - shaderState.surfProps.ambient != surfaceprops.ambient || - shaderState.surfProps.specular != surfaceprops.specular || - shaderState.surfProps.diffuse != surfaceprops.diffuse || - shaderState.extraSurfProp != extraSurfProp){ - float surfProps[4]; - surfProps[0] = surfaceprops.ambient; - surfProps[1] = surfaceprops.specular; - surfProps[2] = surfaceprops.diffuse; - surfProps[3] = extraSurfProp; - glUniform4fv(U(u_surfProps), 1, surfProps); - shaderState.surfProps = surfaceprops; - } + float surfProps[4]; + surfProps[0] = surfaceprops.ambient; + surfProps[1] = surfaceprops.specular; + surfProps[2] = surfaceprops.diffuse; + surfProps[3] = extraSurfProp; + setUniform(u_surfProps, surfProps); } void @@ -1101,80 +1089,54 @@ flushCache(void) #ifndef RW_GL_USE_UBOS - // TODO: this is probably a stupid way to do it without UBOs - if(lastShaderUploaded != currentShader){ - lastShaderUploaded = currentShader; - objectDirty = 1; - sceneDirty = 1; - stateDirty = 1; + // what's this doing here?? + uniformState.fogDisable = rwStateCache.fogEnable ? 0.0f : 1.0f; + uniformState.fogStart = rwStateCache.fogStart; + uniformState.fogEnd = rwStateCache.fogEnd; + uniformState.fogRange = 1.0f/(rwStateCache.fogStart - rwStateCache.fogEnd); - int i; - for(i = 0; i < RWGL_NUM_STATES; i++) - uniformStateDirty[i] = true; + if(uniformStateDirty[RWGL_ALPHAFUNC] || uniformStateDirty[RWGL_ALPHAREF]){ + float alphaTest[4]; + switch(alphaFunc){ + case ALPHAALWAYS: + default: + alphaTest[0] = -1000.0f; + alphaTest[1] = 1000.0f; + break; + case ALPHAGREATEREQUAL: + alphaTest[0] = alphaRef; + alphaTest[1] = 1000.0f; + break; + case ALPHALESS: + alphaTest[0] = -1000.0f; + alphaTest[1] = alphaRef; + break; + } + setUniform(u_alphaRef, alphaTest); + uniformStateDirty[RWGL_ALPHAFUNC] = false; + uniformStateDirty[RWGL_ALPHAREF] = false; } - if(sceneDirty){ - glUniformMatrix4fv(U(u_proj), 1, 0, uniformScene.proj); - glUniformMatrix4fv(U(u_view), 1, 0, uniformScene.view); - sceneDirty = 0; + if(uniformStateDirty[RWGL_FOG] || + uniformStateDirty[RWGL_FOGSTART] || + uniformStateDirty[RWGL_FOGEND]){ + float fogData[4] = { + uniformState.fogStart, + uniformState.fogEnd, + uniformState.fogRange, + uniformState.fogDisable + }; + setUniform(u_fogData, fogData); + uniformStateDirty[RWGL_FOG] = false; + uniformStateDirty[RWGL_FOGSTART] = false; + uniformStateDirty[RWGL_FOGEND] = false; } - if(objectDirty){ - glUniformMatrix4fv(U(u_world), 1, 0, (float*)&uniformObject.world); - glUniform4fv(U(u_ambLight), 1, (float*)&uniformObject.ambLight); - glUniform4fv(U(u_lightParams), MAX_LIGHTS, (float*)uniformObject.lightParams); - glUniform4fv(U(u_lightPosition), MAX_LIGHTS, (float*)uniformObject.lightPosition); - glUniform4fv(U(u_lightDirection), MAX_LIGHTS, (float*)uniformObject.lightDirection); - glUniform4fv(U(u_lightColor), MAX_LIGHTS, (float*)uniformObject.lightColor); - objectDirty = 0; + if(uniformStateDirty[RWGL_FOGCOLOR]){ + setUniform(u_fogColor, &uniformState.fogColor); + uniformStateDirty[RWGL_FOGCOLOR] = false; } -// if(stateDirty){ - - uniformState.fogDisable = rwStateCache.fogEnable ? 0.0f : 1.0f; - uniformState.fogStart = rwStateCache.fogStart; - uniformState.fogEnd = rwStateCache.fogEnd; - uniformState.fogRange = 1.0f/(rwStateCache.fogStart - rwStateCache.fogEnd); - - if(uniformStateDirty[RWGL_ALPHAFUNC] || uniformStateDirty[RWGL_ALPHAREF]){ - switch(alphaFunc){ - case ALPHAALWAYS: - default: - glUniform2f(U(u_alphaRef), -1000.0f, 1000.0f); - break; - case ALPHAGREATEREQUAL: - glUniform2f(U(u_alphaRef), alphaRef, 1000.0f); - break; - case ALPHALESS: - glUniform2f(U(u_alphaRef), -1000.0f, alphaRef); - break; - } - uniformStateDirty[RWGL_ALPHAFUNC] = false; - uniformStateDirty[RWGL_ALPHAREF] = false; - } - - if(uniformStateDirty[RWGL_FOG] || - uniformStateDirty[RWGL_FOGSTART] || - uniformStateDirty[RWGL_FOGEND]){ - float fogData[4] = { - uniformState.fogStart, - uniformState.fogEnd, - uniformState.fogRange, - uniformState.fogDisable - }; - glUniform4fv(U(u_fogData), 1, fogData); - uniformStateDirty[RWGL_FOG] = false; - uniformStateDirty[RWGL_FOGSTART] = false; - uniformStateDirty[RWGL_FOGEND] = false; - } - - if(uniformStateDirty[RWGL_FOGCOLOR]){ - glUniform4fv(U(u_fogColor), 1, (float*)&uniformState.fogColor); - uniformStateDirty[RWGL_FOGCOLOR] = false; - } - -// stateDirty = 0; -// } #else if(objectDirty){ glBindBuffer(GL_UNIFORM_BUFFER, ubo_object); @@ -1214,6 +1176,7 @@ flushCache(void) stateDirty = 0; } #endif + flushUniforms(); } static void @@ -1796,29 +1759,25 @@ initOpenGL(void) } #ifndef RW_GL_USE_UBOS - u_alphaRef = registerUniform("u_alphaRef"); - u_fogData = registerUniform("u_fogData"); -// u_fogStart = registerUniform("u_fogStart"); -// u_fogEnd = registerUniform("u_fogEnd"); -// u_fogRange = registerUniform("u_fogRange"); -// u_fogDisable = registerUniform("u_fogDisable"); - u_fogColor = registerUniform("u_fogColor"); - u_proj = registerUniform("u_proj"); - u_view = registerUniform("u_view"); - u_world = registerUniform("u_world"); - u_ambLight = registerUniform("u_ambLight"); - u_lightParams = registerUniform("u_lightParams"); - u_lightPosition = registerUniform("u_lightPosition"); - u_lightDirection = registerUniform("u_lightDirection"); - u_lightColor = registerUniform("u_lightColor"); + u_alphaRef = registerUniform("u_alphaRef", UNIFORM_VEC4); + u_fogData = registerUniform("u_fogData", UNIFORM_VEC4); + u_fogColor = registerUniform("u_fogColor", UNIFORM_VEC4); + u_proj = registerUniform("u_proj", UNIFORM_MAT4); + u_view = registerUniform("u_view", UNIFORM_MAT4); + u_world = registerUniform("u_world", UNIFORM_MAT4); + u_ambLight = registerUniform("u_ambLight", UNIFORM_VEC4); + u_lightParams = registerUniform("u_lightParams", UNIFORM_VEC4, MAX_LIGHTS); + u_lightPosition = registerUniform("u_lightPosition", UNIFORM_VEC4, MAX_LIGHTS); + u_lightDirection = registerUniform("u_lightDirection", UNIFORM_VEC4, MAX_LIGHTS); + u_lightColor = registerUniform("u_lightColor", UNIFORM_VEC4, MAX_LIGHTS); lastShaderUploaded = nil; #else registerBlock("Scene"); registerBlock("Object"); registerBlock("State"); #endif - u_matColor = registerUniform("u_matColor"); - u_surfProps = registerUniform("u_surfProps"); + u_matColor = registerUniform("u_matColor", UNIFORM_VEC4); + u_surfProps = registerUniform("u_surfProps", UNIFORM_VEC4); glClearColor(0.25, 0.25, 0.25, 1.0); diff --git a/src/gl/gl3immed.cpp b/src/gl/gl3immed.cpp index 2a5361d..de2cf7f 100644 --- a/src/gl/gl3immed.cpp +++ b/src/gl/gl3immed.cpp @@ -53,7 +53,7 @@ static int primTypeMap[] = { void openIm2D(void) { - u_xform = registerUniform("u_xform"); + u_xform = registerUniform("u_xform", UNIFORM_VEC4); #include "shaders/im2d_gl.inc" #include "shaders/simple_fs_gl.inc" @@ -120,7 +120,8 @@ im2DSetXform(void) xform[1] = -2.0f/cam->frameBuffer->height; xform[2] = -1.0f; xform[3] = 1.0f; - glUniform4fv(currentShader->uniformLocations[u_xform], 1, xform); + setUniform(u_xform, xform); +// glUniform4fv(currentShader->uniformLocations[u_xform], 1, xform); } void diff --git a/src/gl/gl3matfx.cpp b/src/gl/gl3matfx.cpp index df7cb34..7ffa3da 100644 --- a/src/gl/gl3matfx.cpp +++ b/src/gl/gl3matfx.cpp @@ -24,8 +24,6 @@ namespace gl3 { #ifdef RW_OPENGL -#define U(i) currentShader->uniformLocations[i] - static Shader *envShader; static int32 u_texMatrix; static int32 u_fxparams; @@ -77,7 +75,7 @@ uploadEnvMatrix(Frame *frame) invMtx.pos.set(0.0f, 0.0f, 0.0f); RawMatrix::mult(&envMtx, &invMtx, &normal2texcoord); } - glUniformMatrix4fv(U(u_texMatrix), 1, GL_FALSE, (float*)&envMtx); + setUniform(u_texMatrix, &envMtx); } void @@ -99,18 +97,19 @@ matfxEnvRender(InstanceDataHeader *header, InstanceData *inst, uint32 flags, Mat setMaterial(flags, m->color, m->surfaceProps); - float fxparams[2]; + float fxparams[4]; fxparams[0] = env->coefficient; fxparams[1] = env->fbAlpha ? 0.0f : 1.0f; + fxparams[2] = fxparams[3] = 0.0f; - glUniform2fv(U(u_fxparams), 1, fxparams); + setUniform(u_fxparams, fxparams); static float zero[4]; static float one[4] = { 1.0f, 1.0f, 1.0f, 1.0f }; // This clamps the vertex color below. With it we can achieve both PC and PS2 style matfx if(MatFX::modulateEnvMap) - glUniform4fv(U(u_colorClamp), 1, zero); + setUniform(u_colorClamp, zero); else - glUniform4fv(U(u_colorClamp), 1, one); + setUniform(u_colorClamp, one); rw::SetRenderState(VERTEXALPHA, 1); rw::SetRenderState(SRCBLEND, BLENDONE); @@ -193,9 +192,9 @@ matfxClose(void *o, int32, int32) void initMatFX(void) { - u_texMatrix = registerUniform("u_texMatrix"); - u_fxparams = registerUniform("u_fxparams"); - u_colorClamp = registerUniform("u_colorClamp"); + u_texMatrix = registerUniform("u_texMatrix", UNIFORM_MAT4); + u_fxparams = registerUniform("u_fxparams", UNIFORM_VEC4); + u_colorClamp = registerUniform("u_colorClamp", UNIFORM_VEC4); Driver::registerPlugin(PLATFORM_GL3, 0, ID_MATFX, matfxOpen, matfxClose); diff --git a/src/gl/gl3shader.cpp b/src/gl/gl3shader.cpp index 1b20231..7614171 100644 --- a/src/gl/gl3shader.cpp +++ b/src/gl/gl3shader.cpp @@ -22,6 +22,12 @@ namespace gl3 { UniformRegistry uniformRegistry; static char nameBuffer[(MAX_UNIFORMS + MAX_BLOCKS)*32]; // static because memory system isn't up yet when we register static uint32 nameBufPtr; +static float uniformData[512*4]; // seems enough +static uint32 dataPtr; + +static int uniformTypesize[] = { + 0, 4, 4, 16 +}; static char* shader_strdup(const char *name) @@ -35,7 +41,7 @@ shader_strdup(const char *name) } int32 -registerUniform(const char *name) +registerUniform(const char *name, UniformType type, int32 num) { int i; i = findUniform(name); @@ -45,7 +51,21 @@ registerUniform(const char *name) assert(0 && "no space for uniform"); return -1; } - uniformRegistry.uniformNames[uniformRegistry.numUniforms] = shader_strdup(name); + Uniform *u = &uniformRegistry.uniforms[uniformRegistry.numUniforms]; + u->name = shader_strdup(name); + u->type = type; +// u->dirty = false; + u->serialNum = 0; + if(type == UNIFORM_NA){ + u->num = 0; + u->data = nil; + }else{ + u->num = num; + u->data = &uniformData[dataPtr]; + dataPtr += uniformTypesize[type]*num; + assert(dataPtr <= nelem(uniformData)); + } + return uniformRegistry.numUniforms++; } @@ -54,7 +74,7 @@ findUniform(const char *name) { int i; for(i = 0; i < uniformRegistry.numUniforms; i++) - if(strcmp(name, uniformRegistry.uniformNames[i]) == 0) + if(strcmp(name, uniformRegistry.uniforms[i].name) == 0) return i; return -1; } @@ -82,6 +102,47 @@ findBlock(const char *name) return -1; } +void +setUniform(int32 id, void *data) +{ + Uniform *u = &uniformRegistry.uniforms[id]; + assert(u->type != UNIFORM_NA); + if(memcmp(u->data, data, uniformTypesize[u->type]*u->num * sizeof(float)) != 0){ + memcpy(u->data, data, uniformTypesize[u->type]*u->num * sizeof(float)); + //u->dirty = true; + u->serialNum++; + } +} + +void +flushUniforms(void) +{ + for(int i = 0; i < uniformRegistry.numUniforms; i++){ + int32 loc = currentShader->uniformLocations[i]; + if(loc == -1) + continue; + + Uniform *u = &uniformRegistry.uniforms[i]; +// if(force || u->dirty) + if(currentShader->serialNums[i] != u->serialNum) + switch(u->type){ + case UNIFORM_NA: + break; + case UNIFORM_VEC4: + glUniform4fv(loc, u->num, (GLfloat*)u->data); + break; + case UNIFORM_IVEC4: + glUniform4iv(loc, u->num, (GLint*)u->data); + break; + case UNIFORM_MAT4: + glUniformMatrix4fv(loc, u->num, GL_FALSE, (GLfloat*)u->data); + break; + } + currentShader->serialNums[i] = u->serialNum; + //u->dirty = false; + } +} + Shader *currentShader; static void @@ -238,9 +299,12 @@ Shader::create(const char **vsrc, const char **fsrc) // query uniform locations sh->program = program; sh->uniformLocations = rwNewT(GLint, uniformRegistry.numUniforms, MEMDUR_EVENT | ID_DRIVER); - for(i = 0; i < uniformRegistry.numUniforms; i++) + sh->serialNums = rwNewT(uint32, uniformRegistry.numUniforms, MEMDUR_EVENT | ID_DRIVER); + for(i = 0; i < uniformRegistry.numUniforms; i++){ sh->uniformLocations[i] = glGetUniformLocation(program, - uniformRegistry.uniformNames[i]); + uniformRegistry.uniforms[i].name); + sh->serialNums[i] = ~0; // let's hope this means dirty + } // set samplers glUseProgram(program); diff --git a/src/gl/gl3skin.cpp b/src/gl/gl3skin.cpp index d97498a..b2b5831 100644 --- a/src/gl/gl3skin.cpp +++ b/src/gl/gl3skin.cpp @@ -24,8 +24,6 @@ namespace gl3 { #ifdef RW_OPENGL -#define U(i) currentShader->uniformLocations[i] - static Shader *skinShader; static int32 u_boneMatrices; @@ -246,8 +244,7 @@ uploadSkinMatrices(Atomic *a) m++; } } - glUniformMatrix4fv(U(u_boneMatrices), 64, GL_FALSE, - (GLfloat*)skinMatrices); + setUniform(u_boneMatrices, skinMatrices); } void @@ -313,7 +310,7 @@ skinClose(void *o, int32, int32) void initSkin(void) { - u_boneMatrices = registerUniform("u_boneMatrices"); + u_boneMatrices = registerUniform("u_boneMatrices", UNIFORM_MAT4, 64); Driver::registerPlugin(PLATFORM_GL3, 0, ID_SKIN, skinOpen, skinClose); diff --git a/src/gl/rwgl3.h b/src/gl/rwgl3.h index ca732bd..4d32330 100644 --- a/src/gl/rwgl3.h +++ b/src/gl/rwgl3.h @@ -196,6 +196,8 @@ inline void setMaterial(uint32 flags, const RGBA &color, const SurfaceProperties void setAlphaBlend(bool32 enable); bool32 getAlphaBlend(void); +bool32 getAlphaTest(void); + void bindFramebuffer(uint32 fbo); uint32 bindTexture(uint32 texid); diff --git a/src/gl/rwgl3shader.h b/src/gl/rwgl3shader.h index f9bb632..414f1ac 100644 --- a/src/gl/rwgl3shader.h +++ b/src/gl/rwgl3shader.h @@ -9,20 +9,41 @@ enum { MAX_BLOCKS = 20 }; +enum UniformType +{ + UNIFORM_NA, // managed by the user + UNIFORM_VEC4, + UNIFORM_IVEC4, + UNIFORM_MAT4 +}; + +struct Uniform +{ + char *name; + UniformType type; + //bool dirty; + uint32 serialNum; + int32 num; + void *data; +}; + struct UniformRegistry { int32 numUniforms; - char *uniformNames[MAX_UNIFORMS]; + Uniform uniforms[MAX_UNIFORMS]; int32 numBlocks; char *blockNames[MAX_BLOCKS]; }; -int32 registerUniform(const char *name); +int32 registerUniform(const char *name, UniformType type = UNIFORM_NA, int32 num = 1); int32 findUniform(const char *name); int32 registerBlock(const char *name); int32 findBlock(const char *name); +void setUniform(int32 id, void *data); +void flushUniforms(void); + extern UniformRegistry uniformRegistry; struct Shader @@ -30,6 +51,7 @@ struct Shader GLuint program; // same number of elements as UniformRegistry::numUniforms GLint *uniformLocations; + uint32 *serialNums; static Shader *create(const char **vsrc, const char **fsrc); // static Shader *fromFiles(const char *vs, const char *fs); diff --git a/src/gl/shaders/header.frag b/src/gl/shaders/header.frag index ffe26e3..da58bba 100644 --- a/src/gl/shaders/header.frag +++ b/src/gl/shaders/header.frag @@ -6,7 +6,7 @@ layout(std140) uniform State vec4 u_fogColor; }; #else -uniform vec2 u_alphaRef; +uniform vec4 u_alphaRef; uniform vec4 u_fogData; uniform vec4 u_fogColor; diff --git a/src/gl/shaders/header.vert b/src/gl/shaders/header.vert index 81f86bd..025c2c4 100644 --- a/src/gl/shaders/header.vert +++ b/src/gl/shaders/header.vert @@ -28,7 +28,7 @@ layout(std140) uniform State vec4 u_fogColor; }; #else -uniform vec2 u_alphaRef; +uniform vec4 u_alphaRef; uniform vec4 u_fogData; uniform vec4 u_fogColor; #endif diff --git a/src/gl/shaders/header_fs.inc b/src/gl/shaders/header_fs.inc index 62ef8f2..b028498 100644 --- a/src/gl/shaders/header_fs.inc +++ b/src/gl/shaders/header_fs.inc @@ -7,7 +7,7 @@ const char *header_frag_src = " vec4 u_fogColor;\n" "};\n" "#else\n" -"uniform vec2 u_alphaRef;\n" +"uniform vec4 u_alphaRef;\n" "uniform vec4 u_fogData;\n" "uniform vec4 u_fogColor;\n" diff --git a/src/gl/shaders/header_vs.inc b/src/gl/shaders/header_vs.inc index cd37b25..ec9e505 100644 --- a/src/gl/shaders/header_vs.inc +++ b/src/gl/shaders/header_vs.inc @@ -29,7 +29,7 @@ const char *header_vert_src = " vec4 u_fogColor;\n" "};\n" "#else\n" -"uniform vec2 u_alphaRef;\n" +"uniform vec4 u_alphaRef;\n" "uniform vec4 u_fogData;\n" "uniform vec4 u_fogColor;\n" "#endif\n" diff --git a/src/gl/shaders/matfx_env.frag b/src/gl/shaders/matfx_env.frag index 4164ed1..a8952cc 100644 --- a/src/gl/shaders/matfx_env.frag +++ b/src/gl/shaders/matfx_env.frag @@ -1,7 +1,7 @@ uniform sampler2D tex0; uniform sampler2D tex1; -uniform vec2 u_fxparams; +uniform vec4 u_fxparams; uniform vec4 u_colorClamp; #define shininess (u_fxparams.x) diff --git a/src/gl/shaders/matfx_gl.inc b/src/gl/shaders/matfx_gl.inc index f7296a8..f2de3a2 100644 --- a/src/gl/shaders/matfx_gl.inc +++ b/src/gl/shaders/matfx_gl.inc @@ -31,7 +31,7 @@ const char *matfx_env_frag_src = "uniform sampler2D tex0;\n" "uniform sampler2D tex1;\n" -"uniform vec2 u_fxparams;\n" +"uniform vec4 u_fxparams;\n" "uniform vec4 u_colorClamp;\n" "#define shininess (u_fxparams.x)\n"