OpenGL define vertex position in pixels

by

This is rather basic knowledge that your favourite OpenGL learning resource should teach you as one of the first things. But anyway the standard OpenGL pipeline is as follows:

  1. The vertex position is transformed from object-space (local to some object) into world-space (in respect to some global coordinate system). This transformation specifies where your object (to which the vertices belong) is located in the world

  2. Now the world-space position is transformed into camera/view-space. This transformation is determined by the position and orientation of the virtual camera by which you see the scene. In OpenGL these two transformations are actually combined into one, the modelview matrix, which directly transforms your vertices from object-space to view-space.

  3. Next the projection transformation is applied. Whereas the modelview transformation should consist only of affine transformations (rotation, translation, scaling), the projection transformation can be a perspective one, which basically distorts the objects to realize a real perspective view (with farther away objects being smaller). But in your case of a 2D view it will probably be an orthographic projection, that does nothing more than a translation and scaling. This transformation is represented in OpenGL by the projection matrix.

  4. After these 3 (or 2) transformations (and then following perspective division by the w component, which actually realizes the perspective distortion, if any) what you have are normalized device coordinates. This means after these transformations the coordinates of the visible objects should be in the range [-1,1]. Everything outside this range is clipped away.

  5. In a final step the viewport transformation is applied and the coordinates are transformed from the [-1,1] range into the [0,w]x[0,h]x[0,1] cube (assuming a glViewport(0, w, 0, h) call), which are the vertex’ final positions in the framebuffer and therefore its pixel coordinates.

When using a vertex shader, steps 1 to 3 are actually done in the shader and can therefore be done in any way you like, but usually one conforms to this standard modelview -> projection pipeline, too.

The main thing to keep in mind is, that after the modelview and projection transforms every vertex with coordinates outside the [-1,1] range will be clipped away. So the [-1,1]-box determines your visible scene after these two transformations.

So from your question I assume you want to use a 2D coordinate system with units of pixels for your vertex coordinates and transformations? In this case this is best done by using glOrtho(0.0, w, 0.0, h, -1.0, 1.0) with w and h being the dimensions of your viewport. This basically counters the viewport transformation and therefore transforms your vertices from the [0,w]x[0,h]x[-1,1]-box into the [-1,1]-box, which the viewport transformation then transforms back to the [0,w]x[0,h]x[0,1]-box.

These have been quite general explanations without mentioning that the actual transformations are done by matrix-vector-multiplications and without talking about homogenous coordinates, but they should have explained the essentials. This documentation of gluProject might also give you some insight, as it actually models the transformation pipeline for a single vertex. But in this documentation they actually forgot to mention the division by the w component (v" = v' / v'(3)) after the v' = P x M x v step.

EDIT: Don’t forget to look at the first link in epatel’s answer, which explains the transformation pipeline a bit more practical and detailed.

More Related Contents:

  1. Reflection and refraction impossible without recursive ray tracing?
  2. OpenGL – How to create Order Independent transparency?
  3. OpenGL object in C++ RAII class no longer works
  4. Normal mapping gone horribly wrong
  5. How to render offscreen on OpenGL? [duplicate]
  6. Transform the modelMatrix
  7. OpenGL Scale Single Pixel Line
  8. How to compile for Windows on Linux with gcc/g++?
  9. Drawing Sphere in OpenGL without using gluSphere()?
  10. How to properly link libraries with cmake?
  11. Why is the sprite not rendering in OpenGL?
  12. OpenGL – Mouse coordinates to Space coordinates
  13. How do I sort the texture positions based on the texture indices given in a Wavefront (.obj) file?
  14. How to get the GL library/headers?
  15. Using Quaternions for OpenGL Rotations [duplicate]
  16. Mesh class called with default constructor not working OpenGL C++
  17. Segmentation fault at glGenVertexArrays( 1, &vao );
  18. Generating a normal map from a height map?
  19. How do I draw text with GLUT / OpenGL in C++?
  20. Image scaling (KeepAspectRatioByExpanding) through OpenGL
  21. Qt3d. Draw transparent QSphereMesh over triangles
  22. object loader in opengl
  23. Confusion between C++ and OpenGL matrix order (row-major vs column-major)
  24. GCC, stringification, and inline GLSL?
  25. How to load a bmp on GLUT to use it as a texture?
  26. Edges on polygon outlines not always correct
  27. C++ – std::thread crashes upon execution
  28. Why does glGetString(GL_VERSION) return null / zero instead of the OpenGL version?
  29. Creating OpenGL context without window
  30. glPixelStorei(GL_UNPACK_ALIGNMENT, 1) Disadvantages?

Leave a Comment