void Shader::setVector2Uniform(const std::string& _name, float _v1, float _v2) const
{
assert(programObj_ != 0);
glUniform2fARB(getUniformLocation(_name.c_str()), _v1, _v2);
}
inline void Uniform<float, 2>::apply()
{
glUniform2fARB(location, value[0], value[1]);
}
void Shader::SetUniVar(char* sVarName, float fValue0, float fValue1)
{
//设置初始一致变量值
glUniform2fARB(getUniLoc(m_Program, sVarName), fValue0, fValue1);
}
void ofxShader::setUniformVariable2f (char * name, float value, float value2){
if (bLoaded == true){
glUniform2fARB(glGetUniformLocationARB(shader, name), value, value2);
}
}
/*
* The main display function. (Where all the magic happens).
* Five renders done here.
* 1) Depth render. Stores depth and depth squared for VSM
* 2) Gaussian Blur render. Blurs depth render's output
* 3) Light Path Tracing render. Path traces light rays for light scattering effect
* 4) Main render. Rendered with shadows and without light scattering. Has phong illumination and shading, bump map.
* 5) Light Scattering Overlay render. Overlays the output of the Light Path Tracing render as an additive overlay over the current scene.
*
*/
void RenderEngine::renderScene() {
//==FIRST RENDER: DEPTH BUFFER
//Render from the light POV to a FBO, store depth and square depth in a 32F frameBuffer
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT,shadowFboId);
//Using the depth shader to do so
glUseProgramObjectARB(depthShade->getProgram());
// In the case we render the shadowmap to a higher resolution, the viewport must be modified accordingly.
glViewport(0,0,kRenderWidth * kShadowMapCoef,kRenderHeight* kShadowMapCoef);
//try to make shadow view "bigger" than normal view
// Clear previous frame values
glClearColor(0,0,0,1.0f);
glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
setupMatrices(p_light[0],p_light[1],p_light[2],l_light[0],l_light[1],l_light[2],0,1,0,10,100,120);
// Culling switching, rendering only backface, this is done to avoid self-shadowing and improve efficiency
glCullFace(GL_FRONT);
//draw objects using the depth shader
//drawObjects(depthShade);
drawObjectTarget(depthShade);
//cout << "0 " << glGetError() << endl;
glGenerateMipmapEXT(GL_TEXTURE_2D);
//Save modelview/projection matrice into texture7, also add a biais
setTextureMatrix();
//==SECOND (and a half) RENDER: DOUBLE PASS GAUSSIAN BLUR
blurShadowMap();
//==THIRD RENDER: PATH TRACED LIGHT SCATTERING EFFECT (CREPUSCULAR RAYS)
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT,scatterFboId);
glViewport(0,0,kLightScatterWidth,kLightScatterHeight);
// Clear previous frame values
if(deathScatter) {
//glClearColor(1,1,1,1.0f);
glClearColor(1,0,0,1.0f);
} else {
glClearColor(0,0,0,1.0f);
}
//glClearColor(1,1,1,1.0f);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
//Using the shadow shader
glUseProgramObjectARB(darkShade->getProgram());
glBindTexture(GL_TEXTURE_2D,colorTextureId);
setupMatrices(p_camera[0],p_camera[1],p_camera[2],l_camera[0],l_camera[1],l_camera[2],u_camera[0],u_camera[1],u_camera[2],0.5,120,70);
glCullFace(GL_BACK);
//Draw light
glPushMatrix();
glTranslatef(p_light_scatter[0],p_light_scatter[1],p_light_scatter[2]);
glColor4f(1.0,1.0,1.0,1.0);
glutSolidSphere(30,20,20);
glPopMatrix();
//Draw objects in black
glColor4f(0.0f,0.0f,0.0f,1);
//drawObjects(darkShade);
drawObjectTarget(darkShade);
//==FOURTH RENDER: MAIN RENDER (without light scattering)
// Now rendering from the camera POV, using the FBO to generate shadows
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT,0);
glViewport(0,0,kRenderWidth,kRenderHeight);
// Clear previous frame values
//glClearColor(.764705882,.890196078,1,1.0f);
glClearColor(skyColor[0], skyColor[1], skyColor[2], skyColor[3]);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
//Using the shadow shader
glUseProgramObjectARB(shade->getProgram());
//glUniform1iARB(shade->getShadowMapAttrib(),7);
glActiveTextureARB(GL_TEXTURE7);
glBindTexture(GL_TEXTURE_2D,colorTextureId);
//declared in third pass
//setupMatrices(p_camera[0],p_camera[1],p_camera[2],l_camera[0],l_camera[1],l_camera[2],u_camera[0],u_camera[1],u_camera[2],1,120);
//okay seriously, why do we have vec and float[] is required by openGL -_-
float tempLight[4] = {p_light[0], p_light[1], p_light[2], 1};
glLightfv(GL_LIGHT0, GL_POSITION, tempLight);
glCullFace(GL_BACK);
//draw objects using our shadow shader
//drawObjects(shade);
drawObjectTarget(shade);
//==FIFTH PASS: LIGHT SCATTERING OVERLAY
//uses main screen
//glBindFramebufferEXT(GL_FRAMEBUFFER_EXT,0);
//glViewport(0,0,kRenderWidth,kRenderHeight);
glClear (GL_DEPTH_BUFFER_BIT );
//glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glUseProgramObjectARB(scatterShade->getProgram());
//default values
vec2 cameraSpaceLightPos = getLightScreenCoor();
glUniform1fARB(scatterShade->getExposureAttrib(),0.0034);
glUniform1fARB(scatterShade->getDecayAttrib(),1.0);
glUniform1fARB(scatterShade->getDensityAttrib(),0.84);
glUniform1fARB(scatterShade->getWeightAttrib(),5.65);
glUniform1iARB(scatterShade->getTextureAttrib(),0);
glUniform2fARB(scatterShade->getLightPositionOnScreenAttrib(),cameraSpaceLightPos[0],cameraSpaceLightPos[1]);
glActiveTextureARB(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D,scatterTextureId);
glEnable(GL_BLEND); //blend the resulting render
glBlendFunc(GL_SRC_ALPHA, GL_ONE);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glOrtho(-kRenderWidth/2,kRenderWidth/2,-kRenderHeight/2,kRenderHeight/2,1,20);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glColor4f(1.0f,1.0f,1.0f,1); //rectangle to display texture
glPushMatrix();
glTranslated(0,0,-5);
glBegin(GL_QUADS);
glTexCoord2d(0,0);glVertex3f(-kRenderWidth/2,-kRenderHeight/2,0);
glTexCoord2d(1,0);glVertex3f(kRenderWidth/2,-kRenderHeight/2,0);
glTexCoord2d(1,1);glVertex3f(kRenderWidth/2,kRenderHeight/2,0);
glTexCoord2d(0,1);glVertex3f(-kRenderWidth/2,kRenderHeight/2,0);
glEnd();
glPopMatrix();
glDisable(GL_BLEND);
drawOverlayTarget();
/*
if(renderOpt.isDepthBuffer())
drawDebugBuffer(renderOpt.getDepthBufferOption());
*/
glutSwapBuffers();
}
ShaderProgram &u(const char *var, GLfloat x, GLfloat y) { glUniform2fARB(uniform(var), x, y); 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 Blur_apply(){
if(multiSamples!=1 && blur==Blur_glsl_depth){
consoleLog("Blur_apply: Blur_glsl_depth can't be used with multisample, disabling\n");
blur=Blur_glsl_simple;
}
if(blur==Blur_none)
return;
float lastMatrix[16];
glGetFloatv(GL_MODELVIEW_MATRIX, lastMatrix);
glMatrixMode(GL_PROJECTION);
glPushMatrix();
glLoadIdentity();
glMatrixMode(GL_MODELVIEW);
glPushMatrix();
glLoadIdentity();
glScalef(2.f/screen->w, -2.f/screen->h, 1.f);
glTranslatef(-screen->w*.5f, -screen->h*.5f, 0.f);
glDisable(GL_DEPTH_TEST);
glDisable(GL_FOG);
glDisable(GL_LIGHTING);
glDepthMask(GL_FALSE);
if(blur==Blur_basic){
glColor4f(1.f, 1.f, 1.f, powf(.3f, blurdt*60.f));
glBindTexture(GL_TEXTURE_2D, tex_screen);
glBegin(GL_QUADS);
glTexCoord2f(0.f, (float)screen->h/sh);
glVertex2i(0, 0);
glTexCoord2f(0.f, 0.f);
glVertex2i(0, screen->h);
glTexCoord2f((float)screen->w/sw, 0.f);
glVertex2i(screen->w, screen->h);
glTexCoord2f((float)screen->w/sw, (float)screen->h/sh);
glVertex2i(screen->w, 0);
glEnd();
totalPolys+=2;
glCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 0, 0, screen->w, screen->h);
}
#if GL_ARB_shader_objects
else if(blur==Blur_glsl_simple){
glUseProgramObjectARB(prg_blurSimple);
glUniform1iARB(glGetUniformLocationARB(prg_blurSimple, "screen"),
0);
glUniform2fARB(glGetUniformLocationARB(prg_blurSimple, "texSize"),
(float)screen->w/sw, (float)screen->h/sh);
float imat[16];
float mat2[16];
memcpy(imat, mx_old, sizeof(imat));
inverseMatrix4(imat);
glUniformMatrix4fvARB(glGetUniformLocationARB(prg_blurSimple, "curMatrix"),
1, GL_FALSE, lastMatrix);
glUniformMatrix4fvARB(glGetUniformLocationARB(prg_blurSimple, "oldMatrix"),
1, GL_FALSE, mx_old);
inverseMatrix4(lastMatrix);
glUniformMatrix4fvARB(glGetUniformLocationARB(prg_blurSimple, "oldMatrixInverse"),
1, GL_FALSE, imat);
glUniformMatrix4fvARB(glGetUniformLocationARB(prg_blurSimple, "curMatrixInverse"),
1, GL_FALSE, lastMatrix);
glColor4f(1,1,1,1);
glBindTexture(GL_TEXTURE_2D, tex_screen);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 0, 0, screen->w, screen->h);
glBegin(GL_QUADS);
glTexCoord2f(-1.f, 1.f);
glVertex2i(0, 0);
glTexCoord2f(-1.f, -1.f);
glVertex2i(0, screen->h);
glTexCoord2f(1.f, -1.f);
glVertex2i(screen->w, screen->h);
glTexCoord2f(1.f, 1.f);
glVertex2i(screen->w, 0);
glEnd();
totalPolys+=2;
glUseProgramObjectARB(0);
}
#if GL_ARB_depth_texture
else if(blur==Blur_glsl_depth){
glActiveTexture(GL_TEXTURE1_ARB);
glBindTexture(GL_TEXTURE_2D, tex_depth);
glCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 0, 0, screen->w, screen->h);
glActiveTexture(GL_TEXTURE0_ARB);
glUseProgramObjectARB(prg_blurDepth);
glUniform1iARB(glGetUniformLocationARB(prg_blurDepth, "screen"),
0);
glUniform1iARB(glGetUniformLocationARB(prg_blurDepth, "depthTex"),
1);
glUniform2fARB(glGetUniformLocationARB(prg_blurDepth, "texSize"),
(float)screen->w/sw, (float)screen->h/sh);
float imat[16];
float mat2[16];
memcpy(imat, mx_old, sizeof(imat));
inverseMatrix4(imat);
glUniformMatrix4fvARB(glGetUniformLocationARB(prg_blurDepth, "curMatrix"),
1, GL_FALSE, lastMatrix);
glUniformMatrix4fvARB(glGetUniformLocationARB(prg_blurDepth, "oldMatrix"),
1, GL_FALSE, mx_old);
inverseMatrix4(lastMatrix);
glUniformMatrix4fvARB(glGetUniformLocationARB(prg_blurDepth, "oldMatrixInverse"),
1, GL_FALSE, imat);
glUniformMatrix4fvARB(glGetUniformLocationARB(prg_blurDepth, "curMatrixInverse"),
1, GL_FALSE, lastMatrix);
glColor4f(1,1,1,1);
glBindTexture(GL_TEXTURE_2D, tex_screen);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 0, 0, screen->w, screen->h);
glBegin(GL_QUADS);
glTexCoord2f(-1.f, 1.f);
glVertex2i(0, 0);
glTexCoord2f(-1.f, -1.f);
glVertex2i(0, screen->h);
glTexCoord2f(1.f, -1.f);
glVertex2i(screen->w, screen->h);
glTexCoord2f(1.f, 1.f);
glVertex2i(screen->w, 0);
glEnd();
totalPolys+=2;
glUseProgramObjectARB(0);
}
#endif
#endif
glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA);
glEnable(GL_LIGHTING);
glMatrixMode(GL_PROJECTION);
glPopMatrix();
glMatrixMode(GL_MODELVIEW);
glPopMatrix();
glEnable(GL_DEPTH_TEST);
glEnable(GL_FOG);
glDepthMask(GL_TRUE);
}
void shade::GLSLARBWrapper::Uniform2f(Handle index, float x, float y)
{
glUniform2fARB(index, x, y);
}
void KShaderProgram::setParam2(Kite::I16 Location, F32 Value1, F32 Value2) const{
if (_kprogId && Location >= 0){
DGL_CALL(glUniform2fARB(Location, Value1, Value2));
}
}
void ofxShader::setUniform2f (string name, float value, float value2) {
if(bLoaded)
glUniform2fARB(glGetUniformLocationARB(shader, name.c_str()), value, value2);
}
panel panel_create(int width, int height, image font) {
panel result = {width, height, font.width, font.height, NULL, NULL, 0, 0, 0, 0, 0};
result.font = texture_create(font);
result.foreground = malloc(4*width*height);
result.background = malloc(4*width*height);
// program and shader handles
GLhandleARB vertex_shader, fragment_shader;
int length;
GLint shader_ok;
// create and compiler vertex shader
vertex_shader = glCreateShaderObjectARB(GL_VERTEX_SHADER_ARB);
length = strlen(vertex_source);
glShaderSourceARB(vertex_shader, 1, &vertex_source, &length);
glCompileShaderARB(vertex_shader);
glGetObjectParameterivARB(vertex_shader, GL_COMPILE_STATUS, &shader_ok);
assert(shader_ok);
// create and compiler fragment shader
fragment_shader = glCreateShaderObjectARB(GL_FRAGMENT_SHADER_ARB);
length = strlen(fragment_source);
glShaderSourceARB(fragment_shader, 1, &fragment_source, &length);
glCompileShaderARB(fragment_shader);
glGetObjectParameterivARB(fragment_shader, GL_COMPILE_STATUS, &shader_ok);
assert(shader_ok);
// create program
result.shader_program = glCreateProgramObjectARB();
// attach shaders
glAttachObjectARB(result.shader_program, vertex_shader);
glAttachObjectARB(result.shader_program, fragment_shader);
// link the program and check for errors
glLinkProgramARB(result.shader_program);
glGetObjectParameterivARB(result.shader_program, GL_LINK_STATUS, &shader_ok);
assert(shader_ok);
// we don't need these anymore
glDeleteObjectARB(vertex_shader);
glDeleteObjectARB(fragment_shader);
// generate and bind the buffer object
glGenBuffersARB(1, &result.vbo);
glBindBufferARB(GL_ARRAY_BUFFER_ARB, result.vbo);
// fill with data
glBufferDataARB(GL_ARRAY_BUFFER_ARB, sizeof(GLfloat)*6*5, quad_data, GL_STATIC_DRAW_ARB);
glActiveTexture(GL_TEXTURE1);
glGenTextures(1, &result.fg_tex);
glBindTexture(GL_TEXTURE_2D, result.fg_tex);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, result.width, result.height, 0, GL_RGBA, GL_UNSIGNED_BYTE, result.foreground);
glActiveTexture(GL_TEXTURE2);
glGenTextures(1, &result.bg_tex);
glBindTexture(GL_TEXTURE_2D, result.bg_tex);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, result.width, result.height, 0, GL_RGBA, GL_UNSIGNED_BYTE, result.background);
glUseProgramObjectARB(result.shader_program);
glUniform1iARB(glGetUniformLocationARB(result.shader_program, "font"), 0);
glUniform1iARB(glGetUniformLocationARB(result.shader_program, "foreground"), 1);
glUniform1iARB(glGetUniformLocationARB(result.shader_program, "background"), 2);
glUniform2fARB(glGetUniformLocationARB(result.shader_program, "panel_size"), width, height);
return result;
}
void pattern_render(struct pattern * pattern, GLuint input_tex) {
GLenum e;
glLoadIdentity();
glViewport(0, 0, config.pattern.master_width, config.pattern.master_height);
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, pattern->fb);
pattern->intensity_integral = fmod(pattern->intensity_integral + pattern->intensity / config.ui.fps, MAX_INTEGRAL);
for (int i = pattern->n_shaders - 1; i >= 0; i--) {
glUseProgramObjectARB(pattern->shader[i]);
// Don't worry about this part.
for(int j = 0; j < pattern->n_shaders; j++) {
// Or, worry about it, but don't think about it.
glActiveTexture(GL_TEXTURE1 + j);
glBindTexture(GL_TEXTURE_2D, pattern->tex[(pattern->flip + j + (i < j)) % (pattern->n_shaders + 1)]);
}
glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_TEXTURE_2D,
pattern->tex[(pattern->flip + i + 1) % (pattern->n_shaders + 1)], 0);
if((e = glGetError()) != GL_NO_ERROR) FAIL("OpenGL error: %s\n", gluErrorString(e));
GLint loc;
loc = glGetUniformLocationARB(pattern->shader[i], "iTime");
glUniform1fARB(loc, time_master.beat_frac + time_master.beat_index);
loc = glGetUniformLocationARB(pattern->shader[i], "iAudioHi");
glUniform1fARB(loc, audio_hi);
loc = glGetUniformLocationARB(pattern->shader[i], "iAudioMid");
glUniform1fARB(loc, audio_mid);
loc = glGetUniformLocationARB(pattern->shader[i], "iAudioLow");
glUniform1fARB(loc, audio_low);
loc = glGetUniformLocationARB(pattern->shader[i], "iAudioLevel");
glUniform1fARB(loc, audio_level);
loc = glGetUniformLocationARB(pattern->shader[i], "iResolution");
glUniform2fARB(loc, config.pattern.master_width, config.pattern.master_height);
loc = glGetUniformLocationARB(pattern->shader[i], "iIntensity");
glUniform1fARB(loc, pattern->intensity);
loc = glGetUniformLocationARB(pattern->shader[i], "iIntensityIntegral");
glUniform1fARB(loc, pattern->intensity_integral);
loc = glGetUniformLocationARB(pattern->shader[i], "iFPS");
glUniform1fARB(loc, config.ui.fps);
loc = glGetUniformLocationARB(pattern->shader[i], "iFrame");
glUniform1iARB(loc, 0);
loc = glGetUniformLocationARB(pattern->shader[i], "iChannel");
glUniform1ivARB(loc, pattern->n_shaders, pattern->uni_tex);
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, input_tex);
if((e = glGetError()) != GL_NO_ERROR) FAIL("OpenGL error: %s\n", gluErrorString(e));
glClear(GL_COLOR_BUFFER_BIT);
glBegin(GL_QUADS);
glVertex2d(-1, -1);
glVertex2d(-1, 1);
glVertex2d(1, 1);
glVertex2d(1, -1);
glEnd();
if((e = glGetError()) != GL_NO_ERROR) FAIL("OpenGL error: %s\n", gluErrorString(e));
}
pattern->flip = (pattern->flip + 1) % (pattern->n_shaders + 1);
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
if((e = glGetError()) != GL_NO_ERROR) FAIL("OpenGL error: %s\n", gluErrorString(e));
pattern->tex_output = pattern->tex[pattern->flip];
}
void GLSLShader::SetFloat2(GLint variable, float v0, float v1) { if (variable!=-1) glUniform2fARB(variable, v0, v1); }
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBShaderObjects_nglUniform2fARB(JNIEnv *env, jclass clazz, jint location, jfloat v0, jfloat v1, jlong function_pointer) {
glUniform2fARBPROC glUniform2fARB = (glUniform2fARBPROC)((intptr_t)function_pointer);
glUniform2fARB(location, v0, v1);
}
void ofxShader::setUniformVariable2f (char const *name, float value, float value2) {
if (loaded)
glUniform2fARB(glGetUniformLocationARB(shader, name), value, value2);
}
bool r_create_shaders(void) {
int i, frames[1 + FRAME_TRACE];
OPENGL_EVENT_BEGIN(0, __PRETTY_FUNCTION__);
// create the terrain GPU program
if (!r_create_program("Terrain", TERRAIN_VS, TERRAIN_FS,
&r_ter_vs, &r_ter_fs, &r_ter_prog)) {
OPENGL_EVENT_END();
return false;
}
// create the compositor GPU program
if (!r_create_program("Compositor", COMPOSITOR_VS,
(m_compatshader ? COMPOSITOR_COMPAT_FS : COMPOSITOR_FS),
&r_comp_vs, &r_comp_fs, &r_comp_prog))
{
// try the compat shader before definitely failing
if (!m_compatshader) {
fprintf(stderr, "Failed compositor shader compilation, "
"falling back to compat\n");
if (!r_create_program("Compositor", COMPOSITOR_VS,
COMPOSITOR_COMPAT_FS, &r_comp_vs, &r_comp_fs, &r_comp_prog)) {
OPENGL_EVENT_END();
return false;
}
}
else
{
OPENGL_EVENT_END();
return false;
}
}
// create the font GPU program
if (!r_create_program("Font", COMPOSITOR_VS, FONT_FS,
&r_font_vs, &r_font_fs, &r_font_prog)) {
OPENGL_EVENT_END();
return false;
}
// create the prop GPU program
if (!r_create_program("Prop", PROP_VS, PROP_FS,
&r_prop_vs, &r_prop_fs, &r_prop_prog)) {
OPENGL_EVENT_END();
return false;
}
// create the sprite GPU program
if (!r_create_program("Sprite", SPRITE_VS, SPRITE_FS,
&r_sprite_vs, &r_sprite_fs, &r_sprite_prog)) {
OPENGL_EVENT_END();
return false;
}
// create the footmobile GPU program
if (!r_create_program("Footmobile", FOOTMOBILE_VS, FONT_FS,
&r_fmb_vs, &r_fmb_fs, &r_fmb_prog)) {
OPENGL_EVENT_END();
return false;
}
// set the terrain shader up
glUseProgramObjectARB(r_ter_prog);
if ((i = glGetUniformLocationARB(r_ter_prog, "terTex")) < 0) {
fprintf(stderr, "Failed to find terrain texture uniform variable\n");
OPENGL_EVENT_END();
return false;
}
glUniform1iARB(i, 0);
if ((i = glGetUniformLocationARB(r_ter_prog, "constParams")) < 0) {
fprintf(stderr, "Failed to find constant params uniform variable\n");
OPENGL_EVENT_END();
return false;
}
glUniform2fARB(i, HEIGHTMAP_SIZE, HEIGHT_SCALE);
if ((r_ter_patch_params = glGetUniformLocationARB(r_ter_prog,
"patchParams")) < 0) {
fprintf(stderr, "Failed to find per-patch params uniform variable\n");
OPENGL_EVENT_END();
return false;
}
if ((r_ter_height_samples = glGetUniformLocationARB(r_ter_prog,
"heightSamples")) < 0) {
fprintf(stderr, "Failed to find height samples uniform variable\n");
OPENGL_EVENT_END();
return false;
}
// set the prop shader up
glUseProgramObjectARB(r_prop_prog);
if ((i = glGetUniformLocationARB(r_prop_prog, "propTex")) < 0) {
fprintf(stderr, "Failed to find prop texture uniform variable\n");
OPENGL_EVENT_END();
return false;
}
glUniform1iARB(i, 0);
// set the sprite shader up
glUseProgramObjectARB(r_sprite_prog);
if ((i = glGetUniformLocationARB(r_sprite_prog, "spriteTex")) < 0) {
fprintf(stderr, "Failed to find sprite texture uniform variable\n");
OPENGL_EVENT_END();
return false;
}
glUniform1iARB(i, 0);
// set the footmobile shader up
glUseProgramObjectARB(r_fmb_prog);
if ((i = glGetUniformLocationARB(r_fmb_prog, "fontTex")) < 0) {
fprintf(stderr, "Failed to find footmobile texture uniform variable\n");
OPENGL_EVENT_END();
return false;
}
glUniform1iARB(i, 0);
// set the font shader up
glUseProgramObjectARB(r_font_prog);
if ((i = glGetUniformLocationARB(r_font_prog, "fontTex")) < 0) {
fprintf(stderr, "Failed to find font texture uniform variable\n");
OPENGL_EVENT_END();
return false;
}
glUniform1iARB(i, 0);
// find uniform locations
glUseProgramObjectARB(r_comp_prog);
if ((i = glGetUniformLocationARB(r_comp_prog, "overlay")) < 0) {
fprintf(stderr, "Failed to find overlay uniform variable\n");
OPENGL_EVENT_END();
return false;
}
glUniform1iARB(i, 0);
if ((r_comp_frames = glGetUniformLocationARB(r_comp_prog, "frames")) < 0) {
fprintf(stderr, "Failed to find frames uniform variable\n");
OPENGL_EVENT_END();
return false;
}
if ((r_comp_neg = glGetUniformLocationARB(r_comp_prog, "negative")) < 0) {
fprintf(stderr, "Failed to find negative uniform variable\n");
OPENGL_EVENT_END();
return false;
}
if ((r_comp_contrast = glGetUniformLocationARB(r_comp_prog, "cont")) < 0) {
fprintf(stderr, "Failed to find contrast uniform variable\n");
OPENGL_EVENT_END();
return false;
}
// fill the frames array; frames at GL_TEXTURE1 + i
for (i = 0; i < 1 + FRAME_TRACE; i++)
frames[i] = i + 1;
glUniform1ivARB(r_comp_frames, 1 + FRAME_TRACE, frames);
glUseProgramObjectARB(0);
OPENGL_EVENT_END();
return true;
}
