Followers 0

# OpenGL Making glOrtho work (or writing an intuitive projection matrix)

## 10 posts in this topic

Hi guys,

I've messed around with my fixed (only the width and heights) orthographic projection in relation to guis.

Now I'd like to put my neat, flexible Projection class to use and create a Camera that will render me an overview map.

The view vectors are potentially much different than the 2d stuff, as it doesn't need to picture my level from straight above, necessarily.

Unlike what many people say on the webs, it can be necessary to provide negative near and far clipping values to glOrtho, to get the wanted result. This is AFAIK because of some old ortho stuff from the early days of OpenGl.
(See http://mlucassmith.tumblr.com/post/10869898438/why-i-hate-glortho-and-all-its-offspring for more on glOrtho and why it doesn't behave like glFrustrum.)

What I'm getting if I just mess around with the values a bit (in case I want the ortho camera oriented directly downwards) is this:

[attachment=16772:argh.png]

(The floor slabs are gray on the top colored on the underside)

I have depth buffering enabled, but it looks like (perhaps because of the inverted clipping plane values (near  -100, far: 100) the depth values are swapped) If it's not this, then it's the "up" vector not working as I intend it to, and it mirrors the projection somehow.

I get the correct projection by swapping near and far, and swapping the target and the eye vectors. (aside from being an orthographic projection, it's similar to me seeing the toy car in my kid's room when i see from the toy car, vieweing from me (near, 32.0f) to it (far, 0.1f)) in the direction of where i stand.

I read up on projection matrices (just how to set them up), and I messed with the values to initially copy the behavior of glOrtho:

    GLfloat tx = -((ortho_right+ortho_left) / (ortho_right-ortho_left));
GLfloat ty = -((ortho_top+ortho_bottom) / (ortho_top-ortho_bottom));
GLfloat tz = -((clip_far+clip_near) / (clip_far-clip_near));
GLfloat cx =  (2.0f / (ortho_right - ortho_left));
GLfloat cy =  (2.0f / (ortho_top   - ortho_bottom));
GLfloat cz = -(2.0f / (clip_far    - clip_near));

GLfloat mtx[16] ={  cx, 0.0f, 0.0f,   0.0f,
0.0f,   cy, 0.0f,   0.0f,
0.0f, 0.0f,   cz,   0.0f,
tx, ty, tz, 1.0f };
glMultMatrixf(mtx);


I'd like to fix this so I end up with a more intuitive "myOrtho()" (meaning the clip_near resembles the direct linear distance ahead of the camera, in the view direction in which the near clipping plane exists, and the clip_far resembles the one of the far clipping plane (both being positive values)).

Unfortunately, my general projection matrix math is very rusty, and I barely managed to copy the khronos man page description for glOrtho.

Have you guys tried this before? The alternative would be to negate view directions and the near and far clipping values on every frame drawn into an orthographic projection. And I'm reluctant to do that as it seems a bit hackish. Shouldn't the projection just "work"?

Edited by SuperVGA
0

##### Share on other sites

To clarify, if i want the same draw order and general view direction with glOrtho projection as I get with glFrustrum,

I need adapt my projection and modelview as such:

[attachment=16777:reverse proj vectors.png]

(And I feel like I shouldn't have to mess with my ModelView matrix just to get the right contents on the screen.

-Can't we just have an orthographic projection set up so it can take the same eye and target vectors as a perspective projection?)

Edited by SuperVGA
0

##### Share on other sites

... Bump! Is there really no good way to set up an ortographic projection in opengl without hacking around with the model view matrix?

0

##### Share on other sites

In your code, you have swapped both the near and far planes, and the view direction. Those two negates each other. If you use an orthographic projection with the same eye and target position, and same near and far planes, you will get an equivalent view of the scene. Only the vertical and horizontal scaling will be different, but that is a natural result of the fundamental differences between the two types of projections.

0

##### Share on other sites

In your code, you have swapped both the near and far planes, and the view direction. Those two negates each other. If you use an orthographic projection with the same eye and target position, and same near and far planes, you will get an equivalent view of the scene. Only the vertical and horizontal scaling will be different, but that is a natural result of the fundamental differences between the two types of projections.

Hi, thanks for responding. The code for the projection is actually a copy of how glOrtho already works (see the glOrtho entry, paste the markup for the page into http://www.madogiwa.org/display-mathml/live.html to get the actual formulas (or use an mml client)). I'll guess Id only need to reverse the depth check to make it work,

but even then it doesn't seem to do the same thing as only using glOrtho without swapping the values. (Also, I read somewhere that only the far value should be negative)

(I'm still basically saying: I cannot replace glFrustrum with glOrtho and expect the same items showing (disregarding of the perspective vs parallel projection bit))

I have to change the eye position or the depth test.

At least, I haven't been able to make it just by changing the projection.

Edited by SuperVGA
0

##### Share on other sites

Perhaps I don't understand your problem. If you have (the equivalent of) the following setup:

glMatrixMode(GL_PROJECTION);
glFrustum(..., 0.1, 32);

glMatrixMode(GL_MODELVIEW);
glLookAt(eye.x, eye.y, eye.z, target.x, target.y, target.z, up.x, up.y, up.z);


then the equivalent orthographic view is:

glMatrixMode(GL_PROJECTION);
glOrtho(l, r, t, b, 0.1, 32);

glMatrixMode(GL_MODELVIEW);
glLookAt(eye.x, eye.y, eye.z, target.x, target.y, target.z, up.x, up.y, up.z);


where you have to adjust l, r, t and b to get the desired horizontal and vertical scaling. The orthographic view will be from the same location, towards the same target location and with the same depth range. Is this what you're trying to achieve?

1

##### Share on other sites

Perhaps I don't understand your problem. If you have (the equivalent of) the following setup:

glMatrixMode(GL_PROJECTION);
glFrustum(..., 0.1, 32);

glMatrixMode(GL_MODELVIEW);
glLookAt(eye.x, eye.y, eye.z, target.x, target.y, target.z, up.x, up.y, up.z);


then the equivalent orthographic view is:

glMatrixMode(GL_PROJECTION);
glOrtho(l, r, t, b, 0.1, 32);

glMatrixMode(GL_MODELVIEW);
glLookAt(eye.x, eye.y, eye.z, target.x, target.y, target.z, up.x, up.y, up.z);


where you have to adjust l, r, t and b to get the desired horizontal and vertical scaling. The orthographic view will be from the same location, towards the same target location and with the same depth range. Is this what you're trying to achieve?

Yes, it's exaclty that. Only, I cannot make it do that. I have a viewport 0,0 -> 800, 600 and set l=-1.0, r=1.0, t=1.0, b=1.0, -1.0

from a view looking from 0.5, -0.5, 0.5 towards 0.5, 0.5, 0.5 where up.z = {0, 0, 1}

I have a 90 deg perspective projection that i can swap with, near set to 0.1 and far to 2.0, still, i draw an object at 0,0,0 (with lengths of all bound sides == 1.0)

Still i end up getting a view as if the depth test was reversed (as if the ortho eye is being far away, looking back at where it should've been),

where the perspective projection shows what is expected off the given parameters.

Edited by SuperVGA
0

##### Share on other sites

Show a complete program demonstrating your behavior, and keep it as simple as you possibly can. If there is a fundamental problem with your setup, you should easily be able to reduce and show it in 50 lines of code with a decent window wrapper API like GLUT or SDL.

Edited by Brother Bob
1

##### Share on other sites

I just rewrote the setup as a small sample. Cannot reproduce the issue.... Thanks for your input man, I must've done something else wrong.

0

##### Share on other sites

If you want to identify the problem, you should reduce your existing code, not rewrite it. If there is an error, it will either remain in the reduced code or you will know which piece of code you just removed when it started working as expected.

0

##### Share on other sites

If you want to identify the problem, you should reduce your existing code, not rewrite it. If there is an error, it will either remain in the reduced code or you will know which piece of code you just removed when it started working as expected.

Alright let me rephrase my previous statement then,

I wrote the part that does just the basic proj and model setup, again (i copied my existing code), into a smaller program.

The problem disappeared. (It behaved as one would expect.)

I found that you swapped the b and t values of glOrtho and found that I had culling set the wrong way (which added to the mystery of obscured objects being drawn).

I've fixed the issue in the bigger project.

0

## Create an account

Register a new account

Followers 0

• ### Similar Content

• Hello, I have been working on SH Irradiance map rendering, and I have been using a GLSL pixel shader to render SH irradiance to 2D irradiance maps for my static objects. I already have it working with 9 3D textures so far for the first 9 SH functions.
In my GLSL shader, I have to send in 9 SH Coefficient 3D Texures that use RGBA8 as a pixel format. RGB being used for the coefficients for red, green, and blue, and the A for checking if the voxel is in use (for the 3D texture solidification shader to prevent bleeding).
My problem is, I want to knock this number of textures down to something like 4 or 5. Getting even lower would be a godsend. This is because I eventually plan on adding more SH Coefficient 3D Textures for other parts of the game map (such as inside rooms, as opposed to the outside), to circumvent irradiance probe bleeding between rooms separated by walls. I don't want to reach the 32 texture limit too soon. Also, I figure that it would be a LOT faster.
Is there a way I could, say, store 2 sets of SH Coefficients for 2 SH functions inside a texture with RGBA16 pixels? If so, how would I extract them from inside GLSL? Let me know if you have any suggestions ^^.
• By DaniDesu
#include "MyEngine.h" int main() { MyEngine myEngine; myEngine.run(); return 0; } MyEngine.h
#pragma once #include "MyWindow.h" #include "MyShaders.h" #include "MyShapes.h" class MyEngine { private: GLFWwindow * myWindowHandle; MyWindow * myWindow; public: MyEngine(); ~MyEngine(); void run(); }; MyEngine.cpp
#pragma once #include <glad\glad.h> #include <GLFW\glfw3.h> class MyWindow { private: GLFWwindow * windowHandle; int windowWidth; int windowHeight; const char * windowTitle; public: MyWindow(int windowWidth, int windowHeight, const char * windowTitle); ~MyWindow(); GLFWwindow * getWindowHandle(); void createWindow(); void MyWindow::destroyWindow(); }; MyWindow.cpp
#include "MyWindow.h" MyWindow::MyWindow(int windowWidth, int windowHeight, const char * windowTitle) { this->windowHandle = NULL; this->windowWidth = windowWidth; this->windowWidth = windowWidth; this->windowHeight = windowHeight; this->windowTitle = windowTitle; glfwInit(); } MyWindow::~MyWindow() { } GLFWwindow * MyWindow::getWindowHandle() { return this->windowHandle; } void MyWindow::createWindow() { // Use OpenGL 3.3 and GLSL 3.3 glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3); glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3); // Limit backwards compatibility glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE); glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE); // Prevent resizing window glfwWindowHint(GLFW_RESIZABLE, GL_FALSE); // Create window this->windowHandle = glfwCreateWindow(this->windowWidth, this->windowHeight, this->windowTitle, NULL, NULL); glfwMakeContextCurrent(this->windowHandle); } void MyWindow::destroyWindow() { glfwTerminate(); } MyShapes.h
#pragma once #include <glad\glad.h> #include <GLFW\glfw3.h> class MyShapes { public: MyShapes(); ~MyShapes(); GLuint & drawTriangle(float coordinates[]); }; MyShapes.cpp
#include "MyShapes.h" MyShapes::MyShapes() { } MyShapes::~MyShapes() { } GLuint & MyShapes::drawTriangle(float coordinates[]) { GLuint vertexBufferObject{}; GLuint vertexArrayObject{}; // Create a VAO glGenVertexArrays(1, &vertexArrayObject); glBindVertexArray(vertexArrayObject); // Send vertices to the GPU glGenBuffers(1, &vertexBufferObject); glBindBuffer(GL_ARRAY_BUFFER, vertexBufferObject); glBufferData(GL_ARRAY_BUFFER, sizeof(coordinates), coordinates, GL_STATIC_DRAW); // Dertermine the interpretation of the array buffer glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 3*sizeof(float), (void *)0); glEnableVertexAttribArray(0); // Unbind the buffers glBindBuffer(GL_ARRAY_BUFFER, 0); glBindVertexArray(0); return vertexArrayObject; } MyFileHandler.h
#pragma once #include <cstdio> #include <cstdlib> class MyFileHandler { private: const char * fileName; unsigned long fileSize; void setFileSize(); public: MyFileHandler(const char * fileName); ~MyFileHandler(); unsigned long getFileSize(); const char * readFile(); }; MyFileHandler.cpp
#include "MyFileHandler.h" MyFileHandler::MyFileHandler(const char * fileName) { this->fileName = fileName; this->setFileSize(); } MyFileHandler::~MyFileHandler() { } void MyFileHandler::setFileSize() { FILE * fileHandle = NULL; fopen_s(&fileHandle, this->fileName, "rb"); fseek(fileHandle, 0L, SEEK_END); this->fileSize = ftell(fileHandle); rewind(fileHandle); fclose(fileHandle); return; } unsigned long MyFileHandler::getFileSize() { return (this->fileSize); } const char * MyFileHandler::readFile() { char * buffer = (char *)malloc((this->fileSize)+1); FILE * fileHandle = NULL; fopen_s(&fileHandle, this->fileName, "rb"); fread(buffer, this->fileSize, sizeof(char), fileHandle); fclose(fileHandle); buffer[this->fileSize] = '\0'; return buffer; } VertexShader.glsl
#version 330 core layout (location = 0) vec3 VertexPositions; void main() { gl_Position = vec4(VertexPositions, 1.0f); } FragmentShader.glsl
#version 330 core out vec4 FragmentColor; void main() { FragmentColor = vec4(1.0f, 0.0f, 0.0f, 1.0f); } I am attempting to create a simple engine/graphics utility using some object-oriented paradigms. My first goal is to get some output from my engine, namely, a simple red triangle.
For this goal, the MyShapes class will be responsible for defining shapes such as triangles, polygons etc. Currently, there is only a drawTriangle() method implemented, because I first wanted to see whether it works or not before attempting to code other shape drawing methods.
The constructor of the MyEngine class creates a GLFW window (GLAD is also initialized here to load all OpenGL functionality), and the myEngine.run() method in Main.cpp is responsible for firing up the engine. In this run() method, the shaders get loaded from files via the help of my FileHandler class. The vertices for the triangle are processed by the myShapes.drawTriangle() method where a vertex array object, a vertex buffer object and vertrex attributes are set for this purpose.
The while loop in the run() method should be outputting me the desired red triangle, but all I get is a grey window area. Why?
(Note: I am aware that this code is not using any good software engineering practices (e.g. exceptions, error handling). I am planning to implement them later, once I get the hang of OpenGL.)

• By KarimIO
EDIT: I thought this was restricted to Attribute-Created GL contexts, but it isn't, so I rewrote the post.
Hey guys, whenever I call SwapBuffers(hDC), I get a crash, and I get a "Too many posts were made to a semaphore." from Windows as I call SwapBuffers. What could be the cause of this?
Update: No crash occurs if I don't draw, just clear and swap.
static PIXELFORMATDESCRIPTOR pfd = // pfd Tells Windows How We Want Things To Be { sizeof(PIXELFORMATDESCRIPTOR), // Size Of This Pixel Format Descriptor 1, // Version Number PFD_DRAW_TO_WINDOW | // Format Must Support Window PFD_SUPPORT_OPENGL | // Format Must Support OpenGL PFD_DOUBLEBUFFER, // Must Support Double Buffering PFD_TYPE_RGBA, // Request An RGBA Format 32, // Select Our Color Depth 0, 0, 0, 0, 0, 0, // Color Bits Ignored 0, // No Alpha Buffer 0, // Shift Bit Ignored 0, // No Accumulation Buffer 0, 0, 0, 0, // Accumulation Bits Ignored 24, // 24Bit Z-Buffer (Depth Buffer) 0, // No Stencil Buffer 0, // No Auxiliary Buffer PFD_MAIN_PLANE, // Main Drawing Layer 0, // Reserved 0, 0, 0 // Layer Masks Ignored }; if (!(hDC = GetDC(windowHandle))) return false; unsigned int PixelFormat; if (!(PixelFormat = ChoosePixelFormat(hDC, &pfd))) return false; if (!SetPixelFormat(hDC, PixelFormat, &pfd)) return false; hRC = wglCreateContext(hDC); if (!hRC) { std::cout << "wglCreateContext Failed!\n"; return false; } if (wglMakeCurrent(hDC, hRC) == NULL) { std::cout << "Make Context Current Second Failed!\n"; return false; } ... // OGL Buffer Initialization glClear(GL_DEPTH_BUFFER_BIT | GL_COLOR_BUFFER_BIT); glBindVertexArray(vao); glUseProgram(myprogram); glDrawElements(GL_TRIANGLES, indexCount, GL_UNSIGNED_SHORT, (void *)indexStart); SwapBuffers(GetDC(window_handle));
• By Tchom
Hey devs!

I've been working on a OpenGL ES 2.0 android engine and I have begun implementing some simple (point) lighting. I had something fairly simple working, so I tried to get fancy and added color-tinting light. And it works great... with only one or two lights. Any more than that, the application drops about 15 frames per light added (my ideal is at least 4 or 5). I know implementing lighting is expensive, I just didn't think it was that expensive. I'm fairly new to the world of OpenGL and GLSL, so there is a good chance I've written some crappy shader code. If anyone had any feedback or tips on how I can optimize this code, please let me know.

uniform mat4 u_MVPMatrix; uniform mat4 u_MVMatrix; attribute vec4 a_Position; attribute vec3 a_Normal; attribute vec2 a_TexCoordinate; varying vec3 v_Position; varying vec3 v_Normal; varying vec2 v_TexCoordinate; void main() { v_Position = vec3(u_MVMatrix * a_Position); v_TexCoordinate = a_TexCoordinate; v_Normal = vec3(u_MVMatrix * vec4(a_Normal, 0.0)); gl_Position = u_MVPMatrix * a_Position; } Fragment Shader
precision mediump float; uniform vec4 u_LightPos["+numLights+"]; uniform vec4 u_LightColours["+numLights+"]; uniform float u_LightPower["+numLights+"]; uniform sampler2D u_Texture; varying vec3 v_Position; varying vec3 v_Normal; varying vec2 v_TexCoordinate; void main() { gl_FragColor = (texture2D(u_Texture, v_TexCoordinate)); float diffuse = 0.0; vec4 colourSum = vec4(1.0); for (int i = 0; i < "+numLights+"; i++) { vec3 toPointLight = vec3(u_LightPos[i]); float distance = length(toPointLight - v_Position); vec3 lightVector = normalize(toPointLight - v_Position); float diffuseDiff = 0.0; // The diffuse difference contributed from current light diffuseDiff = max(dot(v_Normal, lightVector), 0.0); diffuseDiff = diffuseDiff * (1.0 / (1.0 + ((1.0-u_LightPower[i])* distance * distance))); //Determine attenuatio diffuse += diffuseDiff; gl_FragColor.rgb *= vec3(1.0) / ((vec3(1.0) + ((vec3(1.0) - vec3(u_LightColours[i]))*diffuseDiff))); //The expensive part } diffuse += 0.1; //Add ambient light gl_FragColor.rgb *= diffuse; } Am I making any rookie mistakes? Or am I just being unrealistic about what I can do? Thanks in advance
• By yahiko00
Hi,
Not sure to post at the right place, if not, please forgive me...
For a game project I am working on, I would like to implement a 2D starfield as a background.
I do not want to deal with static tiles, since I plan to slowly animate the starfield. So, I am trying to figure out how to generate a random starfield for the entire map.
I feel that using a uniform distribution for the stars will not do the trick. Instead I would like something similar to the screenshot below, taken from the game Star Wars: Empire At War (all credits to Lucasfilm, Disney, and so on...).

Is there someone who could have an idea of a distribution which could result in such a starfield?
Any insight would be appreciated

• 10
• 28
• 14
• 11
• 33