Sign in to follow this  

OpenGL I can't understand matrices

Recommended Posts

Paprica    126
I've been reading this opengl guide: [url=""][/url]
I didn't quite understand the whole idea behind matrices.

Like in the next given reshape function that I'm supposed to assign to my windows library:
void reshape(GLsizei w, GLsizei h)
glMatrixMode (GL_PROJECTION); /* prepare for and then */
glLoadIdentity (); /* define the projection */
glFrustum (-1.0, 1.0, -1.0, 1.0, /* transformation */
1.5, 20.0);
glMatrixMode (GL_MODELVIEW); /* back to modelview matrix */
glViewport (0, 0, w, h); /* define the viewport */

I didn't really get the idea behind changing to matrix modes and what each matrix does.
I also didn't understand what's the difference between glFrustum and glOrtho and when I should use each function.
And, I understood that gluPerspective is used as an alternative function to glFrustum, with both functions using different parameters, so when should I use each one?

Also, I don't know what's that "plane" that the author is talking about all the time. (probably because of my poor English)

Some explanations may help, thanks! Edited by Paprica

Share this post

Link to post
Share on other sites
Joey P    111
The matrices convert points in world coordinates to points in screen coordinates.

The projection matrix takes vertices in 3d geometry and projects them onto your 2d screen. Every frame each vertex is multiplied by the projection matrix to determine its 2d coordinates on screen.

Before this however, the model view matrix is used to convert vertices from object coordinates into world coordinates relative to your view. So if you are rendering a cube for example and you define the center of the cube to be point 0,0,0 in object coordinates, and one of the corners is 1,1,-1, and then it is positioned 12 units in front of your camera, and 5 units up, the model view matrix determines the coordinate of the vertex relative to your camera position, ie what the vertex would be if your camera was 0,0,0.

You can work with the model matrix and view matrix separately, which I prefer, but some versions of OpenGL (like OpenGL ES 1.0) don't allow this. In the end you'll pass only the combined MVP matrix to your shader.

The glPerspective and glFrustrum methods are used to determine the view matrix for you. Use glPerspective if you want to specify a horizontal and vertical FOV.

The "planes" you're talking about are near and far clipping planes, they just determine how far and close you should be able to see objects. So if you specify a far clipping plane of 100, you won't be able to see any objects more than 100 units from the camera (ever wonder why old games use fog?) The farther you set the far clipping plane, the farther away you'll be able to render objects, but if you set it too far out OpenGL will have a harder time determining which objects should be in front of eachother.

Share this post

Link to post
Share on other sites
Alex Melbourne    294
[quote name='Paprica' timestamp='1341658791' post='4956615']Is the far clipping plane the value I pass to zFar in glFrostum?[/quote]

