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 = glGetUniformLocationARB(m_shaderProgram, 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));
}
}
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));
}
}
void draw() {
glUseProgram(shaderProgram);
int projectionMatrixLocation = glGetUniformLocation(shaderProgram, "projectionMatrix");
int viewMatrixLocation = glGetUniformLocation(shaderProgram, "viewMatrix");
int modelMatrixLocation = glGetUniformLocation(shaderProgram, "modelMatrix");
glUniformMatrix4fv(projectionMatrixLocation, 1, GL_FALSE, &projectionMatrix[0][0]);
glUniformMatrix4fv(viewMatrixLocation, 1, GL_FALSE, &viewMatrix[0][0]);
glUniformMatrix4fv(modelMatrixLocation, 1, GL_FALSE, &modelMatrix[0][0]);
int location = glGetUniformLocationARB(shaderProgram, "tex");
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, texture);
glUniform1iARB(location, 0);
glBindVertexArray(vbo);
glBindBuffer(GL_ARRAY_BUFFER, vbo);
glEnableVertexAttribArray( vbo );
glVertexAttribPointer(vbo, 3, GL_FLOAT, GL_FALSE, sizeof(float)*3, 0);
glDrawArrays( GL_TRIANGLE_STRIP, 0, numVertices );
}
/*!
void Joints(Shaderobject shader, String uniform_variable)\n
script function to pass the transformed armature joint positions as uniform
array to a vertex shader
*/
void Item_armature::Joints(QObject* _shader, QString var){
if (glwrapper_shader* shader = dynamic_cast<glwrapper_shader*>(_shader)){
float* space = new float[max_bone_id * 3 + 3];
for (QTreeWidgetItemIterator it(this);*it;it++){
if (Item_bone* bone = dynamic_cast<Item_bone*>(*it)){
space[bone->id * 3 + 0] = bone->joint[0];
space[bone->id * 3 + 1] = bone->joint[1];
space[bone->id * 3 + 2] = bone->joint[2];
}
}
shader->Bind();
int loc = glGetUniformLocationARB(shader->getShaderHandle(),var.toLatin1().constData());
if(loc == -1) return;
glUniform3fvARB(loc, max_bone_id + 1, space);
delete[] space;
}
else{
qDebug() << "Item_armature::Joints parameter is not a shader object";
}
}
void GLShader::setShaderValue(const char *varId, float *value)
{
// if (!program) return;
if (shaderVals.find(varId) == shaderVals.end())
{
// if (shaderVals[varId].binding != -1) use();
shaderVals[varId].binding = glGetUniformLocationARB(program, varId);
shaderVals[varId].valType = SHADER_VAL_4X4;
if (shaderVals[varId].binding!=-1) shaderVals[varId].mat = NULL;
shaderVals[varId].mat = new float[16];
}
// if (shaderVals[varId].xyzVal.x != value)
// {
// if (!shaderVals[varId].mat) shaderVals[varId].mat = new float[16];
memcpy(shaderVals[varId].mat,value,sizeof(float)*16);
// }
// glUniformMatrix4fvARB(shaderVals[varId].binding,1,false,value);
}
CircleFieldRenderer::CircleFieldRenderer(const Manifold& m,
bool smooth,
VertexAttributeVector<Vec2d>& field,
float gamma): SimpleShaderRenderer(vss, fss)
{
GLint old_prog;
glGetIntegerv(GL_CURRENT_PROGRAM, &old_prog);
glUseProgram(prog);
GLuint scalar_attrib = glGetAttribLocation(prog, "circlepos");
// static float& gamma = CreateCVar("display.scalar_field_renderer.gamma",2.2f);
glUniform1fARB(glGetUniformLocationARB(prog, "gamma"), gamma);
glNewList(display_list,GL_COMPILE);
for(FaceIDIterator f = m.faces_begin(); f != m.faces_end(); ++f) {
if(!smooth)
glNormal3dv(normal(m, *f).get());
if(no_edges(m, *f)== 3)
glBegin(GL_TRIANGLES);
else
glBegin(GL_POLYGON);
for(Walker w = m.walker(*f); !w.full_circle(); w = w.circulate_face_ccw()) {
Vec3d n(normal(m, w.vertex()));
if(smooth)
glNormal3dv(n.get());
glVertexAttrib2dv(scalar_attrib, field[w.vertex()].get());
glVertex3dv(m.pos(w.vertex()).get());
}
glEnd();
}
glEndList();
glUseProgram(old_prog);
}
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 VoxGame::RenderFirstPassFullScreen()
{
m_pRenderer->PushMatrix();
m_pRenderer->SetProjectionMode(PM_2D, m_defaultViewport);
m_pRenderer->SetLookAtCamera(vec3(0.0f, 0.0f, 250.0f), vec3(0.0f, 0.0f, 0.0f), vec3(0.0f, 1.0f, 0.0f));
// Blur first pass (Horizontal)
m_pRenderer->StartRenderingToFrameBuffer(m_secondPassFullscreenBuffer);
m_pRenderer->BeginGLSLShader(m_blurHorizontalShader);
glShader* pShader = m_pRenderer->GetShader(m_blurHorizontalShader);
float blurSize = 0.0015f;
unsigned int textureId0 = glGetUniformLocationARB(pShader->GetProgramObject(), "texture");
m_pRenderer->PrepareShaderTexture(0, textureId0);
m_pRenderer->BindRawTextureId(m_pRenderer->GetDiffuseTextureFromFrameBuffer(m_firstPassFullscreenBuffer));
pShader->setUniform1f("blurSize", blurSize);
m_pRenderer->SetRenderMode(RM_TEXTURED);
m_pRenderer->EnableImmediateMode(IM_QUADS);
m_pRenderer->ImmediateTextureCoordinate(0.0f, 0.0f);
m_pRenderer->ImmediateVertex(0.0f, 0.0f, 1.0f);
m_pRenderer->ImmediateTextureCoordinate(1.0f, 0.0f);
m_pRenderer->ImmediateVertex((float)m_windowWidth, 0.0f, 1.0f);
m_pRenderer->ImmediateTextureCoordinate(1.0f, 1.0f);
m_pRenderer->ImmediateVertex((float)m_windowWidth, (float)m_windowHeight, 1.0f);
m_pRenderer->ImmediateTextureCoordinate(0.0f, 1.0f);
m_pRenderer->ImmediateVertex(0.0f, (float)m_windowHeight, 1.0f);
m_pRenderer->DisableImmediateMode();
m_pRenderer->EmptyTextureIndex(0);
m_pRenderer->EndGLSLShader(m_blurHorizontalShader);
m_pRenderer->StopRenderingToFrameBuffer(m_secondPassFullscreenBuffer);
m_pRenderer->PopMatrix();
}
static void panel_draw_internal(panel *p, float x, float y, float width, float height) {
glUseProgramObjectARB(p->shader_program);
glUniform4fARB(glGetUniformLocationARB(p->shader_program, "extents"), x, 1.0f-y-height, width, height);
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, p->font);
glActiveTexture(GL_TEXTURE1);
glBindTexture(GL_TEXTURE_2D, p->fg_tex);
glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, p->width, p->height, GL_RGBA, GL_UNSIGNED_BYTE, p->foreground);
glActiveTexture(GL_TEXTURE2);
glBindTexture(GL_TEXTURE_2D, p->bg_tex);
glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, p->width, p->height, GL_RGBA, GL_UNSIGNED_BYTE, p->background);
glBindBufferARB(GL_ARRAY_BUFFER_ARB, p->vbo);
glEnableClientState(GL_VERTEX_ARRAY);
glVertexPointer(3, GL_FLOAT, 5*sizeof(GLfloat), (char*)0 + 0*sizeof(GLfloat));
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
glTexCoordPointer(2, GL_FLOAT, 5*sizeof(GLfloat), (char*)0 + 3*sizeof(GLfloat));
glDrawArrays(GL_TRIANGLES, 0, 6);
}
void Shader::SetTexture(const std::string& name, const Image& texture)
{
if (myShaderProgram)
{
EnsureGlContext();
// Find the location of the variable in the shader
int location = glGetUniformLocationARB(myShaderProgram, name.c_str());
if (location == -1)
{
Err() << "Texture \"" << name << "\" not found in shader" << std::endl;
return;
}
// Store the location -> texture mapping
TextureTable::iterator it = myTextures.find(location);
if (it == myTextures.end())
{
// New entry, make sure there are enough texture units
GLint maxUnits;
GLCheck(glGetIntegerv(GL_MAX_TEXTURE_COORDS_ARB, &maxUnits));
if (myTextures.size() + 1 >= static_cast<std::size_t>(maxUnits))
{
Err() << "Impossible to use texture \"" << name << "\" for shader: all available texture units are used" << std::endl;
return;
}
myTextures[location] = &texture;
}
else
{
// Location already used, just replace the texture
it->second = &texture;
}
}
}
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 VoxGame::RenderDeferredLighting()
{
// Render deferred lighting to light frame buffer
m_pRenderer->PushMatrix();
m_pRenderer->StartRenderingToFrameBuffer(m_lightingFrameBuffer);
m_pRenderer->SetFrontFaceDirection(FrontFaceDirection_CW);
m_pRenderer->EnableTransparency(BF_ONE, BF_ONE);
m_pRenderer->DisableDepthTest();
// Set the default projection mode
m_pRenderer->SetProjectionMode(PM_PERSPECTIVE, m_defaultViewport);
// Set the lookat camera
m_pGameCamera->Look();
m_pRenderer->PushMatrix();
m_pRenderer->BeginGLSLShader(m_lightingShader);
glShader* pLightShader = m_pRenderer->GetShader(m_lightingShader);
unsigned NormalsID = glGetUniformLocationARB(pLightShader->GetProgramObject(), "normals");
unsigned PositionssID = glGetUniformLocationARB(pLightShader->GetProgramObject(), "positions");
unsigned DepthsID = glGetUniformLocationARB(pLightShader->GetProgramObject(), "depths");
m_pRenderer->PrepareShaderTexture(0, NormalsID);
m_pRenderer->BindRawTextureId(m_pRenderer->GetNormalTextureFromFrameBuffer(m_SSAOFrameBuffer));
m_pRenderer->PrepareShaderTexture(1, PositionssID);
m_pRenderer->BindRawTextureId(m_pRenderer->GetPositionTextureFromFrameBuffer(m_SSAOFrameBuffer));
m_pRenderer->PrepareShaderTexture(2, DepthsID);
m_pRenderer->BindRawTextureId(m_pRenderer->GetDepthTextureFromFrameBuffer(m_SSAOFrameBuffer));
pLightShader->setUniform1i("screenWidth", m_windowWidth);
pLightShader->setUniform1i("screenHeight", m_windowHeight);
pLightShader->setUniform1f("nearZ", 0.01f);
pLightShader->setUniform1f("farZ", 1000.0f);
for (int i = 0; i < m_pLightingManager->GetNumLights(); i++)
{
DynamicLight* lpLight = m_pLightingManager->GetLight(i);
float lightRadius = lpLight->m_radius;
vec3 cameraPos = vec3(m_pGameCamera->GetPosition().x, m_pGameCamera->GetPosition().y, m_pGameCamera->GetPosition().z);
float length = glm::distance(cameraPos, lpLight->m_position);
if (length < lightRadius + 0.5f) // Small change to account for differences in circle render (with slices) and circle radius
{
m_pRenderer->SetCullMode(CM_BACK);
}
else
{
m_pRenderer->SetCullMode(CM_FRONT);
}
pLightShader->setUniform1f("radius", lightRadius);
pLightShader->setUniform1f("diffuseScale", lpLight->m_diffuseScale);
float r = lpLight->m_colour.GetRed();
float g = lpLight->m_colour.GetGreen();
float b = lpLight->m_colour.GetBlue();
float a = lpLight->m_colour.GetAlpha();
pLightShader->setUniform4f("diffuseLightColor", r, g, b, a);
m_pRenderer->PushMatrix();
m_pRenderer->SetRenderMode(RM_SOLID);
m_pRenderer->TranslateWorldMatrix(lpLight->m_position.x, lpLight->m_position.y + 0.5f, lpLight->m_position.z);
m_pRenderer->DrawSphere(lightRadius, 30, 30);
m_pRenderer->PopMatrix();
}
m_pRenderer->EmptyTextureIndex(2);
m_pRenderer->EmptyTextureIndex(1);
m_pRenderer->EmptyTextureIndex(0);
m_pRenderer->EndGLSLShader(m_lightingShader);
m_pRenderer->PopMatrix();
m_pRenderer->SetFrontFaceDirection(FrontFaceDirection_CCW);
m_pRenderer->DisableTransparency();
m_pRenderer->SetCullMode(CM_BACK);
m_pRenderer->EnableDepthTest(DT_LESS);
m_pRenderer->StopRenderingToFrameBuffer(m_lightingFrameBuffer);
m_pRenderer->PopMatrix();
}
void VoxGame::RenderSSAOTexture()
{
m_pRenderer->PushMatrix();
m_pRenderer->SetProjectionMode(PM_2D, m_defaultViewport);
m_pRenderer->SetLookAtCamera(vec3(0.0f, 0.0f, 250.0f), vec3(0.0f, 0.0f, 0.0f), vec3(0.0f, 1.0f, 0.0f));
if (m_multiSampling)
{
m_pRenderer->StartRenderingToFrameBuffer(m_FXAAFrameBuffer);
}
else if (m_blur)
{
m_pRenderer->StartRenderingToFrameBuffer(m_firstPassFullscreenBuffer);
}
// SSAO shader
m_pRenderer->BeginGLSLShader(m_SSAOShader);
glShader* pShader = m_pRenderer->GetShader(m_SSAOShader);
unsigned int textureId0 = glGetUniformLocationARB(pShader->GetProgramObject(), "bgl_DepthTexture");
m_pRenderer->PrepareShaderTexture(0, textureId0);
m_pRenderer->BindRawTextureId(m_pRenderer->GetDepthTextureFromFrameBuffer(m_SSAOFrameBuffer));
unsigned int textureId1 = glGetUniformLocationARB(pShader->GetProgramObject(), "bgl_RenderedTexture");
m_pRenderer->PrepareShaderTexture(1, textureId1);
m_pRenderer->BindRawTextureId(m_pRenderer->GetDiffuseTextureFromFrameBuffer(m_SSAOFrameBuffer));
unsigned int textureId2 = glGetUniformLocationARB(pShader->GetProgramObject(), "light");
m_pRenderer->PrepareShaderTexture(2, textureId2);
m_pRenderer->BindRawTextureId(m_pRenderer->GetDiffuseTextureFromFrameBuffer(m_lightingFrameBuffer));
unsigned int textureId3 = glGetUniformLocationARB(pShader->GetProgramObject(), "bgl_TransparentTexture");
m_pRenderer->PrepareShaderTexture(3, textureId3);
m_pRenderer->BindRawTextureId(m_pRenderer->GetDiffuseTextureFromFrameBuffer(m_transparencyFrameBuffer));
unsigned int textureId4 = glGetUniformLocationARB(pShader->GetProgramObject(), "bgl_TransparentDepthTexture");
m_pRenderer->PrepareShaderTexture(4, textureId4);
m_pRenderer->BindRawTextureId(m_pRenderer->GetDepthTextureFromFrameBuffer(m_transparencyFrameBuffer));
pShader->setUniform1i("screenWidth", m_windowWidth);
pShader->setUniform1i("screenHeight", m_windowHeight);
pShader->setUniform1f("nearZ", 0.01f);
pShader->setUniform1f("farZ", 1000.0f);
pShader->setUniform1f("samplingMultiplier", 0.5f);
pShader->setUniform1i("lighting_enabled", m_dynamicLighting);
pShader->setUniform1i("ssao_enabled", m_ssao);
m_pRenderer->SetRenderMode(RM_TEXTURED);
m_pRenderer->EnableImmediateMode(IM_QUADS);
m_pRenderer->ImmediateTextureCoordinate(0.0f, 0.0f);
m_pRenderer->ImmediateVertex(0.0f, 0.0f, 1.0f);
m_pRenderer->ImmediateTextureCoordinate(1.0f, 0.0f);
m_pRenderer->ImmediateVertex((float)m_windowWidth, 0.0f, 1.0f);
m_pRenderer->ImmediateTextureCoordinate(1.0f, 1.0f);
m_pRenderer->ImmediateVertex((float)m_windowWidth, (float)m_windowHeight, 1.0f);
m_pRenderer->ImmediateTextureCoordinate(0.0f, 1.0f);
m_pRenderer->ImmediateVertex(0.0f, (float)m_windowHeight, 1.0f);
m_pRenderer->DisableImmediateMode();
m_pRenderer->EmptyTextureIndex(4);
m_pRenderer->EmptyTextureIndex(3);
m_pRenderer->EmptyTextureIndex(2);
m_pRenderer->EmptyTextureIndex(1);
m_pRenderer->EmptyTextureIndex(0);
m_pRenderer->EndGLSLShader(m_SSAOShader);
if (m_multiSampling)
{
m_pRenderer->StopRenderingToFrameBuffer(m_FXAAFrameBuffer);
}
else if (m_blur)
{
m_pRenderer->StopRenderingToFrameBuffer(m_firstPassFullscreenBuffer);
}
m_pRenderer->PopMatrix();
}
void Shader::setUniformi1(const std::string &variable, long value) {
if (shaderProgram != -1)
glUniform1iARB (glGetUniformLocationARB (shaderProgram, variable.c_str ()), value);
}
void VoxGame::Render()
{
if (m_pVoxWindow->GetMinimized())
{
// Don't call any render functions if minimized
return;
}
glShader* pShader = NULL;
// Begin rendering
m_pRenderer->BeginScene(true, true, true);
// Shadow rendering to the shadow frame buffer
if (m_shadows)
{
RenderShadows();
}
// SSAO frame buffer rendering start
if (m_deferredRendering)
{
m_pRenderer->StartRenderingToFrameBuffer(m_SSAOFrameBuffer);
}
// ---------------------------------------
// Render 3d
// ---------------------------------------
m_pRenderer->PushMatrix();
// Set the default projection mode
m_pRenderer->SetProjectionMode(PM_PERSPECTIVE, m_defaultViewport);
// Set back culling as default
m_pRenderer->SetCullMode(CM_BACK);
// Set default depth test
m_pRenderer->EnableDepthTest(DT_LESS);
// Set the lookat camera
m_pGameCamera->Look();
// Enable the lights
m_pRenderer->PushMatrix();
m_pRenderer->EnableLight(m_defaultLight, 0);
m_pRenderer->PopMatrix();
// Multisampling MSAA
if (m_multiSampling)
{
m_pRenderer->EnableMultiSampling();
}
else
{
m_pRenderer->DisableMultiSampling();
}
// Render the lights (DEBUG)
m_pRenderer->PushMatrix();
m_pRenderer->SetCullMode(CM_BACK);
m_pRenderer->SetRenderMode(RM_SOLID);
m_pRenderer->RenderLight(m_defaultLight);
m_pRenderer->PopMatrix();
if (m_shadows)
{
m_pRenderer->BeginGLSLShader(m_shadowShader);
pShader = m_pRenderer->GetShader(m_shadowShader);
GLuint shadowMapUniform = glGetUniformLocationARB(pShader->GetProgramObject(), "ShadowMap");
m_pRenderer->PrepareShaderTexture(7, shadowMapUniform);
m_pRenderer->BindRawTextureId(m_pRenderer->GetDepthTextureFromFrameBuffer(m_shadowFrameBuffer));
glUniform1iARB(glGetUniformLocationARB(pShader->GetProgramObject(), "renderShadow"), m_shadows);
glUniform1iARB(glGetUniformLocationARB(pShader->GetProgramObject(), "alwaysShadow"), false);
}
else
{
m_pRenderer->BeginGLSLShader(m_defaultShader);
}
// Render world
//RenderWorld();
// Render the chunks
m_pChunkManager->Render();
// Render the player
if (m_cameraMode == CameraMode_FirstPerson)
{
m_pPlayer->RenderFirstPerson();
}
else
{
m_pPlayer->Render();
}
// Render the block particles
m_pBlockParticleManager->Render();
if (m_shadows)
{
m_pRenderer->EndGLSLShader(m_shadowShader);
}
else
{
m_pRenderer->EndGLSLShader(m_defaultShader);
}
// Debug rendering
if(m_debugRender)
{
m_pLightingManager->DebugRender();
m_pBlockParticleManager->RenderDebug();
m_pPlayer->RenderDebug();
m_pChunkManager->RenderDebug();
}
m_pRenderer->PopMatrix();
// Render the deferred lighting pass
if (m_dynamicLighting)
{
RenderDeferredLighting();
}
// ---------------------------------------
// Render 2d
// ---------------------------------------
m_pRenderer->PushMatrix();
m_pRenderer->PopMatrix();
// SSAO frame buffer rendering stop
if (m_deferredRendering)
{
m_pRenderer->StopRenderingToFrameBuffer(m_SSAOFrameBuffer);
}
// ---------------------------------------
// Render transparency
// ---------------------------------------
RenderTransparency();
// Render the SSAO texture
if (m_deferredRendering)
{
RenderSSAOTexture();
if (m_multiSampling && m_fxaaShader != -1)
{
RenderFXAATexture();
}
if(m_blur)
{
RenderFirstPassFullScreen();
RenderSecondPassFullScreen();
}
}
// Disable multisampling for 2d gui and text
m_pRenderer->DisableMultiSampling();
// Render debug information and text
RenderDebugInformation();
// Render the chunks 2d
if (m_debugRender)
{
//m_pChunkManager->Render2D(m_pGameCamera, m_defaultViewport, m_defaultFont);
}
// Render the GUI
RenderGUI();
// End rendering
m_pRenderer->EndScene();
// Pass render call to the window class, allow to swap buffers
m_pVoxWindow->Render();
}
//--------------------------------------------------------------
void testApp::setup(){
ofBackground(0, 0, 0);
ofSetFrameRate(60);
glEnable(GL_DEPTH_TEST);
glDepthFunc(GL_LEQUAL);
ofDisableArbTex();
neheTexture.loadImage("images/crate.gif");
shader.loadShader("shaders/shader");
glGenBuffersARB(2, &vboId[0]);
//GET ATTRIBUTE AND UNIFORMS
shader.setShaderActive(true);
locationID[VERTEX_POSITION_ATTRIBUTE] = glGetAttribLocationARB(shader.shader, "aVertexPosition");
locationID[TEXTURE_COORD_ATTRIBUTE] = glGetAttribLocationARB(shader.shader, "aTextureCoord");
locationID[VERTEX_NORMAL_ATTRIBUTE] = glGetAttribLocationARB(shader.shader, "aVertexNormal");
glEnableVertexAttribArray(locationID[VERTEX_POSITION_ATTRIBUTE]);
glEnableVertexAttribArray(locationID[TEXTURE_COORD_ATTRIBUTE]);
glEnableVertexAttribArray(locationID[VERTEX_NORMAL_ATTRIBUTE]);
locationID[P_MATRIX_UNIFORM] = glGetUniformLocationARB(shader.shader, "uPMatrix");
locationID[MV_MATRIX_UNIFORM] = glGetUniformLocationARB(shader.shader, "uMVMatrix");
locationID[NORMAL_MATRIX_UNIFORM] = glGetUniformLocationARB(shader.shader, "uNMatrix");
shader.setUniformVariable1i((char*)"uUseLighting", use_lighting=!use_lighting);
shader.setUniformVariable3f((char*)"uAmbientColor",ambient_red_value=0.2,ambient_green_value=0.2,ambient_blue_value=0.2);
lightDirection.set(0.0,0.0,1.0);
shader.setUniformVariable3f((char*)"uLightingDirection", lightDirection.x,lightDirection.y,lightDirection.z);
shader.setUniformVariable3f((char*)"uDirectionalColor", direct_red_value=0.8,direct_green_value=0.8,direct_blue_value=0.8);
shader.setShaderActive(false);
//SQUARE BUFFER
glBindBuffer(GL_ARRAY_BUFFER, vboId[0]);
glBufferData(GL_ARRAY_BUFFER, sizeof(cubeVertexPosition)+sizeof(cubeVertexTextureCoord)+sizeof(cubeVertexNormal), 0, GL_STATIC_DRAW);
glBufferSubData(GL_ARRAY_BUFFER, 0, sizeof(cubeVertexPosition), cubeVertexPosition);
glBufferSubData(GL_ARRAY_BUFFER, sizeof(cubeVertexPosition), sizeof(cubeVertexTextureCoord), cubeVertexTextureCoord);
glBufferSubData(GL_ARRAY_BUFFER, sizeof(cubeVertexPosition)+sizeof(cubeVertexTextureCoord), sizeof(cubeVertexNormal), cubeVertexNormal);
//INDEX BUFFERS
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, vboId[1]);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(cubeVertexIndices), cubeVertexIndices, GL_STATIC_DRAW);
//SETUP ROTATION AND Z VARS
z=-7;
xSpeed=ySpeed=0;
//KEYS
of_key_backspace_pressed=false;
of_key_page_up_pressed=false;
of_key_page_down_pressed=false;
of_key_left_pressed=false;
of_key_right_pressed=false;
of_key_up_pressed=false;
of_key_down_pressed=false;
verdana.loadFont("fonts/verdana.ttf",8, false, true);
verdana.setLineHeight(14.0f);
}
void Shader::setUniformTexture(const std::string &variable, long textureUnit)
{
if (shaderProgram != -1)
glUniform1iARB (glGetUniformLocationARB (shaderProgram, variable.c_str ()), textureUnit);
}
void ofxShader::setUniformVariable3f (char * name, float value, float value2, float value3){
if (bLoaded == true){
glUniform3fARB(glGetUniformLocationARB(shader, name), value, value2, value3);
}
}
void ofxShader::setUniformVariable1i (char * name, int value){
if (bLoaded == true){
glUniform1iARB(glGetUniformLocationARB(shader, name), value);
}
}
bool InitializeApp()
{
glClearColor(0, 0, 0, 1);
glShadeModel(GL_SMOOTH);
glEnable(GL_DEPTH_TEST);
glEnable(GL_TEXTURE_2D);
// Load texture.
int width = 0, height = 0, comp = 0;
unsigned char *image;
image = LoadTGA("/home/aashish/tools/mywork/src.git/data/noise.tga", width, height, comp);
glGenTextures(1, &_gRandomSampler);
glBindTexture(GL_TEXTURE_2D, _gRandomSampler);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB8, width, height,
0, GL_RGB, GL_UNSIGNED_BYTE, image);
delete[] image;
// Load shaders.
if(!CreateGLSLShader("/home/aashish/tools/mywork/src.git/opengl/ssao_crytek/setRenderTargetsVs.glsl",
"/home/aashish/tools/mywork/src.git/opengl/ssao_crytek/setRenderTargetsPs.glsl",
_gSetRenderTargetShader))
return false;
if(!CreateGLSLShader("/home/aashish/tools/mywork/src.git/opengl/ssao_crytek/clearRenderTargetsVs.glsl",
"/home/aashish/tools/mywork/src.git/opengl/ssao_crytek/clearRenderTargetsPs.glsl",
_gClearRenderTargetShader))
return false;
if(!CreateGLSLShader("/home/aashish/tools/mywork/src.git/opengl/ssao_crytek/ssaoVs.glsl",
"/home/aashish/tools/mywork/src.git/opengl/ssao_crytek/ssaoPs.glsl",
_gSsaoShader))
return false;
if(!CreateGLSLShader("/home/aashish/tools/mywork/src.git/opengl/ssao_crytek/hBlurVs.glsl",
"/home/aashish/tools/mywork/src.git/opengl/ssao_crytek/hBlurPs.glsl",
_gHorizontalBlurShader))
return false;
if(!CreateGLSLShader("/home/aashish/tools/mywork/src.git/opengl/ssao_crytek/vBlurVs.glsl",
"/home/aashish/tools/mywork/src.git/opengl/ssao_crytek/vBlurPs.glsl",
_gVerticalBlurShader))
return false;
if(!CreateGLSLShader("/home/aashish/tools/mywork/src.git/opengl/ssao_crytek/renderingVs.glsl",
"/home/aashish/tools/mywork/src.git/opengl/ssao_crytek/renderingPs.glsl",
_gRenderShader))
return false;
// Bind our shader variables.
_gOffset = glGetUniformLocationARB(_gRenderShader, "offset");
_gLight1Pos = glGetUniformLocationARB(_gRenderShader, "light1Pos");
_gLight1AmbientColor = glGetUniformLocationARB(_gRenderShader, "light1AmbientColor");
_gLight1DiffuseColor = glGetUniformLocationARB(_gRenderShader, "light1DiffuseColor");
_gLight1SpecularColor = glGetUniformLocationARB(_gRenderShader, "light1SpecularColor");
_gLight2Pos = glGetUniformLocationARB(_gRenderShader, "light2Pos");
_gLight2AmbientColor = glGetUniformLocationARB(_gRenderShader, "light2AmbientColor");
_gLight2DiffuseColor = glGetUniformLocationARB(_gRenderShader, "light2DiffuseColor");
_gLight2SpecularColor = glGetUniformLocationARB(_gRenderShader, "light2SpecularColor");
_gAmbientOcclusion = glGetUniformLocationARB(_gRenderShader, "aos");
_gSceneColors = glGetUniformLocationARB(_gRenderShader, "colors");
_gSceneDepths = glGetUniformLocationARB(_gRenderShader, "depths");
_gSceneNormals = glGetUniformLocationARB(_gRenderShader, "normals");
_gSsaoOffset = glGetUniformLocationARB(_gSsaoShader, "offset");
_gSsaoNormals = glGetUniformLocationARB(_gSsaoShader, "normals");
_gSsaoDepths = glGetUniformLocationARB(_gSsaoShader, "depths");
_gSsaoRandoms = glGetUniformLocationARB(_gSsaoShader, "randoms");
_gHorizontalBlurSceneSampler = glGetUniformLocationARB(_gHorizontalBlurShader, "scene");
_gHorizontalBlurSceneSamplerDepth = glGetUniformLocationARB(_gHorizontalBlurShader, "depths");
_gHorizontalBlurSceneSamplerNormal = glGetUniformLocationARB(_gHorizontalBlurShader, "normals");
_gVerticalBlurSceneSampler = glGetUniformLocationARB(_gVerticalBlurShader, "scene");
_gVerticalBlurSceneDepthSampler = glGetUniformLocationARB(_gVerticalBlurShader, "depths");
_gVerticalBlurSceneNormalSampler = glGetUniformLocationARB(_gVerticalBlurShader, "normals");
// Create frame buffer objects.
if(_gSceneFbo.Create(WIDTH, HEIGHT) == false)
return false;
// Create frame buffer objects.
if(_gSsaoFbo.Create(WIDTH, HEIGHT) == false)
return false;
// Create frame buffer objects.
if(_gHorizontalBlurFbo.Create(WIDTH, HEIGHT) == false)
return false;
if(_gVerticalBlurFbo.Create(WIDTH, HEIGHT) == false)
return false;
if(_gModel.LoadOBJ("/home/aashish/tools/mywork/src.git/data/sponza.obj") == false)
return false;
return true;
}
void Renderer::Init()
{
//sanity check, make sure required extension are supported
log_file << "Checking for presence of required GL extensions...";
if(!GLEE_ARB_texture_non_power_of_two)
{
throw std::exception("ARB_texture_non_power_of_two NOT supported.");
}
if(!GLEE_ARB_shader_objects)
{
throw std::exception("ARB_shader_objects NOT supported.");
}
if(!GLEE_EXT_framebuffer_object)
{
throw std::exception("EXT_framebuffer_object NOT supported.");
}
log_file << "done." << std::endl;
/////////////////////////
//create fbo
glGenFramebuffersEXT(1, &fbo);
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fbo);
glActiveTexture(GL_TEXTURE0);
glEnable(GL_TEXTURE_2D);
glBindTexture(GL_TEXTURE_2D, 0);
glActiveTexture(GL_TEXTURE1);
glEnable(GL_TEXTURE_2D);
glBindTexture(GL_TEXTURE_2D, 0);
glActiveTexture(GL_TEXTURE0);
glGenTextures(2, input_texture);
glBindTexture(GL_TEXTURE_2D, input_texture[0]);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_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_RGBA32F_ARB, WINDOW_WIDTH, WINDOW_HEIGHT, 0, GL_RGBA, GL_FLOAT, NULL);
glBindTexture(GL_TEXTURE_2D, input_texture[1]);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_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_RGBA32F_ARB, WINDOW_WIDTH, WINDOW_HEIGHT, 0, GL_RGBA, GL_FLOAT, NULL);
glBindTexture(GL_TEXTURE_2D, 0);
glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_TEXTURE_2D, input_texture[0], 0);
glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT1_EXT, GL_TEXTURE_2D, input_texture[1], 0);
GLenum status = glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT);
if(status==GL_FRAMEBUFFER_COMPLETE_EXT)
{
log_file << "FBO successfully created." << std::endl;
}
else
{
log_file << "Create FBO failed." << std::endl;
}
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
log_file << "OpenGL error state: " << gluErrorString(glGetError()) << std::endl;
/////////////////////////
////////////////////////////////
//create shaders
//pass1
LoadShaders(program_pass1, "mandelbrot.vert", "mandelbrot_pass1.frag");
//pass 2
LoadShaders(program_pass2, "mandelbrot.vert", "mandelbrot_pass2.frag");
glUseProgramObjectARB(program_pass2);
uniform_iteration_location = glGetUniformLocationARB(program_pass2, "iteration");
uniform_input_p2_location = glGetUniformLocationARB(program_pass2, "input");
glUseProgramObjectARB(0);
//pass 3
LoadShaders(program_pass3, "mandelbrot.vert", "mandelbrot_pass3.frag");
glUseProgramObjectARB(program_pass3);
uniform_max_iterations_location = glGetUniformLocationARB(program_pass3, "max_iterations");
uniform_input_p3_location = glGetUniformLocationARB(program_pass3, "input");
uniform_iteration_scale_location = glGetUniformLocationARB(program_pass3, "iteration_scale");
glUseProgramObjectARB(0);
log_file << "OpenGL error state: " << gluErrorString(glGetError()) << std::endl;
//////////////////////////////////////
}
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 ofxShader::setUniformVariable4fv (char * name, int count, float * value){
if (bLoaded == true){
glUniform4fvARB(glGetUniformLocationARB(shader, name), count, value);
}
}
int sageDisplay::updateScreen(dispSharedData *shared, bool barrierFlag)
{
context->clearScreen();
for (int i=0; i<tileNum; i++) {
sageRect tileRect = configStruct.tileRect[i];
tileRect.updateBoundary();
int tileX = (i % configStruct.dimX) * configStruct.width;
int tileY = (i / configStruct.dimX) * configStruct.height;
tileRect.x = tileX;
tileRect.y = tileY;
context->setupViewport(i, tileRect);
drawObj.preDraw(tileRect);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glOrtho(tileRect.left, tileRect.right, tileRect.bottom, tileRect.top, 0, 100);
glMatrixMode(GL_MODELVIEW);
for (int j=0; j<noOfMontages[i]; j++) {
sageMontage *mon = montages[i][j];
if (!mon)
continue;
if (!mon->visible)
continue;
//if (!mon->isValidTexCoord()) {
//sage::printLog("sageDisplay::updateScreen : montage %d of tile %d doesn't have valid texture coordinates", mon->id, i);
//continue;
//}
if (mon->pixelType == PIXFMT_YUV) {
#if defined(GLSL_YUV)
glDisable(GL_TEXTURE_2D);
glEnable(GL_TEXTURE_RECTANGLE_ARB);
glBindTexture(GL_TEXTURE_RECTANGLE_ARB, mon->texHandle);
glUseProgramObjectARB(PHandle);
glActiveTexture(GL_TEXTURE0);
int h=glGetUniformLocationARB(PHandle,"yuvtex");
glUniform1iARB(h,0); /* Bind yuvtex to texture unit 0 */
glBindTexture(GL_TEXTURE_RECTANGLE_ARB,mon->texHandle);
#else
glBindTexture(GL_TEXTURE_2D, mon->texHandle);
#endif
}
else {
glBindTexture(GL_TEXTURE_2D, mon->texHandle);
}
//GLenum error = glGetError();
//gluGetErrorString( error ) ) );
float depth = -mon->depth;
glBegin(GL_QUADS);
float texX, texY;
mon->texCoord.genTexCoord(LOWER_LEFT, texX, texY);
// std::cerr << "LL " << texX << " , " << texY << " , " ;
glTexCoord2f(texX, texY);
glVertex3f(mon->left, mon->bottom, depth);
//std::cout << " drawing... " << mon->left << " " << mon->bottom << " " << depth << std::endl;
mon->texCoord.genTexCoord(LOWER_RIGHT, texX, texY);
// std::cerr << "LR " << texX << " , " << texY << " , " ;
glTexCoord2f(texX, texY);
glVertex3f(mon->right, mon->bottom, depth);
mon->texCoord.genTexCoord(UPPER_RIGHT, texX, texY);
// std::cerr << "UR " << texX << " , " << texY << " , " ;
glTexCoord2f(texX, texY);
glVertex3f(mon->right, mon->top, depth);
mon->texCoord.genTexCoord(UPPER_LEFT, texX, texY);
// std::cerr << "UL " << texX << " , " << texY << std::endl;
glTexCoord2f(texX, texY);
glVertex3f(mon->left, mon->top, depth);
glEnd();
if (mon->pixelType == PIXFMT_YUV) {
#if defined(GLSL_YUV)
glUseProgramObjectARB(0);
glDisable(GL_TEXTURE_RECTANGLE_ARB);
glEnable(GL_TEXTURE_2D);
#endif
}
}
drawObj.interDraw(tileRect);
drawObj.postDraw(tileRect);
context->refreshTile(i);
}
//gettimeofday(&tve,NULL);
//double e = ((double)tve.tv_sec + 0.000001*(double)tve.tv_usec) - ((double)tvs.tv_sec + 0.000001*(double)tvs.tv_usec);
//printf("%.9f elapsed\n", e);
//context->refreshScreen();
/** BARRIER **/
if ( barrierFlag ) {
shared->syncClientObj->sendRefreshBarrier(shared->nodeID);
//printf("node %d sent to barrier\n", shared->nodeID);
shared->syncClientObj->recvRefreshBarrier(false); // blocking (set true for nonblock)
//printf("node %d recved frm barrier\n", shared->nodeID);
}
#ifdef DELAY_COMPENSATION
if ( shared ) {
gettimeofday(&shared->localT, NULL); // my time
//fprintf(stderr,"SM sent %ld,%ld\n", shared->syncMasterT.tv_sec, shared->syncMasterT.tv_usec);
//fprintf(stderr,"SDM%d is %ld,%ld\n", shared->nodeID, shared->localT.tv_sec, shared->localT.tv_usec);
double A = (double)shared->syncMasterT.tv_sec + 0.000001*(double)shared->syncMasterT.tv_usec;
A = A + ((double)shared->deltaT * 0.000001);
double B = (double)shared->localT.tv_sec + 0.000001*(double)shared->localT.tv_usec;
double wait = A - B;
wait *= 1000000.0;
int llBusyWait = (int)wait;
if ( llBusyWait > 0 ) {
__usecDelay_RDTSC( llBusyWait );
}
//printf("SDM %d: %.6f msec waited\n", shared->nodeID, elapsed*1000.0);
}
#endif
context->refreshScreen(); // actual swapBuffer occurs in here at displayConext's instance
dirty = false;
return 0;
}
static void ui_render(bool select) {
GLint location;
GLenum e;
// Render strip indicators
switch(strip_indicator) {
case STRIPS_SOLID:
case STRIPS_COLORED:
glLoadIdentity();
glViewport(0, 0, config.pattern.master_width, config.pattern.master_height);
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, strip_fb);
glUseProgramObjectARB(strip_shader);
location = glGetUniformLocationARB(strip_shader, "iPreview");
glUniform1iARB(location, 0);
location = glGetUniformLocationARB(strip_shader, "iResolution");
glUniform2fARB(location, config.pattern.master_width, config.pattern.master_height);
location = glGetUniformLocationARB(strip_shader, "iIndicator");
glUniform1iARB(location, strip_indicator);
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, crossfader.tex_output);
glClear(GL_COLOR_BUFFER_BIT);
glBegin(GL_QUADS);
for(struct output_device * d = output_device_head; d != NULL; d = d->next) {
#ifdef SOLID_LINE_INDICATOR
bool first = true;
double x;
double y;
for(struct output_vertex * v = d->vertex_head; v != NULL; v = v->next) {
if(!first) {
double dx = v->x - x;
double dy = -v->y - y;
double dl = hypot(dx, dy);
dx = config.ui.strip_thickness * dx / dl;
dy = config.ui.strip_thickness * dy / dl;
glVertex2d(x + dy, y - dx);
glVertex2d(v->x + dy, -v->y - dx);
glVertex2d(v->x - dy, -v->y + dx);
glVertex2d(x - dy, y + dx);
} else {
first = false;
}
x = v->x;
y = -v->y;
}
#else // PIXEL INDICATOR
// Maybe this is horrendously slow because it has to draw a quad for every output pixel?
// It looks cool though
for (size_t i = 0; i < d->pixels.length; i++) {
double x = d->pixels.xs[i];
double y = d->pixels.ys[i];
double dx = config.ui.point_thickness;
double dy = config.ui.point_thickness;
glVertex2d(x + dx, y);
glVertex2d(x, y + dy);
glVertex2d(x - dx, y);
glVertex2d(x, y - dy);
}
#endif
}
glEnd();
break;
default:
case STRIPS_NONE:
break;
}
// Render the patterns
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, pat_fb);
int pw = config.ui.pattern_width;
int ph = config.ui.pattern_height;
glUseProgramObjectARB(pat_shader);
location = glGetUniformLocationARB(pat_shader, "iResolution");
glUniform2fARB(location, pw, ph);
glUseProgramObjectARB(pat_shader);
location = glGetUniformLocationARB(pat_shader, "iSelection");
glUniform1iARB(location, select);
location = glGetUniformLocationARB(pat_shader, "iPreview");
glUniform1iARB(location, 0);
location = glGetUniformLocationARB(pat_shader, "iName");
glUniform1iARB(location, 1);
GLint pattern_index = glGetUniformLocationARB(pat_shader, "iPatternIndex");
GLint pattern_intensity = glGetUniformLocationARB(pat_shader, "iIntensity");
GLint name_resolution = glGetUniformLocationARB(pat_shader, "iNameResolution");
glLoadIdentity();
gluOrtho2D(0, pw, 0, ph);
glViewport(0, 0, pw, ph);
for(int i = 0; i < config.ui.n_patterns; i++) {
struct pattern * p = deck[map_deck[i]].pattern[map_pattern[i]];
if(p != NULL) {
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, p->tex_output);
glActiveTexture(GL_TEXTURE1);
SDL_GL_BindTexture(pattern_name_textures[i], NULL, NULL);
glUniform1iARB(pattern_index, i);
glUniform1fARB(pattern_intensity, p->intensity);
glUniform2fARB(name_resolution, pattern_name_width[i], pattern_name_height[i]);
glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_TEXTURE_2D, pattern_textures[i], 0);
glClear(GL_COLOR_BUFFER_BIT);
fill(pw, ph);
}
}
// Render the crossfader
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, crossfader_fb);
int cw = config.ui.crossfader_width;
int ch = config.ui.crossfader_height;
glUseProgramObjectARB(crossfader_shader);
location = glGetUniformLocationARB(crossfader_shader, "iResolution");
glUniform2fARB(location, cw, ch);
location = glGetUniformLocationARB(crossfader_shader, "iSelection");
glUniform1iARB(location, select);
location = glGetUniformLocationARB(crossfader_shader, "iPreview");
glUniform1iARB(location, 0);
location = glGetUniformLocationARB(crossfader_shader, "iStrips");
glUniform1iARB(location, 1);
location = glGetUniformLocationARB(crossfader_shader, "iIntensity");
glUniform1fARB(location, crossfader.position);
location = glGetUniformLocationARB(crossfader_shader, "iIndicator");
glUniform1iARB(location, strip_indicator);
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, crossfader.tex_output);
glActiveTexture(GL_TEXTURE1);
glBindTexture(GL_TEXTURE_2D, strip_texture);
glLoadIdentity();
gluOrtho2D(0, cw, 0, ch);
glViewport(0, 0, cw, ch);
glClear(GL_COLOR_BUFFER_BIT);
fill(cw, ch);
int sw = 0;
int sh = 0;
int vw = 0;
int vh = 0;
if(!select) {
analyze_render(tex_spectrum_data, tex_waveform_data, tex_waveform_beats_data);
// Render the spectrum
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, spectrum_fb);
sw = config.ui.spectrum_width;
sh = config.ui.spectrum_height;
glUseProgramObjectARB(spectrum_shader);
location = glGetUniformLocationARB(spectrum_shader, "iResolution");
glUniform2fARB(location, sw, sh);
location = glGetUniformLocationARB(spectrum_shader, "iBins");
glUniform1iARB(location, config.audio.spectrum_bins);
location = glGetUniformLocationARB(spectrum_shader, "iSpectrum");
glUniform1iARB(location, 0);
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_1D, tex_spectrum_data);
glLoadIdentity();
gluOrtho2D(0, sw, 0, sh);
glViewport(0, 0, sw, sh);
glClear(GL_COLOR_BUFFER_BIT);
fill(sw, sh);
// Render the waveform
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, waveform_fb);
vw = config.ui.waveform_width;
vh = config.ui.waveform_height;
glUseProgramObjectARB(waveform_shader);
location = glGetUniformLocationARB(waveform_shader, "iResolution");
glUniform2fARB(location, sw, sh);
location = glGetUniformLocationARB(waveform_shader, "iLength");
glUniform1iARB(location, config.audio.waveform_length);
location = glGetUniformLocationARB(waveform_shader, "iWaveform");
glUniform1iARB(location, 0);
location = glGetUniformLocationARB(waveform_shader, "iBeats");
glUniform1iARB(location, 1);
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_1D, tex_waveform_data);
glActiveTexture(GL_TEXTURE1);
glBindTexture(GL_TEXTURE_1D, tex_waveform_beats_data);
glLoadIdentity();
gluOrtho2D(0, vw, 0, vh);
glViewport(0, 0, vw, vh);
glClear(GL_COLOR_BUFFER_BIT);
fill(vw, vh);
}
// Render to screen (or select fb)
if(select) {
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, select_fb);
} else {
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
}
glLoadIdentity();
gluOrtho2D(0, ww, 0, wh);
glViewport(0, 0, ww, wh);
glClear(GL_COLOR_BUFFER_BIT);
glUseProgramObjectARB(main_shader);
location = glGetUniformLocationARB(main_shader, "iResolution");
glUniform2fARB(location, ww, wh);
location = glGetUniformLocationARB(main_shader, "iSelection");
glUniform1iARB(location, select);
location = glGetUniformLocationARB(main_shader, "iSelected");
glUniform1iARB(location, selected);
location = glGetUniformLocationARB(main_shader, "iLeftDeckSelector");
glUniform1iARB(location, left_deck_selector);
location = glGetUniformLocationARB(main_shader, "iRightDeckSelector");
glUniform1iARB(location, right_deck_selector);
fill(ww, wh);
// Blit UI elements on top
glEnable(GL_BLEND);
glUseProgramObjectARB(blit_shader);
glActiveTexture(GL_TEXTURE0);
location = glGetUniformLocationARB(blit_shader, "iTexture");
glUniform1iARB(location, 0);
for(int i = 0; i < config.ui.n_patterns; i++) {
struct pattern * pattern = deck[map_deck[i]].pattern[map_pattern[i]];
if(pattern != NULL) {
glBindTexture(GL_TEXTURE_2D, pattern_textures[i]);
blit(map_x[i], map_y[i], pw, ph);
}
}
glBindTexture(GL_TEXTURE_2D, crossfader_texture);
blit(config.ui.crossfader_x, config.ui.crossfader_y, cw, ch);
if(!select) {
glBindTexture(GL_TEXTURE_2D, spectrum_texture);
blit(config.ui.spectrum_x, config.ui.spectrum_y, sw, sh);
glBindTexture(GL_TEXTURE_2D, waveform_texture);
blit(config.ui.waveform_x, config.ui.waveform_y, vw, vh);
if(pat_entry) {
for(int i = 0; i < config.ui.n_patterns; i++) {
if(map_selection[i] == selected) {
glBindTexture(GL_TEXTURE_2D, pat_entry_texture);
blit(map_pe_x[i], map_pe_y[i], config.ui.pat_entry_width, config.ui.pat_entry_height);
break;
}
}
}
}
glDisable(GL_BLEND);
if((e = glGetError()) != GL_NO_ERROR) FAIL("OpenGL error: %s\n", gluErrorString(e));
}
GLint moShaderGLSL::GetUniformID(moText uName)
{
return glGetUniformLocationARB(m_ProgramObject, uName);
}
glEnableClientState(GL_TEXTURE_COORD_ARRAY );
glEnableClientState(GL_NORMAL_ARRAY);
glEnableClientState(GL_VERTEX_ARRAY);
glTexCoordPointer(3, GL_FLOAT, 0, (void*)(sizeof(marcFace_VERT) + sizeof(marcFace_NORM)));
glNormalPointer(GL_FLOAT, 0, (void*)sizeof(marcFace_VERT));
glVertexPointer(3, GL_FLOAT, 0, 0);
//SPECULAR_textureID;
//SPECULAR_textureID = glGetUniformLocationARB(marcFace_SHADER,"SpecularMap");
//glUniform1iARB(SPECULAR_textureID, 2);
//glActiveTextureARB(GL_TEXTURE2_ARB);
//glBindTexture(GL_TEXTURE_2D, specularMap[201]);
DOT3_textureID;
DOT3_textureID = glGetUniformLocationARB(marcFace_SHADER,"NormalMap");
glUniform1iARB(DOT3_textureID, 1);
glActiveTextureARB(GL_TEXTURE1_ARB);
glBindTexture(GL_TEXTURE_2D, normalMap[201]);
textureID;
textureID = glGetUniformLocationARB(marcFace_SHADER,"Texture1");
glUniform1iARB(textureID, 0);
glActiveTextureARB(GL_TEXTURE0_ARB);
glBindTexture(GL_TEXTURE_2D, textureMap[201]);
//glLightfv(GL_LIGHT0,GL_POSITION,lightPos_marcFace);
//glLightf (GL_LIGHT0, GL_QUADRATIC_ATTENUATION, lightAttenuation_marcFace);
glDrawArrays(GL_TRIANGLES, 0, 1761);
int main(int argc, char **argv)
{
float r = 0.5, g = 0.5, b = 1, ratio = 0;
int dir = 1;
ALLEGRO_DISPLAY *display;
ALLEGRO_BITMAP *mysha;
ALLEGRO_BITMAP *buffer;
const char *tinter_shader_src[] = {
"uniform sampler2D backBuffer;",
"uniform float r;",
"uniform float g;",
"uniform float b;",
"uniform float ratio;",
"void main() {",
" vec4 color;",
" float avg, dr, dg, db;",
" color = texture2D(backBuffer, gl_TexCoord[0].st);",
" avg = (color.r + color.g + color.b) / 3.0;",
" dr = avg * r;",
" dg = avg * g;",
" db = avg * b;",
" color.r = color.r - (ratio * (color.r - dr));",
" color.g = color.g - (ratio * (color.g - dg));",
" color.b = color.b - (ratio * (color.b - db));",
" gl_FragColor = color;",
"}"
};
const int TINTER_LEN = 18;
double start;
GLint loc;
(void)argc;
(void)argv;
if (!al_init()) {
abort_example("Could not init Allegro\n");
}
al_install_keyboard();
al_init_image_addon();
al_set_new_display_flags(ALLEGRO_OPENGL);
display = al_create_display(320, 200);
if (!display) {
abort_example("Error creating display\n");
}
mysha = al_load_bitmap("data/mysha.pcx");
if (!mysha) {
abort_example("Could not load image.\n");
}
buffer = al_create_bitmap(320, 200);
if (!al_have_opengl_extension("GL_EXT_framebuffer_object")
&& !al_have_opengl_extension("GL_ARB_fragment_shader")) {
abort_example("Fragment shaders not supported.\n");
}
tinter_shader = glCreateShaderObjectARB(GL_FRAGMENT_SHADER_ARB);
glShaderSourceARB(tinter_shader, TINTER_LEN, tinter_shader_src, NULL);
glCompileShaderARB(tinter_shader);
tinter = glCreateProgramObjectARB();
glAttachObjectARB(tinter, tinter_shader);
glLinkProgramARB(tinter);
loc = glGetUniformLocationARB(tinter, "backBuffer");
glUniform1iARB(loc, al_get_opengl_texture(buffer));
start = al_get_time();
while (1) {
double now, diff;
ALLEGRO_KEYBOARD_STATE state;
al_get_keyboard_state(&state);
if (al_key_down(&state, ALLEGRO_KEY_ESCAPE)) {
break;
}
now = al_get_time();
diff = now - start;
start = now;
ratio += diff * 0.5 * dir;
if (dir < 0 && ratio < 0) {
ratio = 0;
dir = -dir;
}
else if (dir > 0 && ratio > 1) {
ratio = 1;
dir = -dir;
}
al_set_target_bitmap(buffer);
glUseProgramObjectARB(tinter);
loc = glGetUniformLocationARB(tinter, "ratio");
glUniform1fARB(loc, ratio);
loc = glGetUniformLocationARB(tinter, "r");
glUniform1fARB(loc, r);
loc = glGetUniformLocationARB(tinter, "g");
glUniform1fARB(loc, g);
loc = glGetUniformLocationARB(tinter, "b");
glUniform1fARB(loc, b);
al_draw_bitmap(mysha, 0, 0, 0);
glUseProgramObjectARB(0);
al_set_target_backbuffer(display);
al_draw_bitmap(buffer, 0, 0, 0);
al_flip_display();
al_rest(0.001);
}
glDetachObjectARB(tinter, tinter_shader);
glDeleteObjectARB(tinter_shader);
al_uninstall_system();
return 0;
}
void CWater::RenderWater(CVec3f cameraPos, CFloat elapsedTime )
{
if( g_fogBlurPass )
{
glDisable( GL_CULL_FACE );
glBegin( GL_QUADS );
glVertex3f(m_sidePoint[0].x, m_sidePoint[0].y, m_sidePoint[0].z);
glVertex3f(m_sidePoint[1].x, m_sidePoint[1].y, m_sidePoint[1].z);
glVertex3f(m_sidePoint[2].x, m_sidePoint[2].y, m_sidePoint[2].z);
glVertex3f(m_sidePoint[3].x, m_sidePoint[3].y, m_sidePoint[3].z);
glEnd();
glEnable( GL_CULL_FACE );
}
else
{
glDisable( GL_CULL_FACE );
// Turn on the first texture unit and bind the REFLECTION texture
glActiveTexture(GL_TEXTURE0);
glEnable(GL_TEXTURE_2D);
glBindTexture(GL_TEXTURE_2D, m_waterTexture[WATER_REFLECTION_ID]);
// Turn on the second texture unit and bind the REFRACTION texture
glActiveTexture(GL_TEXTURE1);
glEnable(GL_TEXTURE_2D);
glBindTexture(GL_TEXTURE_2D, m_waterTexture[WATER_REFRACTION_ID]);
// Turn on the third texture unit and bind the NORMAL MAP texture
glActiveTexture(GL_TEXTURE2);
glEnable(GL_TEXTURE_2D);
glBindTexture(GL_TEXTURE_2D, m_normalMapImg->GetId() );
// Turn on the fourth texture unit and bind the DUDV MAP texture
glActiveTexture(GL_TEXTURE3);
glEnable(GL_TEXTURE_2D);
glBindTexture(GL_TEXTURE_2D, m_dudvMapImg->GetId() );
// Turn on the fifth texture unit and bind the DEPTH texture
glActiveTexture(GL_TEXTURE4);
glEnable(GL_TEXTURE_2D);
glBindTexture(GL_TEXTURE_2D, m_waterTexture[WATER_DEPTH_ID]);
// Set the variable "reflection" to correspond to the first texture unit
GLint uniform = glGetUniformLocationARB(g_render.m_waterProgram, "reflection");
glUniform1iARB(uniform, 0); //second paramter is the texture unit
// Set the variable "refraction" to correspond to the second texture unit
uniform = glGetUniformLocationARB(g_render.m_waterProgram, "refraction");
glUniform1iARB(uniform, 1);
// Set the variable "normalMap" to correspond to the third texture unit
uniform = glGetUniformLocationARB(g_render.m_waterProgram, "normalMap");
glUniform1iARB(uniform, 2);
// Set the variable "dudvMap" to correspond to the fourth texture unit
uniform = glGetUniformLocationARB(g_render.m_waterProgram, "dudvMap");
glUniform1iARB(uniform, 3);
// Set the variable "depthMap" to correspond to the fifth texture unit
uniform = glGetUniformLocationARB(g_render.m_waterProgram, "depthMap");
glUniform1iARB(uniform, 4);
// Give the variable "waterColor" a blue color
uniform = glGetUniformLocationARB(g_render.m_waterProgram, "waterColor");
glUniform4fARB(uniform, 0.1f, 0.2f, 0.3f, 1.0f);
// We don't use lighting, but we do need to calculate
// the diffuse and specular lighting on the water to increase realism.
// position the light so it's near the light in the sky box texture.
CVec3f lightPos(m_fWaterLPos[0], m_fWaterLPos[1], m_fWaterLPos[2]);
// Give the variable "lightPos" our hard coded light position
uniform = glGetUniformLocationARB(g_render.m_waterProgram, "lightPos");
glUniform4fARB(uniform, lightPos.x, lightPos.y, lightPos.z, 1.0f);
// Give the variable "cameraPos" our camera position
uniform = glGetUniformLocationARB(g_render.m_waterProgram, "cameraPos");
glUniform4fARB(uniform, cameraPos.x, cameraPos.y, cameraPos.z, 1.0f);
// Create a static variable for the movement of the water
static float move = 0.0f;
// Use this variable for the normal map and make it slower
// than the refraction map's speed. We want the refraction
// map to be jittery, but not the normal map's waviness.
float move2 = move * kNormalMapScale;
// Set the refraction map's UV coordinates to our global g_WaterUV
float refrUV = m_fWaterUV;
// Set our normal map's UV scale and shrink it by kNormalMapScale
float normalUV = m_fWaterUV * kNormalMapScale;
// Move the water by our global speed
move += m_fWaterSpeed * elapsedTime;
glUseProgram( g_render.m_waterProgram );
// Draw our huge water quad
glBegin(GL_QUADS);
// The back left vertex for the water
glMultiTexCoord2fARB(GL_TEXTURE0_ARB, 0.0f, m_fWaterUV); // Reflection texture
glMultiTexCoord2fARB(GL_TEXTURE1_ARB, 0.0f, refrUV - move); // Refraction texture
glMultiTexCoord2fARB(GL_TEXTURE2_ARB, 0.0f, normalUV + move2); // Normal map texture
glMultiTexCoord2fARB(GL_TEXTURE3_ARB, 0, 0); // DUDV map texture
glMultiTexCoord2fARB(GL_TEXTURE4_ARB, 0, 0); // Depth texture
glVertex3f(m_sidePoint[0].x, m_sidePoint[0].y, m_sidePoint[0].z);
// The front left vertex for the water
glMultiTexCoord2fARB(GL_TEXTURE0_ARB, 0.0f, 0.0f); // Reflection texture
glMultiTexCoord2fARB(GL_TEXTURE1_ARB, 0.0f, 0.0f - move); // Refraction texture
glMultiTexCoord2fARB(GL_TEXTURE2_ARB, 0.0f, 0.0f + move2); // Normal map texture
glMultiTexCoord2fARB(GL_TEXTURE3_ARB, 0, 0); // DUDV map texture
glMultiTexCoord2fARB(GL_TEXTURE4_ARB, 0, 0); // Depth texture
glVertex3f(m_sidePoint[1].x, m_sidePoint[1].y, m_sidePoint[1].z);
// The front right vertex for the water
glMultiTexCoord2fARB(GL_TEXTURE0_ARB, m_fWaterUV, 0.0f); // Reflection texture
glMultiTexCoord2fARB(GL_TEXTURE1_ARB, refrUV, 0.0f - move); // Refraction texture
glMultiTexCoord2fARB(GL_TEXTURE2_ARB, normalUV, 0.0f + move2); // Normal map texture
glMultiTexCoord2fARB(GL_TEXTURE3_ARB, 0, 0); // DUDV map texture
glMultiTexCoord2fARB(GL_TEXTURE4_ARB, 0, 0); // Depth texture
glVertex3f(m_sidePoint[2].x, m_sidePoint[2].y, m_sidePoint[2].z);
// The back right vertex for the water
glMultiTexCoord2fARB(GL_TEXTURE0_ARB, m_fWaterUV, m_fWaterUV); // Reflection texture
glMultiTexCoord2fARB(GL_TEXTURE1_ARB, refrUV, refrUV - move); // Refraction texture
glMultiTexCoord2fARB(GL_TEXTURE2_ARB, normalUV, normalUV + move2); // Normal map texture
glMultiTexCoord2fARB(GL_TEXTURE3_ARB, 0, 0); // DUDV map texture
glMultiTexCoord2fARB(GL_TEXTURE4_ARB, 0, 0); // Depth texture
glVertex3f(m_sidePoint[3].x, m_sidePoint[3].y, m_sidePoint[3].z);
glEnd();
// Turn the fifth multi-texture pass off
glActiveTexture(GL_TEXTURE4);
glBindTexture( GL_TEXTURE_2D, 0 );
glDisable(GL_TEXTURE_2D);
// Turn the fourth multi-texture pass off
glActiveTexture(GL_TEXTURE3);
glBindTexture( GL_TEXTURE_2D, 0 );
glDisable(GL_TEXTURE_2D);
// Turn the third multi-texture pass off
glActiveTexture(GL_TEXTURE2);
glBindTexture( GL_TEXTURE_2D, 0 );
glDisable(GL_TEXTURE_2D);
// Turn the second multi-texture pass off
glActiveTexture(GL_TEXTURE1);
glBindTexture( GL_TEXTURE_2D, 0 );
glDisable(GL_TEXTURE_2D);
// Turn the first multi-texture pass off
glActiveTexture(GL_TEXTURE0);
glBindTexture( GL_TEXTURE_2D, 0 );
glDisable(GL_TEXTURE_2D);
glEnable( GL_CULL_FACE );
glDisable(GL_TEXTURE_2D);
}
}
int setup(void)
{
GLuint major, minor;
GLint success;
GLuint model_id;
srand( (unsigned)time( NULL ) );
// Make sure required functionality is available!
if (!getGLversion( &major, &minor))
return -1;
if (major < 2)
{
printf("<!> OpenGL 2.0 or higher is required\n");
return -1;
}
windowpos = IsExtSupported("GL_ARB_window_pos");
// Make sure required functionality is available!
if (!(IsExtSupported("GL_ARB_vertex_program")))
{
printf("<!> ARB vertex program extension not supported\n");
return -1;
}
if (!(IsExtSupported("GL_ARB_fragment_program")))
{
printf("<!> ARB fragment program extension not supported\n");
return -1;
}
if (!(IsExtSupported("GL_ARB_vertex_shader")))
{
printf("<!> ARB vertex shader extension not supported\n");
return -1;
}
if (!(IsExtSupported("GL_ARB_fragment_shader")))
{
printf("<!> ARB fragment shader extension not supported\n");
return -1;
}
if (!(IsExtSupported("GL_EXT_framebuffer_object")))
{
printf("<!> Framebuffer object extension not supported\n");
return -1;
}
//Define extension prointers
glGenFramebuffersEXT = (PFNGLGENFRAMEBUFFERSEXTPROC)glXGetProcAddressARB("glGenFramebuffersEXT");
glBindFramebufferEXT = (PFNGLBINDFRAMEBUFFEREXTPROC)glXGetProcAddressARB("glBindFramebufferEXT");
glFramebufferTexture2DEXT = (PFNGLFRAMEBUFFERTEXTURE2DEXTPROC)glXGetProcAddressARB("glFramebufferTexture2DEXT");
glGenRenderbuffersEXT = (PFNGLGENRENDERBUFFERSEXTPROC)glXGetProcAddressARB("glGenRenderbuffersEXT");
glBindRenderbufferEXT = (PFNGLBINDRENDERBUFFEREXTPROC)glXGetProcAddressARB("glBindRenderbufferEXT");
glRenderbufferStorageEXT = (PFNGLRENDERBUFFERSTORAGEEXTPROC)glXGetProcAddressARB("glRenderbufferStorageEXT");
glFramebufferRenderbufferEXT = (PFNGLFRAMEBUFFERRENDERBUFFEREXTPROC)glXGetProcAddressARB("glFramebufferRenderbufferEXT");
glDeleteFramebuffersEXT = (PFNGLDELETEFRAMEBUFFERSEXTPROC)glXGetProcAddressARB("glDeleteFramebuffersEXT");
glDeleteRenderbuffersEXT = (PFNGLDELETERENDERBUFFERSEXTPROC)glXGetProcAddressARB("glDeleteRenderbuffersEXT");
glCheckFramebufferStatusEXT = (PFNGLCHECKFRAMEBUFFERSTATUSEXTPROC)glXGetProcAddressARB("glCheckFramebufferStatusEXT");
if ( !glGenFramebuffersEXT || !glBindFramebufferEXT ||
!glFramebufferTexture2DEXT || !glGenRenderbuffersEXT ||
!glBindRenderbufferEXT || !glRenderbufferStorageEXT ||
!glFramebufferRenderbufferEXT || !glDeleteFramebuffersEXT ||
!glDeleteRenderbuffersEXT || !glCheckFramebufferStatusEXT )
{
printf("<!> Required extension not supported\n");
return -1;
}
//Enable smooth shading
glShadeModel(GL_SMOOTH);
//Enable depth testing
glEnable(GL_DEPTH_TEST);
glPolygonOffset( scalePoly, biasPoly );
//Enable backface culling
glEnable(GL_CULL_FACE);
glCullFace(GL_BACK);
glFrontFace( GL_CW );
//Background color (Ligth blue)
glClearColor(0.0f, 0.4f, 0.8f, 1.0f);
//Generate texture objects
texture_id = (GLuint *)malloc( NUM_TEXTURES * sizeof(GLuint) );
glGenTextures( NUM_TEXTURES, texture_id );
// Enable Anisotropic filtering (for 2D textures only)
if( enable_anisotropic )
{
glGetFloatv(GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT, &MaxAnisoLevel);
if( AnisoLevel > MaxAnisoLevel)
AnisoLevel = MaxAnisoLevel;
if( print_info )
printf("<-> %.0fX anisotropic filtering enabled\n", AnisoLevel);
}
else
AnisoLevel = 0.0f;
// Enable FSAA
if (enable_fsaa)
glEnable(GL_MULTISAMPLE);
//Load MD2 models and textures
for (model_id = 0; model_id < NUM_MODELS; ++model_id)
{
// Load the .md2 model
if ( (md2_model[model_id] = (MD2_MODEL_PTR)malloc(sizeof(MD2_MODEL))) == NULL)
{
printf("<!> Unable to allocate memory for MD2 model in %s\n", filename[3*model_id]);
return -1;
}
if ( !LoadMD2(md2_model[model_id], filename[3*model_id]) )
{
printf("<!> Unable to load MD2 model from %s\n", filename[3*model_id]);
return -1;
}
if( print_info )
printf("<-> Loaded MD2 model from \"%s\" for model #%d\n", filename[3*model_id], model_id);
// Load texture from disk
if ( !LoadImageFromDisk(md2_model[model_id]->skin, filename[3*model_id+1]) )
{
printf("<!> Unable to load texture from %s \n", filename[3*model_id+1]);
return -1;
}
if( print_info )
printf("<-> Loaded texture from \"%s\" for model #%d\n", filename[3*model_id+1], model_id);
//Set up model texture parameters
glBindTexture(GL_TEXTURE_2D, texture_id[2*model_id]);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexImage2D( GL_TEXTURE_2D, 0, md2_model[model_id]->skin->components,
md2_model[model_id]->skin->width, md2_model[model_id]->skin->height,
0, md2_model[model_id]->skin->format, GL_UNSIGNED_BYTE,
md2_model[model_id]->skin->data);
// Load normal from disk
if ( !LoadImageFromDisk(md2_model[model_id]->normal, filename[3*model_id+2]) )
{
printf("<!> Unable to load texture from %s \n", filename[3*model_id+2]);
return -1;
}
if( print_info )
printf("<-> Loaded texture from \"%s\" for model #%d\n", filename[3*model_id+2], model_id);
//Set up model texture parameters
glBindTexture(GL_TEXTURE_2D, texture_id[2*model_id+1]);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexImage2D( GL_TEXTURE_2D, 0, md2_model[model_id]->normal->components,
md2_model[model_id]->normal->width, md2_model[model_id]->normal->height,
0, md2_model[model_id]->normal->format, GL_UNSIGNED_BYTE,
md2_model[model_id]->normal->data);
}
// Load floor texture from disk
floor_texture = (IMAGE_PTR)malloc(sizeof(IMAGE));
floor_texture->data = NULL;
if ( !LoadImageFromDisk(floor_texture, filename[3*NUM_MODELS]) )
{
printf("<!> Unable to load texture from %s\n", filename[3*NUM_MODELS]);
return -1;
}
if( print_info )
printf("<-> Loaded texture from \"%s\"\n", filename[3*NUM_MODELS]);
//Set up floor texture parameters
glBindTexture(GL_TEXTURE_2D, texture_id[NUM_TEXTURES-2]);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
if (enable_anisotropic)
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAX_ANISOTROPY_EXT, AnisoLevel);
glTexImage2D( GL_TEXTURE_2D, 0, floor_texture->components,
floor_texture->width, floor_texture->height,
0, floor_texture->format, GL_UNSIGNED_BYTE,
floor_texture->data);
if (floor_texture->data)
{
free(floor_texture->data);
floor_texture->data = NULL;
}
// Load floor normal map from disk
floor_texture = (IMAGE_PTR)malloc(sizeof(IMAGE));
floor_texture->data = NULL;
if ( !LoadImageFromDisk(floor_texture, filename[3*NUM_MODELS+1]) )
{
printf("<!> Unable to load texture from %s\n", filename[3*NUM_MODELS+1]);
return -1;
}
if( print_info )
printf("<-> Loaded texture from \"%s\"\n", filename[3*NUM_MODELS+1]);
//Set up floor texture parameters
glBindTexture(GL_TEXTURE_2D, texture_id[NUM_TEXTURES-1]);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
if (enable_anisotropic)
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAX_ANISOTROPY_EXT, AnisoLevel);
glTexImage2D( GL_TEXTURE_2D, 0, floor_texture->components,
floor_texture->width, floor_texture->height,
0, floor_texture->format, GL_UNSIGNED_BYTE,
floor_texture->data);
if (floor_texture->data)
{
free(floor_texture->data);
floor_texture->data = NULL;
}
// Load and compile low-level shaders
glGenProgramsARB(NUM_SHADERS, ids);
if (!CompileShader(GL_VERTEX_PROGRAM_ARB, ids[0], DATA_DIR "data/shaders/light.vp"))
return -1;
if (!CompileShader(GL_FRAGMENT_PROGRAM_ARB, ids[1], DATA_DIR "data/shaders/lightMasked.fp"))
return -1;
// Create program object and compile GLSL shaders
progObj = glCreateProgramObjectARB();
if (!CompileGLSLshaders(&progObj,
DATA_DIR "data/shaders/bumpTBN_SH_VP.glsl",
DATA_DIR "data/shaders/bumpTBN_SH_FP.glsl", GL_FALSE))
return -1;
// Retrieve uniform and attributes locations
glUseProgramObjectARB(progObj);
colorMap = glGetUniformLocationARB(progObj, "colorMap");
bumpMap = glGetUniformLocationARB(progObj, "bumpMap");
shadowMap = glGetUniformLocationARB(progObj, "shadowMap");
tangent = glGetAttribLocation(progObj, "tangent");
binormal = glGetAttribLocation(progObj, "binormal");
for (model_id = 0; model_id < NUM_MODELS; ++model_id)
{
md2_model[model_id]->tangent = tangent;
md2_model[model_id]->binormal = binormal;
}
// Set texture units
glUniform1i( colorMap, 0 );
glUniform1i( bumpMap, 1 );
glUniform1i( shadowMap, 2 );
//Validate shaders
glValidateProgramARB(progObj);
glGetObjectParameterivARB(progObj, GL_OBJECT_VALIDATE_STATUS_ARB, &success);
if (!success)
{
GLbyte infoLog[MAX_INFO_LOG_SIZE];
glGetInfoLogARB(progObj, MAX_INFO_LOG_SIZE, NULL, (char *)infoLog);
printf("<!> Error in program validation\n");
printf("Info log: %s\n", infoLog);
return -1;
}
//Disable GLSL and enable low-level shaders
glUseProgramObjectARB(0);
glEnable(GL_VERTEX_PROGRAM_ARB);
glEnable(GL_FRAGMENT_PROGRAM_ARB);
glBindProgramARB(GL_VERTEX_PROGRAM_ARB, ids[0]);
glBindProgramARB(GL_FRAGMENT_PROGRAM_ARB, ids[1]);
// Create FrameBuffer
if (!CreateFB( shadow_sz, &FBO, &shadow_tx ))
return -1;
//Prebuild the display lists
FList = glGenLists(1);
glNewList(FList, GL_COMPILE);
DrawGround();
glEndList();
//Init animations and kinematic state
md2_model[0]->anim_state = ANIMATION_RUN;
md2_model[0]->anim_command = ANIMATION_START;
md2_model[0]->delta_rate = 30.f;
md2_model[0]->position.x = 85.f;
md2_model[0]->position.z = 0.f;
md2_model[0]->rotation = 90.f;
md2_model[1]->anim_state = ANIMATION_RUN;
md2_model[1]->anim_command = ANIMATION_START;
md2_model[1]->delta_rate = 30.f;
md2_model[1]->position.x = 85.f;
md2_model[1]->position.z = 0.f;
md2_model[1]->rotation = 90.f;
md2_model[2]->anim_state = ANIMATION_STANDING_IDLE;
md2_model[2]->anim_command = ANIMATION_START;
// Set initial camera position and orientation
xCam = 0.0f;
yCam = 70.0f;
zCam = 200.0f;
eCam = -0.35f;
aCam = 0.0f;
lCam = 0.0f;
vCam = 0.0f;
dCam = 0.0f;
//Set initial light
aLit = 0.0f;
eLit = 0.75f;
// Initialise timer
gettimeofday(&tv, NULL);
t0 = (double)tv.tv_sec + tv.tv_usec / 1000000.0f;
t1 = t0;
t2 = t0;
return 0;
}