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);
}
}
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);
}
}
/*
* sendUniform3f
*
* parameter name - char*
* parameter value0 - GLfloat
* parameter value1 - GLfloat
* parameter value2 - GLfloat
* return - bool
*/
bool ShaderObject::sendUniform3f(const char * name, GLfloat value0, GLfloat value1, GLfloat value2) {
GLint location = getUniLoc(name);
if (location == -1)
return false;
glUniform3fARB(location, value0, value1, value2);
return true;
} // end sendUniform3f()
void Shader::bindResource(const char *name, float *data, int count){
int location = glGetUniformLocationARB(mProgram, name);
//LOG("Got location for %s: %d\n", name, location);
if(location == -1){
LOG("Error binding resource %s (size %d)\n", name, count);
return;
}
if(count == 3){
//Log::debug("location=%d, %f %f %f\n", location, data[0], data[1], data[2]);
}
//LOG("About to call glUniform%df\n", count);
//hacky!
//Is this really the best the GL API has to offer :|?
if(count == 1) glUniform1fARB(location, data[0]);
else if(count == 2) glUniform2fARB(location, data[0], data[1]);
else if(count == 3) glUniform3fARB(location, data[0], data[1], data[2]);
else if(count == 4) glUniform4fARB(location, data[0], data[1], data[2], data[3]);
else{
LOG("Bad count %d in bindResource(%s)\n", count, name);
}
//LOG("Called\n");
}
void Shader::SetVector3(std::string name, Vector3 value)
{
int uloc = SIG_FindUniform(name);
if (uloc != -1) {
glUniform3fARB(uloc, value.X(), value.Y(), value.Z());
} else {
SIG_LOG("Could not find uniform \"" << name << "\"");
}
}
bool Shader::sendUniform3f(char* varname, GLfloat v0, GLfloat v1, GLfloat v2)
{
GLint loc = GetUniformLocation(varname);
if (loc == -1) return false;
glUniform3fARB(loc, v0, v1, v2);
return true;
}
static void
bind_vec3_arb (cairo_gl_shader_t *shader,
const char *name,
float value0,
float value1,
float value2)
{
GLint location = glGetUniformLocationARB (shader->program, name);
assert (location != -1);
glUniform3fARB (location, value0, value1, value2);
}
// Set a uniform global parameter of the program by name.
void STShaderProgram::SetUniform(const std::string& name,
float v0, float v1, float v2)
{
GLint location = GetUniformLocation(name);
if(GLEW_VERSION_2_0) {
glUniform3f(location, v0, v1, v2);
}
else {
glUniform3fARB(location, v0, v1, v2);
}
}
void Shader::setParameter(const std::string &name, float x, float y, float z) {
if (mShaderProgram) {
ensureGLContext();
GLhandleARB program = glCheck(glGetHandleARB(glGetHandleARB(GL_PROGRAM_OBJECT_ARB)));
glCheck(glUseProgramObjectARB(mShaderProgram));
GLint location = getParamLocation(name);
if (location != -1) {
glCheck(glUniform3fARB(location, x, y, z));
}
glCheck(glUseProgramObjectARB(program));
}
}
void Shader::setParameter(const std::string& name, float x, float y, float z)
{
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(glUniform3fARB(location, x, y, z));
// Disable program
glCheck(glUseProgramObjectARB(program));
}
}
void Shader::SetParameter(const std::string& name, float x, float y, float z)
{
if (myShaderProgram)
{
// 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(glUniform3fARB(location, x, y, z));
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 ProgramUniformGLSL::Set(float fX, float fY, float fZ)
{
glUniform3fARB(m_nOpenGLUniformLocation, fX, fY, fZ);
}
void ofxShader::setUniformVariable3f (char const * name, float value, float value2, float value3) {
if (loaded)
glUniform3fARB(glGetUniformLocationARB(shader, name), value, value2, value3);
}
void GLSLShader::SetFloat3(GLint variable, float v0, float v1, float v2)
{
if (variable!=-1)
glUniform3fARB(variable, v0, v1, v2);
}
void
Butterfly::draw()
{
// the position of the butterfly
// used by the shader
glUniform3fARB(glGetUniformLocationARB(shader->getPid(), "worldpos"), pos[0], pos[1], pos[2]);
glDepthMask(GL_TRUE);
glEnable(GL_DEPTH_TEST);
// local frame
float rot[16] =
{
binormal[0], binormal[1], binormal[2], 0,
dir[0], dir[1], dir[2], 0,
normal[0], normal[1], normal[2], 0,
pos[0], pos[1], pos[2], 1
};
glPushMatrix();
glMultMatrixf(rot);
// fprintf(stdout, "%f, %f, %f\n", pos[0], pos[1], pos[2]);
for(int j=0; j<NUM_OBJS; j++)
{
glPushMatrix();
float tmp = fabs(wing_cnt)-wing_angle;
if(j<(NUM_OBJS>>1)) glRotatef(tmp, 0, 1, 0);
else glRotatef(-tmp, 0, 1, 0);
glScalef(size, size, size);
// thickness/bump mapping texture
glActiveTexture(GL_TEXTURE0);
tex[(j*2)%NUM_TEXTURES].bind();
// backface texture
glActiveTexture(GL_TEXTURE1);
tex[(j*2+1)%NUM_TEXTURES].bind();
// if(j%2==0)
// {
// glEnable (GL_POLYGON_OFFSET_FILL);
// glPolygonOffset (1., 1.);
// }
glBegin(GL_TRIANGLES);
for(int i=0; i<geom[j].numFacets*3; i++)
{
glNormal3fv(geom[j].normals[geom[j].normalIdx[i]]);
glMultiTexCoord2fv(GL_TEXTURE0, geom[j].texcoords[geom[j].texcoordIdx[i]]);
glVertex3fv(geom[j].verts[geom[j].vertIdx[i]]);
}
glEnd();
// if(j%2==0) glDisable (GL_POLYGON_OFFSET_FILL);
glActiveTexture(GL_TEXTURE0);
tex[(j*2)%NUM_TEXTURES].unbind();
glActiveTexture(GL_TEXTURE1);
tex[(j*2+1)%NUM_TEXTURES].unbind();
glPopMatrix();
}
void Shader::SetUniVar(char* sVarName, float fValue0, float fValue1, float fValue2)
{
//设置初始一致变量值
glUniform3fARB(getUniLoc(m_Program, sVarName), fValue0, fValue1, fValue2);
}
void RawVolumeModelRenderer::_putVolumeDataToShader(
const VolumeInfo& volumeInfo,
const float sliceDistance,
const eq::Matrix4f& invRotationM,
const eq::Vector4f& taintColor,
const int normalsQuality )
{
LBASSERT( _glewContext );
GLhandleARB shader = _shaders.getProgram();
LBASSERT( shader );
const DataInTextureDimensions& TD = volumeInfo.TD;
GLint tParamNameGL;
// Put texture coordinates modifyers to the shader
tParamNameGL = glGetUniformLocationARB( shader, "W" );
glUniform1fARB( tParamNameGL, TD.W );
tParamNameGL = glGetUniformLocationARB( shader, "H" );
glUniform1fARB( tParamNameGL, TD.H );
tParamNameGL = glGetUniformLocationARB( shader, "D" );
glUniform1fARB( tParamNameGL, TD.D );
tParamNameGL = glGetUniformLocationARB( shader, "Do" );
glUniform1fARB( tParamNameGL, TD.Do );
tParamNameGL = glGetUniformLocationARB( shader, "Db" );
glUniform1fARB( tParamNameGL, TD.Db );
// Put Volume data to the shader
glActiveTextureARB( GL_TEXTURE1 );
glBindTexture( GL_TEXTURE_2D, volumeInfo.preint ); //preintegrated values
tParamNameGL = glGetUniformLocationARB( shader, "preInt" );
glUniform1iARB( tParamNameGL, 1 ); //f-shader
// Activate last because it has to be the active texture
glActiveTextureARB( GL_TEXTURE0 );
glBindTexture( GL_TEXTURE_3D, volumeInfo.volume ); //gx, gy, gz, val
glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_MAG_FILTER,GL_LINEAR );
tParamNameGL = glGetUniformLocationARB( shader, "volume" );
glUniform1iARB( tParamNameGL , 0 ); //f-shader
tParamNameGL = glGetUniformLocationARB( shader, "sliceDistance" );
glUniform1fARB( tParamNameGL, sliceDistance ); //v-shader
tParamNameGL = glGetUniformLocationARB( shader, "perspProj" );
glUniform1fARB( tParamNameGL, _ortho ? 0.0f : 1.0f ); //v-shader
tParamNameGL = glGetUniformLocationARB( shader, "shininess" );
glUniform1fARB( tParamNameGL, 8.0f ); //f-shader
tParamNameGL = glGetUniformLocationARB( shader, "taint" );
glUniform4fARB( tParamNameGL, taintColor.r(),
taintColor.g(),
taintColor.b(),
taintColor.a() ); //f-shader
tParamNameGL = glGetUniformLocationARB( shader, "sizeVec" );
glUniform3fARB( tParamNameGL, volumeInfo.voxelSize.W,
volumeInfo.voxelSize.H,
volumeInfo.voxelSize.D ); //f-shader
tParamNameGL = glGetUniformLocationARB( shader, "normalsQuality");
glUniform1iARB( tParamNameGL, normalsQuality ); //f-shader
// rotate viewPosition in the opposite direction of model rotation
// to keep light position constant but not recalculate normals
// in the fragment shader
// viewPosition = invRotationM * eq::Vector4f( 0, 0, 1, 0 );
tParamNameGL = glGetUniformLocationARB( shader, "viewVec" );
glUniform3fARB( tParamNameGL, invRotationM.array[8],
invRotationM.array[9],
invRotationM.array[10] ); //f-shader
}
ShaderProgram &u(const char *var, GLfloat x, GLfloat y, GLfloat z) { glUniform3fARB(uniform(var), x, y, z); return *this; }
void glsl_program :: renderARB()
{
if (m_linked) {
glUseProgramObjectARB( m_programARB );
for(int i=0; i<m_uniformCount; i++)
{
if(m_flag[i])
{
switch (m_type[i])
{
/* float vectors */
case GL_FLOAT:
glUniform1fARB( m_loc[i], static_cast<GLfloat>(m_param[i][0]) );
break;
case GL_FLOAT_VEC2_ARB:
glUniform2fARB( m_loc[i], static_cast<GLfloat>(m_param[i][0]), static_cast<GLfloat>(m_param[i][1]) );
break;
case GL_FLOAT_VEC3_ARB:
glUniform3fARB( m_loc[i], static_cast<GLfloat>(m_param[i][0]), static_cast<GLfloat>(m_param[i][1]),
static_cast<GLfloat>(m_param[i][2]) );
break;
case GL_FLOAT_VEC4_ARB:
glUniform4fARB( m_loc[i], static_cast<GLfloat>(m_param[i][0]), static_cast<GLfloat>(m_param[i][1]),
static_cast<GLfloat>(m_param[i][2]), static_cast<GLfloat>(m_param[i][3]) );
break;
/* int vectors */
case GL_INT:
glUniform1iARB( m_loc[i], static_cast<GLint>(m_param[i][0]) );
break;
case GL_INT_VEC2_ARB:
glUniform2iARB( m_loc[i], static_cast<GLint>(m_param[i][0]), static_cast<GLint>(m_param[i][1]) );
break;
case GL_INT_VEC3_ARB:
glUniform3iARB( m_loc[i], static_cast<GLint>(m_param[i][0]), static_cast<GLint>(m_param[i][1]),
static_cast<GLint>(m_param[i][2]) );
break;
case GL_INT_VEC4_ARB:
glUniform4iARB( m_loc[i], static_cast<GLint>(m_param[i][0]), static_cast<GLint>(m_param[i][1]),
static_cast<GLint>(m_param[i][2]), static_cast<GLint>(m_param[i][3]) );
break;
/* bool vectors */
case GL_BOOL_ARB:
glUniform1fARB( m_loc[i], static_cast<GLfloat>(m_param[i][0]) );
break;
case GL_BOOL_VEC2_ARB:
glUniform2fARB( m_loc[i], static_cast<GLfloat>(m_param[i][0]), static_cast<GLfloat>(m_param[i][1]) );
break;
case GL_BOOL_VEC3_ARB:
glUniform3fARB( m_loc[i], static_cast<GLfloat>(m_param[i][0]), static_cast<GLfloat>(m_param[i][1]),
static_cast<GLfloat>(m_param[i][2]) );
break;
case GL_BOOL_VEC4_ARB:
glUniform4fARB( m_loc[i], static_cast<GLfloat>(m_param[i][0]), static_cast<GLfloat>(m_param[i][1]),
static_cast<GLfloat>(m_param[i][2]), static_cast<GLfloat>(m_param[i][3]) );
break;
/* float matrices */
case GL_FLOAT_MAT2_ARB:
// GL_TRUE = row major order, GL_FALSE = column major
glUniformMatrix2fvARB( m_loc[i], 1, GL_FALSE, m_param[i] );
break;
case GL_FLOAT_MAT3_ARB:
glUniformMatrix3fvARB( m_loc[i], 1, GL_FALSE, m_param[i] );
break;
case GL_FLOAT_MAT4_ARB:
glUniformMatrix4fvARB( m_loc[i], 1, GL_FALSE, m_param[i] );
break;
/* textures */
case GL_SAMPLER_1D_ARB: break;
case GL_SAMPLER_2D_ARB:
glUniform1iARB(m_loc[i], m_param[i][0]);
break;
case GL_SAMPLER_3D_ARB: break;
case GL_SAMPLER_CUBE_ARB: break;
case GL_SAMPLER_1D_SHADOW_ARB: break;
case GL_SAMPLER_2D_SHADOW_ARB: break;
case GL_SAMPLER_2D_RECT_ARB:
glUniform1iARB(m_loc[i], m_param[i][0]);
break;
default:
;
}
// remove flag because the value is in GL's state now...
m_flag[i]=0;
}
}
// glUniform1iARB(glGetUniformLocationARB(program_object, "MyTex1"), 1);
} else {
/* JMZ: this is really annoying... */
//error("no program linked");
}
}
void shade::GLSLARBWrapper::Uniform3f(Handle index, float x, float y, float z)
{
glUniform3fARB(index, x, y, z);
}
void ofxShader::setUniform3f (string name, float value, float value2, float value3) {
if(bLoaded)
glUniform3fARB(glGetUniformLocationARB(shader, name.c_str()), value, value2, value3);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBShaderObjects_nglUniform3fARB(JNIEnv *env, jclass clazz, jint location, jfloat v0, jfloat v1, jfloat v2, jlong function_pointer) {
glUniform3fARBPROC glUniform3fARB = (glUniform3fARBPROC)((intptr_t)function_pointer);
glUniform3fARB(location, v0, v1, v2);
}
inline void Uniform<float, 3>::apply()
{
glUniform3fARB(location, value[0], value[1], value[2]);
}
void Shader::setUniformf3(const std::string &variable, float value0, float value1, float value2) {
if (shaderProgram != -1)
glUniform3fARB (glGetUniformLocationARB (shaderProgram, variable.c_str ()), value0, value1, value2);
}
void WShaderProgram::setValue3f( const char *name, float v1,float v2, float v3 )
{
GLint loc = glGetUniformLocationARB( programId(), name );
glUniform3fARB( loc, v1, v2, v3 );
}
///////////////////////////////////////////////////////////////////////////////
//
// Render scene.
//
///////////////////////////////////////////////////////////////////////////////
void RenderScene()
{
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, _gSceneFbo.GetFBO());
// Clear each rendering target first before drawing the scene.
glUseProgram(_gClearRenderTargetShader);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glLoadIdentity();
RenderScreenQuad();
// Now draw scene once destinations have been cleared.
glUseProgram(_gSetRenderTargetShader);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glLoadIdentity();
RenderScenePass();
// For BLUR the code need to do the following.
// Use same or different FBO.
// Our Display shader will become SSAO shader.
// RenderSceneQuad().. using mostly the code below.
// But using a HBLUR render target shader.
// Now Again do RenderSceneQuad() this time with VBLUR shader.
// Now draw the final image.
// Draw to the back buffer using deferred shading.
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, _gSsaoFbo.GetFBO());
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glLoadIdentity();
glUseProgram(_gSsaoShader);
glActiveTexture(GL_TEXTURE0_ARB);
glBindTexture(GL_TEXTURE_2D, _gSceneFbo.GetColorDest1());
glUniform1i(_gSsaoNormals, 0);
glActiveTexture(GL_TEXTURE1_ARB);
glBindTexture(GL_TEXTURE_2D, _gRandomSampler);
glUniform1i(_gSsaoRandoms, 1);
glActiveTexture(GL_TEXTURE2_ARB);
glBindTexture(GL_TEXTURE_2D, _gSceneFbo.GetColorDest2());
glUniform1i(_gSsaoDepths, 2);
glActiveTexture(GL_TEXTURE3_ARB);
glBindTexture(GL_TEXTURE_2D, _gRandomSampler);
glUniform2fARB(_gSsaoOffset, 1.0f / (float)WIDTH, 1.0f / (float)HEIGHT);
RenderScreenQuad();
// Horizontal blur.
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, _gHorizontalBlurFbo.GetFBO());
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glLoadIdentity();
glUseProgram(_gHorizontalBlurShader);
glActiveTexture(GL_TEXTURE0_ARB);
glBindTexture(GL_TEXTURE_2D, _gSsaoFbo.GetColorDest0());
glActiveTexture(GL_TEXTURE1_ARB);
glBindTexture(GL_TEXTURE_2D, _gSceneFbo.GetColorDest1());
glActiveTexture(GL_TEXTURE2_ARB);
glBindTexture(GL_TEXTURE_2D, _gSceneFbo.GetColorDest2());
glUniform1i(_gHorizontalBlurSceneSampler, 0);
glUniform1i(_gHorizontalBlurSceneSamplerNormal, 1);
glUniform1i(_gHorizontalBlurSceneSamplerDepth, 2);
RenderScreenQuad();
// Vertical blur.
glBindFramebufferEXT( GL_FRAMEBUFFER_EXT, _gVerticalBlurFbo.GetFBO() );
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glLoadIdentity();
glUseProgram( _gVerticalBlurShader );
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, _gHorizontalBlurFbo.GetColorDest0());
glActiveTexture(GL_TEXTURE1);
glBindTexture(GL_TEXTURE_2D, _gSceneFbo.GetColorDest1());
glActiveTexture(GL_TEXTURE2);
glBindTexture(GL_TEXTURE_2D, _gSceneFbo.GetColorDest2());
glUniform1i( _gVerticalBlurSceneSampler, 0 );
glUniform1i( _gVerticalBlurSceneNormalSampler, 1 );
glUniform1i( _gVerticalBlurSceneDepthSampler, 2 );
RenderScreenQuad();
// Final stage.
glUseProgram( _gRenderShader );
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glLoadIdentity();
glUniform2fARB(_gOffset, 1.0f / (float)WIDTH, 1.0f / (float)HEIGHT);
glUniform3fARB(_gLight1Pos, 0.0f, 20.0f, 15.0f);
glUniform4fARB(_gLight1AmbientColor, 0.4f, 0.4f, 0.4f, 1.0f);
glUniform4fARB(_gLight1DiffuseColor, 0.6f, 0.6f, 0.6f, 1.0f);
glUniform4fARB(_gLight1SpecularColor, 0.6f, 0.6f, 0.6f, 1.0f);
glUniform3fARB(_gLight2Pos, 100.0f, 20.0f, 15.0f);
glUniform4fARB(_gLight2AmbientColor, 0.2f, 0.2f, 0.2f, 1.0f);
glUniform4fARB(_gLight2DiffuseColor, 0.1f, 0.1f, 0.1f, 1.0f);
glUniform4fARB(_gLight2SpecularColor, 0.5f, 0.7f, 0.5f, 1.0f);
glActiveTexture(GL_TEXTURE0_ARB);
glBindTexture(GL_TEXTURE_2D, _gVerticalBlurFbo.GetColorDest0());
glUniform1i(_gAmbientOcclusion, 0);
glActiveTexture(GL_TEXTURE1_ARB);
glBindTexture(GL_TEXTURE_2D, _gSceneFbo.GetColorDest0());
glUniform1i(_gSceneColors, 1);
glActiveTexture(GL_TEXTURE2_ARB);
glBindTexture(GL_TEXTURE_2D, _gSceneFbo.GetColorDest1());
glUniform1i(_gSceneNormals, 2);
glActiveTexture(GL_TEXTURE3_ARB);
glBindTexture(GL_TEXTURE_2D, _gSceneFbo.GetColorDest2());
glUniform1i(_gSceneDepths, 2);
RenderScreenQuad();
glutSwapBuffers();
glutPostRedisplay();
}
void KShaderProgram::setParam3(Kite::I16 Location, F32 Value1, F32 Value2, F32 Value3) const{
if (_kprogId && Location >= 0){
DGL_CALL(glUniform3fARB(Location, Value1, Value2, Value3));
}
}
void ofxShader::setUniformVariable3f (char * name, float value, float value2, float value3){
if (bLoaded == true){
glUniform3fARB(glGetUniformLocationARB(shader, name), value, value2, value3);
}
}
void Shader::setVector3Uniform(const std::string& _name, float _v1, float _v2, float _v3) const
{
assert(programObj_ != 0);
glUniform3fARB(getUniformLocation(_name.c_str()), _v1, _v2, _v3);
}
