GLSLProgram* ShaderManager::UseShader(const char* vertName, const char* fragName, std::string vertString, std::string fragString)
{
GLSLProgram* prog = GetShader(vertName, fragName,vertString, fragString);
assert(prog != NULL);
prog->use();
return prog;
}
GLSLProgram* ShaderManager::UseShader(const char* vertName, const char* fragName)
{
GLSLProgram* prog = GetShader(vertName, fragName);
assert(prog != NULL);
prog->use();
return prog;
}
///////////////////////////////////////////////////////////////////////////////
// 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);
}
///////////////////////////////////////////////////////////////////////////////
// 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 );
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 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);
}
void Renderer::init(GLSLProgram & shader)
{
setProjectionMatrix(30,1, 1, -100, projection);
shader.use();
shader.setUniformMatrix4fv("projectionMatrix", projection);
shader.unuse();
}
void CascadedShadowMap::buildShadowMaps(Camera *camera, View *view, DirectLight *light)
{
//Profiler::getInstance()->startProfile("Build Shadow Maps");
float nSlice[] = {0.0, m_nSlices[0], m_nSlices[1], m_nSlices[2], 1.0};
Frustum *frustum = new Frustum();
frustum->getFrustum(camera, view);
m_shadowMaps[3]->bind();
glClearDepth(1.0);
glClear(GL_DEPTH_BUFFER_BIT);
glDisable(GL_CULL_FACE);
for (int i=0; i<4; i++)
{
Camera *lightCamera = createLightCamera(nSlice[i],nSlice[i+1],camera,view,light);
View *lightView = createLightView(nSlice[i],nSlice[i+1],camera,lightCamera,view,frustum);
Frustum *lightFrustum = new Frustum();
lightFrustum->getOrthoFrustum(lightCamera,lightView);
MatrixManager::getInstance()->putMatrix4(MODELVIEW, glm::mat4(1.0f));
MatrixManager::getInstance()->putMatrix4(PROJECTION, glm::mat4(1.0f));
m_shadowMaps[i]->bind();
glClearDepth(1.0);
glEnable(GL_DEPTH_TEST);
glClear(GL_DEPTH_BUFFER_BIT);
glPushAttrib( GL_VIEWPORT_BIT );
glViewport( 0, 0, m_nSize, m_nSize);
lightView->use3D(false);
GLSLProgram *glslProgram = ShaderManager::getInstance()->getShader("DirectShadow");
glslProgram->use();
glm::mat4 cameraMat = glm::mat4(1.0f);
cameraMat = lightCamera->transformToMatrix(cameraMat);
m_m4LightMatrix[i] = MatrixManager::getInstance()->getMatrix4(PROJECTION) * cameraMat;
MatrixManager::getInstance()->putMatrix4(MODELVIEW, cameraMat);
glslProgram->sendUniform("projectionMatrix", &MatrixManager::getInstance()->getMatrix4(PROJECTION)[0][0]);
glBindAttribLocation(glslProgram->getHandle(), 0, "v_vertex");
SceneManager::getInstance()->draw("DirectShadow");
glslProgram->disable();
glPopAttrib();
m_shadowMaps[i]->unbind();
delete lightCamera;
delete lightView;
delete lightFrustum;
}
glEnable(GL_CULL_FACE);
//Profiler::getInstance()->endProfile();
}
void HelloGLSL::onRender()
{
glslProgram.use();
glBindVertexArray(vao);
glDrawArrays(GL_TRIANGLES, 0, 3);
glslProgram.unUse();
glBindVertexArray(0);
}
void MainGraphicsWidget::voxelRender()
{
VoxelGrid::getInstance()->buildVoxels(m_lightBuffer->getLight());
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
MatrixManager::getInstance()->putMatrix4(MODELVIEW, glm::mat4(1.0f));
MatrixManager::getInstance()->putMatrix4(PROJECTION, glm::mat4(1.0f));
MatrixManager::getInstance()->putMatrix3(NORMAL, glm::mat3(1.0f));
view->viewport();
view->use3D(true);
camera->transform();
GLSLProgram *glslProgram = ShaderManager::getInstance()->getShader("Voxel");
glslProgram->use();
glBindFragDataLocation(glslProgram->getHandle(), 0, "fragColor");
glBindAttribLocation(glslProgram->getHandle(), 0, "v_vertex");
glslProgram->sendUniform("projectionMatrix", &MatrixManager::getInstance()->getMatrix4(PROJECTION)[0][0]);
glslProgram->sendUniform("modelviewMatrix", &MatrixManager::getInstance()->getMatrix4(MODELVIEW)[0][0]);
glm::mat4 cameraInverse = glm::mat4(1.0);
cameraInverse = camera->transformToMatrix(cameraInverse);
cameraInverse = glm::inverse(cameraInverse);
glslProgram->sendUniform("invCameraMatrix", &cameraInverse[0][0]);
glslProgram->sendUniform("worldSize", WORLD_SIZE);
//glslProgram->sendUniform("numVoxels", VOXEL_SIZE);
//glslProgram->sendUniform("mipLevel", VoxelGrid::getInstance()->getMipLevel());
int mipFactor = pow(2.0, VoxelGrid::getInstance()->getMipLevel());
glActiveTexture(GL_TEXTURE8);
glEnable(GL_TEXTURE_3D);
VoxelGrid::getInstance()->bind(VoxelGrid::getInstance()->getMipLevel());
glslProgram->sendUniform("voxelmap", 8);
//glEnable(GL_POINT_SMOOTH);
glPointSize(10.0f*mipFactor);
float voxelWidth = (float)WORLD_SIZE / (float)VOXEL_SIZE * mipFactor;
glBegin(GL_POINTS);
for (float x=-(WORLD_SIZE/2.0)+(voxelWidth/2.0); x<(WORLD_SIZE/2.0); x+=voxelWidth)
{
for (float y=-(WORLD_SIZE/2.0)+(voxelWidth/2.0); y<(WORLD_SIZE/2.0); y+=voxelWidth)
{
for (float z=-(WORLD_SIZE/2.0)+(voxelWidth/2.0); z<(WORLD_SIZE/2.0); z+=voxelWidth)
{
glVertex3f(x,y,z);
}
}
}
glEnd();
glslProgram->disable();
}
void OgroInvasion::onRender()
{
glslProgram.use();
glBindVertexArray(vaoID);
glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_SHORT, nullptr);
glBindVertexArray(0);
glslProgram.unUse();
}
///////////////////////////////////////////////////////////////////////////////
// This function does any needed initialization on the rendering context.
// This is the first opportunity to do any OpenGL related tasks.
void SetupRC()
{
// Black background
glClearColor(0.0f , 0.0f , 0.0f , 1.0f );
prog.compileShaderFromString (szIdentityShaderVP, GLSLShader:: VERTEX);
prog.compileShaderFromString (szIdentityShaderFP, GLSLShader:: FRAGMENT);
prog.link ();
prog.use ();
/////////////////// Create the VBO ////////////////////
GLfloat positionData [] = {
-0.8f, -0.8f , 0.0f ,
0.8f, -0.8f, 0.0f,
0.0f, 0.8f, 0.0f };
GLfloat colorData[] = {
1.0f, 0.0f, 0.0f,
0.0f, 1.0f, 0.0f,
0.0f, 0.0f, 1.0f };
// Create and populate the buffer objects
GLuint vboHandles[2];
glGenBuffers(2, vboHandles);
GLuint positionBufferHandle = vboHandles[0];
GLuint colorBufferHandle = vboHandles[1];
glBindBuffer(GL_ARRAY_BUFFER, positionBufferHandle);
glBufferData(GL_ARRAY_BUFFER, 9 * sizeof(GLfloat), positionData, GL_STATIC_DRAW);
glBindBuffer(GL_ARRAY_BUFFER, colorBufferHandle);
glBufferData(GL_ARRAY_BUFFER, 9 * sizeof(GLfloat), colorData, GL_STATIC_DRAW);
// Create and set-up the vertex array object
glGenVertexArrays( 1, &vaoHandle );
glBindVertexArray(vaoHandle);
glEnableVertexAttribArray(0); // Vertex position
glEnableVertexAttribArray(1); // Vertex color
glBindBuffer(GL_ARRAY_BUFFER, positionBufferHandle);
glVertexAttribPointer( 0, 3, GL_FLOAT, GL_FALSE, 0, (GLubyte *)NULL );
glBindBuffer(GL_ARRAY_BUFFER, colorBufferHandle);
glVertexAttribPointer( 1, 3, GL_FLOAT, GL_FALSE, 0, (GLubyte *)NULL );
}
void MainGraphicsWidget::forwardRender()
{
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
MatrixManager::getInstance()->putMatrix4(MODELVIEW, glm::mat4(1.0f));
MatrixManager::getInstance()->putMatrix4(PROJECTION, glm::mat4(1.0f));
MatrixManager::getInstance()->putMatrix3(NORMAL, glm::mat3(1.0f));
view->viewport();
view->use3D(true);
camera->transform();
GLSLProgram *glslProgram = ShaderManager::getInstance()->getShader("Basic");
glslProgram->use();
glBindFragDataLocation(glslProgram->getHandle(), 0, "fragColor");
glBindAttribLocation(glslProgram->getHandle(), 0, "v_vertex");
glBindAttribLocation(glslProgram->getHandle(), 1, "v_texture");
glBindAttribLocation(glslProgram->getHandle(), 2, "v_normal");
glBindAttribLocation(glslProgram->getHandle(), 3, "v_tangent");
glBindAttribLocation(glslProgram->getHandle(), 4, "v_bitangent");
glslProgram->sendUniform("light.direction", 1.0f,-5.0f,2.0f);
glslProgram->sendUniform("light.color", 1.0f,1.0f,1.0f);
glslProgram->sendUniform("light.ambient", 0.7f);
glslProgram->sendUniform("light.diffuse", 0.6f);
glslProgram->sendUniform("projectionMatrix", &MatrixManager::getInstance()->getMatrix4(PROJECTION)[0][0]);
glslProgram->sendUniform("modelviewMatrix", &MatrixManager::getInstance()->getMatrix4(MODELVIEW)[0][0]);
glslProgram->sendUniform("curveGeometry", false);
glm::mat4 cameraInverse = glm::mat4(1.0);
cameraInverse = camera->transformToMatrix(cameraInverse);
cameraInverse = glm::inverse(cameraInverse);
glslProgram->sendUniform("inverseCameraMatrix", &cameraInverse[0][0]);
glslProgram->sendUniform("cameraPos", camera->getEyeX(), camera->getEyeY(), camera->getEyeZ());
MaterialManager::getInstance()->getMaterial("Default")->sendToShader("Basic");
myGrid->draw();
SceneManager::getInstance()->draw("Basic");
glslProgram->disable();
SceneManager::getInstance()->drawTransformers();
}
void draw() {
glClearDepth(1.0);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glGenBuffers(1, &_vboID);
float vertexData[12];
float height = 1.0f;
float width = 1.0f;
float x = -1.0f;
float y = -1.0f;
//First Triangle
vertexData[0] = x + width;
vertexData[1] = y + height;
vertexData[2] = x;
vertexData[3] = y + height;
vertexData[4] = x;
vertexData[5] = y;
//Second Triangle
vertexData[6] = x;
vertexData[7] = y;
vertexData[8] = x + width;
vertexData[9] = y;
vertexData[10] = x + width;
vertexData[11] = y + height;
_Program.use();
glBindBuffer(GL_ARRAY_BUFFER, _vboID);
glBufferData(GL_ARRAY_BUFFER, sizeof(vertexData), vertexData, GL_STATIC_DRAW);
glEnableVertexAttribArray(0);
glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 0, 0);
glDrawArrays(GL_TRIANGLES, 0, 6);
glDisableVertexAttribArray(0);
glBindBuffer(GL_ARRAY_BUFFER, 0);
_Program.unuse();
SDL_GL_SwapWindow(_window);
}
int compile_link_shaders(GLSLProgram& prog, int num_shaders, ...)
{
va_list shader_list;
va_start(shader_list, num_shaders);
int type;
char *file= NULL;
GLSLProgram tmp_prog;
// Iterate over this argument list
for (int i=0; i<num_shaders; ++i) {
type = va_arg(shader_list, int);// Number of attributes
file = va_arg(shader_list, char*);
if (!tmp_prog.compile_shader_file(file, GLSLShader::GLSLShaderType(type)))
{
printf("%s shader failed to compile!\n%s", file, tmp_prog.log().c_str());
return 0;
}
}
va_end(shader_list);
if (!tmp_prog.link()) {
printf("Shader program failed to link!\n%s", tmp_prog.log().c_str());
return 0;
}
if (prog.isLinked())
prog.delete_program();
prog = tmp_prog;
prog.use();
return 1;
}
GLuint Model::getVAOForContext(GLSLProgram &shader, QGLContext *context){
if (!vaoHashContainer_.contains(context)) {
glGenVertexArrays(1, &vaoID_);
glBindVertexArray(vaoID_);
shader.use();
glBindBuffer (GL_ARRAY_BUFFER, vboVerticesID_);
glEnableVertexAttribArray(shader["vVertex"]);
glVertexAttribPointer(shader["vVertex"], 3, GL_FLOAT, GL_FALSE,sizeof(Vertex),0);
if (shader.isActive(shader["vNormal"])) {
glEnableVertexAttribArray(shader["vNormal"]);
glVertexAttribPointer(shader["vNormal"], 3, GL_FLOAT,
GL_FALSE, sizeof(Vertex), (const GLvoid*)(offsetof(Vertex, normal)) );
}
if (shader.isActive(shader["vUV"])) {
glEnableVertexAttribArray(shader["vUV"]);
glVertexAttribPointer(shader["vUV"], 2, GL_FLOAT,
GL_FALSE, sizeof(Vertex), (const GLvoid*)(offsetof(Vertex, uv)) );
}
if (materials_.size()==1)
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, vboIndicesID_);
glBindVertexArray(0);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER,0);
vaoHashContainer_.insert(context, vaoID_);
shader.unUse();
}
return vaoHashContainer_[context];
}
void IndirectBuffer::drawToBuffer(GLuint nDepthTex, GLuint nTangentTex, GLuint nBiangentTex, GLuint nNormalTex, GLuint nDiffuseTex, View *view, Camera *camera)
{
GLSLProgram *glslProgram = ShaderManager::getInstance()->getShader("Indirect");
glslProgram->use();
bind();
GLenum mrt[] = {GL_COLOR_ATTACHMENT0_EXT};
glDrawBuffers(1, mrt);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glPushAttrib( GL_VIEWPORT_BIT );
glViewport( 0, 0, getWidth(), getHeight());
MatrixManager::getInstance()->putMatrix4(MODELVIEW, glm::mat4(1.0f));
MatrixManager::getInstance()->putMatrix4(PROJECTION, glm::mat4(1.0f));
camera->transform();
view->use3D(true);
glm::mat4 m4InvMVP = MatrixManager::getInstance()->getMatrix4(PROJECTION) * MatrixManager::getInstance()->getMatrix4(MODELVIEW);
m4InvMVP = glm::inverse(m4InvMVP);
MatrixManager::getInstance()->putMatrix4(MODELVIEW, glm::mat4(1.0f));
MatrixManager::getInstance()->putMatrix4(PROJECTION, glm::mat4(1.0f));
view->use3D(false);
glBindFragDataLocation(glslProgram->getHandle(), 0, "glossyBuffer");
glBindAttribLocation(glslProgram->getHandle(), 0, "v_vertex");
glBindAttribLocation(glslProgram->getHandle(), 1, "v_texture");
glslProgram->sendUniform("projectionMatrix", &MatrixManager::getInstance()->getMatrix4(PROJECTION)[0][0]);
glslProgram->sendUniform("inverseMVPMatrix", &m4InvMVP[0][0]);
glslProgram->sendUniform("worldSize", WORLD_SIZE);
glslProgram->sendUniform("numVoxels", VOXEL_SIZE);
glActiveTexture(GL_TEXTURE8);
glEnable(GL_TEXTURE_3D);
VoxelGrid::getInstance()->bind(0);
glActiveTexture(GL_TEXTURE9);
glEnable(GL_TEXTURE_3D);
VoxelGrid::getInstance()->bind(1);
glActiveTexture(GL_TEXTURE10);
glEnable(GL_TEXTURE_3D);
VoxelGrid::getInstance()->bind(2);
glActiveTexture(GL_TEXTURE11);
glEnable(GL_TEXTURE_3D);
VoxelGrid::getInstance()->bind(3);
glslProgram->sendUniform("voxelmap[0]", 8);
glslProgram->sendUniform("voxelmap[1]", 9);
glslProgram->sendUniform("voxelmap[2]", 10);
glslProgram->sendUniform("voxelmap[3]", 11);
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, nDepthTex);
glActiveTexture(GL_TEXTURE1);
glBindTexture(GL_TEXTURE_2D, nTangentTex);
glActiveTexture(GL_TEXTURE2);
glBindTexture(GL_TEXTURE_2D, nBiangentTex);
glActiveTexture(GL_TEXTURE3);
glBindTexture(GL_TEXTURE_2D, nNormalTex);
glActiveTexture(GL_TEXTURE4);
glBindTexture(GL_TEXTURE_2D, nDiffuseTex);
glslProgram->sendUniform("depthTex",0);
glslProgram->sendUniform("tanTex",1);
glslProgram->sendUniform("bitanTex",2);
glslProgram->sendUniform("normalTex",3);
glslProgram->sendUniform("diffuseTex",4);
drawScreenShader(0,0,1.0f,1.0f);
glFinish();
glslProgram->disable();
unbind();
}
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 SceneParticlesInstanced::compileAndLinkShader
(GLSLProgram& glslProg, const char* vertexPath, const char* fragmentPath, const char* geometryPath)
{
// "shader/particleinstanced.vs"
if( !glslProg.compileShaderFromFile(vertexPath, GLSLShader::VERTEX) )
{
printf("Vertex shader failed to compile!\n%s",
glslProg.log().c_str());
do
{
cout << '\n' << "Press a key to continue...";
} while (cin.get() != '\n');
exit(1);
}
// "shader/particleinstanced.fs"
if( !glslProg.compileShaderFromFile(fragmentPath, GLSLShader::FRAGMENT))
{
printf("Fragment shader failed to compile!\n%s",
glslProg.log().c_str());
do
{
cout << '\n' << "Press a key to continue...";
} while (cin.get() != '\n');
exit(1);
}
if (geometryPath != NULL && geometryPath[0] != '\0') {
// compile geometry shader
if (!glslProg.compileShaderFromFile(geometryPath, GLSLShader::GEOMETRY))
{
printf("Geometry shader failed to compile!\n%s",
glslProg.log().c_str());
do
{
cout << '\n' << "Press a key to continue...";
} while (cin.get() != '\n');
exit(1);
}
}
if( !glslProg.link() )
{
printf("Shader program failed to link!\n%s",
glslProg.log().c_str());
do
{
cout << '\n' << "Press a key to continue...";
} while (cin.get() != '\n');
exit(1);
}
glslProg.use();
}
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);
}
int main()
{
GLFWwindow* window = nullptr;
if(!init(window))
{
system("pause");
exit(0);
}
glClearColor(0.0, 0.0, 0.0, 0.0);
//set up audio engine
SoundSystemClass sounds;
GLSLProgram shaders;
//load shaders, compile and link
shaders.compileShaderFromFile("triangle.v.glsl", VERTEX);
shaders.compileShaderFromFile("triangle.f.glsl", FRAGMENT);
shaders.link();
shaders.use();
Screen* currentScreen;
MainMenuScreen *mms = new MainMenuScreen(&sounds, &shaders);
currentScreen = mms;
//Text t(glm::vec3(0, 0, 0), glm::vec4(1.0, 0.0, 0.0, 1.0), 40, 40, "arial_0.png", "arial.fnt");
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
//create projection matrix
glm::mat4 projectionMatrix = glm::ortho(0.0f, 800.0f, 0.0f, 600.0f);
double lastTime = glfwGetTime(), currentTime;
while(!glfwWindowShouldClose(window) && currentScreen != nullptr)
{
//calculate delta time
currentTime = glfwGetTime();
double deltaTime = currentTime - lastTime;
//draw
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
currentScreen->Draw();
glfwSwapBuffers(window);
//update
Screen* next = currentScreen->Update(deltaTime);
//if returned screen is null, pop current screen
if(next != currentScreen)
{
delete currentScreen;
currentScreen = next;
}
//else continue with current top of stack
glfwPollEvents();
lastTime = currentTime;
}
glfwDestroyWindow(window);
glfwTerminate();
return 0;
}
