bool RenderManager::DrawMesh(int meshID)
{
Mesh* m = Mesh::GetMeshPointer(meshID);
if (m != NULL) {
Material mat = m->GetMaterial();
UniformLocations uniforms = mat.GetUniforms();
mat.Apply();
// Build the modelview matrix for the mesh
GameObject* g = m->GetParentPointer();
BuildModelViewMatrix(*g);
// Find the uniform locations for this program and put relevant data into said locations
SetUniforms(uniforms);
// Bind the VAO and draw the array
glBindVertexArray(VAOMap[meshID]);
glDrawElements(GL_TRIANGLES, m->GetNumberOfVerts(), GL_UNSIGNED_INT, (void*)0);
// unbind our shaders and arrays
glBindVertexArray(0);
glUseProgram(0);
return true;
} else {
// If the mesh pointer is NULL then retrun false so we know to remove it from the renderlist
return false;
}
}
//.......................................................................................
void Object::RenderVertices()
{
if (m_bInitializedGPU)
{
static GLuint aPos = (m_vertexFlags & VERTEX_POSITION ? m_pShaderProgram->GetAttribute("attributePosition") : -1);
static GLuint aNorm = (m_vertexFlags & VERTEX_NORMAL ? m_pShaderProgram->GetAttribute("attributeNormal") : -1);
static GLuint aTexCoord = (m_vertexFlags & VERTEX_TEXCOORD ? m_pShaderProgram->GetAttribute("attributeTexCoord") : -1);
glUseProgram(m_pShaderProgram->ProgramID());
SetUniforms();
glBindVertexArray(m_vaoObject);
// bind vertex attributes
if (m_vertexFlags & VERTEX_POSITION) glEnableVertexAttribArray(aPos);
if (m_vertexFlags & VERTEX_NORMAL) glEnableVertexAttribArray(aNorm);
if (m_vertexFlags & VERTEX_TEXCOORD) glEnableVertexAttribArray(aTexCoord);
glPointSize(1.0f);
glDrawArrays(GL_POINTS, 0, m_nVertices);
}
} // end Object::RenderVertices()
void MeshActor::Render()
{
glUseProgram(shaderProgram);
FreeBuffers();
SetUniforms();
SetBufferData();
DrawBuffers();
CleanUp();
FreeBuffers();
}
bool Shader::Compile()
{
compiled = false;
char buf[256];
int flag = 0;
fragmentID = glCreateShader(GL_FRAGMENT_SHADER);
vertexID = glCreateShader(GL_VERTEX_SHADER);
const GLchar* vertexPtr = this->vertexSource.c_str();
const GLchar* fragPtr = this->fragmentSource.c_str();
glShaderSource(vertexID, 1, &vertexPtr, 0);
glShaderSource(fragmentID, 1, &fragPtr, 0);
memset((void*)errorLog, 0, sizeof(char) * 1024);
glID = glCreateProgram();
sprintf(buf, "VertexShader:\n");
strncat(errorLog, buf, strlen(buf));
glCompileShader(vertexID);
glGetShaderInfoLog(vertexID, 256, NULL, buf);
strncat(errorLog, buf, 256);
glGetShaderiv(vertexID, GL_COMPILE_STATUS, &flag);
if (!flag)
return false;
sprintf(buf, "FragmentShader:\n");
strncat(errorLog, buf, strlen(buf));
glCompileShader(fragmentID);
glGetShaderInfoLog(fragmentID, 256, NULL, buf);
strncat(errorLog, buf, 256);
glGetShaderiv(fragmentID, GL_COMPILE_STATUS, &flag);
if (!flag)
return false;
sprintf(buf, "Link:\n");
strncat(errorLog, buf, strlen(buf));
glAttachShader(glID, vertexID);
glAttachShader(glID, fragmentID);
glLinkProgram(glID);
glGetProgramInfoLog(glID, 256, NULL, buf);
strncat(errorLog, buf, 256);
glGetProgramiv(glID, GL_LINK_STATUS, &flag);
if (!flag)
return false;
SetUniforms();
compiled = true;
return true;
}
void RenderManager::DrawTerrain()
{
float xmul = 0;
float ymul = 0;
Vector2 b = terrainManager->GetBase(0, 0);
Vector2 b2 = terrainManager->GetBase(1, 1);
float dif = b.u - b2.u;
for (int i = 0; i < terrainManager->GetSize(); i++) {
for (int j = 0; j < terrainManager->GetSize(); j++) {
Material mat = terrainManager->GetMaterial(i, j);
UniformLocations uniforms = mat.GetUniforms();
mat.Apply();
xmul = terrainManager->GetBase(i, j).u;
ymul = terrainManager->GetBase(i, j).v;
GameObject base;
base.SetLocation(xmul, 0.0f, ymul);
// Build the modelview matrix for the mesh
BuildModelViewMatrix(base);
// Find the uniform locations for this program and put relevant data into said locations
SetUniforms(uniforms);
glUniform1f(uniforms.XMulFactor, xmul);
glUniform1f(uniforms.YMulFactor, ymul);
// Bind the VAO and draw the array
glBindVertexArray(terrain);
glPatchParameteri(GL_PATCH_VERTICES, 3);
glDrawElements(GL_PATCHES, terrainManager->GetTerrainMesh().GetIndexLength(), GL_UNSIGNED_INT, (void*)0);
// unbind our shaders and arrays
glBindVertexArray(0);
glUseProgram(0);
}
}
}
void DrawScene()
{
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glPatchParameteri(GL_PATCH_VERTICES, 4);
glUniform4f(u("Color"), 1.3f, 1.3f, 1.3f, 1.0f);
glBindVertexArray(Scene.StatueVao);
glDrawArrays(GL_PATCHES, 0, Scene.StatueVertexCount);
if (CurrentProgram() == Scene.OffscreenProgram) {
glUseProgram(Scene.FloorProgram);
SetUniforms();
}
glUniform4f(u("Color"), 0.0f/255.0f,165.0f/255.0f,211.0f/255.0f, 1.0f);
glBindVertexArray(Scene.FloorVao);
glVertexAttrib3f(NormalSlot, 0, -1, 0);
glDrawElements(GL_PATCHES, Scene.FloorIndexCount, GL_UNSIGNED_INT, 0);
}
//.......................................................................................
void Object::RenderIndices()
{
static GLuint aPos = (m_vertexFlags & VERTEX_POSITION ? m_pShaderProgram->GetAttribute("attributePosition") : -1);
static GLuint aNorm = (m_vertexFlags & VERTEX_NORMAL ? m_pShaderProgram->GetAttribute("attributeNormal") : -1);
static GLuint aTexCoord = (m_vertexFlags & VERTEX_TEXCOORD ? m_pShaderProgram->GetAttribute("attributeTexCoord") : -1);
glUseProgram(m_pShaderProgram->ProgramID());
SetUniforms();
glBindVertexArray(m_vaoObject);
// bind vertex attributes
if (m_vertexFlags & VERTEX_POSITION) glEnableVertexAttribArray(aPos);
if (m_vertexFlags & VERTEX_NORMAL) glEnableVertexAttribArray(aNorm);
if (m_vertexFlags & VERTEX_TEXCOORD) glEnableVertexAttribArray(aTexCoord);
glDrawElements(GL_TRIANGLES, m_nIndices, GL_UNSIGNED_INT, (GLvoid *)0);
} // end Object::Render()
static void Render(const Model& a_model)
{
// Set uniform values
SetUniforms();
glUniformMatrix4fv(sg_modelLocation, 1, false, glm::value_ptr(a_model.modelMatrix));
glUniform4fv(sg_diffuseColorLocation, 1, &(a_model.texture.diffuseColor[0]));
glUniform4fv(sg_specularColorLocation, 1, &(a_model.texture.specularColor[0]));
if (GL_TRUE == glIsTexture(a_model.texture.imageID))
{
glUniform1ui(sg_hasTextureLocation, GL_TRUE);
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, a_model.texture.imageID);
}
else
{
glUniform1ui(sg_hasTextureLocation, GL_FALSE);
}
// draw triangles
glBindVertexArray(a_model.mesh.vertexArrayID);
glDrawElements(GL_TRIANGLES, a_model.mesh.indexCount, GL_UNSIGNED_INT, 0);
glBindVertexArray(0);
}
void RenderManager::DrawSkyBox()
{
Mesh* m = Mesh::GetMeshPointer(sky);
Material mat = m->GetMaterial();
UniformLocations uniforms = mat.GetUniforms();
mat.Apply();
// Build the modelview matrix for the mesh
BuildSkyBoxViewMatrix(*activeCamera->GetParent());
// Find the uniform locations for this program and put relevant data into said locations
SetUniforms(uniforms);
// Bind the VAO and draw the array
glBindVertexArray(skyBox);
glDisable(GL_DEPTH_TEST);
glDrawElements(GL_TRIANGLES, m->GetNumberOfVerts(), GL_UNSIGNED_INT, (void*)0);
glEnable(GL_DEPTH_TEST);
// unbind our shaders and arrays
glBindVertexArray(0);
glUseProgram(0);
}
void PezRender()
{
glGetError();
// Pass 1: draw into offscreen FBO
if (ShowAO || ComputeAO)
{
glUseProgram(Scene.OffscreenProgram);
SetUniforms();
glBindFramebuffer(GL_FRAMEBUFFER, Scene.Surfaces.FboHandle);
GLenum renderTargets[3] = {GL_COLOR_ATTACHMENT0, GL_COLOR_ATTACHMENT1, GL_COLOR_ATTACHMENT2};
glDrawBuffers(3, &renderTargets[0]);
DrawScene();
}
pezCheck(glGetError() == GL_NO_ERROR, "OpenGL error.\n");
// Read the offscreen buffers into CPU memory
if (ComputeAO)
{
ComputeAO = 0;
PezConfig cfg = PezGetConfig();
static float* PositionData = (float*) malloc(sizeof(float) * 3 * cfg.Width * cfg.Height);
glReadBuffer(GL_COLOR_ATTACHMENT0 + FboDesc::Positions);
glReadPixels(0, 0, cfg.Width, cfg.Height, GL_RGB, GL_FLOAT, PositionData);
static float* NormalData = (float*) malloc(sizeof(float) * 3 * cfg.Width * cfg.Height);
glReadBuffer(GL_COLOR_ATTACHMENT0 + FboDesc::Normals);
glReadPixels(0, 0, cfg.Width, cfg.Height, GL_RGB, GL_FLOAT, NormalData);
static float* ColorData = (float*) malloc(sizeof(float) * 3 * cfg.Width * cfg.Height);
glReadBuffer(GL_COLOR_ATTACHMENT0 + FboDesc::Colors);
glReadPixels(0, 0, cfg.Width, cfg.Height, GL_RGB, GL_FLOAT, ColorData);
static float* CompositeData = (float*) malloc(sizeof(float) * 4 * cfg.Width * cfg.Height);
float* pPosition = PositionData;
float* pNormal = NormalData;
float* pColor = ColorData;
float* pComposite = CompositeData;
for (int x = 0; x < cfg.Width; ++x) {
for (int y = 0; y < cfg.Height; ++y) {
AO_MaxDist = 0.025f;
AO_NumPoints = 16;
if (pColor[0] > 0.0f || pColor[1] > 0.0f || pColor[2] > 0.0f) {
float occlusion = 0.5f;
PtcGetNearestPointsData(Scene.PointCloud, pPosition, pNormal, AO_MaxDist, AO_NumPoints, &occlusion);
occlusion = 1.0f - occlusion;
pComposite[0] = pColor[0] * occlusion;
pComposite[1] = pColor[1] * occlusion;
pComposite[2] = pColor[2] * occlusion;
pComposite[3] = 1.0f;
} else {
pComposite[0] = 0;
pComposite[1] = 0;
pComposite[2] = 0;
pComposite[3] = 0;
}
pPosition += 3;
pNormal += 3;
pColor += 3;
pComposite += 4;
}
}
pezCheck(glGetError() == GL_NO_ERROR, "OpenGL error.\n");
glBindTexture(GL_TEXTURE_2D, Scene.CompositeTexture);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA32F, cfg.Width, cfg.Height, GL_FALSE, GL_RGBA, GL_FLOAT, CompositeData);
pezCheck(glGetError() == GL_NO_ERROR, "OpenGL error.\n");
glBindFramebuffer(GL_FRAMEBUFFER, 0);
}
glBindFramebuffer(GL_FRAMEBUFFER, 0);
GLenum renderTargets[3] = {GL_BACK_LEFT, GL_NONE, GL_NONE};
glDrawBuffers(3, &renderTargets[0]);
pezCheck(glGetError() == GL_NO_ERROR, "OpenGL error.\n");
// Draw into backbuffer
if (ShowAO) {
glBindTexture(GL_TEXTURE_2D, Scene.CompositeTexture);
glUseProgram(Scene.QuadProgram);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glBindVertexArray(Scene.QuadVao);
glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
} else {
glUseProgram(Scene.DisplayProgram);
SetUniforms();
DrawScene();
}
pezCheck(glGetError() == GL_NO_ERROR, "OpenGL error.\n");
glUseProgram(0);
glBindVertexArray(0);
TwDraw();
glGetError();
}
//---------------------------------------------------------------------------
void Material::ActivateMaterial()
{
BindTextures();
UseProgram();
SetUniforms();
}
