void setMatrices()
{
mat4 mv = view * model;
prog.setUniform("ModelViewMatrix", mv);
prog.setUniform("NormalMatrix",
mat3( vec3(mv[0]), vec3(mv[1]), vec3(mv[2]) ));
prog.setUniform("MVP", projection * mv);
}
void PlaneModelData::useMaterial(GLSLProgram const& prog) const
{
prog.setUniform("material.ambient", *reinterpret_cast<glm::vec3 const*>(material.ambient));
prog.setUniform("material.diffuse", *reinterpret_cast<glm::vec3 const*>(material.diffuse));
prog.setUniform("material.specular", *reinterpret_cast<glm::vec3 const*>(material.specular));
prog.setUniform("material.shininess", material.shininess);
glActiveTexture(GL_TEXTURE0 + 5);
glBindTexture(GL_TEXTURE_2D, (GLuint) material.texture1_map.user_ptr);
}
///////////////////////////////////////////////////////////////////////////////
// Called to draw scene
void RenderScene(void)
{
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
mat4 mv = view * model;
prog.setUniform("ModelViewMatrix", mv);
prog.setUniform("NormalMatrix", mat3( vec3(mv[0]), vec3(mv[1]), vec3(mv[2]) ));
prog.setUniform("MVP", projection * mv);
current->render();
}
void PlaneModelData::drawInstances(GLSLProgram const& prog) const
{
glBindVertexArray(modelVAO);
useMaterial(prog);
BOOST_FOREACH(DrawInstance const& inst, drawInst)
{
prog.setUniform("modelMatrix", inst.modelMatrix);
prog.setUniform("tint", inst.tint);
glDrawElements(GL_TRIANGLE_STRIP, NUM_INDICES, GL_UNSIGNED_BYTE, NULL);
}
void OgroInvasion::customInit()
{
filename = g_programName + "/" + "Lenna.png";
try
{
glslProgram.loadShader(GLSLShaderType::VERTEX, g_programName + "/" + "shader.vert");
glslProgram.loadShader(GLSLShaderType::FRAGMENT, g_programName + "/" + "shader.frag");
}
catch (GLSLProgramException& e)
{
printf("%s\n", e.what());
system("pause");
exit(EXIT_FAILURE);
}
glslProgram.link();
GLint vertexAttribLoc = glslProgram.getAttributeLocation("vVertex");
//quad vertices and indices
glm::vec2 vertices[4];
GLushort indices[6];
vertices[0] = glm::vec2(0.0f, 0.0f);
vertices[1] = glm::vec2(1.0f, 0.0f);
vertices[2] = glm::vec2(1.0f, 1.0f);
vertices[3] = glm::vec2(0.0f, 1.0f);
GLushort* id = indices;
*id++ = 0;
*id++ = 1;
*id++ = 2;
*id++ = 0;
*id++ = 2;
*id++ = 3;
glGenVertexArrays(1, &vaoID);
glBindVertexArray(vaoID);
glGenBuffers(1, &vboVerticesID);
glGenBuffers(1, &vboIndicesID);
glBindBuffer(GL_ARRAY_BUFFER, vboVerticesID);
glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, vboIndicesID);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(indices), indices, GL_STATIC_DRAW);
glVertexAttribPointer(vertexAttribLoc, 2, GL_FLOAT, GL_FALSE, 0, BUFFER_OFFSET(0));
glEnableVertexAttribArray(vertexAttribLoc);
glBindVertexArray(0);
glBindBuffer(GL_ARRAY_BUFFER, 0);
mTexture = new Texture(filename);
mTexture->load();
mTexture->activateTexture(0); // GL_TEXTURE0
glslProgram.setUniform("textureMap", 0); // GL_TEXTURE0
}
///////////////////////////////////////////////////////////////////////////////
// This function does any needed initialization on the rendering context.
// This is the first opportunity to do any OpenGL related tasks.
void SetupRC()
{
glClearColor(0.0f, 0.0f, 0.0f, 1.0f );
prog.compileShaderFromFile("phong.vert", GLSLShader::VERTEX);
prog.compileShaderFromFile("phong.frag", GLSLShader::FRAGMENT);
prog.link();
prog.use();
glEnable(GL_DEPTH_TEST);
teapot = new VBOTeapot(13, mat4(1.0f));
//torus = new VBOTorus(0.7f, 0.3f, 50, 50);
torus = new VBOTorus(1.75f, 0.75f, 50, 50);
current = teapot;
model = mat4(1.0f);
model *= glm::translate(vec3(0.0f,0.0f,0.0f));
model *= glm::rotate(-90.0f, vec3(1.0f,0.0f,0.0f));
view = glm::lookAt(vec3(0.0f,3.0f,5.0f), vec3(0.0f,0.75f,0.0f), vec3(0.0f,1.0f,0.0f));
vec4 worldLight = vec4(5.0f,5.0f,2.0f,1.0f);
prog.setUniform("Material.Kd", 0.9f, 0.5f, 0.3f);
prog.setUniform("Light.Ld", 1.0f, 1.0f, 1.0f);
prog.setUniform("Light.Position", view * worldLight );
prog.setUniform("Material.Ka", 0.9f, 0.5f, 0.3f);
prog.setUniform("Light.La", 0.4f, 0.4f, 0.4f);
prog.setUniform("Material.Ks", 0.8f, 0.8f, 0.8f);
prog.setUniform("Light.Ls", 1.0f, 1.0f, 1.0f);
prog.setUniform("Material.Shininess", 100.0f);
}
///////////////////////////////////////////////////////////////////////////////
// This function does any needed initialization on the rendering context.
// This is the first opportunity to do any OpenGL related tasks.
void SetupRC()
{
glClearColor(0.0f, 0.0f, 0.0f, 1.0f );
glEnable(GL_DEPTH_TEST);
prog.compileShaderFromFile("texture.vs", GLSLShader::VERTEX);
prog.compileShaderFromFile("texture.fs", GLSLShader::FRAGMENT);
prog.link();
prog.use();
cube = new VBOCube();
glActiveTexture(GL_TEXTURE0);
GLuint tex_2d = SOIL_load_OGL_texture("brick1.jpg", SOIL_LOAD_AUTO, SOIL_CREATE_NEW_ID, SOIL_FLAG_MIPMAPS|SOIL_FLAG_INVERT_Y);
// Typical Texture Generation Using Data From The Bitmap
glBindTexture(GL_TEXTURE_2D, tex_2d);
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR);
prog.setUniform("Tex1", 0);
view = glm::lookAt(vec3(1.0f,1.25f,1.25f), vec3(0.0f,0.0f,0.0f), vec3(0.0f,1.0f,0.0f));
projection = mat4(1.0f);
prog.setUniform("Light.Position", vec4(0.0f,0.0f,0.0f,1.0f) );
prog.setUniform("Light.Intensity", vec3(1.0f,1.0f,1.0f) );
prog.setUniform("Material.Kd", 0.9f, 0.9f, 0.9f);
prog.setUniform("Material.Ks", 0.95f, 0.95f, 0.95f);
prog.setUniform("Material.Ka", 0.1f, 0.1f, 0.1f);
prog.setUniform("Material.Shininess", 100.0f);
}
void BlockModelData::drawInstances(GLSLProgram const& prog, Frustum const& cullFrustum) const
{
glBindVertexArray(modelVAO);
useMaterial(prog);
BOOST_FOREACH(DrawInstance const& inst, drawInst)
{
if (OrientedBoundingBox(boundingBox, inst.modelMatrix).frustumIntersect(cullFrustum) == IntersectionResult::OUTSIDE)
{
continue;
}
prog.setUniform("modelMatrix", inst.modelMatrix);
prog.setUniform("tint", inst.tint);
glDrawElements(GL_TRIANGLES, NUM_INDICES, GL_UNSIGNED_BYTE, NULL);
}
glBindVertexArray(0);
}
///////////////////////////////////////////////////////////////////////////////
// Called to draw scene
void RenderScene(void)
{
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
// Time Based animation
static CStopWatch rotTimer;
float yRot = rotTimer.GetElapsedSeconds() * 60.0f;
//model = glm::rotate(mat4(1.0f), yRot, vec3(0.0f, 1.0f, 0.0f));
model = mat4(1.0f);
model *= glm::rotate(-35.0f, vec3(1.0f,0.0f,0.0f));
model *= glm::rotate(yRot, vec3(0.0f, 1.0f, 0.0f));
mat4 mv = view * model;
prog.setUniform("ModelViewMatrix", mv);
prog.setUniform("NormalMatrix", mat3( vec3(mv[0]), vec3(mv[1]), vec3(mv[2]) ));
prog.setUniform("MVP", projection * mv);
torus->render();
}
///////////////////////////////////////////////////////////////////////////////
// This function does any needed initialization on the rendering context.
// This is the first opportunity to do any OpenGL related tasks.
void SetupRC()
{
glClearColor(0.0f, 0.0f, 0.0f, 1.0f );
prog.compileShaderFromFile("subroutine.vert", GLSLShader::VERTEX);
prog.compileShaderFromFile("subroutine.frag", GLSLShader::FRAGMENT);
prog.link();
prog.use();
glEnable(GL_DEPTH_TEST);
plane = new VBOPlane(50.0f, 50.0f, 1, 1);
teapot = new VBOTeapot(14, mat4(1.0f));
view = glm::lookAt(vec3(0.0f,0.0f,10.0f), vec3(0.0f,0.0f,0.0f), vec3(0.0f,1.0f,0.0f));
prog.setUniform("Light.Position", vec4(0.0f,0.0f,0.0f,1.0f));
prog.setUniform("Light.La", 0.4f, 0.4f, 0.4f);
prog.setUniform("Light.Ld", 1.0f, 1.0f, 1.0f);
prog.setUniform("Light.Ls", 1.0f, 1.0f, 1.0f);
prog.setUniform("Material.Kd", 0.9f, 0.5f, 0.3f);
prog.setUniform("Material.Ka", 0.9f, 0.5f, 0.3f);
prog.setUniform("Material.Ks", 0.8f, 0.8f, 0.8f);
prog.setUniform("Material.Shininess", 100.0f);
}
void renderPlane(const struct aiNode *nd)
{
aiMatrix4x4 m = nd->mTransformation;
m.Transpose();
GLfloat aux[16];
memcpy(aux, &m, sizeof(GLfloat) * 16);
mat4 matrix = mstack.top() * glm::make_mat4(aux);
mstack.push(matrix);
for (GLuint n = 0; n < nd->mNumMeshes; ++n) {
GLuint index = nd->mMeshes[n];
const aiMesh* mesh = scene->mMeshes[index];
d_program.setUniform("ModelView", mstack.top());
d_program.setUniform("Projection", pstack.top());
d_program.setUniform("MVP", pstack.top() * mstack.top());
d_program.setUniform("NormalMatrix",
glm::inverseTranspose(mat3(mstack.top()) * mat3(g_modelview)));
if (mesh->mPrimitiveTypes == aiPrimitiveType_TRIANGLE) {
glBindVertexArray(vaos[index]);
glDrawElements(GL_TRIANGLES, index_count[index], GL_UNSIGNED_INT, 0);
}
else if (mesh->mPrimitiveTypes == aiPrimitiveType_POINT) {
glBindVertexArray(vaos[index]);
glDrawElements(GL_POINTS, index_count[index], GL_UNSIGNED_INT, 0);
}
else if (mesh->mPrimitiveTypes == aiPrimitiveType_LINE) {
glBindVertexArray(vaos[index]);
glDrawElements(GL_LINES, index_count[index], GL_UNSIGNED_INT, 0);
}
}
for (GLuint n = 0; n < nd->mNumChildren; ++n)
renderPlane(nd->mChildren[n]);
mstack.pop();
}
void renderFn()
{
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
g_program.use();
setPerspective();
glActiveTexture(GL_TEXTURE9);
glBindTexture(GL_TEXTURE_2D, omap2);
g_program.setUniform("MaxTessLevel", max_tess);
g_program.setUniform("ModelView", g_modelview);
g_program.setUniform("Projection", g_projection);
g_program.setUniform("MVP", g_projection * g_modelview);
g_program.setUniform("NormalMatrix",
glm::inverseTranspose(mat3(g_modelview)));
g_program.setUniform("MousePosition", mouse);
g_program.setUniform("Time", elapsed);
glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
renderLand();
d_program.use();
glUniformSubroutinesuiv(GL_VERTEX_SHADER, 1, &plv);
glUniformSubroutinesuiv(GL_FRAGMENT_SHADER, 1, &plf);
glActiveTexture(GL_TEXTURE9);
glBindTexture(GL_TEXTURE_2D, plane);
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
renderPlane(scene->mRootNode);
glDisable(GL_DEPTH_TEST);
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
d_program.setUniform("FrameTime", clockdiff);
d_program.setUniform("Elapsed", elapsed);
glUniformSubroutinesuiv(GL_VERTEX_SHADER, 1, &pav);
glUniformSubroutinesuiv(GL_FRAGMENT_SHADER, 1, &paf);
renderParticles();
glEnable(GL_DEPTH_TEST);
glDisable(GL_BLEND);
}
int main()
{
// Create and initialize window.
setErrorCallbackAndInit(error_callback);
GraphicsWindow* window = new GraphicsWindow(1200,800,"Test Window",NULL,NULL,key_callback);
window->makeContextCurrent();
// Initalize glew.
initGlew();
// Create and initialize Camera
FreeCamera* camera = new FreeCamera(45.0f, 16.0f/9.0f,
0.0f, 0.0f,
0.1f, 10000.0f,
0.0004f, 3.0f,
glm::vec3(0,0,-50),
glm::vec3(0,1,0),
glm::vec3(0,0,0),
true);
camera->setViewport(window->getWindowWidth(),window->getWindowHeight(),0.5f,0.5f);
// Load accumulation shader for accumulating all the transparent matrials, as well as their alphas.
GLSLProgram* defaultShader = new GLSLProgram();
defaultShader->initShaderProgram("Vert.glsl","","","","Frag.glsl");
// Load screen filling quad shader.
GLSLProgram* screenFillingQuadShader = new GLSLProgram();
screenFillingQuadShader->initShaderProgram("screenFillingQuadVert.glsl","","","","screenFillingQuadFrag.glsl");
// Load accumulation shader for accumulating all the transparent matrials, as well as their alphas.
GLSLProgram* accumTransparencyRevealageShader = new GLSLProgram();
accumTransparencyRevealageShader->initShaderProgram("AccumTransparencyRevealageVert.glsl","","","","AccumTransparencyRevealageFrag.glsl");
// Load Weighted Average shader, which will be used for final compositing (a variation of screen filling quad shader using multiple textures).
GLSLProgram* newOITCoverageShader = new GLSLProgram();
newOITCoverageShader->initShaderProgram("NewOITCoverageVert.glsl","","","","NewOITCoverageFrag.glsl");
// Create screen filling quad.
Quad* screenFillingQuad = new Quad(glm::vec3(-1.0,1.0,0), glm::vec3(-1.0,-1.0,0), glm::vec3(1.0,-1.0,0), glm::vec3(1.0,1.0,0), glm::vec3(0), 0, 0, 0);
screenFillingQuad->initQuad();
screenFillingQuad->setGLSLProgram(*newOITCoverageShader);
TextureManager::GetInstance().loadTexture("../Content/Textures/Particle_Smoke/smoke_particle_red_base.png");
TextureManager::GetInstance().loadTexture("../Content/Textures/Particle_Smoke/smoke_particle_grey_base_2.png");
TextureManager::GetInstance().loadTexture("../Content/Textures/Particle_Smoke/smoke_particle_grey_base_3.png");
Quad* quad1 = new Quad(glm::vec3(100+100,100+100,-1), glm::vec3(100+100,-100+100,-1), glm::vec3(-100+100,-100+100,-1), glm::vec3(-100+100,100+100,-1), glm::vec3(0), 10, 10, 0);
quad1->initQuad();
quad1->initDefaultTexture(255,0,0,89);
quad1->setTexture(TextureManager::GetInstance().getTextureHandle("../Content/Textures/Particle_Smoke/smoke_particle_grey_base_3.png"));
Quad* quad2 = new Quad(glm::vec3(100+100,100+100,-20), glm::vec3(100+100,-100+100,-20), glm::vec3(-100+100,-100+100,-20), glm::vec3(-100+100,100+100,-20), glm::vec3(0), 10, 10, 0);
quad2->initQuad();
quad2->initDefaultTexture(0,255,0,89);
quad2->setTexture(TextureManager::GetInstance().getTextureHandle("../Content/Textures/Particle_Smoke/smoke_particle_grey_base_2.png"));
Quad* quad3 = new Quad(glm::vec3(100+100,100+100,20), glm::vec3(100+100,-100+100,20), glm::vec3(-100+100,-100+100,20), glm::vec3(-100+100,100+100,20), glm::vec3(0), 10, 10, 0);
quad3->initQuad();
quad3->initDefaultTexture(0,0,255,89);
quad3->setTexture(TextureManager::GetInstance().getTextureHandle("../Content/Textures/Particle_Smoke/smoke_particle_red_base.png"));
Quad* quad4 = new Quad(glm::vec3(100+100,100+100,-40), glm::vec3(100+100,-100+100,-40), glm::vec3(-100+100,-100+100,-40), glm::vec3(-100+100,100+100,-40), glm::vec3(0), 10, 10, 0);
quad4->initQuad();
quad4->initDefaultTexture(255,0,127,50);
Quad* quad5 = new Quad(glm::vec3(100+100,100+100,40), glm::vec3(100+100,-100+100,40), glm::vec3(-100+100,-100+100,40), glm::vec3(-100+100,100+100,40), glm::vec3(0), 10, 10, 0);
quad5->initQuad();
quad5->initDefaultTexture(255,127,0,50);
ModelLoader* modelImporter = new ModelLoader();
modelImporter->importModel("../Content/Models/crytek-sponza/sponza.obj", processFlagsOnModelImport);
// Create and initialize model
Model* model = new Model(glm::vec3(0,0,0), "../Content/Models/crytek-sponza/");
model->loadModel(modelImporter->getScene());
// Create framebuffers
std::vector<unsigned int> activeColorAttachmentsOpaque;
std::vector<unsigned int> activeColorAttachmentsTransparent;
Framebuffer* opaqueFrameBuffer = new Framebuffer(window->getWindowWidth(),window->getWindowHeight());
activeColorAttachmentsOpaque.push_back(0);
opaqueFrameBuffer->setColorAttachment(0);
//frameBuffer->setDepthAttachment();
opaqueFrameBuffer->setDepthStencilTexture();
opaqueFrameBuffer->unbind();
Framebuffer* accumFrameBuffer = new Framebuffer(window->getWindowWidth(),window->getWindowHeight());
activeColorAttachmentsTransparent.push_back(0);
activeColorAttachmentsTransparent.push_back(1);
accumFrameBuffer->setColorAttachment(0);
accumFrameBuffer->setColorAttachment(1);
//frameBuffer->setDepthAttachment();
accumFrameBuffer->setDepthStencilTexture();
accumFrameBuffer->unbind();
// Additional textures to pass for the second transparency render pass.
std::vector<GLuint> additionalTextureHandles;
additionalTextureHandles.push_back(accumFrameBuffer->getColorAttachment(0));
additionalTextureHandles.push_back(accumFrameBuffer->getColorAttachment(1));
std::vector<GLuint> opaqueTextureHandle;
opaqueTextureHandle.push_back(opaqueFrameBuffer->getColorAttachment(0));
// Move this to "GraphicsWindow"
glfwSetCursorPos(window->getWindowHandle(), (double) (window->getWindowWidth()/2.0), (double) (window->getWindowHeight()/2.0));
// Move this to "Camera"
//glClearColor(0.4f,0.6f,0.94f,0.0f);
glClearColor(0.0f,0.0f,0.0f,0.0f);
const float clearColorWhite = 1.0f;
const float clearColorBlack = 0.0f;
// Sampler
GLuint sampler = 0;
glGenSamplers(1, &sampler);
glSamplerParameteri(sampler, GL_TEXTURE_WRAP_S, GL_REPEAT);
glSamplerParameteri(sampler, GL_TEXTURE_WRAP_T, GL_REPEAT);
glSamplerParameteri(sampler, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glSamplerParameteri(sampler, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
check_gl_error();
// Render Loop
while(!window->shouldClose())
{
//glClearColor(0.0f,0.0f,0.0f,0.0f);
glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
glEnable(GL_DEPTH_TEST);
glDepthFunc(GL_LEQUAL);
glEnable(GL_CULL_FACE);
glCullFace(GL_BACK);
// Update camera
camera->camControll(window->getWindowHandle());
camera->update();
// Update shader uniforms
model->getCurrentGLSLProgram()->use();
model->getCurrentGLSLProgram()->setUniform("lightPosition", camera->getCamPos());
model->getCurrentGLSLProgram()->setUniform("camPosition", camera->getCamPos());
model->getCurrentGLSLProgram()->setUniform("viewMatrix", camera->getVMatrix());
model->getCurrentGLSLProgram()->setUniform("normalMatrix", camera->getTranspInvMVMatrix()); // Change this!
model->getCurrentGLSLProgram()->setUniform("VPMatrix", camera->getVPMatrix());
opaqueFrameBuffer->clean();
opaqueFrameBuffer->bind();
opaqueFrameBuffer->bindForRenderPass(activeColorAttachmentsOpaque);
model->renderOpaque();
//quad4->render();
//quad5->render();
//opaqueFrameBuffer->unbind();
//// Blitting the opaque scene depth to propperly depth test the transparen against it.
//opaqueFrameBuffer->bindForReading();
//accumFrameBuffer->bindForWriting();
//glBlitFramebuffer(0, 0, window->getWindowWidth(), window->getWindowHeight(), 0, 0, window->getWindowWidth(), window->getWindowHeight(),
// GL_DEPTH_BUFFER_BIT, GL_NEAREST);
//opaqueFrameBuffer->unbind();
//_______________________________________________________________________________________________________________________________________________________________________________
// Acuumulation pass
accumTransparencyRevealageShader->use();
accumTransparencyRevealageShader->setUniform("VPMatrix", camera->getVPMatrix());
model->setGLSLProgram(accumTransparencyRevealageShader);
quad1->setGLSLProgram(*accumTransparencyRevealageShader);
quad2->setGLSLProgram(*accumTransparencyRevealageShader);
quad3->setGLSLProgram(*accumTransparencyRevealageShader);
quad4->setGLSLProgram(*accumTransparencyRevealageShader);
quad5->setGLSLProgram(*accumTransparencyRevealageShader);
accumFrameBuffer->clean();
accumFrameBuffer->bind();
accumFrameBuffer->bindForRenderPass(activeColorAttachmentsTransparent);
accumFrameBuffer->cleanColorAttachment(1,clearColorWhite);
opaqueFrameBuffer->unbind();
// Blitting the opaque scene depth to propperly depth test the transparen against it.
opaqueFrameBuffer->bindForReading();
accumFrameBuffer->bindForWriting();
glBlitFramebuffer(0, 0, window->getWindowWidth(), window->getWindowHeight(), 0, 0, window->getWindowWidth(), window->getWindowHeight(),
GL_DEPTH_BUFFER_BIT, GL_NEAREST);
opaqueFrameBuffer->unbind();
accumFrameBuffer->bind();
accumFrameBuffer->bindForRenderPass(activeColorAttachmentsTransparent);
glEnable(GL_BLEND);
glBlendFunci(0, GL_ONE, GL_ONE);
glBlendFunci(1, GL_ZERO, GL_ONE_MINUS_SRC_ALPHA);
//glEnable(GL_DEPTH_TEST);
glDepthMask(GL_FALSE);
glDisable(GL_CULL_FACE);
model->renderTransparent();
quad1->render();
quad2->render();
quad3->render();
//quad4->render();
//quad5->render();
accumFrameBuffer->unbind();
model->setGLSLProgram(defaultShader);
quad1->setGLSLProgram(*defaultShader);
quad2->setGLSLProgram(*defaultShader);
quad3->setGLSLProgram(*defaultShader);
quad4->setGLSLProgram(*defaultShader);
quad5->setGLSLProgram(*defaultShader);
glDisable(GL_BLEND);
//glEnable(GL_DEPTH_TEST);
glDepthMask(GL_TRUE);
glEnable(GL_CULL_FACE);
glCullFace(GL_BACK);
//_______________________________________________________________________________________________________________________________________________________________________________
// Final compositing pass
//screenFillingQuad->setGLSLProgram(*screenFillingQuadShader);
//screenFillingQuad->getCurrentShaderProgram()->use();
//screenFillingQuad->renderWithAdditionalTextures(opaqueTextureHandle,sampler);
newOITCoverageShader->use();
glDepthMask(GL_FALSE);
glEnable(GL_BLEND);
glBlendFunc(GL_ONE_MINUS_SRC_ALPHA, GL_SRC_ALPHA);
screenFillingQuad->renderWithAdditionalTextures(additionalTextureHandles,sampler);
glDepthMask(GL_TRUE);
glDisable(GL_BLEND);
//_______________________________________________________________________________________________________________________________________________________________________________
// For debug!
//screenFillingQuad->setGLSLProgram(*screenFillingQuadShader);
//screenFillingQuad->getCurrentShaderProgram()->use();
//screenFillingQuad->setTexture(opaqueFrameBuffer->getColorAttachment(0));
//screenFillingQuad->render();
accumFrameBuffer->clean();
window->swapBuffers();
glfwPollEvents();
check_gl_error();
}
glfwTerminate();
window->release();
return 0;
}
void loadAssets()
{
loadParticles();
loadPlane();
pstack.push(glm::perspective(45.0f,
(GLfloat)window.GetWidth()/window.GetHeight(), 0.1f, 175.0f));
mstack.push(glm::lookAt(vec3(0, 2.7, 7), vec3(0, 2.4, 6), vec3(0, 1, 0)));
// Load terrain shader
if (!g_program.compileShaderFromFile(
ROOT_PATH_RELATIVE SHADER_DIR "terrain-vert.glsl",
GLSLShader::VERTEX)) {
fprintf(stderr, "%s\n", g_program.log().c_str());
exit(1);
}
if (!g_program.compileShaderFromFile(
ROOT_PATH_RELATIVE SHADER_DIR "terrain-frag.glsl",
GLSLShader::FRAGMENT)) {
fprintf(stderr, "%s\n", g_program.log().c_str());
exit(1);
}
if (!g_program.compileShaderFromFile(
ROOT_PATH_RELATIVE SHADER_DIR "terrain-tc.glsl",
GLSLShader::TESS_CONTROL)) {
fprintf(stderr, "%s\n", g_program.log().c_str());
exit(1);
}
if (!g_program.compileShaderFromFile(
ROOT_PATH_RELATIVE SHADER_DIR "terrain-te.glsl",
GLSLShader::TESS_EVALUATION)) {
fprintf(stderr, "%s\n", g_program.log().c_str());
exit(1);
}
if (!g_program.link()) {
fprintf(stderr, "%s\n", g_program.log().c_str());
exit(1);
}
// Load plane shader
if (!d_program.compileShaderFromFile(
ROOT_PATH_RELATIVE SHADER_DIR "default-vert.glsl",
GLSLShader::VERTEX)) {
fprintf(stderr, "%s\n", d_program.log().c_str());
exit(1);
}
if (!d_program.compileShaderFromFile(
ROOT_PATH_RELATIVE SHADER_DIR "default-frag.glsl",
GLSLShader::FRAGMENT)) {
fprintf(stderr, "%s\n", d_program.log().c_str());
exit(1);
}
const char *outputNames[] = { "Position" };
glTransformFeedbackVaryings(d_program.getHandle(), 1, outputNames, GL_SEPARATE_ATTRIBS);
if (!d_program.link()) {
fprintf(stderr, "%s\n", d_program.log().c_str());
exit(1);
}
g_program.use();
g_program.setUniform("Viewport", viewport);
g_program.setUniform("MinTessLevel", 1.0f);
g_program.setUniform("MaxTessLevel", max_tess);
//g_program.setUniform("MaxTessLevel", 20.0f);
g_program.setUniform("NearClip", 0.1f);
g_program.setUniform("FarClip", 175.0f);
g_program.setUniform("NearFog", 10.0f);
g_program.setUniform("FarFog", 125.0f);
g_program.setUniform("Light0.position", vec3(L0POSITION));
g_program.setUniform("Light0.La", vec3(L0AMBIENT));
g_program.setUniform("Light0.Ld", vec3(L0DIFFUSE));
GLuint terrainmap = SOIL_load_OGL_texture (
ROOT_PATH_RELATIVE TEXTURE_DIR "heightmap-vlarge.png",
SOIL_LOAD_AUTO, SOIL_CREATE_NEW_ID, SOIL_LOAD_L );
GLuint watermap = SOIL_load_OGL_texture (
ROOT_PATH_RELATIVE TEXTURE_DIR "watermap.jpg",
SOIL_LOAD_AUTO, SOIL_CREATE_NEW_ID, SOIL_LOAD_L );
GLuint ttex1 = SOIL_load_OGL_texture (
ROOT_PATH_RELATIVE TEXTURE_DIR "grass.jpg",
SOIL_LOAD_AUTO, SOIL_CREATE_NEW_ID, SOIL_LOAD_L );
GLuint ttex2 = SOIL_load_OGL_texture (
ROOT_PATH_RELATIVE TEXTURE_DIR "stonesnow.jpg",
SOIL_LOAD_AUTO, SOIL_CREATE_NEW_ID, SOIL_LOAD_L );
GLuint ttex3 = SOIL_load_OGL_texture (
ROOT_PATH_RELATIVE TEXTURE_DIR "water.jpg",
SOIL_LOAD_AUTO, SOIL_CREATE_NEW_ID, SOIL_LOAD_L );
GLuint ttex4 = SOIL_load_OGL_texture (
ROOT_PATH_RELATIVE TEXTURE_DIR "foam.jpg",
SOIL_LOAD_AUTO, SOIL_CREATE_NEW_ID, SOIL_LOAD_L );
GLuint nmap1 = SOIL_load_OGL_texture (
ROOT_PATH_RELATIVE TEXTURE_DIR "normalmap-vlarge.png",
SOIL_LOAD_AUTO, SOIL_CREATE_NEW_ID, SOIL_LOAD_L );
GLuint nmap2 = SOIL_load_OGL_texture (
ROOT_PATH_RELATIVE TEXTURE_DIR "watermap_NRM.jpg",
SOIL_LOAD_AUTO, SOIL_CREATE_NEW_ID, SOIL_LOAD_L );
GLuint omap1 = SOIL_load_OGL_texture (
ROOT_PATH_RELATIVE TEXTURE_DIR "occmap-vlarge.jpg",
SOIL_LOAD_AUTO, SOIL_CREATE_NEW_ID, SOIL_LOAD_L );
omap2 = SOIL_load_OGL_texture (
ROOT_PATH_RELATIVE TEXTURE_DIR "watermap_OCC.jpg",
SOIL_LOAD_AUTO, SOIL_CREATE_NEW_ID, SOIL_LOAD_L );
plane = SOIL_load_OGL_texture (
ROOT_PATH_RELATIVE TEXTURE_DIR "F16_diffusemap2.tga",
SOIL_LOAD_AUTO, SOIL_CREATE_NEW_ID, SOIL_LOAD_L );
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, terrainmap);
g_program.setUniform("TerrainMap", 0);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
glActiveTexture(GL_TEXTURE1);
glBindTexture(GL_TEXTURE_2D, watermap);
g_program.setUniform("WaterMap", 1);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
glActiveTexture(GL_TEXTURE2);
glBindTexture(GL_TEXTURE_2D, ttex1);
g_program.setUniform("TTex1", 2);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
glActiveTexture(GL_TEXTURE3);
glBindTexture(GL_TEXTURE_2D, ttex2);
g_program.setUniform("TTex2", 3);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
glActiveTexture(GL_TEXTURE4);
glBindTexture(GL_TEXTURE_2D, ttex3);
g_program.setUniform("TTex3", 4);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
glActiveTexture(GL_TEXTURE5);
glBindTexture(GL_TEXTURE_2D, ttex4);
g_program.setUniform("TTex4", 5);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
glActiveTexture(GL_TEXTURE6);
glBindTexture(GL_TEXTURE_2D, nmap1);
g_program.setUniform("NMap1", 6);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
glActiveTexture(GL_TEXTURE7);
glBindTexture(GL_TEXTURE_2D, nmap2);
g_program.setUniform("NMap2", 7);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
glActiveTexture(GL_TEXTURE8);
glBindTexture(GL_TEXTURE_2D, omap1);
g_program.setUniform("OMap1", 8);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
glActiveTexture(GL_TEXTURE9);
glBindTexture(GL_TEXTURE_2D, omap2);
g_program.setUniform("OMap2", 9);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
d_program.use();
plv = glGetSubroutineIndex(d_program.getHandle(), GL_VERTEX_SHADER, "RenderPlane");
plf = glGetSubroutineIndex(d_program.getHandle(), GL_FRAGMENT_SHADER, "RenderPlane");
pav = glGetSubroutineIndex(d_program.getHandle(), GL_VERTEX_SHADER, "RenderParticles");
paf = glGetSubroutineIndex(d_program.getHandle(), GL_FRAGMENT_SHADER, "RenderParticles");
glActiveTexture(GL_TEXTURE9);
glBindTexture(GL_TEXTURE_2D, plane);
d_program.setUniform("PlaneTex", 9);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
d_program.setUniform("Light0.position", vec3(L0POSITION));
d_program.setUniform("Light0.La", vec3(L0AMBIENT));
d_program.setUniform("Light0.Ld", vec3(L0DIFFUSE));
loadLand(156, 100);
}
