void setShaderVariables(GLuint shaderProg)
{
GLfloat projMatrix[16];
GLfloat viewMatrix[16];
glGetFloatv(GL_PROJECTION_MATRIX, projMatrix);
glGetFloatv(GL_MODELVIEW_MATRIX, viewMatrix);
if(GL20Support)
{
//TODO: Clean up shaders
glUniform2f(glGetUniformLocation(shaderProg, "resolution"), currentRes[0], currentRes[1]);
glUniform3f(glGetUniformLocation(shaderProg, "lightPos"), lightPos[0], lightPos[1], lightPos[2]);
glUniform3f(glGetUniformLocation(shaderProg, "cameraPos"), camera.getX(), camera.getY(), camera.getZ());
glUniform3f(glGetUniformLocation(shaderProg, "ambientLight"), 1.0, 1.0, 1.0);
glUniform3f(glGetUniformLocation(shaderProg, "diffuseLight"), 1.0, 1.0, 1.0);
glUniform3f(glGetUniformLocation(shaderProg, "specularLight"), 1.0, 1.0, 1.0);
glUniform1f(glGetUniformLocation(shaderProg, "a"), 1.0);
glUniform1f(glGetUniformLocation(shaderProg, "b"), 0.1);
glUniform1f(glGetUniformLocation(shaderProg, "c"), 0.1);
glUniformMatrix4fv(glGetUniformLocation(shaderProg, "projMatrix"), 1, false, projMatrix);
glUniformMatrix4fv(glGetUniformLocation(shaderProg, "viewMatrix"), 1, false, viewMatrix);
}
else
{
//TODO: Match ARB block with block above
glUniform2fARB(glGetUniformLocationARB(shaderProg, "resolution"), currentRes[0], currentRes[1]);
glUniform3fARB(glGetUniformLocationARB(shaderProg, "lightPos"), lightPos[0], lightPos[1], lightPos[2]);
glUniformMatrix4fvARB(glGetUniformLocationARB(shaderProg, "projMatrix"), 1, false, projMatrix);
glUniformMatrix4fvARB(glGetUniformLocationARB(shaderProg, "viewMatrix"), 1, false, viewMatrix);
}
}
inline void Uniform<vr::Matrix, 3>::apply()
{
std::stringstream ss;
glUniformMatrix4fvARB(location , 1, GL_FALSE, value[0].ptr());
ss << __FILE__ << ":" << __LINE__; CheckErrorsGL( string(ss.str()) );
glUniformMatrix4fvARB(location+1, 1, GL_FALSE, value[1].ptr());
ss << __FILE__ << ":" << __LINE__; CheckErrorsGL( string(ss.str()) );
glUniformMatrix4fvARB(location+2, 1, GL_FALSE, value[2].ptr());
ss << __FILE__ << ":" << __LINE__; CheckErrorsGL( string(ss.str()) );
}
void setShaderVariables(GLuint bubbleShaderProg)
{
GLfloat projMatrix[16];
GLfloat viewMatrix[16];
glGetFloatv(GL_PROJECTION_MATRIX, projMatrix);
glGetFloatv(GL_MODELVIEW_MATRIX, viewMatrix);
if(GL20Support)
{
glUniform1f(glGetUniformLocation(bubbleShaderProg, "elapsedTime"), motionClock.GetElapsedTime());
glUniform1f(glGetUniformLocation(bubbleShaderProg, "near"), _near);
glUniform1f(glGetUniformLocation(bubbleShaderProg, "far"), _far);
glUniform1f(glGetUniformLocation(bubbleShaderProg, "fov"), fov);
glUniform1f(glGetUniformLocation(bubbleShaderProg, "cursorScrollAmount"), cursorScrollAmount);
glUniform2f(glGetUniformLocation(bubbleShaderProg, "resolution"), RES_WIDTH, RES_HEIGHT);
glUniform3f(glGetUniformLocation(bubbleShaderProg, "modelCenter"), center[0], center[1], center[2]);
glUniform3f(glGetUniformLocation(bubbleShaderProg, "cameraPos"), cameraPos[0], cameraPos[1], cameraPos[2]);
glUniform3f(glGetUniformLocation(bubbleShaderProg, "lookAtPos"), lookAtPos[0], lookAtPos[1], lookAtPos[2]);
glUniform3f(glGetUniformLocation(bubbleShaderProg, "cameraUp"), cameraUp[0], cameraUp[1], cameraUp[2]);
glUniformMatrix4fv(glGetUniformLocation(bubbleShaderProg, "projMatrix"), 1, false, projMatrix);
glUniformMatrix4fv(glGetUniformLocation(bubbleShaderProg, "viewMatrix"), 1, false, viewMatrix);
glUniform2f(glGetUniformLocation(bubbleShaderProg, "lightPos"), lightPos[0], lightPos[1]);
glUniform2f(glGetUniformLocation(bubbleShaderProg, "cursorAbsolutePos"), cursorAbsolutePos[0], cursorAbsolutePos[1]);
glUniform2f(glGetUniformLocation(bubbleShaderProg, "cursorDragAmount"), cursorDragAmount[0], cursorDragAmount[1]);
glUniform2f(glGetUniformLocation(bubbleShaderProg, "lastClickPos"), lastClickPos[0], lastClickPos[1]);
glUniform2f(glGetUniformLocation(bubbleShaderProg, "lastFrameDragPos"), lastFrameDragPos[0], lastFrameDragPos[1]);
glUniform1i(glGetUniformLocation(bubbleShaderProg, "mouseButtonDown"), mouseButtonDown);
} else {
glUniform1fARB(glGetUniformLocationARB(bubbleShaderProg, "elapsedTime"), Clock.GetElapsedTime());
glUniform1fARB(glGetUniformLocationARB(bubbleShaderProg, "near"), _near);
glUniform1fARB(glGetUniformLocationARB(bubbleShaderProg, "far"), _far);
glUniform1fARB(glGetUniformLocationARB(bubbleShaderProg, "fov"), fov);
glUniform1fARB(glGetUniformLocationARB(bubbleShaderProg, "cursorScrollAmount"), cursorScrollAmount);
glUniform2fARB(glGetUniformLocationARB(bubbleShaderProg, "resolution"), RES_WIDTH, RES_HEIGHT);
glUniform3fARB(glGetUniformLocationARB(bubbleShaderProg, "modelCenter"), center[0], center[1], center[2]);
glUniform3fARB(glGetUniformLocationARB(bubbleShaderProg, "cameraPos"), cameraPos[0], cameraPos[1], cameraPos[2]);
glUniform3fARB(glGetUniformLocationARB(bubbleShaderProg, "lookAtPos"), lookAtPos[0], lookAtPos[1], lookAtPos[2]);
glUniform3fARB(glGetUniformLocationARB(bubbleShaderProg, "cameraUp"), cameraUp[0], cameraUp[1], cameraUp[2]);
glUniformMatrix4fvARB(glGetUniformLocationARB(bubbleShaderProg, "projMatrix"), 1, false, projMatrix);
glUniformMatrix4fvARB(glGetUniformLocationARB(bubbleShaderProg, "viewMatrix"), 1, false, viewMatrix);
glUniform2fARB(glGetUniformLocationARB(bubbleShaderProg, "cursorAbsolutePos"), cursorAbsolutePos[0], cursorAbsolutePos[1]);
glUniform2fARB(glGetUniformLocationARB(bubbleShaderProg, "cursorDragAmount"), cursorDragAmount[0], cursorDragAmount[1]);
glUniform2fARB(glGetUniformLocationARB(bubbleShaderProg, "lastClickPos"), lastClickPos[0], lastClickPos[1]);
glUniform2fARB(glGetUniformLocationARB(bubbleShaderProg, "lastFrameDragPos"), lastFrameDragPos[0], lastFrameDragPos[1]);
glUniform1iARB(glGetUniformLocationARB(bubbleShaderProg, "mouseButtonDown"), mouseButtonDown);
}
}
/*
* sendUniformMatrix4fv
*
* parameter name - char*
* parameter count - GLsizei
* parameter transpose - GLboolean
* parameter values - GLfloat*
* return - bool
*/
bool ShaderObject::sendUniformMatrix4fv(const char * name, GLsizei count, GLboolean transpose, GLfloat* values) {
GLint location = getUniLoc(name);
if (location == -1)
return false;
glUniformMatrix4fvARB(location, count, transpose, values);
return true;
} // end sendUniformMatrix4fv()
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 );
}
}
bool Shader::sendUniformMatrix4fv(char* varname, GLsizei count, GLboolean transpose, GLfloat *value)
{
GLint loc = GetUniformLocation(varname);
if (loc == -1) return false;
glUniformMatrix4fvARB(loc, count, transpose, value);
return true;
}
void Shader::SetMatrix4(std::string name, Matrix4 &value)
{
int uloc = SIG_FindUniform(name);
if (uloc != -1) {
glUniformMatrix4fvARB(uloc, 1, GL_FALSE, &value.Raw()[0][0]);
} else {
SIG_LOG("Could not find uniform \"" << name << "\"");
}
}
/*!
void Matrices(Shaderobject shader, String uniform_variable)\n
Function to pass 4x4 matrices as uniform array to a vertexshader
*/
void Item_armature::Matrices(QObject* _shader, QString var){
if (glwrapper_shader* shader = dynamic_cast<glwrapper_shader*>(_shader)){
float* space = new float[max_bone_id * 16 + 16];
for (QTreeWidgetItemIterator it(this);*it;it++){
if (Item_bone* bone = dynamic_cast<Item_bone*>(*it)){
float xx = bone->quat[0] * bone->quat[0];
float xy = bone->quat[0] * bone->quat[1];
float xz = bone->quat[0] * bone->quat[2];
float xw = bone->quat[0] * bone->quat[3];
float yy = bone->quat[1] * bone->quat[1];
float yz = bone->quat[1] * bone->quat[2];
float yw = bone->quat[1] * bone->quat[3];
float zz = bone->quat[2] * bone->quat[2];
float zw = bone->quat[2] * bone->quat[3];
//Matrix in OpenGL order!!!
int ofs = bone->id * 16;
space[ofs + 0] = 1.0 - 2.0 * (yy + zz);
space[ofs + 1] = 2.0 * (xy + zw);
space[ofs + 2] = 2.0 * (xz - yw);
space[ofs + 3] = 0.0;
space[ofs + 4] = 2.0 * (xy - zw);
space[ofs + 5] = 1.0 - 2.0 * (xx + zz);
space[ofs + 6] = 2.0 * (yz + xw);
space[ofs + 7] = 0.0;
space[ofs + 8] = 2.0 * (xz + yw);
space[ofs + 9] = 2.0 * (yz - xw);
space[ofs + 10] = 1.0 - 2.0 * (xx + yy);
space[ofs + 11] = 0;
float x = bone->initJoint[0];
float y = bone->initJoint[1];
float z = bone->initJoint[2];
space[ofs + 12] = bone->joint[0] - (space[ofs+0] * x + space[ofs+4] * y + space[ofs+8] * z);
space[ofs + 13] = bone->joint[1] - (space[ofs+1] * x + space[ofs+5] * y + space[ofs+9] * z);
space[ofs + 14] = bone->joint[2] - (space[ofs+2] * x + space[ofs+6] * y + space[ofs+10]* z);
space[ofs + 15] = 1.0;
}
}
shader->Bind();
int loc = glGetUniformLocationARB(shader->getShaderHandle(),var.toLatin1().constData());
glUniformMatrix4fvARB(loc, max_bone_id + 1,GL_FALSE, space);
GL_CHECK_ERROR();
delete[] space;
}
else{
qDebug() << "Item_armature::Joints parameter is not a shader object";
}
}
bool GLSLShader::setUniformMatrix( const char *name, const float *m )
{
if (!programObj) return false;
int loc = glGetUniformLocationARB( programObj, name );
if (loc < 0)
return false;
glUniformMatrix4fvARB( loc, 1, GL_FALSE, m );
return true;
}
bool GlslProgram :: setUniformMatrix ( const char * name, float value [16] )
{
int loc = glGetUniformLocationARB ( program, name );
if ( loc < 0 )
return false;
glUniformMatrix4fvARB ( loc, 1, GL_FALSE, value );
return true;
}
void Shader::uniformMatrix(const std::string & uniformName, const Matrix4& value)
{
GLuint id = glGetUniformLocation(_program, uniformName.c_str());
if (id == -1)
{
#ifdef DEBUG_SHADERS
FLog(FLog::WARNING, _name + " Couldn't get uniform location of " + uniformName);
#endif
}
glUniformMatrix4fvARB(id, 1, false, value.getValuePtr());
}
void BL_Shader::SetUniform(int uniform, const MT_Matrix4x4& vec, bool transpose)
{
if ( GLEW_ARB_fragment_shader &&
GLEW_ARB_vertex_shader &&
GLEW_ARB_shader_objects
)
{
float value[16];
// note: getValue gives back column major as needed by OpenGL
vec.getValue(value);
glUniformMatrix4fvARB(uniform, 1, transpose?GL_TRUE:GL_FALSE, value);
}
}
void Shader::setParameter(const std::string &name, const Transform &transform) {
if (mShaderProgram) {
ensureGLContext();
GLhandleARB program = glCheck(glGetHandleARB(glGetHandleARB(GL_PROGRAM_OBJECT_ARB)));
glCheck(glUseProgramObjectARB(mShaderProgram));
GLint location = getParamLocation(name);
if (location != -1) {
glCheck(glUniformMatrix4fvARB(location, 1, GL_FALSE, transform.getMatrix()));
}
glCheck(glUseProgramObjectARB(program));
}
}
void VolumeRayCasting::display(GLContextData& contextData) const
{
/* Get the data item: */
DataItem* dataItem=contextData.retrieveDataItem<DataItem>(this);
/* Access this window's display state: */
const Vrui::DisplayState& displayState=Vrui::getDisplayState(contextData);
glPushAttrib(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT|GL_ENABLE_BIT|GL_POLYGON_BIT|GL_TRANSFORM_BIT|GL_VIEWPORT_BIT);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
SetTexture(dataItem->rayCastingShader, "volumeTex", dataItem->volumeTex, GL_TEXTURE_3D);
SetTexture(dataItem->rayCastingShader, "transferFuncTex", dataItem->transferFuncTex, GL_TEXTURE_2D);
//Set uniform
//modelview
Mat4f modelViewMat = Mat4f(1.0f);
for(int row = 0; row <3; row++)
for(int col = 0; col<3; col++)
{
modelViewMat(row,col) = rotation(row,col);
}
for(int i = 0; i<3;i++)
modelViewMat(i,3)=translation[i];
Mat4f invModelView = invert(modelViewMat);
GLint location = glGetUniformLocationARB(dataItem->rayCastingShader, "invModelView");
glUniformMatrix4fvARB(dataItem->rayCastingShader, location, true, &invModelView(0,0));
//aspect
float aspect = 1.0f;
//cotFOV
float cotfov = tan(Math::rad(90.f)-Math::rad(22.5f));
glUseProgramObjectARB(dataItem->rayCastingShader);
std::cout<<"start draw"<<std::endl;
for(int i=0;i<1;++i)
glCallList(dataItem->displayListIds[i]);
glUseProgramObjectARB(0);
// glBegin(GL_TRIANGLES);
// glVertex3f(0.0f,0.0f,1.0f);
// glVertex3f(-1.0f,0.0f,-1.0f);
// glVertex3f(1.0f,0.0f,-1.0f);
// glEnd();
glPopAttrib();
}
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");
}
void Shader::setParameter(const std::string& name, math::Matrix4f matrix)
{
if (m_shaderProgram)
{
ensureGlContext();
// Enable program
GLhandleARB program = glGetHandleARB(GL_PROGRAM_OBJECT_ARB);
glCheck(glUseProgramObjectARB(m_shaderProgram));
// Get parameter location and assign it new values
GLint location = getParamLocation(name);
if (location != -1) {
std::array<float, 16> glmatrix = matrix.toGlMatrix();
glCheck(glUniformMatrix4fvARB(location, 1, GL_FALSE, glmatrix.data()));
}
// Disable program
glCheck(glUseProgramObjectARB(program));
}
}
void Shader::setParameter(const std::string& name, const sf::Transform& transform)
{
if (m_shaderProgram)
{
ensureGlContext();
// Enable program
GLhandleARB program = glGetHandleARB(GL_PROGRAM_OBJECT_ARB);
glCheck(glUseProgramObjectARB(m_shaderProgram));
// Get parameter location and assign it new values
GLint location = getParamLocation(name);
if (location != -1)
glCheck(glUniformMatrix4fvARB(location, 1, GL_FALSE, transform.getMatrix()));
// Disable program
glCheck(glUseProgramObjectARB(program));
}
}
bool ShaderProgram::SetMatrixVariable(const char* name, int dim, const float* values, int count, bool transpose)
{
if (!_linked) return false;
if (_id)
{
GLint location = glGetUniformLocationARB(_id, name);
if (location == -1) return false;
GLboolean trans = transpose ? GL_TRUE : GL_FALSE;
switch (dim)
{
case 2: glUniformMatrix2fvARB(location, count, trans, values); break;
case 3: glUniformMatrix3fvARB(location, count, trans, values); break;
case 4: glUniformMatrix4fvARB(location, count, trans, values); break;
default:
return false;
}
return true;
} else
return false;
}
void Perlin3DViewerWidget::renderBox( const myGL::GL_Matrix& modelviewMatrix, const Perlin3D_Chunk& Chunk )
{
const myGL::Vec3i& pos = Chunk.getPosition();
myGL::Vec3f to_move(pos.x, pos.y, pos.z);
to_move *= (float)_ChunkGenerator.getChunkSize();
myGL::GL_Matrix Matrix_Model;
Matrix_Model.PreMultTranslate( to_move );
///
myGL::GL_Matrix tmp_modelviewMatrix = modelviewMatrix * Matrix_Model;
glUniformMatrix4fvARB( _shader._location_u_modelviewMatrix, 1, GL_FALSE, tmp_modelviewMatrix.Ptr() );
///
_Geometry_Box.render();
}
void Shader::SetParameter(const std::string& name, const sf::Transform& transform)
{
if (myShaderProgram)
{
EnsureGlContext();
// Enable program
GLhandleARB program = glGetHandleARB(GL_PROGRAM_OBJECT_ARB);
GLCheck(glUseProgramObjectARB(myShaderProgram));
// Get parameter location and assign it new values
GLint location = glGetUniformLocationARB(myShaderProgram, name.c_str());
if (location != -1)
GLCheck(glUniformMatrix4fvARB(location, 1, GL_FALSE, transform.GetMatrix()));
else
Err() << "Parameter \"" << name << "\" not found in shader" << std::endl;
// Disable program
GLCheck(glUseProgramObjectARB(program));
}
}
static void use_uniform(struct brush *b, struct uniform *u)
{
int L;
/* Apply the uniform values to the OpenGL state. */
if (GL_has_shader_objects && u && b->shad_prog)
{
glUseProgramObjectARB(b->shad_prog);
if ((L = glGetUniformLocationARB(b->shad_prog, u->name)) != -1)
{
const float *k = u->vals;
int r = u->rows;
int c = u->cols;
if (r == 0 && c == 0)
glUniform1iARB(L, u->indx);
else if (r == 1 && c == 1)
glUniform1fARB(L, k[0]);
else if (r == 1 && c == 2)
glUniform2fARB(L, k[0], k[1]);
else if (r == 1 && c == 3)
glUniform3fARB(L, k[0], k[1], k[2]);
else if (r == 1 && c == 4)
glUniform4fARB(L, k[0], k[1], k[2], k[3]);
else if (r == 2 && c == 2) glUniformMatrix2fvARB(L, 1, 0, k);
else if (r == 3 && c == 3) glUniformMatrix3fvARB(L, 1, 0, k);
else if (r == 4 && c == 4) glUniformMatrix4fvARB(L, 1, 0, k);
}
glUseProgramObjectARB(0);
}
}
void Raycaster::bindShader(const Raycaster::PTransform& pmv,const Raycaster::PTransform& mv,Raycaster::DataItem* dataItem) const
{
/* Set up the data space transformation: */
glUniform3fvARB(dataItem->mcScaleLoc,1,dataItem->mcScale);
glUniform3fvARB(dataItem->mcOffsetLoc,1,dataItem->mcOffset);
/* Bind the ray termination texture: */
glActiveTextureARB(GL_TEXTURE0_ARB);
glBindTexture(GL_TEXTURE_2D,dataItem->depthTextureID);
glUniform1iARB(dataItem->depthSamplerLoc,0);
/* Set the termination matrix: */
glUniformMatrix4fvARB(dataItem->depthMatrixLoc,1,GL_TRUE,pmv.getMatrix().getEntries());
/* Set the depth texture size: */
glUniform2fARB(dataItem->depthSizeLoc,float(dataItem->depthTextureSize[0]),float(dataItem->depthTextureSize[1]));
/* Calculate the eye position in model coordinates: */
Point eye=pmv.inverseTransform(PTransform::HVector(0,0,1,0)).toPoint();
glUniform3fvARB(dataItem->eyePositionLoc,1,eye.getComponents());
/* Set the sampling step size: */
glUniform1fARB(dataItem->stepSizeLoc,stepSize*cellSize);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBShaderObjects_nglUniformMatrix4fvARB(JNIEnv *env, jclass clazz, jint location, jint count, jboolean transpose, jobject matrices, jint matrices_position, jlong function_pointer) {
const GLfloat *matrices_address = ((const GLfloat *)(*env)->GetDirectBufferAddress(env, matrices)) + matrices_position;
glUniformMatrix4fvARBPROC glUniformMatrix4fvARB = (glUniformMatrix4fvARBPROC)((intptr_t)function_pointer);
glUniformMatrix4fvARB(location, count, transpose, matrices_address);
}
static void UniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value) {
glUniformMatrix4fvARB(location, count, transpose, value);
}
void BL_Uniform::Apply(class BL_Shader *shader)
{
#ifdef SORT_UNIFORMS
MT_assert(mType > UNI_NONE && mType < UNI_MAX && mData);
if (!mDirty)
return;
switch (mType) {
case UNI_FLOAT:
{
float *f = (float*)mData;
glUniform1fARB(mLoc,(GLfloat)*f);
break;
}
case UNI_INT:
{
int *f = (int*)mData;
glUniform1iARB(mLoc, (GLint)*f);
break;
}
case UNI_FLOAT2:
{
float *f = (float*)mData;
glUniform2fvARB(mLoc,1, (GLfloat*)f);
break;
}
case UNI_FLOAT3:
{
float *f = (float*)mData;
glUniform3fvARB(mLoc,1,(GLfloat*)f);
break;
}
case UNI_FLOAT4:
{
float *f = (float*)mData;
glUniform4fvARB(mLoc,1,(GLfloat*)f);
break;
}
case UNI_INT2:
{
int *f = (int*)mData;
glUniform2ivARB(mLoc,1,(GLint*)f);
break;
}
case UNI_INT3:
{
int *f = (int*)mData;
glUniform3ivARB(mLoc,1,(GLint*)f);
break;
}
case UNI_INT4:
{
int *f = (int*)mData;
glUniform4ivARB(mLoc,1,(GLint*)f);
break;
}
case UNI_MAT4:
{
float *f = (float*)mData;
glUniformMatrix4fvARB(mLoc, 1, mTranspose?GL_TRUE:GL_FALSE,(GLfloat*)f);
break;
}
case UNI_MAT3:
{
float *f = (float*)mData;
glUniformMatrix3fvARB(mLoc, 1, mTranspose?GL_TRUE:GL_FALSE,(GLfloat*)f);
break;
}
}
mDirty = false;
#endif
}
void ProgramUniformGLSL::Set(const Matrix4x4 &mMatrix, bool bTranspose)
{
glUniformMatrix4fvARB(m_nOpenGLUniformLocation, 1, bTranspose, mMatrix);
}
void GLSLShader::setUniformMatrix( const GLint location, const float *m )
{
glUniformMatrix4fvARB( location, 1, GL_FALSE, m );
}
void Shader::setUniformMatrixf4(const std::string &variable, const glm::mat4 &value)
{
const long matrixCount = 1; const bool shouldTranspose = GL_FALSE;
if (shaderProgram != -1)
glUniformMatrix4fvARB (glGetUniformLocationARB (shaderProgram, variable.c_str ()), matrixCount, shouldTranspose, glm::value_ptr(value));
}
void GLShader::setupShader()
{
use();
std::map<const char *, shaderValPair>::iterator shaderVals_i;
for (shaderVals_i = shaderVals.begin(); shaderVals_i != shaderVals.end(); shaderVals_i++)
{
if ((*shaderVals_i).second.binding == -1) continue;
switch ((*shaderVals_i).second.valType)
{
case SHADER_VAL_XYZ:
if ((*shaderVals_i).second.xyzVal != (*shaderVals_i).second.xyzLastVal)
{
cubicvr_profiler.shaderval_count++;
glUniform3f((*shaderVals_i).second.binding, (float)(*shaderVals_i).second.xyzVal.x,(float)(*shaderVals_i).second.xyzVal.y,(float)(*shaderVals_i).second.xyzVal.z);
shaderVals[(*shaderVals_i).first].xyzLastVal = (*shaderVals_i).second.xyzVal;
}
break;
case SHADER_VAL_INT:
if ((*shaderVals_i).second.curVal != (*shaderVals_i).second.lastVal)
{
cubicvr_profiler.shaderval_count++;
glUniform1i((*shaderVals_i).second.binding, (GLuint)(*shaderVals_i).second.curVal);
shaderVals[(*shaderVals_i).first].lastVal = (*shaderVals_i).second.curVal;
}
break;
case SHADER_VAL_FLOAT:
if ((*shaderVals_i).second.xyzVal.x != (*shaderVals_i).second.xyzLastVal.x)
{
cubicvr_profiler.shaderval_count++;
glUniform1f((*shaderVals_i).second.binding, (float)(*shaderVals_i).second.xyzVal.x);
shaderVals[(*shaderVals_i).first].xyzLastVal.x = (*shaderVals_i).second.xyzVal.x;
}
break;
case SHADER_VAL_4X4:
cubicvr_profiler.shaderval_count++;
// printf("set matrix %s\n",(*shaderVals_i).first.c_str());
glUniformMatrix4fvARB(shaderVals[(*shaderVals_i).first].binding,1,false,(*shaderVals_i).second.mat);
// shaderVals[(*shaderVals_i).first].xyzLastVal.x = (*shaderVals_i).second.xyzVal.x;
break;
case SHADER_VAL_ATTRIB:
cubicvr_profiler.shaderval_count++;
if ((*shaderVals_i).second.curVal != (*shaderVals_i).second.lastVal)
{
//glEnableVertexAttribArrayARB(shaderVals[(*shaderVals_i).first].binding);
// extern void glVertexAttribPointer (GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const GLvoid *pointer);
// GL_BYTE,
// GL_UNSIGNED_BYTE,
// GL_SHORT,
// GL_UNSIGNED_SHORT,
// GL_INT,
// GL_UNSIGNED_INT,
// GL_FLOAT, or
// GL_DOUBLE
glVertexAttribPointer(shaderVals[(*shaderVals_i).first].binding, 3, GL_FLOAT, 0, 0, 0);
glEnableVertexAttribArray(shaderVals[(*shaderVals_i).first].binding);
}
break;
}
}
}
void WaterRenderer::render(const PTransform& projection,const OGTransform& modelview,GLContextData& contextData) const
{
/* Get the data item: */
DataItem* dataItem=contextData.retrieveDataItem<DataItem>(this);
/* Calculate the required matrices: */
PTransform projectionModelview=projection;
projectionModelview*=modelview;
/* Bind the water rendering shader: */
glUseProgramObjectARB(dataItem->waterShader);
const GLint* ulPtr=dataItem->waterShaderUniforms;
/* Bind the water quantity texture: */
glActiveTextureARB(GL_TEXTURE0_ARB);
waterTable->bindQuantityTexture(contextData);
glUniform1iARB(*(ulPtr++),0);
/* Bind the bathymetry texture: */
glActiveTextureARB(GL_TEXTURE1_ARB);
waterTable->bindBathymetryTexture(contextData);
glUniform1iARB(*(ulPtr++),1);
/* Calculate and upload the vertex transformation from grid space to eye space: */
PTransform modelviewGridTransform=gridTransform;
modelviewGridTransform.leftMultiply(modelview);
glUniformARB(*(ulPtr++),modelviewGridTransform);
/* Calculate the transposed tangent plane transformation from grid space to eye space: */
PTransform tangentModelviewGridTransform=tangentGridTransform;
tangentModelviewGridTransform*=Geometry::invert(modelview);
/* Transpose and upload the transposed tangent plane transformation: */
const Scalar* tmvgtPtr=tangentModelviewGridTransform.getMatrix().getEntries();
GLfloat tangentModelviewGridTransformMatrix[16];
GLfloat* tmvgtmPtr=tangentModelviewGridTransformMatrix;
for(int i=0;i<16;++i,++tmvgtPtr,++tmvgtmPtr)
*tmvgtmPtr=GLfloat(*tmvgtPtr);
glUniformMatrix4fvARB(*(ulPtr++),1,GL_FALSE,tangentModelviewGridTransformMatrix);
/* Calculate and upload the vertex transformation from grid space to clip space: */
PTransform projectionModelviewGridTransform=gridTransform;
projectionModelviewGridTransform.leftMultiply(modelview);
projectionModelviewGridTransform.leftMultiply(projection);
glUniformARB(*(ulPtr++),projectionModelviewGridTransform);
/* Bind the vertex and index buffers: */
glBindBufferARB(GL_ARRAY_BUFFER_ARB,dataItem->vertexBuffer);
glBindBufferARB(GL_ELEMENT_ARRAY_BUFFER_ARB,dataItem->indexBuffer);
/* Draw the surface: */
GLVertexArrayParts::enable(Vertex::getPartsMask());
glVertexPointer(static_cast<const Vertex*>(0));
GLuint* indexPtr=0;
for(unsigned int y=1;y<waterGridSize[1];++y,indexPtr+=waterGridSize[0]*2)
glDrawElements(GL_QUAD_STRIP,waterGridSize[0]*2,GL_UNSIGNED_INT,indexPtr);
GLVertexArrayParts::disable(Vertex::getPartsMask());
/* Unbind all textures and buffers: */
glBindBufferARB(GL_ARRAY_BUFFER_ARB,0);
glBindBufferARB(GL_ELEMENT_ARRAY_BUFFER_ARB,0);
glBindTexture(GL_TEXTURE_RECTANGLE_ARB,0);
glActiveTextureARB(GL_TEXTURE0_ARB);
glBindTexture(GL_TEXTURE_RECTANGLE_ARB,0);
/* Unbind the water rendering shader: */
glUseProgramObjectARB(0);
}
