I am currently trying to learn openGL (and 3d programming in general) using this tutorial:
http://www.opengl-tu...ners-tutorials/
I have finished the first 3 tutorials and I think that I have a basic grasp of what's going on.
Now, my problem is that when I try to follow the authors advice to experiment with glm::ortho as an alternative to glm::perspective I cannot, for the life of me, get anything to show in the cameras "field of view".
The problematic code:
// Projection matrix : 45° Field of View, 4:3 ratio, display range : 0.1 unit <-> 100 units
//glm::mat4 Projection = glm::perspective(45.f, 4.0f / 3.0f, 0.1f, 100.0f);
glm::mat4 Projection = glm::ortho(
0.0f,
static_cast<float>(SCREEN_WIDTH),
static_cast<float>(SCREEN_HEIGHT),
0.0f,
0.0f,
100.0f
);
// Camera matrix
glm::mat4 View = glm::lookAt(
glm::vec3(0,0,5), // Camera is at (0,0,5), in World Space
glm::vec3(0,0,0), // and looks at the origin
glm::vec3(0,1,0) // Head is up (set to 0,-1,0 to look upside-down)
);
// Model matrix : an identity matrix (model will be at the origin)
glm::mat4 Model = glm::mat4(1.0f);
// Our ModelViewProjection : multiplication of our 3 matrices
glm::mat4 MVP = Projection * View * Model; // Remember, matrix multiplication is the other way around
// An array of 3 vectors which represents 3 vertices
static const GLfloat g_vertex_buffer_data[] =
{
1.0f, 1.0f, 0.0f,
1.0f, 2.0f, 0.0f,
0.0f, 1.0f, 0.0f,
};
SCREEN_WIDTH and SCREEN_HEIGHT are int constants 1024, 768 respectively.
If I use a projection matrix generated with glm::perspective (the on commented out at line 2) everything works as it should.
As I move the object around and change the projection matrix parameters, it behaves as you think it should.
But when I use glm::ortho I cannot get the triangle to show, no mather what coordinates I use for the triangles vertices or what values I pass as parameters to glm::ortho. (And I've tried a lot of them )
If I understand it correctly you would use ortho when you want to display objects without depth, kind of like how you would in normal 2d space, (which makes me a bit confused about the zNear and zFar parameters, but still, if I'm not misstaken, the triangle should be visible given the projeciton matrix im producing with glm::ortho and the triangles position)
I've searched both gamedev and other resources on the web but I can't find that I'm doing anything wrong or different compared to working examples.
So, the only conclusion I can come to is that I'm missunderstanding the use of glm::ortho or 3d space in general, or that I made some noob mistake, as my grasp of 3d programming is close to nonexisting.
So please, if you have the time, enlighten me as to what I am doing wrong!
Whole main.cpp if needed:
// Include standard headers
#include <iostream>
// Include GLEW
#define GLEW_STATIC
#include "glew.h"
// Include GLFW
#include "glfw.h"
// Include GLM
#include <glm/glm.hpp>
#include <glm/gtc/matrix_transform.hpp>
#include <glm/gtx/transform.hpp>
// Include Shaders
#include "common/shader.hpp"
const int SCREEN_WIDTH = 1024;
const int SCREEN_HEIGHT = 768;
const int SCREEN_BPP = 32;
int main( void )
{
// Initialise GLFW
if (!glfwInit())
{
std::cout << stderr << "Failed to initialize GLFW." << std::endl;
return -1;
}
glfwOpenWindowHint(GLFW_FSAA_SAMPLES, 4);
glfwOpenWindowHint(GLFW_OPENGL_VERSION_MAJOR, 3);
glfwOpenWindowHint(GLFW_OPENGL_VERSION_MINOR, 3);
glfwOpenWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
// Open a window and create its OpenGL context
if (!glfwOpenWindow(SCREEN_WIDTH, SCREEN_HEIGHT, 0, 0, 0, 0, SCREEN_BPP, 0, GLFW_WINDOW))
{
std::cout << stderr << "Failed to open GLFW window." << std::endl;
glfwTerminate();
return -1;
}
// Initialize GLEW
if (glewInit() != GLEW_OK)
{
std::cout << stderr << "Failed to initialize GLEW." << std::endl;
return -1;
}
glfwSetWindowTitle("OpenGL 3 Training");
// Ensure we can capture the escape key being pressed below
glfwEnable(GLFW_STICKY_KEYS);
// Black background
glClearColor(0.f, 0.f, 1.f, 1.f);
GLuint VertexArrayID;
glGenVertexArrays(1, &VertexArrayID);
glBindVertexArray(VertexArrayID);
// Create and compile our GLSL program from the shaders
GLuint programID = LoadShaders("SimpleTransformShader.vertexshader", "SimpleFragmentShader.fragmentshader");
// Get a handle for our "MVP" uniform
GLuint MatrixID = glGetUniformLocation(programID, "MVP");
// Projection matrix : 45° Field of View, 4:3 ratio, display range : 0.1 unit <-> 100 units
//glm::mat4 Projection = glm::perspective(45.f, 4.0f / 3.0f, 0.1f, 100.0f);
glm::mat4 Projection = glm::ortho(
0.0f,
static_cast<float>(SCREEN_WIDTH),
static_cast<float>(SCREEN_HEIGHT),
0.0f,
0.0f,
100.0f
);
// Camera matrix
glm::mat4 View = glm::lookAt(
glm::vec3(0,0,5), // Camera is at (0,0,5), in World Space
glm::vec3(0,0,0), // and looks at the origin
glm::vec3(0,1,0) // Head is up (set to 0,-1,0 to look upside-down)
);
// Model matrix : an identity matrix (model will be at the origin)
glm::mat4 Model = glm::mat4(1.0f);
// Our ModelViewProjection : multiplication of our 3 matrices
glm::mat4 MVP = Projection * View * Model; // Remember, matrix multiplication is the other way around
// An array of 3 vectors which represents 3 vertices
static const GLfloat g_vertex_buffer_data[] =
{
1.0f, 1.0f, 0.0f,
1.0f, 2.0f, 0.0f,
0.0f, 1.0f, 0.0f,
};
static const GLushort g_element_buffer_data[] = { 0, 1, 2 };
// This will identify our vertex buffer
GLuint vertexbuffer;
// Generate 1 buffer, put the resulting identifier in vertexbuffer
glGenBuffers(1, &vertexbuffer);
// The following commands will talk about our 'vertexbuffer' buffer
glBindBuffer(GL_ARRAY_BUFFER, vertexbuffer);
// Give our vertices to OpenGL.
glBufferData(GL_ARRAY_BUFFER, sizeof(g_vertex_buffer_data), g_vertex_buffer_data, GL_STATIC_DRAW);
while (true)
{
// Check if the ESC key was pressed or the window was closed
if (glfwGetKey(GLFW_KEY_ESC) == GLFW_PRESS || !glfwGetWindowParam(GLFW_OPENED))
break;
// Clear the screen with the clearcolor
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
// User our shader
glUseProgram(programID);
// Send our transformation to the currently bound shader, in the "MVP" uniform
glUniformMatrix4fv(MatrixID, 1, GL_FALSE, &MVP[0][0]);
// First attribute buffer : vertices
glEnableVertexAttribArray(0);
glBindBuffer(GL_ARRAY_BUFFER, vertexbuffer);
glVertexAttribPointer(
0, // attribute 0. No particular reason for 0, but must match the layout in the shader.
3, // size
GL_FLOAT, // type
GL_FALSE, // normalized?
0, // stride
(void*)0 // array buffer offset
);
// Draw the triangle !
glDrawArrays(GL_TRIANGLES, 0, 3); // Starting from vertex 0; 3 vertices total -> 1 triangle
glDisableVertexAttribArray(0);
// Swap buffers
glfwSwapBuffers();
}
// Cleanup VBO and shader
glDeleteBuffers(1, &vertexbuffer);
glDeleteProgram(programID);
glDeleteVertexArrays(1, &VertexArrayID);
// Close OpenGL window and terminate GLFW
glfwTerminate();
return 0;
}
Thanks in advance / AS.