static int program_set_uniform_number(lua_State *L)
{
shader_type *p = (shader_type*)lua_touserdata(L, 1);
const char *var = luaL_checkstring(L, 2);
bool change = gl_c_shader != p->shader;
if (change) tglUseProgramObject(p->shader);
// Uniform array
if (lua_istable(L, 3)) {
int nb = lua_objlen(L, 3);
int i;
GLfloat is[nb];
for (i = 0; i < nb; i++) {
lua_rawgeti(L, 3, i + 1); is[i*4+0] = lua_tonumber(L, -1); lua_pop(L, 1);
}
glUniform1fvARB(glGetUniformLocationARB(p->shader, var), nb, is);
} else {
GLfloat i = luaL_checknumber(L, 3);
glUniform1fvARB(glGetUniformLocationARB(p->shader, var), 1, &i);
}
if (change) tglUseProgramObject(0);
return 0;
}
/*
* sendUniform1fv
*
* parameter name - char*
* parameter count - GLsizei
* parameter values - GLfloat*
* return - bool
*/
bool ShaderObject::sendUniform1fv(const char * name, GLsizei count, GLfloat* values) {
GLint location = getUniLoc(name);
if (location == -1)
return false;
glUniform1fvARB(location, count, values);
return true;
} // end sendUniform1fv()
void GPU::Shader::SetUniform( const std::string& name,
const void *value )
{
UniformMap::iterator uu = m_Uniforms.find( name );
if( uu != m_Uniforms.end() )
{
GLuint activeProgBackup = glGetHandleARB( GL_PROGRAM_OBJECT_ARB );
glUseProgramObjectARB( m_Id );
Uniform &u = uu->second;
switch( u.type )
{
case GL_FLOAT: glUniform1fvARB( u.location, u.size, (GLfloat*) value ); break;
case GL_FLOAT_VEC2_ARB: glUniform2fvARB( u.location, u.size, (GLfloat*) value ); break;
case GL_FLOAT_VEC3_ARB: glUniform3fvARB( u.location, u.size, (GLfloat*) value ); break;
case GL_FLOAT_VEC4_ARB: glUniform4fvARB( u.location, u.size, (GLfloat*) value ); break;
case GL_INT: glUniform1ivARB( u.location, u.size, (GLint*) value ); break;
case GL_INT_VEC2_ARB: glUniform2ivARB( u.location, u.size, (GLint*) value ); break;
case GL_INT_VEC3_ARB: glUniform3ivARB( u.location, u.size, (GLint*) value ); break;
case GL_INT_VEC4_ARB: glUniform4ivARB( u.location, u.size, (GLint*) value ); break;
case GL_BOOL_ARB: glUniform1ivARB( u.location, u.size, (GLint*) value ); break;
case GL_BOOL_VEC2_ARB: glUniform2ivARB( u.location, u.size, (GLint*) value ); break;
case GL_BOOL_VEC3_ARB: glUniform3ivARB( u.location, u.size, (GLint*) value ); break;
case GL_BOOL_VEC4_ARB: glUniform4ivARB( u.location, u.size, (GLint*) value ); break;
case GL_FLOAT_MAT2_ARB: glUniformMatrix2fvARB( u.location, u.size, GL_FALSE, (GLfloat*) value ); break;
case GL_FLOAT_MAT3_ARB: glUniformMatrix3fvARB( u.location, u.size, GL_FALSE, (GLfloat*) value ); break;
case GL_FLOAT_MAT4_ARB: glUniformMatrix4fvARB( u.location, u.size, GL_FALSE, (GLfloat*) value ); break;
}
glUseProgramObjectARB( activeProgBackup );
}
}
void useShader(shader_type *p, int x, int y, int w, int h, float tx, float ty, float tw, float th, float r, float g, float b, float a)
{
tglUseProgramObject(p->shader);
GLfloat t = cur_frame_tick;
glUniform1fvARB(p->p_tick, 1, &t);
GLfloat d[4];
d[0] = r;
d[1] = g;
d[2] = b;
d[3] = a;
glUniform4fvARB(p->p_color, 1, d);
GLfloat c[2];
c[0] = x;
c[1] = y;
glUniform2fvARB(p->p_mapcoord, 1, c);
c[0] = w;
c[1] = h;
glUniform2fvARB(p->p_texsize, 1, c);
d[0] = tx;
d[1] = ty;
d[2] = tw;
d[3] = th;
glUniform4fvARB(p->p_texcoord, 1, d);
shader_reset_uniform *ru = p->reset_uniforms;
while (ru) {
switch (ru->kind) {
case UNIFORM_NUMBER:
glUniform1fvARB(ru->p, 1, &ru->data.number);
break;
case UNIFORM_VEC2:
glUniform2fvARB(ru->p, 1, ru->data.vec2);
break;
case UNIFORM_VEC3:
glUniform3fvARB(ru->p, 1, ru->data.vec3);
break;
case UNIFORM_VEC4:
glUniform4fvARB(ru->p, 1, ru->data.vec4);
break;
}
ru = ru->next;
}
}
bool Shader::sendUniform1fv(char* varname, GLsizei count, GLfloat *value)
{
GLint loc = GetUniformLocation(varname);
if (loc == -1) return false;
glUniform1fvARB(loc, count, value);
return true;
}
void CShadersManager::SetScaleBiasFactor (GLfloat * factor)
{
if(this->Program == ParallaxMappingSPT)
{
GLint loc = glGetUniformLocationARB(this->Programs[ParallaxMappingSPT].GetHandle(),
"ScaleBiasFactor");
glUniform1fvARB(loc, 2, factor);
}
}
static int program_set_uniform_number_fast(lua_State *L)
{
shader_type *p = (shader_type*)lua_touserdata(L, 1);
GLfloat i = luaL_checknumber(L, 2);
bool change = gl_c_shader != p->shader;
GLint pos = lua_tonumber(L, lua_upvalueindex(1));
if (change) tglUseProgramObject(p->shader);
glUniform1fvARB(pos, 1, &i);
if (change) tglUseProgramObject(0);
return 0;
}
void GPU_shader_uniform_vector(GPUShader *UNUSED(shader), int location, int length, int arraysize, float *value)
{
if (location == -1)
return;
GPU_print_error("Pre Uniform Vector");
if (length == 1) glUniform1fvARB(location, arraysize, value);
else if (length == 2) glUniform2fvARB(location, arraysize, value);
else if (length == 3) glUniform3fvARB(location, arraysize, value);
else if (length == 4) glUniform4fvARB(location, arraysize, value);
else if (length == 9) glUniformMatrix3fvARB(location, arraysize, 0, value);
else if (length == 16) glUniformMatrix4fvARB(location, arraysize, 0, value);
GPU_print_error("Post Uniform Vector");
}
static int program_use(lua_State *L)
{
shader_type *p = (shader_type*)lua_touserdata(L, 1);
bool active = lua_toboolean(L, 2);
if (active)
{
tglUseProgramObject(p->shader);
// GLfloat t = SDL_GetTicks();
GLfloat t = cur_frame_tick;
glUniform1fvARB(p->p_tick, 1, &t);
}
else
{
tglUseProgramObject(0);
}
return 0;
}
bool ShaderProgram::SetVariable(const char* name, int varDim, const float* values, int count)
{
if (!_linked) return false;
if (_id)
{
GLint location = glGetUniformLocationARB(_id, name);
if (location == -1) return false;
switch (varDim)
{
case 1: glUniform1fvARB(location, count, values); break;
case 2: glUniform2fvARB(location, count, values); break;
case 3: glUniform3fvARB(location, count, values); break;
case 4: glUniform4fvARB(location, count, values); break;
default:
return false;
}
return true;
} else
return false;
}
//-----------------------------------------------------------------------
void GLSLLinkProgram::updatePassIterationUniforms(GpuProgramParametersSharedPtr params)
{
if (params->hasPassIterationNumber())
{
size_t index = params->getPassIterationNumberIndex();
GLUniformReferenceIterator currentUniform = mGLUniformReferences.begin();
GLUniformReferenceIterator endUniform = mGLUniformReferences.end();
// need to find the uniform that matches the multi pass entry
for (; currentUniform != endUniform; ++currentUniform)
{
// get the index in the parameter real list
if (index == currentUniform->mConstantDef->physicalIndex)
{
glUniform1fvARB( currentUniform->mLocation, 1, params->getFloatPointer(index));
// there will only be one multipass entry
return;
}
}
}
}
void loadFieldShader()
{
GLhandleARB vertexShaderHandle;
GLhandleARB fragmentShaderHandle;
vertexShaderHandle = loadShader("VertexShader.c",GL_VERTEX_SHADER);
fragmentShaderHandle = loadShader("FragmentShader.c",GL_FRAGMENT_SHADER);
fieldShaderId = glCreateProgramObjectARB();
glAttachObjectARB(fieldShaderId,vertexShaderHandle);
glAttachObjectARB(fieldShaderId,fragmentShaderHandle);
glLinkProgramARB(fieldShaderId);
fieldUniform = glGetUniformLocationARB(fieldShaderId, "field");
if (fieldUniform == -1) {
printf("Error getting uniform `%s'.\n", "field");
exit(1);
}
kernelsUniform = glGetUniformLocationARB(fieldShaderId, "kernels");
if (kernelsUniform == -1) {
printf("Error getting uniform `%s'.\n", "kernels");
exit(1);
}
gainUniform = glGetUniformLocationARB(fieldShaderId, "gain");
if (gainUniform == -1) {
printf("Error getting uniform `%s'.\n", "gain");
exit(1);
}
glUseProgramObjectARB(fieldShaderId);
glUniform1fvARB(kernelsUniform, 25, kernels);
glUniform1fARB(gainUniform, convolutionGain);
}
void ofxShader::setUniformVariable1fv (char * name, int count, float * value){
if (bLoaded == true){
glUniform1fvARB(glGetUniformLocationARB(shader, name), count, value);
}
}
void ofxShader::setUniform1fv (string name, int count, float * value) {
if(bLoaded)
glUniform1fvARB(glGetUniformLocationARB(shader, name.c_str()), count, value);
}
void ccShaderARB::setTabUniform1fv(const char* uniform, int size, float* val)
{
int loc = glGetUniformLocationARB(prog,uniform);
glUniform1fvARB(loc,size,val);
}
void MGLContext::sendUniformFloat(unsigned int fxId, const char * name, float * values, const int count){
GLint uValue = glGetUniformLocationARB((GLhandleARB)fxId, name);
if(uValue != -1) glUniform1fvARB(uValue, count, values);
}
ShaderProgram &u1(const char *var, GLfloat *f) { glUniform1fvARB(uniform(var), 1, f); return *this; }
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBShaderObjects_nglUniform1fvARB(JNIEnv *env, jclass clazz, jint location, jint count, jobject values, jint values_position, jlong function_pointer) {
const GLfloat *values_address = ((const GLfloat *)(*env)->GetDirectBufferAddress(env, values)) + values_position;
glUniform1fvARBPROC glUniform1fvARB = (glUniform1fvARBPROC)((intptr_t)function_pointer);
glUniform1fvARB(location, count, values_address);
}
void ofxShader::setUniformVariable1fv (char const *name, int count, float const *value) {
if (loaded)
glUniform1fvARB(glGetUniformLocationARB(shader, name), count, value);
}
void GLSLShader::SetFloatVector(GLint variable, GLsizei count, const float *value) { if (variable!=-1) glUniform1fvARB(variable, count, value); }
void DiGLShaderParam::Bind() const
{
if (!mShaderLinker || !mShaderLinker->GetGLHandle())
return;
// bind built-in (global) uniforms
auto env = Driver->GetShaderEnvironment();
for (auto it = mBuiltinFuncs.begin(); it != mBuiltinFuncs.end(); ++it)
{
it->second(env, it->first);
}
// bind custom uniforms
for (uint32 i = 0; i < NUM_VARIABLE_TYPES; ++i)
{
for (auto it = mShaderParams[i].begin(); it != mShaderParams[i].end(); ++it)
{
const DiAny& data = it->second;
if (data.isEmpty())
continue;
GLuint location = 0;
int samplerUnit = 0;
if (i == VARIABLE_SAMPLER2D || i == VARIABLE_SAMPLERCUBE)
{
auto sampler = mShaderLinker->GetSampler(it->first);
if (!sampler)
continue;
location = sampler->location;
samplerUnit = (int)sampler->unit;
}
else
{
auto constant = mShaderLinker->GetConstant(it->first);
if (!constant)
continue;
location = constant->location;
}
switch (i)
{
case DiShaderParameter::VARIABLE_FLOAT:
{
float val = any_cast<float>(data);
glUniform1fvARB(location, 1, &val);
break;
}
case DiShaderParameter::VARIABLE_FLOAT2:
{
DiVec2 vec2 = any_cast<DiVec2>(data);
glUniform2fvARB(location, 1, vec2.ptr());
break;
}
case DiShaderParameter::VARIABLE_FLOAT3:
{
DiVec3 vec3 = any_cast<DiVec3>(data);
glUniform3fvARB(location, 1, vec3.ptr());
break;
}
case DiShaderParameter::VARIABLE_FLOAT4:
{
DiVec4 vec4 = any_cast<DiVec4>(data);
glUniform4fvARB(location, 1, vec4.ptr());
break;
}
case DiShaderParameter::VARIABLE_MAT4:
{
DiMat4 vec4 = any_cast<DiMat4>(data);
glUniformMatrix4fvARB(location, 1, GL_TRUE, vec4[0]);
break;
}
case DiShaderParameter::VARIABLE_COLOR:
{
DiColor c = any_cast<DiColor>(data);
DiVec4 vec4(c.r,c.g,c.b,c.a);
glUniform4fvARB(location, 1, vec4.ptr());
break;
}
case DiShaderParameter::VARIABLE_FLOAT4_ARRAY:
{
DiPair<DiVec4*,uint32> v4Arr = any_cast<DiPair<DiVec4*,uint32>>(data);
glUniform4fvARB(location, v4Arr.second, v4Arr.first->ptr());
break;
}
case DiShaderParameter::VARIABLE_SAMPLER2D:
case DiShaderParameter::VARIABLE_SAMPLERCUBE:
{
glUniform1ivARB(location, 1, &samplerUnit);
DiTexture* tex = any_cast<DiTexture*>(data);
tex->Bind((uint32)samplerUnit);
}
break;
}
}
}
}
//-----------------------------------------------------------------------
void GLSLLinkProgram::updateUniforms(GpuProgramParametersSharedPtr params,
uint16 mask, GpuProgramType fromProgType)
{
// iterate through uniform reference list and update uniform values
GLUniformReferenceIterator currentUniform = mGLUniformReferences.begin();
GLUniformReferenceIterator endUniform = mGLUniformReferences.end();
for (; currentUniform != endUniform; ++currentUniform)
{
// Only pull values from buffer it's supposed to be in (vertex or fragment)
// This method will be called twice, once for vertex program params,
// and once for fragment program params.
if (fromProgType == currentUniform->mSourceProgType)
{
const GpuConstantDefinition* def = currentUniform->mConstantDef;
if (def->variability & mask)
{
GLsizei glArraySize = (GLsizei)def->arraySize;
// get the index in the parameter real list
switch (def->constType)
{
case GCT_FLOAT1:
glUniform1fvARB(currentUniform->mLocation, glArraySize,
params->getFloatPointer(def->physicalIndex));
break;
case GCT_FLOAT2:
glUniform2fvARB(currentUniform->mLocation, glArraySize,
params->getFloatPointer(def->physicalIndex));
break;
case GCT_FLOAT3:
glUniform3fvARB(currentUniform->mLocation, glArraySize,
params->getFloatPointer(def->physicalIndex));
break;
case GCT_FLOAT4:
glUniform4fvARB(currentUniform->mLocation, glArraySize,
params->getFloatPointer(def->physicalIndex));
break;
case GCT_MATRIX_2X2:
glUniformMatrix2fvARB(currentUniform->mLocation, glArraySize,
GL_TRUE, params->getFloatPointer(def->physicalIndex));
break;
case GCT_MATRIX_2X3:
if (GLEW_VERSION_2_1)
{
glUniformMatrix2x3fv(currentUniform->mLocation, glArraySize,
GL_TRUE, params->getFloatPointer(def->physicalIndex));
}
break;
case GCT_MATRIX_2X4:
if (GLEW_VERSION_2_1)
{
glUniformMatrix2x4fv(currentUniform->mLocation, glArraySize,
GL_TRUE, params->getFloatPointer(def->physicalIndex));
}
break;
case GCT_MATRIX_3X2:
if (GLEW_VERSION_2_1)
{
glUniformMatrix3x2fv(currentUniform->mLocation, glArraySize,
GL_TRUE, params->getFloatPointer(def->physicalIndex));
}
break;
case GCT_MATRIX_3X3:
glUniformMatrix3fvARB(currentUniform->mLocation, glArraySize,
GL_TRUE, params->getFloatPointer(def->physicalIndex));
break;
case GCT_MATRIX_3X4:
if (GLEW_VERSION_2_1)
{
glUniformMatrix3x4fv(currentUniform->mLocation, glArraySize,
GL_TRUE, params->getFloatPointer(def->physicalIndex));
}
break;
case GCT_MATRIX_4X2:
if (GLEW_VERSION_2_1)
{
glUniformMatrix4x2fv(currentUniform->mLocation, glArraySize,
GL_TRUE, params->getFloatPointer(def->physicalIndex));
}
break;
case GCT_MATRIX_4X3:
if (GLEW_VERSION_2_1)
{
glUniformMatrix4x3fv(currentUniform->mLocation, glArraySize,
GL_TRUE, params->getFloatPointer(def->physicalIndex));
}
break;
case GCT_MATRIX_4X4:
glUniformMatrix4fvARB(currentUniform->mLocation, glArraySize,
GL_TRUE, params->getFloatPointer(def->physicalIndex));
break;
case GCT_INT1:
glUniform1ivARB(currentUniform->mLocation, glArraySize,
(GLint*)params->getIntPointer(def->physicalIndex));
break;
case GCT_INT2:
glUniform2ivARB(currentUniform->mLocation, glArraySize,
(GLint*)params->getIntPointer(def->physicalIndex));
break;
case GCT_INT3:
glUniform3ivARB(currentUniform->mLocation, glArraySize,
(GLint*)params->getIntPointer(def->physicalIndex));
break;
case GCT_INT4:
glUniform4ivARB(currentUniform->mLocation, glArraySize,
(GLint*)params->getIntPointer(def->physicalIndex));
break;
case GCT_SAMPLER1D:
case GCT_SAMPLER1DSHADOW:
case GCT_SAMPLER2D:
case GCT_SAMPLER2DSHADOW:
case GCT_SAMPLER3D:
case GCT_SAMPLERCUBE:
// samplers handled like 1-element ints
glUniform1ivARB(currentUniform->mLocation, 1,
(GLint*)params->getIntPointer(def->physicalIndex));
break;
case GCT_UNKNOWN:
break;
} // end switch
#if OGRE_DEBUG_MODE
checkForGLSLError( "GLSLLinkProgram::updateUniforms", "Error updating uniform", 0 );
#endif
} // variability & mask
} // fromProgType == currentUniform->mSourceProgType
} // end for
}