Hi!

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.

You cannot just replace a perspective projection with an orthographic projection and expect things to just work with the same vertex data. The two are vastly different.

For example, just ignoring the look-at matrix for the moment, the orthographic projection matrix you use defines the visible coordinate range from 0 to 1024 along the X-axis, from 768 to 0 along the Y-axis (that is, a top-down axis), and from 0 to 100 along the Z-axis. If you then draw a triangle on the scale of 1 unit large (it extends between 0 and 1 on the X-axis and 1 and 2 on the Y-axis), inside a view volume 1024 by 768 units large, the triangle is only one pixel large.

If your triangle is inside the view volume, it will cover at most half of a single pixel in one of the four corners (once you add the look-at matrix, can't directly figure out which one though). It may even be too small to even be rasterized at all if the rasterizer decides it's doesn't cover enough of the pixel.

There are some things you can do to locate your triangle:

1. Look closer in the very corners of your window. It may be that there is in fact a small pixel there and the triangle is just too small that you haven't see it yet.
   
2. Make the view volume smaller or the triangle larger. Much smaller, or much larger. By a factor 100 or so.
   
3. Extend the view volume into the negative coordinates. It may be that your look-at matrix rotates the view volume such that the visible X-range is rotated around the Y-axis, from its original visible range from 0 to 1024, into the new visible range from 0 to -1024.
   
4. Drop the look-at matrix and focus just on getting the triangle to show up with the orthographic projection alone.
   

Hi Brother Bob.

Thanks for the quick reply.

If you then draw a triangle on the scale of 1 unit large (it extends between 0 and 1 on the X-axis and 1 and 2 on the Y-axis), inside a view volume 1024 by 768 units large, the triangle is only one pixel large.

From reading posts on stack overflow, I actually came to understand this but for some reason i started to doubt if I actually understood it correctly.
I did try with a few hundered pixels large triangle without any result so I doubt that is the problem, but I might be wrong, I'll try it again!

If your triangle is inside the view volume

This is the only reason I could think of trying to work it out on my own - that the triangle is out of bounds and thus not shown.
Using a larger triangle I can deduct wheter this is the case or not.

The main problem is that since this is uncharted territory for me, it's hard to trust instincts or information, your post cleared out some of the mist - thanks!

There are some things you can do to locate your triangle:
1.Look closer in the very corners of your window. It may be that there is in fact a small pixel there and the triangle is just too small that you haven't see it yet.
2.Make the view volume smaller or the triangle larger. Much smaller, or much larger. By a factor 100 or so.
3.Extend the view volume into the negative coordinates. It may be that your look-at matrix rotates the view volume such that the visible X-range is rotated around the Y-axis, from its original visible range from 0 to 1024, into the new visible range from 0 to -1024.
4.Drop the look-at matrix and focus just on getting the triangle to show up with the orthographic projection alone.

I think the major cause of confusion for me was the translation from "-1 to 1" space to "Screen width*height in pixels" space.
Unfortunatley I had to go to work for a few hours so I can't try this out right now, but I'm sure I'll get it working following these steps when I get home.


Thanks for taking your time to help me.

OK! So, I'm home now and able to go through it again.

1. Look closer in the very corners of your window. It may be that there is in fact a small pixel there and the triangle is just too small that you haven't see it yet.
[/quote]
Wow, It's there! Right where you'd think it would be, in the top left corner ( since it has 1,1 as coords).

Im such a retard. i THOUGHT i made a 100 pixel large triangle but what I really did was that I increased ALL points by 100 so I only moved the 1 pixel large triangle 100 pixels in the posetive x and y axis. *sigh*

static const GLfloat g_vertex_buffer_data[] =
{
1.0f, 1.0f, 0.0f,
100.0f, 1.0f, 0.0f,
0.0f, 100.0f, 0.0f,
};

Works as intended!

Thanks alot m8!