OpenGL problem

    This site uses cookies. By continuing to browse this site, you are agreeing to our Cookie Policy.

    • [SOLVED]OpenGL problem

      I've been following the beginners tutorials from opengl-tutorial.org and decided to try and put it in to a class which would show a square with a random texture in the middle of the screen. However I seem to have hit a problem, whenever I run it, it just shows a white screen whereas it should show a square with a texture on a dark blue background. I assume I have missed a function or passed in a variable wrong, however I can't seem to find it. So I would really appreciate an experienced eye taking a look and pointing where I went wrong and other things that I have done badly.

      I will post my code first and the example that I modified and am effectively copying from below that.

      There may be some random and unused functions and variables about the place since I have been experimenting.

      Just previewed and it seems while the code is properly indented in the message editor, it does not seem to be when previewed. Is there anyway to do this?

      C Source Code

      1. #include <GL/glew.h>
      2. #include "glm/glm.hpp"
      3. #include "glm/gtc/matrix_transform.hpp"
      4. #include <Windows.h>
      5. #include "GLFW\glfw.h"
      6. #include <stdio.h>
      7. #include <typeinfo>
      8. #include <string>
      9. #include <iostream>
      10. #include <fstream>
      11. using namespace std;
      13. class Render;
      14. static Render* current;
      15. class Render
      16. {
      17. enum State
      18. {
      19. RUNNING,
      20. QUIT
      21. };
      22. State m_state;
      23. GLuint m_ProgramID;
      24. GLuint m_MatrixID;
      25. GLuint m_Texture;
      26. GLuint m_TextureID;
      28. GLuint m_VertexArrayID;
      30. GLuint m_VertexBuffer;
      31. GLuint m_UVBuffer;
      33. static const long m_Width;
      34. static const long m_Height;
      36. static const GLfloat g_vertex_buffer_data[12];
      37. static const GLfloat g_uv_buffer_data[8];
      39. glm::mat4 m_Model;
      40. glm::mat4 m_Projection;
      41. glm::mat4 m_View;
      43. glm::mat4 m_MVP;
      45. glm::vec2 m_speed; //units per sec
      46. public:
      47. static void GLFWCALL INPUTCALLBACK(int Key, int Action);
      48. Render();
      49. ~Render();
      50. void Init();
      51. void Destruct();
      52. void RenderNow();
      53. void Update(float deltaTime);
      54. int Run();
      55. private:
      56. GLuint LoadShaders(const char * vertex_file_path,const char * fragment_file_path)
      57. {
      59. // Create the shaders
      60. GLuint VertexShaderID = glCreateShader(GL_VERTEX_SHADER);
      61. GLuint FragmentShaderID = glCreateShader(GL_FRAGMENT_SHADER);
      63. // Read the Vertex Shader code from the file
      64. std::string VertexShaderCode;
      65. std::ifstream VertexShaderStream(vertex_file_path, std::ios::in);
      66. if(VertexShaderStream.is_open())
      67. {
      68. std::string Line = "";
      69. while(getline(VertexShaderStream, Line))
      70. VertexShaderCode += "\n" + Line;
      71. VertexShaderStream.close();
      72. }
      73. else
      74. {
      75. printf("Impossible to open %s. Are you in the right directory ? Don't forget to read the FAQ !\n", vertex_file_path);
      76. return 0;
      77. }
      79. // Read the Fragment Shader code from the file
      80. std::string FragmentShaderCode;
      81. std::ifstream FragmentShaderStream(fragment_file_path, std::ios::in);
      82. if(FragmentShaderStream.is_open())
      83. {
      84. std::string Line = "";
      85. while(getline(FragmentShaderStream, Line))
      86. FragmentShaderCode += "\n" + Line;
      87. FragmentShaderStream.close();
      89. }
      90. }
      91. GLuint loadTGA_glfw(const char * imagepath){
      93. // Create one OpenGL texture
      94. GLuint textureID;
      95. glGenTextures(1, &textureID);
      97. // "Bind" the newly created texture : all future texture functions will modify this texture
      98. glBindTexture(GL_TEXTURE_2D, textureID);
      100. // Read the file, call glTexImage2D with the right parameters
      101. glfwLoadTexture2D(imagepath, 0);
      103. // Nice trilinear filtering.
      104. glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
      105. glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
      106. glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
      107. glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
      108. glGenerateMipmap(GL_TEXTURE_2D);
      110. // Return the ID of the texture we just created
      111. return textureID;
      112. }
      113. };
      114. #pragma region vertexData
      115. const GLfloat Render::g_vertex_buffer_data[12] =
      116. {
      117. -100.0f, 100.0f, 0.0f,
      118. -100.0f, -100.0f, 0.0f,
      119. 100.0f, 100.0f, 0.0f,
      120. 100.0f, -100.0f, 0.0f
      121. };
      122. const GLfloat Render::g_uv_buffer_data[8] =
      123. {
      124. 0.0f, 1.0f,
      125. 0.0f, 0.0f,
      126. 1.0f, 1.0f,
      127. 1.0f, 0.0f
      128. };
      129. #pragma endregion
      130. const long Render::m_Width = 1024;
      131. const long Render::m_Height = 768;
      132. int main()
      133. {
      134. current = new Render();
      135. current->Init();
      136. while (current->Run() != 0)
      137. {
      138. }
      139. current->Destruct();
      140. return 0;
      141. }
      142. Render::Render()
      143. {
      144. m_state = State::RUNNING;
      145. printf("Render Object created! \n");
      146. }
      147. void Render::Init()
      148. {
      149. if(!glfwInit())
      150. {
      151. fprintf(stderr, "Failed to initialize GLFW \n");
      152. }
      153. glfwOpenWindowHint(GLFW_FSAA_SAMPLES, 4);
      154. glfwOpenWindowHint(GLFW_OPENGL_VERSION_MAJOR, 3);
      155. glfwOpenWindowHint(GLFW_OPENGL_VERSION_MINOR, 3);
      156. glfwOpenWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
      158. if(!glfwOpenWindow(m_Width, m_Height, 0, 0,0,0,32, 0, GLFW_WINDOW))
      159. {
      160. fprintf(stderr, "Open window failed :( \n");
      161. glfwTerminate();
      162. }
      164. glewExperimental = true;
      166. if(glewInit() != GLEW_OK)
      167. {
      168. fprintf(stderr, "Failed to initialize GLEW! :( ");
      169. }
      171. glfwSetWindowTitle("Render");
      173. glfwEnable(GLFW_STICKY_KEYS);
      175. glClearColor(0.0f, 0.0f, 0.4f, 0.0f);
      177. glEnable(GL_DEPTH_TEST);
      179. glDepthFunc(GL_LESS);
      181. glGenVertexArrays(1, &m_VertexArrayID);
      182. glBindVertexArray(m_VertexArrayID);
      184. m_ProgramID = LoadShaders("Transform.vertexshader","Texture.fragmentshader");
      186. m_MatrixID = glGetUniformLocation(m_ProgramID, "MVP");
      188. m_Texture = loadTGA_glfw("textu.tga");
      190. m_TextureID = glGetUniformLocation(m_ProgramID, "myTextureSampler");
      192. glGenBuffers(1, &m_VertexBuffer);
      193. glBindBuffer(GL_ARRAY_BUFFER, m_VertexBuffer);
      194. glBufferData(GL_ARRAY_BUFFER, sizeof(g_vertex_buffer_data), g_vertex_buffer_data, GL_STATIC_DRAW);
      196. glGenBuffers(1, &m_UVBuffer);
      197. glBindBuffer(GL_ARRAY_BUFFER, m_UVBuffer);
      198. glBufferData(GL_ARRAY_BUFFER, sizeof(g_uv_buffer_data), g_uv_buffer_data, GL_STATIC_DRAW);
      200. m_Model = glm::mat4(1.0f);
      202. glfwSetKeyCallback(INPUTCALLBACK);
      204. m_Projection = glm::ortho(float(-(m_Width/2)),float( m_Width/2), float(-(m_Height/2)), float(m_Height/2), 1.0f, 100.0f);
      205. m_View = glm::lookAt(
      206. glm::vec3(0,0,3),
      207. glm::vec3(0,0,0),
      208. glm::vec3(0,1,0)
      209. );
      211. printf("INIT SUCCEEDED!");
      212. }
      213. void Render::Destruct()
      214. {
      215. glDeleteBuffers(1, &m_VertexBuffer);
      216. glDeleteBuffers(1, &m_UVBuffer);
      217. glDeleteProgram(m_ProgramID);
      218. glDeleteTextures(1, &m_TextureID);
      219. glDeleteVertexArrays(1, &m_VertexArrayID);
      220. }
      221. void Render::RenderNow()
      222. {
      223. glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
      225. glUseProgram(m_ProgramID);
      226. glUniformMatrix4fv(m_MatrixID, 1, GL_FALSE, &m_MVP[0][0]);
      227. glActiveTexture(GL_TEXTURE0);
      228. glBindTexture(GL_TEXTURE_2D, m_Texture);
      229. glUniform1i(m_TextureID, 0);
      231. glEnableVertexAttribArray(0);
      232. glBindBuffer(GL_ARRAY_BUFFER, m_VertexBuffer);
      233. glVertexAttribPointer(0,3,GL_FLOAT,GL_FALSE,0,(void*)0);
      235. glEnableVertexAttribArray(1);
      236. glBindBuffer(GL_ARRAY_BUFFER, m_UVBuffer);
      237. glVertexAttribPointer(1,2,GL_FLOAT,GL_FALSE,0,(void*)0);
      239. glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
      241. glDisableVertexAttribArray(0);
      242. glDisableVertexAttribArray(1);
      244. glfwSwapBuffers();
      245. }
      246. void Render::Update(float deltaTime)
      247. {
      248. m_Model[3].x += (m_speed.x * deltaTime);
      249. m_Model[3].y += (m_speed.y * deltaTime);
      250. m_MVP = m_Projection * m_View * m_Model;
      251. }
      252. Render::~Render()
      253. {
      254. }
      255. void Render::INPUTCALLBACK(int Key, int Action)
      256. {
      257. if(Key == GLFW_KEY_DOWN && Action == GLFW_PRESS)
      258. current->m_speed.y += -0.2;
      259. if(Key == GLFW_KEY_UP && Action == GLFW_PRESS)
      260. current->m_speed.y += 0.2;
      261. if(Key == GLFW_KEY_RIGHT && Action == GLFW_PRESS)
      262. current->m_speed.x += 0.2;
      263. if(Key == GLFW_KEY_LEFT && Action == GLFW_PRESS)
      264. current->m_speed.x += -0.2;
      265. }
      266. int Render::Run()
      267. {
      268. float lastTime = glfwGetTime();
      269. float deltaTime;
      270. while(m_state != State::QUIT)
      271. {
      272. deltaTime = glfwGetTime() - lastTime;
      273. lastTime = glfwGetTime();
      274. Update(deltaTime);
      275. RenderNow();
      276. }
      277. return 0;
      278. }
      Display All


      VertexShader:

      Source Code

      1. #version 330 core
      3. // Input vertex data, different for all executions of this shader.
      4. layout(location = 0) in vec3 vertexPosition_modelspace;
      5. layout(location = 1) in vec2 vertexUV;
      7. // Output data ; will be interpolated for each fragment.
      8. out vec2 UV;
      10. // Values that stay constant for the whole mesh.
      11. uniform mat4 MVP;
      13. void main(){
      15. // Output position of the vertex, in clip space : MVP * position
      16. gl_Position = MVP * vec4(vertexPosition_modelspace,1);
      18. // UV of the vertex. No special space for this one.
      19. UV = vertexUV;
      20. }
      Display All


      Fragment Shader:

      Source Code

      1. #version 330 core
      3. // Interpolated values from the vertex shaders
      4. in vec2 UV;
      6. // Ouput data
      7. out vec3 color;
      9. // Values that stay constant for the whole mesh.
      10. uniform sampler2D myTextureSampler;
      12. void main(){
      14. // Output color = color of the texture at the specified UV
      15. color = texture2D( myTextureSampler, UV ).rgb;
      16. }
      Display All
      Files

      • Main.cpp

        (7.04 kB, downloaded 1,323 times, last: )

      The post was edited 1 time, last by olivermd ().

    • C Source Code

      1. // Include standard headers
      2. #include <stdio.h>
      3. #include <stdlib.h>
      5. // Include GLEW
      6. #include <GL/glew.h>
      8. // Include GLFW
      9. #include <GL/glfw.h>
      11. // Include GLM
      12. #include <glm/glm.hpp>
      13. #include <glm/gtc/matrix_transform.hpp>
      14. using namespace glm;
      16. #include <common/shader.hpp>
      17. #include <common/texture.hpp>
      19. void GLFWCALL DownCallBack(int Key, int action);
      23. int main( void )
      24. {
      27. // Initialise GLFW
      28. if( !glfwInit() )
      29. {
      30. fprintf( stderr, "Failed to initialize GLFW\n" );
      31. return -1;
      32. }
      34. glfwOpenWindowHint(GLFW_FSAA_SAMPLES, 4);
      35. glfwOpenWindowHint(GLFW_OPENGL_VERSION_MAJOR, 3);
      36. glfwOpenWindowHint(GLFW_OPENGL_VERSION_MINOR, 3);
      37. glfwOpenWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
      39. // Open a window and create its OpenGL context
      40. if( !glfwOpenWindow( 1024, 768, 0,0,0,0, 32,0, GLFW_WINDOW ) )
      41. {
      42. fprintf( stderr, "Failed to open GLFW window. If you have an Intel GPU, they are not 3.3 compatible. Try the 2.1 version of the tutorials.\n" );
      43. glfwTerminate();
      44. return -1;
      45. }
      47. // Initialize GLEW
      48. glewExperimental = true; // Needed for core profile
      49. if (glewInit() != GLEW_OK) {
      50. fprintf(stderr, "Failed to initialize GLEW\n");
      51. return -1;
      52. }
      54. glfwSetWindowTitle( "Tutorial 05" );
      56. // Ensure we can capture the escape key being pressed below
      57. glfwEnable( GLFW_STICKY_KEYS );
      59. // Dark blue background
      60. glClearColor(0.0f, 0.0f, 0.4f, 0.0f);
      62. // Enable depth test
      63. glEnable(GL_DEPTH_TEST);
      64. // Accept fragment if it closer to the camera than the former one
      65. glDepthFunc(GL_LESS);
      67. GLuint VertexArrayID;
      68. glGenVertexArrays(1, &VertexArrayID);
      69. glBindVertexArray(VertexArrayID);
      71. // Create and compile our GLSL program from the shaders
      72. GLuint programID = LoadShaders( "TransformVertexShader.vertexshader", "TextureFragmentShader.fragmentshader" );
      74. // Get a handle for our "MVP" uniform
      75. GLuint MatrixID = glGetUniformLocation(programID, "MVP");
      78. // Load the texture using any two methods
      79. //GLuint Texture = loadBMP_custom("uvtemplate.bmp");
      80. GLuint Texture = loadTGA_glfw("textu.tga");
      82. // Get a handle for our "myTextureSampler" uniform
      83. GLuint TextureID = glGetUniformLocation(programID, "myTextureSampler");
      85. // Our vertices. Tree consecutive floats give a 3D vertex; Three consecutive vertices give a triangle.
      86. // A cube has 6 faces with 2 triangles each, so this makes 6*2=12 triangles, and 12*3 vertices
      87. static const GLfloat g_vertex_buffer_data[] = {
      88. -100.0f, 100.0f, 0.0f,
      89. -100.0f, -100.0f, 0.0f,
      90. 100.0f, 100.0f, 0.0f,
      91. 100.0f, -100.0f, 0.0f
      92. };
      94. // Two UV coordinatesfor each vertex. They were created withe Blender.
      95. static const GLfloat g_uv_buffer_data[] = {
      96. 0.0f, 1.0f,
      97. 0.0f, 0.0f,
      98. 1.0f, 1.0f,
      99. 1.0f, 0.0f
      100. };
      102. GLuint vertexbuffer;
      103. glGenBuffers(1, &vertexbuffer);
      104. glBindBuffer(GL_ARRAY_BUFFER, vertexbuffer);
      105. glBufferData(GL_ARRAY_BUFFER, sizeof(g_vertex_buffer_data), g_vertex_buffer_data, GL_STATIC_DRAW);
      107. GLuint uvbuffer;
      108. glGenBuffers(1, &uvbuffer);
      109. glBindBuffer(GL_ARRAY_BUFFER, uvbuffer);
      110. glBufferData(GL_ARRAY_BUFFER, sizeof(g_uv_buffer_data), g_uv_buffer_data, GL_STATIC_DRAW);
      112. glm::mat4 Model = glm::mat4(1.0f);
      114. glfwSetKeyCallback(DownCallBack);
      116. do{
      117. static double lastTime = glfwGetTime();
      118. double deltaTime = glfwGetTime() - lastTime;
      119. // Clear the screen
      120. glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
      122. // Projection matrix : 45° Field of View, 4:3 ratio, display range : 0.1 unit <-> 100 units
      123. glm::mat4 Projection = glm::ortho(-1024.0f/2.0f, 1024.0f/2.0f, -768.0f/2.0f, 768.0f/2.0f, 1.0f, 100.0f);
      124. // Camera matrix
      125. glm::mat4 View = glm::lookAt(
      126. glm::vec3(0,0,3), // Camera is at (4,3,3), in World Space
      127. glm::vec3(0,0,0), // and looks at the origin
      128. glm::vec3(0,1,0) // Head is up (set to 0,-1,0 to look upside-down)
      129. );
      130. // Model matrix : an identity matrix (model will be at the origin)
      132. // Our ModelViewProjection : multiplication of our 3 matrices
      134. if(glfwGetKey(GLFW_KEY_DOWN ) == GLFW_PRESS)
      135. {
      136. Model[3].x += (4 * deltaTime);
      137. //printf();
      138. }
      140. glm::mat4 MVP = Projection * View * Model; // Remember, matrix multiplication is the other way around
      142. // Use our shader
      143. glUseProgram(programID);
      145. // Send our transformation to the currently bound shader,
      146. // in the "MVP" uniform
      147. glUniformMatrix4fv(MatrixID, 1, GL_FALSE, &MVP[0][0]);
      149. // Bind our texture in Texture Unit 0
      150. glActiveTexture(GL_TEXTURE0);
      151. glBindTexture(GL_TEXTURE_2D, Texture);
      152. // Set our "myTextureSampler" sampler to user Texture Unit 0
      153. glUniform1i(TextureID, 0);
      155. // 1rst attribute buffer : vertices
      156. glEnableVertexAttribArray(0);
      157. glBindBuffer(GL_ARRAY_BUFFER, vertexbuffer);
      158. glVertexAttribPointer(
      159. 0, // attribute. No particular reason for 0, but must match the layout in the shader.
      160. 3, // size
      161. GL_FLOAT, // type
      162. GL_FALSE, // normalized?
      163. 0, // stride
      164. (void*)0 // array buffer offset
      165. );
      167. // 2nd attribute buffer : UVs
      168. glEnableVertexAttribArray(1);
      169. glBindBuffer(GL_ARRAY_BUFFER, uvbuffer);
      170. glVertexAttribPointer(
      171. 1, // attribute. No particular reason for 1, but must match the layout in the shader.
      172. 2, // size : U+V => 2
      173. GL_FLOAT, // type
      174. GL_FALSE, // normalized?
      175. 0, // stride
      176. (void*)0 // array buffer offset
      177. );
      179. // Draw the triangle !
      180. glDrawArrays(GL_TRIANGLE_STRIP, 0, 4); // 12*3 indices starting at 0 -> 12 triangles
      182. glDisableVertexAttribArray(0);
      183. glDisableVertexAttribArray(1);
      185. // Swap buffers
      186. glfwSwapBuffers();
      188. } // Check if the ESC key was pressed or the window was closed
      189. while( glfwGetKey( GLFW_KEY_ESC ) != GLFW_PRESS &&
      190. glfwGetWindowParam( GLFW_OPENED ) );
      192. // Cleanup VBO and shader
      193. glDeleteBuffers(1, &vertexbuffer);
      194. glDeleteBuffers(1, &uvbuffer);
      195. glDeleteProgram(programID);
      196. glDeleteTextures(1, &TextureID);
      197. glDeleteVertexArrays(1, &VertexArrayID);
      199. // Close OpenGL window and terminate GLFW
      200. glfwTerminate();
      202. return 0;
      203. }
      205. void GLFWCALL DownCallBack(int Key, int action)
      206. {
      209. }
      Display All


      EDIT:
      Just done some more tests and discovered that if I copy the original source to my new file the white screen still appears and if I copy the source from my new file to the original the white screen also appears. This leads me to believe that it is due to an included file since I used the new file's include files for both tests. Fixed it by changing some header files although I'm not sure why it worked.

      The post was edited 2 times, last by olivermd ().

    • I was just about to go through your code, too late I guess!
      PC - Custom Built
      CPU: 3rd Gen. Intel i7 3770 3.4Ghz
      GPU: ATI Radeon HD 7959 3GB
      RAM: 16GB

      Laptop - Alienware M17x
      CPU: 3rd Gen. Intel i7 - Ivy Bridge
      GPU: NVIDIA GeForce GTX 660M - 2GB GDDR5
      RAM: 8GB Dual Channel DDR3 @ 1600mhz