A viewing frustum has six clipping planes ([url=""]http://en.wikipedia....Viewing_frustum[/url]). OpenGL checks vertices passed to it to see which side of the plane they exist on. If they are within the frustum then they are observable on screen.

You're sort of the right lines with your statement. The value you pass to zFar forms the z-coordinate that is used when creating the frustum.

[source lang="cpp"]
/* perform camera movement */
/* list coordinates */

glMatrixMode(GL_PROJECTION); /* switch to the projection matrix */
glLoadIdentity(); /* load an identity matrix so we don't add to the previous matrix */
glFrustum(-aspect, aspect, -1.0, 1.0, aspect / tan(fov / 2.0f), 1000.0); /* create a frustum */

glViewport(0, 0, WIDTH, HEIGHT);

Where 'aspect' is defined as your aspect ratio (WIDTH / HEIGHT) and 'fov' is the desired field of view.

[quote name='Paprica' timestamp='1341616966' post='4956521']I didn't quite understand the whole idea behind matrices.[/quote]

A matrix is a method presenting transformations in a coordinate system. OpenGL multiples the vertices that are passed to it by the matrix so that their final position can be determined. For example if you had a rotation matrix R that stored the details to rotate a model by 45 degrees and we had a model (a model is just a series of vertices) then we can multiple all of the points in the model by R and rotate the model.

[quote name='Paprica' timestamp='1341616966' post='4956521']I didn't really get the idea behind changing to matrix modes and what each matrix does.[/quote]

OpenGL is written as a giant finite state machine. It contains three matrices - the projection matrix, the modelview matrix, and the texture matrix (I won't talk about the last).

Vertices that are passed to OpenGL are actually multiple by both the modelview and projection matrices. This is odd because it isn't like you can modify the camera in the projection matrix and coordinates in the modelview matrix (this is what I thought when I started).

OpenGL first multiples vertices by the modelview matrix to determine the 'eye'-coordinates. The eye coordinates are the position of the points in the world relative to the camera.

The projection matrix is used for clipping.

[quote name='Paprica' timestamp='1341616966' post='4956521']I also didn't understand what's the difference between glFrustum and glOrtho and when I should use each function.[/quote]

They are different methods of projection. Frustum creates the illusion of depth because of the way objects are mapped to the final viewport and Ortho is short for orthographic.

[quote name='Paprica' timestamp='1341616966' post='4956521']And, I understood that gluPerspective is used as an alternative function to glFrustum, with both functions using different parameters, so when should I use each one?[/quote]

The answer is that it doesn't really matter. I'm slightly hardcore (or stupid; probably) and I try and use only OpenGL's commands and avoid GLUT and the utility library (glu*). Both glFrustum and gluPerspective dump the same matrix on the projection matrix stack they just allow it to be specified with different ways.

[quote name='Paprica' timestamp='1341616966' post='4956521']Also, I don't know what's that "plane" that the author is talking about all the time. (probably because of my poor English)[/quote]

A plane is a mathematical object that has only two dimensions ([url=""]http://en.wikipedia....lane_(geometry)[/url]). Edited by BinaryPhysics

Share this post

Link to post
Share on other sites
FireInDark    148
Maybe you should read the books about 3D Graphics first, then you will understand how [font="arial"][size="2"][color="#000000"]it works..[/color][/size][/font]

Share this post

Link to post
Share on other sites

Create an account or sign in to comment

You need to be a member in order to leave a comment

Create an account

Sign up for a new account in our community. It's easy!

Register a new account

Sign in

Already have an account? Sign in here.

Sign In Now

Sign in to follow this  

  • Partner Spotlight

  • Similar Content

    • By pseudomarvin
      I assumed that if a shader is computationally expensive then the execution is just slower. But running the following GLSL FS instead just crashes
      void main() { float x = 0; float y = 0; int sum = 0; for (float x = 0; x < 10; x += 0.00005) { for (float y = 0; y < 10; y += 0.00005) { sum++; } } fragColor = vec4(1, 1, 1 , 1.0); } with unhandled exception in nvoglv32.dll. Are there any hard limits on the number of steps/time that a shader can take before it is shut down? I was thinking about implementing some time intensive computation in shaders where it would take on the order of seconds to compute a frame, is that possible? Thanks.
    • By Arulbabu Donbosco
      There are studios selling applications which is just copying any 3Dgraphic content and regenerating into another new window. especially for CAVE Virtual reality experience. so that the user opens REvite or CAD or any other 3D applications and opens a model. then when the user selects the rendered window the VR application copies the 3D model information from the OpenGL window. 
      I got the clue that the VR application replaces the windows opengl32.dll file. how this is possible ... how can we copy the 3d content from the current OpenGL window.
      anyone, please help me .. how to go further... to create an application like VR CAVE. 
    • By cebugdev
      hi all,

      i am trying to build an OpenGL 2D GUI system, (yeah yeah, i know i should not be re inventing the wheel, but this is for educational and some other purpose only),
      i have built GUI system before using 2D systems such as that of HTML/JS canvas, but in 2D system, i can directly match a mouse coordinates to the actual graphic coordinates with additional computation for screen size/ratio/scale ofcourse.
      now i want to port it to OpenGL, i know that to render a 2D object in OpenGL we specify coordiantes in Clip space or use the orthographic projection, now heres what i need help about.
      1. what is the right way of rendering the GUI? is it thru drawing in clip space or switching to ortho projection?
      2. from screen coordinates (top left is 0,0 nd bottom right is width height), how can i map the mouse coordinates to OpenGL 2D so that mouse events such as button click works? In consideration ofcourse to the current screen/size dimension.
      3. when let say if the screen size/dimension is different, how to handle this? in my previous javascript 2D engine using canvas, i just have my working coordinates and then just perform the bitblk or copying my working canvas to screen canvas and scale the mouse coordinates from there, in OpenGL how to work on a multiple screen sizes (more like an OpenGL ES question).
      lastly, if you guys know any books, resources, links or tutorials that handle or discuss this, i found one with marekknows opengl game engine website but its not free,
      Just let me know. Did not have any luck finding resource in google for writing our own OpenGL GUI framework.
      IF there are no any available online, just let me know, what things do i need to look into for OpenGL and i will study them one by one to make it work.
      thank you, and looking forward to positive replies.
    • By fllwr0491
      I have a few beginner questions about tesselation that I really have no clue.
      The opengl wiki doesn't seem to talk anything about the details.
      What is the relationship between TCS layout out and TES layout in?
      How does the tesselator know how control points are organized?
          e.g. If TES input requests triangles, but TCS can output N vertices.
             What happens in this case?
      In this article,
      the isoline example TCS out=4, but TES in=isoline.
      And gl_TessCoord is only a single one.
      So which ones are the control points?
      How are tesselator building primitives?
    • By Orella
      I've been developing a 2D Engine using SFML + ImGui.
      Here you can see an image
      The editor is rendered using ImGui and the scene window is a sf::RenderTexture where I draw the GameObjects and then is converted to ImGui::Image to render it in the editor.
      Now I need to create a 3D Engine during this year in my Bachelor Degree but using SDL2 + ImGui and I want to recreate what I did with the 2D Engine. 
      I've managed to render the editor like I did in the 2D Engine using this example that comes with ImGui. 
      3D Editor preview
      But I don't know how to create an equivalent of sf::RenderTexture in SDL2, so I can draw the 3D scene there and convert it to ImGui::Image to show it in the editor.
      If you can provide code will be better. And if you want me to provide any specific code tell me.
  • Popular Now