GLSLProgram* ShaderManager::LoadFromStrings(const char* vertName, const char*fragName, std::string vertString, std::string fragString) { GLSLProgram* prog = new GLSLProgram(); if(!prog->compileShaderFromString(vertString, GLSLShader::VERTEX)) { printf("Vertex shader failed to compile from string!\n%s", prog->log().c_str()); sLog(Level::Severe) << "Vertex shader <" << vertName << "> failed to compile from string." << prog->log(); assert(false && "Vertex shader failed to compile from string"); return NULL; } if(!prog->compileShaderFromString(fragString, GLSLShader::FRAGMENT)) { printf("Fragment shader failed to compile from string!\n%s", prog->log().c_str()); sLog(Level::Severe) << "Fragment shader <" << fragName << "> failed to compile from string." << prog->log(); assert(false && "Fragment shader failed to compile from string"); return NULL; } if(!prog->link()) { printf("Shader program failed to link!\n%s", prog->log().c_str()); sLog(Level::Severe) << "Shader program failed to link." << prog->log(); assert(false && "Shader program failed to link."); return NULL; } assert(prog != NULL); return prog; }
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 }
void HelloGLSL::customInit() { try { glslProgram.loadShader(GLSLShaderType::VERTEX, g_programName + "/" + "HelloGLSL.vert"); glslProgram.loadShader(GLSLShaderType::FRAGMENT, g_programName + "/" + "HelloGLSL.frag"); } catch (GLSLProgramException& e) { printf("%s\n", e.what()); system("pause"); exit(EXIT_FAILURE); } glslProgram.link(); glGenBuffers(1, &positionBufferObject); glBindBuffer(GL_ARRAY_BUFFER, positionBufferObject); glBufferData(GL_ARRAY_BUFFER, sizeof(vertexPositions), vertexPositions, GL_STATIC_DRAW); glGenVertexArrays(1, &vao); glBindVertexArray(vao); GLint positionLoc = glslProgram.getAttributeLocation("position"); glEnableVertexAttribArray(positionLoc); glVertexAttribPointer(positionLoc, 4, GL_FLOAT, GL_FALSE, 0, 0); glBindVertexArray(0); glBindBuffer(GL_ARRAY_BUFFER, 0); }
//Loads and compiles vertice and fragment shaders from strings into one GLSLProgram* GLSLProgram* ShaderManager::LoadFromStrings(std::string vertName, std::string fragName, std::string vertString, std::string fragString) { GLSLProgram* prog = new GLSLProgram(); ///Compile the vertex portion of the shader if(!prog->compileShaderFromString(vertString, GLSLShader::VERTEX)) { printf("Vertex shader failed to compile from string!\n%s", prog->log().c_str()); assert(false && "Vertex shader failed to compile from string"); return NULL; } ///Compile the fragment portion of the shader if(!prog->compileShaderFromString(fragString, GLSLShader::FRAGMENT)) { printf("Fragment shader failed to compile from string!\n%s", prog->log().c_str()); assert(false && "Fragment shader failed to compile from string"); return NULL; } ///Links the shader to OpenGL using the handle obtained during the compile if ( !prog->link() ) { printf("Shader program failed to link!\n%s", prog->log().c_str()); assert(false && "Shader program failed to link."); return NULL; } assert(prog != NULL); 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 ); 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); }
/////////////////////////////////////////////////////////////////////////////// // 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 GLSLProgram::createFromSourceStrings ( GLSLProgram & prog, const std::string &shader, unsigned int shaderType, const GLuint & geomIn , const GLuint & geomOut ) { prog.clear(); prog.handle_ = glCreateProgram(); prog._geomIn = geomIn; prog._geomOut = geomOut; switch ( shaderType ) { case GL_VERTEX_SHADER_ARB: prog.vertex_ = new GLSLShader ( shader, shaderType ); prog.attach ( prog.vertex_ ); break; case GL_GEOMETRY_SHADER_EXT: prog.geometry_ = new GLSLShader ( shader, shaderType ); prog.attach ( prog.geometry_ ); if ( ( prog._geomIn == 0 ) || ( prog._geomOut == 0 ) ) { _ERROR ( "invalid geomin/geomout" ); throw "invalid geomin/geomout at "; } break; case GL_FRAGMENT_SHADER_ARB: prog.fragment_ = new GLSLShader ( shader, shaderType ); prog.attach ( prog.fragment_ ); break; } prog.link(); }
/////////////////////////////////////////////////////////////////////////////// // 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 GLSLProgram::createFromSourceStrings ( GLSLProgram &prog, const std::string &vertexShader, const std::string &geometryShader, const std::string &fragmentShader, const GLuint &geomIn, const GLuint &geomOut ) { prog.clear(); prog.handle_ = glCreateProgram(); prog._geomIn = geomIn; prog._geomOut = geomOut; if ( vertexShader.size() != 0 ) { prog.vertex_ = new GLSLShader ( GL_VERTEX_SHADER_ARB ); prog.vertex_->setShaderSource ( vertexShader ); prog.vertex_->compile(); prog.attach ( prog.vertex_ ); } if ( geometryShader.size() != 0 ) { prog.geometry_ = new GLSLShader ( GL_GEOMETRY_SHADER_EXT ); prog.geometry_->setShaderSource ( geometryShader ); prog.geometry_->compile(); prog.attach ( prog.geometry_ ); } if ( fragmentShader.size() != 0 ) { prog.fragment_ = new GLSLShader ( GL_FRAGMENT_SHADER_ARB ); prog.fragment_->setShaderSource ( fragmentShader ); prog.fragment_->compile(); prog.attach ( prog.fragment_ ); } prog.link(); }
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; }