void Initialize() { printf("Version Pilote OpenGL : %s\n", glGetString(GL_VERSION)); printf("Type de GPU : %s\n", glGetString(GL_RENDERER)); printf("Fabricant : %s\n", glGetString(GL_VENDOR)); printf("Version GLSL : %s\n", glGetString(GL_SHADING_LANGUAGE_VERSION)); int numExtensions; glGetIntegerv(GL_NUM_EXTENSIONS, &numExtensions); GLenum error = glewInit(); if (error != GL_NO_ERROR) { // TODO } for (int index = 0; index < numExtensions; ++index) { printf("Extension[%d] : %s\n", index, glGetStringi(GL_EXTENSIONS, index)); } #ifdef _WIN32 // on coupe la synchro vertical pour voir l'effet du delta time wglSwapIntervalEXT(0); #endif basicShader.LoadVertexShader("basic.vs"); basicShader.LoadFragmentShader("basic.fs"); basicShader.Create(); auto program = basicShader.GetProgram(); // UN UBO SERAIT UTILE ICI auto basicProgram = basicShader.GetProgram(); auto blockIndex = glGetUniformBlockIndex(basicProgram, "ViewProj"); GLuint blockBinding = 1; glGenBuffers(1, &g_Camera.UBO); glBindBuffer(GL_UNIFORM_BUFFER, g_Camera.UBO); //glBufferData(GL_UNIFORM_BUFFER, sizeof(glm::mat4) * 2, NULL, GL_STREAM_DRAW); glBufferSubData(GL_UNIFORM_BUFFER, 0, sizeof(glm::mat4), glm::value_ptr(g_Camera.projectionMatrix)); glBufferSubData(GL_UNIFORM_BUFFER, sizeof(glm::mat4), sizeof(glm::mat4), glm::value_ptr(g_Camera.viewMatrix)); glBindBufferBase(GL_UNIFORM_BUFFER, blockBinding, g_Camera.UBO); glBindBuffer(GL_UNIFORM_BUFFER, 0); glUniformBlockBinding(basicProgram, blockIndex, blockBinding); previousTime = glutGet(GLUT_ELAPSED_TIME); InitCube(); // render states par defaut glEnable(GL_DEPTH_TEST); glDepthFunc(GL_LESS); glEnable(GL_CULL_FACE); }
void Initialize(int width, int height) { printf("Version Pilote OpenGL : %s\n", glGetString(GL_VERSION)); printf("Type de GPU : %s\n", glGetString(GL_RENDERER)); printf("Fabricant : %s\n", glGetString(GL_VENDOR)); printf("Version GLSL : %s\n", glGetString(GL_SHADING_LANGUAGE_VERSION)); int numExtensions; glGetIntegerv(GL_NUM_EXTENSIONS, &numExtensions); GLenum error = glewInit(); if (error != GL_NO_ERROR) { // TODO } for (int index = 0; index < numExtensions; ++index) { printf("Extension[%d] : %s\n", index, glGetStringi(GL_EXTENSIONS, index)); } glEnable(GL_DEPTH_TEST); glEnable(GL_CULL_FACE); //glFrontFace(GL_CW); basicShader.LoadVertexShader("basic.vs"); basicShader.LoadFragmentShader("basic.fs"); basicShader.Create(); textureShader.LoadVertexShader("texture.vs"); textureShader.LoadFragmentShader("texture.fs"); textureShader.Create(); glGenBuffers(1, &cubeVBO); glGenBuffers(1, &cubeIBO); glBindBuffer(GL_ARRAY_BUFFER, cubeVBO); glBufferData(GL_ARRAY_BUFFER, sizeof(float) * 8 * 3, g_cubeVertices, GL_STATIC_DRAW); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, cubeIBO); glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(GLushort) * 6 * 2 * 3, g_cubeIndices, GL_STATIC_DRAW); glBindBuffer(GL_ARRAY_BUFFER, 0); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0); previousTime = glutGet(GLUT_ELAPSED_TIME); glGenVertexArrays(1, &cubeVAO); glBindVertexArray(cubeVAO); GLuint program = basicShader.GetProgram(); glBindBuffer(GL_ARRAY_BUFFER, cubeVBO); GLint positionLocation = glGetAttribLocation(program, "a_position"); glEnableVertexAttribArray(positionLocation); glVertexAttribPointer(positionLocation, 3, GL_FLOAT, GL_FALSE, sizeof(float)*3, 0); glBindVertexArray(0); CreateFBO(width, height); }
void Render() { auto width = glutGet(GLUT_WINDOW_WIDTH); auto height = glutGet(GLUT_WINDOW_HEIGHT); glClearColor(0.5f, 0.5f, 0.5f, 1.0f); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); auto program = basicShader.GetProgram(); glUseProgram(program); // variables uniformes (constantes) g_Camera.projectionMatrix = glm::perspectiveFov(45.f, (float)width, (float)height, 0.1f, 1000.f); // rotation orbitale de la camera float rotY = glm::radians(g_Camera.rotation.y); glm::vec4 position = glm::eulerAngleY(rotY) * glm::vec4(0.0f, 0.0f, 80.0f, 1.0f); g_Camera.viewMatrix = glm::lookAt(glm::vec3(position), glm::vec3(0.f), glm::vec3(0.f, 1.f, 0.f)); // IL FAUT TRANSFERER LES MATRICES VIEW ET PROJ AU SHADER glBindBuffer(GL_UNIFORM_BUFFER, g_Camera.UBO); glBufferData(GL_UNIFORM_BUFFER, sizeof(glm::mat4) * 2, glm::value_ptr(g_Camera.viewMatrix), GL_STREAM_DRAW); float yaw = glm::radians(g_Cube.rotation.y); float pitch = glm::radians(g_Cube.rotation.x); float roll = glm::radians(g_Cube.rotation.z); g_Cube.worldMatrix = glm::eulerAngleYXZ(yaw, pitch, roll); auto worldLocation = glGetUniformLocation(program, "u_worldMatrix"); auto colorLocation = glGetUniformLocation(program, "u_objectColor"); glBindVertexArray(g_Cube.VAO); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, g_Cube.IBO); for (float x = -24.f; x < 24.f; x += 3.0f) { for (float y = -24.f; y < 24.f; y += 3.0f) { for (float z = -24.f; z < 24.f; z += 3.0f) { glUniform4f(colorLocation, (x + 24.0f) / 48.f, (y + 24.0f) / 48.f, (z + 24.0f) / 48.f, 1.0f); //glm::mat4 transform = glm::translate(g_Cube.worldMatrix, glm::vec3(x, y, z)); glm::mat4& transform = g_Cube.worldMatrix; transform[3] = glm::vec4(x, y, z, 1.0f); glUniformMatrix4fv(worldLocation, 1, GL_FALSE, glm::value_ptr(transform)); glDrawElements(GL_TRIANGLES, g_Cube.ElementCount, GL_UNSIGNED_INT, 0); } } } glBindVertexArray(0); glutSwapBuffers(); }
void Render() { glBindFramebuffer(GL_FRAMEBUFFER, sceneFBO); glViewport(0, 0, glutGet(GLUT_WINDOW_WIDTH), glutGet(GLUT_WINDOW_HEIGHT)); glClearColor(1.f, 0.0f, 0.5f, 1.0f); glClearDepth(1.F); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); GLuint program = basicShader.GetProgram(); glUseProgram(program); DrawCube(program); glUseProgram(0); #if COPY_FBO glBindFramebuffer(GL_DRAW_FRAMEBUFFER, 0); glBindFramebuffer(GL_READ_FRAMEBUFFER, sceneFBO); glBlitFramebuffer(0, 0, w, h, 0, 0, w, h, GL_COLOR_BUFFER_BIT, GL_LINEAR); #else glBindFramebuffer(GL_FRAMEBUFFER, 0); glClearColor(0.f, 0.5f, 0.5f, 1.0f); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); program = textureShader.GetProgram(); glUseProgram(program); //glActiveTexture(GL_TEXTURE0); //glBindTexture(GL_TEXTURE_2D, textureObj); //GLint textureLocation = glGetUniformLocation(program, "u_texture"); //glUniform1i(textureLocation, 0); DrawCube(program); #endif glutSwapBuffers(); glutPostRedisplay(); }
void Render() { glClearColor(0.0f, 0.0f, 0.0f, 1.0f); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); // alternativement on peut utiliser la nouvelle fonction glClearBufferxx() auto basicProgram = g_BasicShader.GetProgram(); glUseProgram(basicProgram); glBindBuffer(GL_ARRAY_BUFFER, g_Object.VBO); g_Object.worldMatrix = glm::mat4(1.0f); g_Camera.projectionMatrix = glm::perspectiveFov(45.f, (float) glutGet(GLUT_WINDOW_WIDTH), (float) glutGet(GLUT_WINDOW_HEIGHT), 0.1f, 1000.f); glm::vec4 position = glm::vec4(0.0f, 0.0f, -5.0f, 1.0f); g_Camera.viewMatrix = glm::lookAt(glm::vec3(position), glm::vec3(0.f), glm::vec3(0.f, 1.f, 0.f)); auto projLocation = glGetUniformLocation(basicProgram, "u_projectionMatrix"); glUniformMatrix4fv(projLocation, 1, GL_FALSE, glm::value_ptr(g_Camera.projectionMatrix)); auto viewLocation = glGetUniformLocation(basicProgram, "u_viewMatrix"); glUniformMatrix4fv(viewLocation, 1, GL_FALSE, glm::value_ptr(g_Camera.viewMatrix)); auto worldLocation = glGetUniformLocation(basicProgram, "u_worldMatrix"); glUniformMatrix4fv(worldLocation, 1, GL_FALSE, glm::value_ptr(g_Object.worldMatrix)); GLint colorLocation = glGetUniformLocation(basicProgram, "u_color"); GLint offsetLocation = glGetUniformLocation(basicProgram, "u_offset"); // zero correspond ici a la valeur de layout(location=0) dans le shader basic.vs glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, sizeof(float) * 2, 0); glEnableVertexAttribArray(0); //rand() % 10 - 4.5 for(int i = 0; i < 10; ++i) { glUniform3f(offsetLocation, i - 4.5, 0.0f, 0.0f); glUniform4f(colorLocation, 0.0f, 0.0f, (float) i / 10, 0.0f); glDrawArrays(GL_TRIANGLES, 0, 3); } glutSwapBuffers(); }
void Draw() { glClearColor(1.f, 1.f, 1.f, 1.f); glClearDepth(1.f); glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT); glEnable(GL_DEPTH_TEST); glEnable(GL_CULL_FACE); mat4 cameraMatrix = esgiLookAt(camera.position, camera.position + camera.target, vec3(0.0, 1.0, 0.0)); mat4 projectionMatrix = esgiPerspective(45, (float)((float)WINDOW_WIDTH/(float)WINDOW_HEIGHT), 0.01f, 10000.f); mat4 viewMatrix = esgiMultiplyMatrix(cameraMatrix, esgiRotateY(camera.orientation.y)); mat4 modelviewMatrix; mat4 worldMatrix; modelviewMatrix.Identity(); worldMatrix.Identity(); modelviewMatrix = esgiMultiplyMatrix(viewMatrix, worldMatrix); esgiUtilsDrawAxes(modelviewMatrix,projectionMatrix,1.f); GLuint programObject = shader.GetProgram(); glUseProgram(programObject); GLint position_attrib = glGetAttribLocation(programObject,"a_Position"); GLint color_uniform = glGetUniformLocation(programObject, "u_Color"); GLint texture_uniform = glGetUniformLocation(programObject, "u_UseTexture"); GLint depthHall_uniform = glGetUniformLocation(programObject, "u_DepthHole"); glUniform1f(depthHall_uniform, depthExplosion); GLint viewUniform = glGetUniformLocation(programObject, "u_ViewMatrix"); glUniformMatrix4fv(viewUniform, 1, 0, &viewMatrix.I.x); mat4 uniformMatrix = esgiRotateX(0); GLint rotationUniform = glGetUniformLocation(programObject, "u_RotationMatrix"); glUniformMatrix4fv(rotationUniform, 1, 0, &uniformMatrix.I.x); GLint projectionUniform = glGetUniformLocation(programObject, "u_ProjectionMatrix"); glUniformMatrix4fv(projectionUniform, 1, 0, &projectionMatrix.I.x); worldMatrix.Identity(); worldMatrix.T.set(0.f, 0.f, 0.f, 1.f); // Translate sur l'axe z GLint worldUnifrom = glGetUniformLocation(programObject, "u_WorldMatrix"); glUniformMatrix4fv(worldUnifrom, 1, 0, &worldMatrix.I.x); glActiveTexture(GL_TEXTURE0); glBindTexture(GL_TEXTURE_2D, groundTextureIds[0]); GLint textureUnit0 = glGetUniformLocation(programObject, "u_Texture1"); glUniform1i(textureUnit0, 0); glActiveTexture(GL_TEXTURE1); glBindTexture(GL_TEXTURE_2D, groundTextureIds[1]); GLint textureUnit1 = glGetUniformLocation(programObject, "u_Texture2"); glUniform1i(textureUnit1, 1); glEnableVertexAttribArray(position_attrib); objectManager.render(&position_attrib, &color_uniform, &texture_uniform); glDisableVertexAttribArray(position_attrib); //---------------= SKYBOX =--------------// programObject = shaderSkybox.GetProgram(); glUseProgram(programObject); position_attrib = glGetAttribLocation(programObject,"a_Position"); color_uniform = glGetUniformLocation(programObject, "u_Color"); glUniform4f(color_uniform,0.f, 0.f, 0.f, 1.f); viewUniform = glGetUniformLocation(programObject, "u_ViewMatrix"); glUniformMatrix4fv(viewUniform, 1, 0, &viewMatrix.I.x); rotationUniform = glGetUniformLocation(programObject, "u_RotationMatrix"); glUniformMatrix4fv(rotationUniform, 1, 0, &uniformMatrix.I.x); GLuint uniformScale = glGetUniformLocation(programObject, "u_Scale"); glUniform1f(uniformScale, scale); GLuint uniformFace = glGetUniformLocation(programObject, "u_Face"); projectionUniform = glGetUniformLocation(programObject, "u_ProjectionMatrix"); glUniformMatrix4fv(projectionUniform, 1, 0, &projectionMatrix.I.x); worldMatrix.Identity(); worldMatrix.T.set(0.f, 0.f, 0.f, 1.f); // Translate sur l'axe z worldUnifrom = glGetUniformLocation(programObject, "u_WorldMatrix"); glUniformMatrix4fv(worldUnifrom, 1, 0, &worldMatrix.I.x); for(int i = 0; i < 6; ++i) { glVertexAttribPointer(position_attrib, 3, GL_FLOAT, false, 0, &skybox[i].getListOfVertices()->at(0).x); glUniform1i(uniformFace, i); glActiveTexture(GL_TEXTURE0); glBindTexture(GL_TEXTURE_2D, skyboxTextureIds[i]); GLint textureUnit0 = glGetUniformLocation(programObject, "u_Texture"); glUniform1i(textureUnit0, 0); glEnableVertexAttribArray(position_attrib); glDrawArrays(GL_TRIANGLE_STRIP, 0, 4); } glDisableVertexAttribArray(position_attrib); }
void Render() { if (!g_CanDraw) return; auto width = glutGet(GLUT_WINDOW_WIDTH); auto height = glutGet(GLUT_WINDOW_HEIGHT); glClearColor(0.5f, 0.5f, 0.5f, 1.0f); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); // variables uniformes (constantes) g_Camera.projectionMatrix = glm::perspectiveFov(45.f, (float)width, (float)height, 0.1f, 1000.f); // rotation orbitale de la camera float rotY = glm::radians(g_Camera.rotation.y); const glm::vec4 orbitDistance(0.0f, 0.0f, 200.0f, 1.0f); glm::vec4 position = /*glm::eulerAngleY(rotY) **/ orbitDistance; g_Camera.viewMatrix = glm::lookAt(glm::vec3(position), glm::vec3(0.f), glm::vec3(0.f, 1.f, 0.f)); glBindBuffer(GL_UNIFORM_BUFFER, g_Camera.UBO); //glBufferData(GL_UNIFORM_BUFFER, sizeof(glm::mat4) * 2, glm::value_ptr(g_Camera.viewMatrix), GL_STREAM_DRAW); glBufferSubData(GL_UNIFORM_BUFFER, 0, sizeof(glm::mat4) * 2, glm::value_ptr(g_Camera.viewMatrix)); for (uint32_t index = 0; index < g_Spheres.size(); ++index) { static const float radius = 100.0f; // L'illumination s'effectue dans le repere de la camera, il faut donc que les positions des lumieres // soient egalement exprimees dans le meme repere (view space) g_PointLights[index].position = g_Camera.viewMatrix * glm::vec4(g_Spheres[index].position, 1.0f); g_PointLights[index].position.w = radius; } glBindBuffer(GL_UNIFORM_BUFFER, PointLight::UBO); glBufferSubData(GL_UNIFORM_BUFFER, 0, sizeof(PointLight) * g_NumPointLights, g_PointLights); // rendu des murs avec illumination glBindVertexArray(g_WallMesh.VAO); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0); auto program = g_BlinnPhongShader.GetProgram(); glUseProgram(program); auto numLightsLocation = glGetUniformLocation(program, "u_numLights"); glUniform1i(numLightsLocation, g_NumPointLights); auto worldLocation = glGetUniformLocation(program, "u_worldMatrix"); glm::mat4& transform = g_Walls.worldMatrix; glUniformMatrix4fv(worldLocation, 1, GL_FALSE, glm::value_ptr(transform)); auto startIndex = 0; glBindTexture(GL_TEXTURE_2D, g_Walls.textures[Walls::gWallTexture]); glDrawArrays(GL_TRIANGLES, startIndex, 6 * 4); startIndex += 6 * 4; // 4 murs glBindTexture(GL_TEXTURE_2D, g_Walls.textures[Walls::gCeilingTexture]); glDrawArrays(GL_TRIANGLES, startIndex, 6); startIndex += 6; // plafond glBindTexture(GL_TEXTURE_2D, g_Walls.textures[Walls::gFloorTexture]); glDrawArrays(GL_TRIANGLES, startIndex, 6); startIndex += 6; // sol // rendu debug glBindTexture(GL_TEXTURE_2D, 0); glBindVertexArray(g_SphereMesh.VAO); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, g_SphereMesh.IBO); program = g_AmbientShader.GetProgram(); glUseProgram(program); worldLocation = glGetUniformLocation(program, "u_worldMatrix"); for (auto index = 0; index < g_Spheres.size(); ++index) { glm::mat4& transform = g_Spheres[index].worldMatrix; glUniformMatrix4fv(worldLocation, 1, GL_FALSE, glm::value_ptr(transform)); glDrawElements(GL_TRIANGLES, g_SphereMesh.ElementCount, GL_UNSIGNED_INT, 0); } glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0); //glBindVertexArray(0); // dessine les tweakBar TwDraw(); glutSwapBuffers(); }
void Initialize() { printf("Version Pilote OpenGL : %s\n", glGetString(GL_VERSION)); printf("Type de GPU : %s\n", glGetString(GL_RENDERER)); printf("Fabricant : %s\n", glGetString(GL_VENDOR)); printf("Version GLSL : %s\n", glGetString(GL_SHADING_LANGUAGE_VERSION)); int numExtensions; glGetIntegerv(GL_NUM_EXTENSIONS, &numExtensions); GLenum error = glewInit(); if (error != GL_NO_ERROR) { // TODO } #if LIST_EXTENSIONS for (int index = 0; index < numExtensions; ++index) { printf("Extension[%d] : %s\n", index, glGetStringi(GL_EXTENSIONS, index)); } #endif #ifdef _WIN32 // on coupe la synchro vertical pour voir l'effet du delta time wglSwapIntervalEXT(0); #endif // render states par defaut glEnable(GL_DEPTH_TEST); glDepthFunc(GL_LESS); glEnable(GL_CULL_FACE); // AntTweakBar TwInit(TW_OPENGL, NULL); // ou TW_OPENGL_CORE selon le cas de figure objTweakBar = TwNewBar("Multiple Point Lights"); TwAddVarRW(objTweakBar, "Num Point Lights", TW_TYPE_UINT32, &g_NumPointLights, ""); TwAddButton(objTweakBar, "Quitter", &ExitCallbackTw, nullptr, ""); // Objets OpenGL glGenBuffers(1, &g_Camera.UBO); glBindBuffer(GL_UNIFORM_BUFFER, g_Camera.UBO); glBufferData(GL_UNIFORM_BUFFER, sizeof(glm::mat4) * 2, nullptr, GL_STREAM_DRAW); glGenBuffers(1, &PointLight::UBO); glBindBuffer(GL_UNIFORM_BUFFER, PointLight::UBO); glBufferData(GL_UNIFORM_BUFFER, sizeof(PointLight) * MAX_POINT_LIGHTS, nullptr, GL_STREAM_DRAW); glGenBuffers(1, &Material::UBO); glBindBuffer(GL_UNIFORM_BUFFER, Material::UBO); glBufferData(GL_UNIFORM_BUFFER, sizeof(Material), &g_ShinyMaterial, GL_STATIC_DRAW); error = glGetError(); assert(error == GL_NO_ERROR); g_AmbientShader.LoadVertexShader("ambient.vs"); g_AmbientShader.LoadFragmentShader("ambient.fs"); g_AmbientShader.Create(); auto program = g_AmbientShader.GetProgram(); glBindBufferBase(GL_UNIFORM_BUFFER, 0, g_Camera.UBO); auto blockIndex = glGetUniformBlockIndex(program, "ViewProj"); glUniformBlockBinding(program, blockIndex, 0); error = glGetError(); assert(error == GL_NO_ERROR); g_BlinnPhongShader.LoadVertexShader("blinnPhong.vs"); g_BlinnPhongShader.LoadFragmentShader("blinnPhong.fs"); g_BlinnPhongShader.Create(); program = g_BlinnPhongShader.GetProgram(); //glBindBufferBase(GL_UNIFORM_BUFFER, 0, g_Camera.UBO); // deja bound blockIndex = glGetUniformBlockIndex(program, "ViewProj"); glUniformBlockBinding(program, blockIndex, 0); glBindBufferBase(GL_UNIFORM_BUFFER, 1, PointLight::UBO); blockIndex = glGetUniformBlockIndex(program, "Lights"); glUniformBlockBinding(program, blockIndex, 1); glBindBufferBase(GL_UNIFORM_BUFFER, 2, Material::UBO); blockIndex = glGetUniformBlockIndex(program, "Material"); glUniformBlockBinding(program, blockIndex, 2); // Setup error = glGetError(); assert(error == GL_NO_ERROR); previousTime = glutGet(GLUT_ELAPSED_TIME); LoadMesh(g_WallMesh, g_Room); LoadAndCreateTextureRGBA("wall_color_map.jpg", g_Walls.textures[Walls::gWallTexture]); glBindTexture(GL_TEXTURE_2D, g_Walls.textures[Walls::gWallTexture]); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT); LoadAndCreateTextureRGBA("floor_color_map.jpg", g_Walls.textures[Walls::gFloorTexture]); glBindTexture(GL_TEXTURE_2D, g_Walls.textures[Walls::gFloorTexture]); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT); LoadAndCreateTextureRGBA("ceiling_color_map.jpg", g_Walls.textures[Walls::gCeilingTexture]); glBindTexture(GL_TEXTURE_2D, g_Walls.textures[Walls::gCeilingTexture]); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT); const std::string inputFile = "sphere.obj"; LoadOBJ(g_SphereMesh, inputFile); g_Spheres.resize(g_NumPointLights); for (uint32_t index = 0; index < g_NumPointLights; ++index) { g_Spheres[index].initialize(index); } error = glGetError(); assert(error == GL_NO_ERROR); }