Opengl Stages of Vertex Transformation

-
Stages of Vertex Transformation
Required to render the desired scene of a 3d world in a 2d screen

Object Coordinates: local coordinate system of object before any transformation is applied.
Eye coordinates: the result of multiplication of GL_MODELVIEW matrix and
object coordinates. Objects are transformed from object space to eye space.
M(ModelView) = M(view). M(model)
where M(model) = object space to world space and M(view) = world space to eye space.
Clip coordinates: the result of multiplication of GL_PROJECTION matrix and eye coordinates.
GL_PROJECTION matrix used to define the frustum. It determined hot the 3D scene is projected onto the screen.
NDC: Perspective division which is yielded by dividing the clip coordinates by w.
Window coordinates: NDC are scaled and translated in order to fit into the rendering screen.

Analogy With a Camera
Transformations:
Viewing Transformation: Setting up tripod and pointing the camera at the scene.
Two ways to define viewing transformation. Both changes the view keeping camera at (0,0,0)
  1. gluLookAt(eyeX,eyeY,eyeZ,centerX,centerY,centerZ,upX,upY,upZ) - positioning the view in the perspective of camera position. Eye is the camera position.center is the target destination to look at. Up is camera up direction (for y direction value is (0,1,0))
  2. Identity Matrix - positioning the view from the default position(0,0,0).
Projection Transformation: Choose a camera lens or adjust the zoom
  • Orthographic - Parallel Projection. Parallel lines will never meet. Assumptions made in this projection - camera position is in +Inf and Camera is a plane & view is in (0,0,0).
  • glOrtho( left,  right, bottom,  top, nearVal, farVal)
















  • Perspective - Perspective Projection. Parallel lines meet at infinity. Two ways to generate perspective projection matrix.
  • gluPerspective( fovy,  aspect, zNear,  zFar)



  • glFrustum(left,right,bottom,top,nearVal,farValue)















Viewport Transformation: Determine how large you want the final photograph to be (Defining render area using glViewPort)
Coordinates:
Object Coordinates: It is the local coordinate system of objects and is initial position and orientation of objects before any transform is applied


Eye Coordinates: It is yielded by multiplying GL_MODELVIEW matrix and object coordinates. Objects are transformed from object space to eye space using GL_MODELVIEW matrix in OpenGL. GL_MODELVIEW matrix is a combination of Model and View matrices. Model transform is to convert from object space to world space. And, View transform is to convert from world space to eye space.


Note that there is no separate camera (view) matrix in OpenGL. Therefore, in order to simulate transforming the camera or view, the scene (3D objects and lights) must be transformed with the inverse of the view transformation. In other words, OpenGL defines that the camera is always located at (0, 0, 0) and facing to -Z axis in the eye space coordinates, and cannot be transformed.


Clip Coordinates: The eye coordinates are now multiplied with GL_PROJECTION matrix, and become the clip coordinates. This GL_PROJECTION matrix defines the viewing volume (frustum); how the vertex data are projected onto the screen (perspective or orthogonal). The reason it is called clip coordinates is that the transformed vertex (x, y, z) is clipped by comparing with ±w.


Normalized Device Coordinates (NDC): It is yielded by dividing the clip coordinates by w. It is called perspective division. It is more like window (screen) coordinates, but has not been translated and scaled to screen pixels yet. The range of values is now normalized from -1 to 1 in all 3 axes.



Window Coordinates (Screen Coordinates): It is yielded by applying normalized device coordinates (NDC) to viewport transformation. The NDC are scaled and translated in order to fit into the rendering screen. The window coordinates finally are passed to the rasterization process of OpenGL pipeline to become a fragment.


Matrix Transformation: Matrix is used to transform modelview easily, which converts from one coordinate system to another coordinate system.
  • Translate
  • Scale
  • Rotate

Homogeneous Coordinates: Homogeneous coordinates introduce to describe projective space by adding another dimension called w-coordinate, which is the distance from camera to view. For making normalization w have to be 1 so all the matrix elements are divided by w. Three dimensional euclidean coordinate (x,y,z) equivalent homogeneous coordinate is (x,y,z,w).
If w = 0.0, it corresponds to no euclidean point, but rather to some idealized "point at infinity." To understand this point at infinity, consider the point (1, 2, 0, 0), and note that the sequence of points (1, 2, 0, 1), (1, 2, 0, 0.01), and (1, 2.0, 0.0, 0.0001), corresponds to the euclidean points (1, 2), (100, 200), and (10000, 20000). Thus, we can think of (1, 2, 0, 0) as the point at infinity in the direction of that line.

References

Comments

Post a Comment

Popular posts from this blog

Thread & Locks

-
Image
Threads Threads are subunits of processes, which can be scheduled independently by the operating system scheduler. Multiple threads can be executed at the same time on a single CPU core. The operating system assigns small slices of computing time to each thread, so that it seems to the user as if multiple tasks are executed at the same time. If multiple CPU cores are available, then multiple threads can be executed truly in parallel. We can either use the POSIX thread API, or the Objective-C wrapper around this API, NSThread. NSThread is a simple Objective-C wrapper around pthreads. Grand Central Dispatch With GCD you don’t interact with threads directly anymore. Instead you add blocks of code to queues, and GCD manages a thread pool behind the scenes. GCD decides on which particular thread your code blocks are going to be executed on, and it manages these threads according to the available system resources. This alleviates the problem of too many threads being cre...
Read more

Opengl-es Buffer

-
Image
Framebuffer A  Framebuffer  is a collection of buffers that can be used as the destination for rendering. OpenGL has two kinds of framebuffers: the  Default Framebuffer , which is provided by the  OpenGL Context ; and user-created framebuffers called  Framebuffer Objects  (FBOs). The buffers for default framebuffers are part of the context and usually represent a window or display device. The buffers for FBOs reference images from either  Textures  or  Renderbuffers ; they are never directly visible. Default Framebuffer The Default Framebuffer is the Framebuffer that OpenGL is created with. It is created along with the OpenGL Context. Like Framebuffer Objects , the default framebuffer is a series of images. Unlike FBOs, one of these images usually represents what you actually see on some part of your screen. Framebuffer Object FBO contains a collection of rendering destinations; color, depth and stencil buffer. These logical buff...
Read more

Kernel Startup

-
Image
BootLoader GRUB Version 2 (GRUB) Stage 1 :  boot.img  is stored in the master boot record (MBR) or optionally in any of the  volume boot records  (VBRs), and addresses the next stage by an  LBA48  address (thus, the 1024-cylinder limitation of GRUB legacy is avoided); at installation time it is configured to load the first sector of  core.img . Stage 1.5 :   core.img  is by default written to the sectors between the MBR and the first partition, when these sectors are free and available. For legacy reasons, the first partition of a hard drive does not begin at sector 1 (counting begins with 0) but at sector 63, leaving 62 sectors of empty space not part of any partition or file system, and therefore not prone to any problems related with it. Once executed,  core.img  will load its configuration file and any other modules needed, particularly  file system  drivers; at installation time, it is generated from...
Read more