void
piglit_init(int argc, char **argv)
{
static const char *vs_source =
"#version 150\n"
"in vec4 piglit_vertex;\n"
"void main()\n"
"{\n"
" gl_Position = piglit_vertex;\n"
"}\n";
static const char *fs_source =
"#version 150\n"
"#extension GL_ARB_gpu_shader5: require\n"
"uniform samplerBuffer s[2];\n"
"uniform int offset;\n"
"uniform int index = 1;\n"
"void main()\n"
"{\n"
" gl_FragColor = texelFetch(s[index], offset);\n"
"}\n";
GLuint tex[2], tbo[2];
GLint indices[2] = { 0, 1 };
static const uint8_t datag[4] = {0x00, 0xff, 0x00, 0x00};
static const uint8_t datar[4] = {0xff, 0x00, 0x00, 0x00};
GLuint prog;
GLint size = 4;
piglit_require_extension("GL_ARB_gpu_shader5");
prog = piglit_build_simple_program(vs_source, fs_source);
glUseProgram(prog);
glGenBuffers(2, tbo);
glGenTextures(2, tex);
glBindBuffer(GL_TEXTURE_BUFFER, tbo[0]);
glBindTexture(GL_TEXTURE_BUFFER, tex[0]);
glTexBuffer(GL_TEXTURE_BUFFER, GL_RGBA8, tbo[0]);
glBufferData(GL_TEXTURE_BUFFER,
size * sizeof(datar), NULL, GL_STATIC_READ);
glBufferSubData(GL_TEXTURE_BUFFER,
(size - 1) * sizeof(datar), sizeof(datar), datar);
glActiveTexture(GL_TEXTURE1);
glBindBuffer(GL_TEXTURE_BUFFER, tbo[1]);
glBindTexture(GL_TEXTURE_BUFFER, tex[1]);
glTexBuffer(GL_TEXTURE_BUFFER, GL_RGBA8, tbo[1]);
glBufferData(GL_TEXTURE_BUFFER,
size * sizeof(datag), NULL, GL_STATIC_READ);
glBufferSubData(GL_TEXTURE_BUFFER,
(size - 1) * sizeof(datag), sizeof(datag), datag);
glUniform1i(glGetUniformLocation(prog, "offset"), size - 1);
glUniform1iv(glGetUniformLocation(prog, "s"), 2, indices);
}
void GLWidget::passShadowMaps(QOpenGLShaderProgram *shaderProgram, const int texOffset) {
//Send all the lighting information and shadowmaps
std::vector<GLfloat> lightViews = scene->lightViews();
std::vector<GLfloat> lightPerspectives = scene->lightPerspectives();
glUniformMatrix4fv(shaderProgram->uniformLocation("lightViews"), lightViews.size() / 16, GL_FALSE, lightViews.data());
glUniformMatrix4fv(shaderProgram->uniformLocation("lightPerspectives"), lightPerspectives.size() / 16, GL_FALSE, lightPerspectives.data());
//Now the shadowmaps
std::vector<GLuint> shadowMapLocs = scene->shadowMapLocations();
std::vector<GLuint> shadowSATLocs = scene->shadowSATs();
GLint *shadowSamplers = new GLint[shadowMapLocs.size()];
GLint *shadowSATs = new GLint[shadowSATLocs.size()];
unsigned int shadowsOffset = texOffset;
for(unsigned int i = 0; i < shadowMapLocs.size(); i++) {
shadowSamplers[i] = i + shadowsOffset;
shadowSATs[i] = i + shadowsOffset + shadowMapLocs.size();
//Start at GL_TEXTURE0 + shadowsOffset
glActiveTexture(GL_TEXTURE0 + shadowsOffset + i);
glBindTexture(GL_TEXTURE_2D, shadowMapLocs[i]);
glActiveTexture(GL_TEXTURE0 + shadowsOffset + shadowMapLocs.size() + i);
glBindTexture(GL_TEXTURE_2D, shadowSATLocs[i]);
}
glUniform1iv(shaderProgram->uniformLocation("shadowMaps"), shadowMapLocs.size(), shadowSamplers);
glUniform1iv(shaderProgram->uniformLocation("shadowSATs"), shadowSATLocs.size(), shadowSATs);
delete[] shadowSamplers;
//An additional bias matrix
GLfloat bias[16] = {0.5, 0.0, 0.0, 0.5,
0.0, 0.5, 0.0, 0.5,
0.0, 0.0, 0.5, 0.5,
0.0, 0.0, 0.0, 1.0};
glUniformMatrix4fv(shaderProgram->uniformLocation("lightBias"), 1, GL_TRUE, bias);
glUniformMatrix4fv(shaderProgram->uniformLocation("inverseCameraMatrix"), 1, GL_FALSE, camera->getCameraMatrix().inverted().constData());
}
bool COGLES2SLMaterialRenderer::setUniform( int index, const void* data, int count )
{
if ((u32)index>=UniformInfo.size())
return false;
SUniformInfo& ui = UniformInfo[index];
if ( ui.location == -1 )
return false;
switch ( ui.type )
{
case GL_FLOAT:
glUniform1fv( ui.location, count, static_cast<const GLfloat*>( data ) );
break;
case GL_FLOAT_VEC2:
glUniform2fv( ui.location, count, static_cast<const GLfloat*>( data ) );
break;
case GL_FLOAT_VEC3:
glUniform3fv( ui.location, count, static_cast<const GLfloat*>( data ) );
break;
case GL_FLOAT_VEC4:
glUniform4fv( ui.location, count, static_cast<const GLfloat*>( data ) );
break;
case GL_INT:
case GL_BOOL:
glUniform1iv( ui.location, count, static_cast<const GLint*>( data ) );
break;
case GL_INT_VEC2:
case GL_BOOL_VEC2:
glUniform2iv( ui.location, count, static_cast<const GLint*>( data ) );
break;
case GL_INT_VEC3:
case GL_BOOL_VEC3:
glUniform3iv( ui.location, count, static_cast<const GLint*>( data ) );
break;
case GL_INT_VEC4:
case GL_BOOL_VEC4:
glUniform4iv( ui.location, count, static_cast<const GLint*>( data ) );
break;
case GL_FLOAT_MAT2:
glUniformMatrix2fv( ui.location, count, false, static_cast<const GLfloat*>( data ) );
break;
case GL_FLOAT_MAT3:
glUniformMatrix3fv( ui.location, count, false, static_cast<const GLfloat*>( data ) );
break;
case GL_FLOAT_MAT4:
glUniformMatrix4fv( ui.location, count, false, static_cast<const GLfloat*>( data ) );
break;
default: // sampler
glUniform1iv( ui.location, count, static_cast<const GLint*>( data ) );
break;
}
return !Driver->testGLError();
}
void Attribute::bindAsUniform( int index )
{
switch( numComponents() )
{
case 1:
if( m_internalComponentType == GL_FLOAT )
{
//printf("setting uniform tmp: %f at uniform location %i\n", *((float *)getRawPointer()), index );
glUniform1fv( index, numElements(), (float *)getRawPointer());
}
else if( m_internalComponentType == GL_INT )
{
glUniform1iv( index, numElements(), (int*)getRawPointer());
}else if( m_internalComponentType == SAMPLER )
{
int *texIds = (int*)getRawPointer();
int textureUnits[32];
int num = numElements();
for( int i=0;i<num;++i )
{
glActiveTexture(GL_TEXTURE0+g_nextTextureUnit);
glBindTexture(m_textureTarget, *texIds);
textureUnits[i] = g_nextTextureUnit;
++texIds;
++g_nextTextureUnit;
}
glUniform1iv( index, num, textureUnits);
}
break;
case 2:
if( m_internalComponentType == GL_FLOAT )
glUniform2fv( index, numElements(), (float *)getRawPointer());
break;
case 3:
if( m_internalComponentType == GL_FLOAT )
glUniform3fv( index, numElements(), (float *)getRawPointer());
break;
case 4:
if( m_internalComponentType == GL_FLOAT )
glUniform4fv( index, numElements(), (float *)getRawPointer());
break;
case 9:
glUniformMatrix3fv( index, numElements(), false, (float *)getRawPointer() );
break;
case 16:
glUniformMatrix4fv( index, numElements(), false, (float *)getRawPointer() );
break;
};
}
inline bool CShader::setArray<int>( const std::string & pName, int count, const int * v) const
{
const GLint iP= getParamLocation(pName);
if (iP < 0) return false;
glUniform1iv(iP, static_cast<const GLint>(count), static_cast<const GLint*>(v));CHECK_GLERROR("");
return true;
}
int gl_Uniformi(State& state){
int argc = state.stack->getTop();
switch (argc){
case 5:
glUniform4i((GLint) state.stack->to<int>(1), (GLint) state.stack->to<int>(2), (GLint) state.stack->to<int>(3), (GLint) state.stack->to<int>(4), (GLint) state.stack->to<int>(5));
break;
case 4:
glUniform3i((GLint) state.stack->to<int>(1), (GLint) state.stack->to<int>(2), (GLint) state.stack->to<int>(3), (GLint) state.stack->to<int>(4));
break;
case 3:
glUniform2i((GLint) state.stack->to<int>(1), (GLint) state.stack->to<int>(2), (GLint) state.stack->to<int>(3));
break;
case 2:
if (state.stack->is<LUA_TTABLE>(2)){
size_t size = 0;
GLint * data;
vector<int> _data;
size = getArray<int>(state, 2, _data);
data = _data.data();
glUniform1iv((GLint) state.stack->to<int>(1), (GLsizei) size, (GLint *) data);
}else if (state.stack->is<LUA_TNUMBER>(2)){
glUniform1i((GLint) state.stack->to<int>(1), (GLint) state.stack->to<int>(2));
}
break;
default:
break;
}
return 0;
}
void OGLESRenderEngine::Uniform1iv(GLint location, GLsizei count, GLint const * value)
{
bool dirty = false;
KLAYGE_AUTO(iter_p, uniformi_cache_.find(cur_program_));
if (iter_p == uniformi_cache_.end())
{
dirty = true;
iter_p = uniformi_cache_.insert(std::make_pair(cur_program_, std::map<GLint, int4>())).first;
}
for (GLsizei i = 0; i < count; ++ i)
{
KLAYGE_AUTO(iter_v, iter_p->second.find(location + i));
if (iter_v == iter_p->second.end())
{
dirty = true;
iter_p->second.insert(std::make_pair(location, int4(value[i], 0, 0, 0)));
}
else
{
if (iter_v->second.x() != value[i])
{
dirty = true;
iter_v->second.x() = value[i];
}
}
}
if (dirty)
{
glUniform1iv(location, count, value);
}
}
/** bind uniform array of int-scalars/vectors
*/
void FragmentProgram::BindInt(string parameterName, vector<vector<int> > intvectors) {
if (intvectors.size() == 0) return;
int vectorsize = intvectors.at(0).size();
if (vectorsize < 1 || vectorsize > 4) throw PPEResourceException("GLSL doesn't have a ivecX type, with the supplied X!");
// create a C array of all the intvector-values (to be supplied to OpenGL)
GLint* intarray = new GLint[vectorsize * intvectors.size()];
for (unsigned int i=0; i<intvectors.size(); i++) {
vector<int> intvector = intvectors.at(i);
if (intvector.size() != vectorsize) throw PPEResourceException("all vectors in an array must have the same size!");
for (unsigned int j=0; j<vectorsize; j++)
intarray[i*vectorsize + j] = intvector.at(j);
}
GuardedBind();
// get input parameter handle by name
GLint paramID = glGetUniformLocation(programID, parameterName.c_str());
if (paramID == -1) logger.error << "uniform \"" << parameterName << "\" does not exist" << logger.end;
// set value of variable (type: float, float2, float3, float4)
if (vectorsize==1) glUniform1iv(paramID, intvectors.size(), intarray); // see: http://www.thescripts.com/forum/thread394740.html
if (vectorsize==2) glUniform2iv(paramID, intvectors.size(), intarray); // see: http://developer.3dlabs.com/documents/glmanpages/glUniform.htm
if (vectorsize==3) glUniform3iv(paramID, intvectors.size(), intarray);
if (vectorsize==4) glUniform4iv(paramID, intvectors.size(), intarray);
GuardedUnbind();
delete intarray;
}
void GpuProgramUniform::update(const void *data) const
{
switch (m_glType)
{
case GL_INT:
glUniform1iv(m_location, 1, (GLint *)data);
break;
case GL_FLOAT:
glUniform1fv(m_location, 1, (GLfloat *)data);
break;
case GL_FLOAT_VEC2:
glUniform2fv(m_location, 1, (GLfloat *)data);
break;
case GL_FLOAT_VEC3:
glUniform3fv(m_location, 1, (GLfloat *)data);
break;
case GL_FLOAT_VEC4:
glUniform4fv(m_location, 1, (GLfloat *)data);
break;
case GL_FLOAT_MAT3:
glUniformMatrix3fv(m_location, 1, GL_FALSE, (GLfloat *)data);
break;
case GL_FLOAT_MAT4:
glUniformMatrix4fv(m_location, 1, GL_FALSE, (GLfloat *)data);
break;
default:
break;
}
}
void Uniform1iv(
const GLint Location,
const GLsizei Count,
const GLint* const Value)
{
glUniform1iv(Location, Count, Value);
}
void GLProgramData::setUniformSource(const std::string & valName, const std::shared_ptr<GLTextureBuffer> * source, const int count)
{
if (source == 0 || count == 0)
{
mSetters.erase(mSetters.find(valName));
}
else
{
const GLint loc = mProgram->getUniformLocation(valName);
mSetters[valName] = [loc, count, source, this]()
{
if (mCurrentTextureUnit + count > getMaxTextureUintsCount())
{
throw std::logic_error("Too much textures bound to the program.");
}
for (int i = 0; i < count; ++i)
{
glActiveTexture(GL_TEXTURE0 + mCurrentTextureUnit + i);
CHECK_GL_ERROR();
if (source[i])
{
source[i]->bind();
}
mBoundTextures.push_back(source[i]);
}
mProgram->checkBound();
glUniform1iv(loc, count, &textureIndexArray[mCurrentTextureUnit]);
CHECK_GL_ERROR();
mCurrentTextureUnit += count;
};
}
}
void Material::loadFromFiles(const char* vert, const char* frag, const char* geom) {
loadShader(vert, vertex_shader);
loadShader(frag, fragment_shader);
if (geom != nullptr)
loadShader(geom, geometry_shader);
shader_program.attachShader(vertex_shader);
shader_program.attachShader(fragment_shader);
if (geom != nullptr)
shader_program.attachShader(geometry_shader);
shader_program.link();
if (!shader_program.linkSuccess()) {
shader_program.printInfoLog(std::cerr);
}
GLuint sys_uniform_index = glGetUniformBlockIndex(shader_program, "SystemUniforms");
GLuint mtl_uniform_index = glGetUniformBlockIndex(shader_program, "MaterialUniforms");
if (sys_uniform_index != GL_INVALID_INDEX)
glUniformBlockBinding(shader_program, sys_uniform_index, 0);
if (mtl_uniform_index != GL_INVALID_INDEX)
glUniformBlockBinding(shader_program, mtl_uniform_index, 1);
GLuint tex_uniform_index = glGetUniformLocation(shader_program, "tex");
shader_program.use();
if (tex_uniform_index != -1) {
static const int samplers[4] = { 0, 1, 2, 3 };
glUniform1iv(tex_uniform_index, 4, samplers);
}
}
void
cogl_program_uniform_int (int uniform_no,
int size,
int count,
const int *value)
{
_COGL_GET_CONTEXT (ctx, NO_RETVAL);
switch (size)
{
case 1:
glUniform1iv (uniform_no, count, value);
break;
case 2:
glUniform2iv (uniform_no, count, value);
break;
case 3:
glUniform3iv (uniform_no, count, value);
break;
case 4:
glUniform4iv (uniform_no, count, value);
break;
default:
g_warning ("%s called with invalid size parameter", G_STRFUNC);
}
}
void Shader::setUniform1Array(const char* varname, const int* input, const int count)
{
GLint loc = getLocation(varname, &locations);
CHECK_SHADER_VAR(loc,varname);
glUniform1iv(loc,count,input);
assert (glGetError() == GL_NO_ERROR);
}
inline void Program::Uniform(GLint location, GLsizei count, const GLint *value)
{
GL_ASSERT(m_id > 0);
GL_ASSERT(location >= 0);
glUniform1iv(location, count, value);
}
void CModel::SendShaderParam() {
/*
ライト設定
*/
glUniform3fv(glGetUniformLocation(m_shader->getProgram(),"lightPos"),CLight::LIGHT_MAX,(float*)CLight::getPosPointer());
glUniform3fv(glGetUniformLocation(m_shader->getProgram(),"lightDir"),CLight::LIGHT_MAX,(float*)CLight::getDirPointer());
glUniform3fv(glGetUniformLocation(m_shader->getProgram(),"lightAmbientColor"),CLight::LIGHT_MAX,(float*)CLight::getAmbientColorPointer());
glUniform3fv(glGetUniformLocation(m_shader->getProgram(),"lightDiffuseColor"),CLight::LIGHT_MAX,(float*)CLight::getDiffuseColorPointer());
glUniform1fv(glGetUniformLocation(m_shader->getProgram(),"lightAttenuation"),CLight::LIGHT_MAX,(float*)CLight::getAttenuationPointer());
glUniform1fv(glGetUniformLocation(m_shader->getProgram(),"lightRadiationAngle"),CLight::LIGHT_MAX,(float*)CLight::getRadiationAnglePointer());
glUniform1iv(glGetUniformLocation(m_shader->getProgram(),"lightType"),CLight::LIGHT_MAX,(int*)CLight::getTypeColorPointer());
glUniform1i(glGetUniformLocation(m_shader->getProgram(),"lighting"),CLight::getLighting());
/*
視線設定
*/
CVector3D vec=CCamera::getCurrent()->getDir();
int eyeId = glGetUniformLocation(m_shader->getProgram(),"eyeVec"); //ライトの向きを設定
glUniform3fv(eyeId,1,(float*)&vec);
/*
ワールドトランスフォーム
*/
int worldId = glGetUniformLocation(m_shader->getProgram(),"WorldMatrix"); //ライトの向きを設定
glUniformMatrix4fv(worldId,1,false,m_matrix.f);
}
Material MaterialTemplate::compile() {
gl::ShaderProgram shader_program;
for (const gl::Shader& shader : shaders) {
shader_program.attachShader(shader);
}
shader_program.link();
if (!shader_program.linkSuccess()) {
shader_program.printInfoLog(std::cerr);
}
GLuint sys_uniform_index = glGetUniformBlockIndex(shader_program, "SystemUniforms");
GLuint mtl_uniform_index = glGetUniformBlockIndex(shader_program, "MaterialUniforms");
if (sys_uniform_index != GL_INVALID_INDEX)
glUniformBlockBinding(shader_program, sys_uniform_index, 0);
if (mtl_uniform_index != GL_INVALID_INDEX)
glUniformBlockBinding(shader_program, mtl_uniform_index, 1);
GLuint tex_uniform_index = glGetUniformLocation(shader_program, "tex");
shader_program.use();
if (tex_uniform_index != -1) {
static const int samplers[4] = { 0, 1, 2, 3 };
glUniform1iv(tex_uniform_index, 4, samplers);
}
return Material(std::move(shader_program), options_size);
}
static bool glsl_set_shader_int_vector(ALLEGRO_SHADER *shader,
const char *name, int num_components, int *i, int num_elems)
{
ALLEGRO_SHADER_GLSL_S *gl_shader = (ALLEGRO_SHADER_GLSL_S *)shader;
GLint handle;
handle = glGetUniformLocation(gl_shader->program_object, name);
if (handle < 0) {
ALLEGRO_WARN("No uniform variable '%s' in shader program\n", name);
return false;
}
switch (num_components) {
case 1:
glUniform1iv(handle, num_elems, i);
break;
case 2:
glUniform2iv(handle, num_elems, i);
break;
case 3:
glUniform3iv(handle, num_elems, i);
break;
case 4:
glUniform4iv(handle, num_elems, i);
break;
default:
ASSERT(false);
break;
}
return check_gl_error(name);
}
void GFXGLShader::setConstantsFromBuffer(GFXGLShaderConstBuffer* buffer)
{
for(Vector<GFXGLShaderConstHandle*>::iterator i = mValidHandles.begin(); i != mValidHandles.end(); ++i)
{
GFXGLShaderConstHandle* handle = *i;
AssertFatal(handle, "GFXGLShader::setConstantsFromBuffer - Null handle");
if(handle->mInstancingConstant)
continue;
// Don't set if the value has not be changed.
if(dMemcmp(mConstBuffer + handle->mOffset, buffer->mBuffer + handle->mOffset, handle->getSize()) == 0)
continue;
// Copy new value into our const buffer and set in GL.
dMemcpy(mConstBuffer + handle->mOffset, buffer->mBuffer + handle->mOffset, handle->getSize());
switch(handle->mDesc.constType)
{
case GFXSCT_Float:
glUniform1fv(handle->mLocation, handle->mDesc.arraySize, (GLfloat*)(mConstBuffer + handle->mOffset));
break;
case GFXSCT_Float2:
glUniform2fv(handle->mLocation, handle->mDesc.arraySize, (GLfloat*)(mConstBuffer + handle->mOffset));
break;
case GFXSCT_Float3:
glUniform3fv(handle->mLocation, handle->mDesc.arraySize, (GLfloat*)(mConstBuffer + handle->mOffset));
break;
case GFXSCT_Float4:
glUniform4fv(handle->mLocation, handle->mDesc.arraySize, (GLfloat*)(mConstBuffer + handle->mOffset));
break;
case GFXSCT_Int:
case GFXSCT_Sampler:
case GFXSCT_SamplerCube:
glUniform1iv(handle->mLocation, handle->mDesc.arraySize, (GLint*)(mConstBuffer + handle->mOffset));
break;
case GFXSCT_Int2:
glUniform2iv(handle->mLocation, handle->mDesc.arraySize, (GLint*)(mConstBuffer + handle->mOffset));
break;
case GFXSCT_Int3:
glUniform3iv(handle->mLocation, handle->mDesc.arraySize, (GLint*)(mConstBuffer + handle->mOffset));
break;
case GFXSCT_Int4:
glUniform4iv(handle->mLocation, handle->mDesc.arraySize, (GLint*)(mConstBuffer + handle->mOffset));
break;
case GFXSCT_Float2x2:
glUniformMatrix2fv(handle->mLocation, handle->mDesc.arraySize, true, (GLfloat*)(mConstBuffer + handle->mOffset));
break;
case GFXSCT_Float3x3:
glUniformMatrix3fv(handle->mLocation, handle->mDesc.arraySize, true, (GLfloat*)(mConstBuffer + handle->mOffset));
break;
case GFXSCT_Float4x4:
glUniformMatrix4fv(handle->mLocation, handle->mDesc.arraySize, true, (GLfloat*)(mConstBuffer + handle->mOffset));
break;
default:
AssertFatal(0,"");
break;
}
}
}
void shader_gl3::uniform(const char* name, const bool* arg1, const size_t& count) const {
A2E_CHECK_UNIFORM_EXISTENCE(name);
A2E_CHECK_UNIFORM_TYPE(name, GL_BOOL);
GLint* int_array = new int[count];
for(size_t i = 0; i < count; i++) { int_array[i] = arg1[i]; }
glUniform1iv(A2E_SHADER_GET_UNIFORM_POSITION(name), (GLsizei)count, int_array);
delete [] int_array;
}
bool ShaderProgram::setUniform(const std::string &name, GLint* v, int count)
{
GLint l = getUniformLocation(name);
if (l == -1)
return false;
glUniform1iv(l, count, v);
return true;
}
void GLSLProgram::setUniform1iv( const std::string & name, const GLint * value, const GLsizei count )
{
const GLint loc = getUniformLocation( name );
assert( value != 0 );
assert( count != 0 );
if ( loc != -1 ) glUniform1iv( loc, count, value );
}
bool GLSL::SetUniformv(int shader, const char *name, int count, int *v)
{
GLint id = glGetUniformLocation(shader, name);
if (id < 0)
return false;
glUniform1iv(id, count, v);
return true;
}
void ForwardShader::SetShaderState (const ShaderState* shaderState) {
const ForwardShaderState* forwardShaderState = (ForwardShaderState*)shaderState;
glUniform1i(b_animatedGeometry, forwardShaderState->m_attributeLocation.m_animatedGeometry ? 1 : 0);
glUniformMatrix4fv(m_projectionMatrix, 1, GL_TRUE, (GLfloat*)&forwardShaderState->m_projectionMatrix);
glUniformMatrix4fv(m_modelviewMatrix, 1, GL_TRUE, (GLfloat*)&forwardShaderState->m_modelviewMatrix);
glUniform1i(b_useDiffuseTexture, forwardShaderState->b_useDiffuseTexture);
glUniform1i(b_useEnvironmentMap, forwardShaderState->b_useEnvironmentMap);
glUniform1i(b_useNormalMap, forwardShaderState->b_useNormalMap);
glUniform3fv(m_eyePosition, 1, forwardShaderState->m_eyePosition);
glUniform3fv(m_lightDirection, 1, forwardShaderState->m_lightDirection);
glUniform3fv(m_lightCombinedAmbient, 1, forwardShaderState->m_lightCombinedAmbient);
glUniform3fv(m_lightCombinedDiffuse, 1, forwardShaderState->m_lightCombinedDiffuse);
glUniform3fv(m_lightCombinedSpecular, 1, forwardShaderState->m_lightCombinedSpecular);
glUniform1f(m_materialSpecularExponent, forwardShaderState->m_materialSpecularExponent);
glUniform1f(m_materialGloss, forwardShaderState->m_materialGloss);
glUniform1f(m_materialOpacity, forwardShaderState->m_materialOpacity);
glUniform1iv(b_usePointLight, c_num_point_lights, forwardShaderState->b_usePointLight);
glUniform3fv(m_pointLightPosition, c_num_point_lights, (GLfloat*)forwardShaderState->m_pointLightPosition);
glUniform3fv(m_pointLightCombinedAmbient, c_num_point_lights, (GLfloat*)forwardShaderState->m_pointLightCombinedAmbient);
glUniform3fv(m_pointLightCombinedDiffuse, c_num_point_lights, (GLfloat*)forwardShaderState->m_pointLightCombinedDiffuse);
glUniform3fv(m_pointLightCombinedSpecular, c_num_point_lights, (GLfloat*)forwardShaderState->m_pointLightCombinedSpecular);
glUniform1fv(m_pointLightRange, c_num_point_lights, forwardShaderState->m_pointLightRange);
glUniform1fv(m_pointLightAttenuationMultiplier, c_num_point_lights, forwardShaderState->m_pointLightAttenuationMultiplier);
glEnableVertexAttribArray(m_vPosition0);
glVertexAttribPointer(m_vPosition0, 3, GL_FLOAT, GL_FALSE, sizeof(Vertex), BUFFER_OFFSET(forwardShaderState->m_attributeLocation.m_position0));
glEnableVertexAttribArray(m_vNormal0);
glVertexAttribPointer(m_vNormal0, 3, GL_FLOAT, GL_FALSE, sizeof(Vertex), BUFFER_OFFSET(forwardShaderState->m_attributeLocation.m_normal0));
glEnableVertexAttribArray(m_vTexCoord0);
glVertexAttribPointer(m_vTexCoord0, 2, GL_FLOAT, GL_FALSE, sizeof(Vertex), BUFFER_OFFSET(forwardShaderState->m_attributeLocation.m_texCoord0));
if (forwardShaderState->m_attributeLocation.m_animatedGeometry) {
glEnableVertexAttribArray(m_vPosition1);
glVertexAttribPointer(m_vPosition1, 3, GL_FLOAT, GL_FALSE, sizeof(Vertex), BUFFER_OFFSET(forwardShaderState->m_attributeLocation.m_position1));
glEnableVertexAttribArray(m_vNormal1);
glVertexAttribPointer(m_vNormal1, 3, GL_FLOAT, GL_FALSE, sizeof(Vertex), BUFFER_OFFSET(forwardShaderState->m_attributeLocation.m_normal1));
glEnableVertexAttribArray(m_vTexCoord1);
glVertexAttribPointer(m_vTexCoord1, 2, GL_FLOAT, GL_FALSE, sizeof(Vertex), BUFFER_OFFSET(forwardShaderState->m_attributeLocation.m_texCoord1));
glUniform1f(m_attributeLerp, forwardShaderState->m_attributeLerp);
}
else {
glDisableVertexAttribArray(m_vPosition1);
glDisableVertexAttribArray(m_vNormal1);
}
m_currentState = *forwardShaderState;
}
template <> void shaderUniformConstant<unsigned int>::bind( unsigned int programID )
{
if (updated)
{
int location = glGetUniformLocation( programID, name.c_str() );
if (location >= 0) glUniform1iv( location, values.size(), (int*) &values[0] );
updated = false;
}
}
void Lib3dapp::setTextureUniforms(Program& shader, unsigned int n) {
shader.use();
int* tab = new int[n];
for (unsigned int i=0; i<n; i++) {
tab[i] = i;
}
glUniform1iv(shader.getUfmHandle(NAME_U_TEXTURES), n, (const GLint*)tab);
delete[] tab;
}
/**
* Binds a shader to the backend renderer
* @param active_texture_unit Active texture unit to bind to
* @param backend_data Pointer to renderer-specific data used for binding
*/
void ShaderInterface::Bind(const ShaderManager::CacheEntry::BackendData* backend_data) {
static const int texture_locations[] = { 0, 1, 2, 3, 4, 5, 6, 7 };
const BackendData* data = static_cast<const BackendData*>(backend_data);
// TODO(ShizZy): move this to the uniform manager
glUniform1iv(glGetUniformLocation(data->program_, "texture"), 8, texture_locations);
glUseProgram(data->program_);
}
void CShaderMngr::SetUniformData(const char *strShaderName, const char *strVariableName, int *pData, int nNumElements)
{
shaderData *pShaderData = GetShaderData(strShaderName);
if (pShaderData)
{
const GLint location = glGetUniformLocation(pShaderData->nProgID, strVariableName);
glUniform1iv(location, nNumElements, pData);
}
}
bool GLMeshRenderer::ProgramBindSamplerIndex(GLuint prog_id, char const *name, GLint idx)
{
GLint loc = glGetUniformLocation(prog_id, name);
if (loc < 0) {
// didn't exist
return false;
}
glUniform1iv(loc, 1, (GLint*)&idx);
return true;
}
void vesUniform::callGL(int location) const
{
if (this->m_numberElements < 1)
return;
switch (this->m_type)
{
case Bool:
case Int:
if (this->m_intArray)
glUniform1iv(location, this->m_numberElements,
&this->m_intArray->front());
break;
case Float:
if (this->m_floatArray)
glUniform1fv(location, this->m_numberElements,
&this->m_floatArray->front());
break;
case FloatVec2:
if (this->m_floatArray)
glUniform2fv(location, this->m_numberElements,
&this->m_floatArray->front());
break;
case FloatVec3:
if (this->m_floatArray)
glUniform3fv(location, this->m_numberElements,
&this->m_floatArray->front());
break;
case FloatVec4:
if (this->m_floatArray)
glUniform4fv(location, this->m_numberElements,
&this->m_floatArray->front());
break;
case FloatMat3:
if (m_floatArray)
glUniformMatrix3fv(location, this->m_numberElements, GL_FALSE,
&this->m_floatArray->front());
break;
case FloatMat4:
if (this->m_floatArray)
glUniformMatrix4fv(location, this->m_numberElements, GL_FALSE,
&this->m_floatArray->front());
break;
default:
std::cerr << "ERROR: " << __FILE__ ":" << __LINE__ << std::endl;
break;
}
}
