Understanding GPU Rasterization and Graphics Pipeline

 
Software Rasterization
 
Stanislaw Jaroszynski
 
History
 
GPU’s used to be expensive and
a non-consumer product
John Carmack pioneered 3D in
video games through software
rasterization
 
Quake Engine
 
Very fast
Heavily optimized and limited to use case
Uses BSP to only render a small portion of map
Most lighting and effects pre rendered
Uses palette for gradients and full screen post-
processing
 
Pipeline
Model
View
Transform
Cull Faces
Lighting
Calculations
Projection
Transform
Div by W
To Screen
Space
Triangle
Rasterizati
on
 
Follows general fixed pipeline of early GPU’s
 
Homogeneous Coordinates
 
Allows for simplification of calculations with
transformation matrices
Matrices can be concatenated which results in one
matrix multiplication per vertex
1
0
 
Affine Transformations
 
Projection Matrix
 
not affine
s = 1 / tan(fov * 0.5)
a = aspect ratio (width / height)
s/a
S
 
Modelview Transformation
 
Composed of affine transformations
World/Camera space
Could be combined with projection if not doing
calculations in world space
Lighting and backface culling done in this space
 
Backface Culling
 
If triangles are in counter-clockwise direction, we can
take the cross product of u and v to get n
Since we are in camera space, if z > 0, the triangle
must be facing away from the camera and can be
culled
 
Lighting
 
Diffuse light = cos(theta) between face and direction
to light
 
 
Projection Transform
 
Converts world coordinates to unit cube (except Z)
Stores form of Z in W (vertices no longer
homogenous)
Space is still linear
 
Clipping
 
Faces clipped to unit cube in projection space
Faces outside are removed
Faces partially inside are clipped and form two new
triangles with interpolated values.
Projection space is the best for clipping because
visible vertices are bound to -1 to 1 and space is still
linear.
 
W Divide
 
Transforms viewing cube to frustrum
Coordinates are homogenized (in theory; W keeps Z
value for later because a 1 W isn’t useful anymore
anyway)
 
Screen Space Transformation
 
Just maps -1 -> 1 to 0 -> [Screen Dimension]
 
Triangle Rasterization
 
Fills triangles line by line
Implemented by traversing edges
Not true to GPU implementations which use barycentric coordinates
(more parallel + other useful properties)
 
Value Interpolation
 
Values are interpolated linearly between the ends of
two edges and then again between the edges
This is good enough for most properties but it is not
correct
When interpolating textures the error is apparent
 
Perspective Correct Textures
 
The solution to this is to interpolate [u/w, v/w, 1/w]
Then u/w / 1/w = u
Can be done every couple steps to improve
performance with less significant visual errors
Slide Note
Embed
Share

Delve into the world of GPU rasterization, from the history of GPUs and software rasterization to the intricacies of the Quake Engine, graphics pipeline, homogeneous coordinates, affine transformations, projection matrices, and lighting calculations. Explore concepts such as backface culling and diffuse lighting to gain a comprehensive understanding of 3D graphics rendering.


Uploaded on Aug 08, 2024 | 0 Views


Download Presentation

Please find below an Image/Link to download the presentation.

The content on the website is provided AS IS for your information and personal use only. It may not be sold, licensed, or shared on other websites without obtaining consent from the author. Download presentation by click this link. If you encounter any issues during the download, it is possible that the publisher has removed the file from their server.

E N D

Presentation Transcript


  1. Software Rasterization Stanislaw Jaroszynski

  2. History GPU s used to be expensive and a non-consumer product John Carmack pioneered 3D in video games through software rasterization

  3. Quake Engine Very fast Heavily optimized and limited to use case Uses BSP to only render a small portion of map Most lighting and effects pre rendered Uses palette for gradients and full screen post- processing

  4. Pipeline Model View Transform Projection Transform Lighting Calculations Cull Faces Div by W To Screen Space Follows general fixed pipeline of early GPU s Triangle Rasterizati on

  5. Homogeneous Coordinates Allows for simplification of calculations with transformation matrices Matrices can be concatenated which results in one matrix multiplication per vertex 0 1

  6. Affine Transformations

  7. Projection Matrix not affine s/a s = 1 / tan(fov * 0.5) S a = aspect ratio (width / height)

  8. Modelview Transformation Composed of affine transformations World/Camera space Could be combined with projection if not doing calculations in world space Lighting and backface culling done in this space

  9. Backface Culling If triangles are in counter-clockwise direction, we can take the cross product of u and v to get n Since we are in camera space, if z > 0, the triangle must be facing away from the camera and can be culled

  10. Lighting Diffuse light = cos(theta) between face and direction to light

  11. Projection Transform Converts world coordinates to unit cube (except Z) Stores form of Z in W (vertices no longer homogenous) Space is still linear

  12. Clipping Faces clipped to unit cube in projection space Faces outside are removed Faces partially inside are clipped and form two new triangles with interpolated values. Projection space is the best for clipping because visible vertices are bound to -1 to 1 and space is still linear.

  13. W Divide Transforms viewing cube to frustrum Coordinates are homogenized (in theory; W keeps Z value for later because a 1 W isn t useful anymore anyway)

  14. Screen Space Transformation Just maps -1 -> 1 to 0 -> [Screen Dimension]

  15. Triangle Rasterization Fills triangles line by line Implemented by traversing edges Not true to GPU implementations which use barycentric coordinates (more parallel + other useful properties)

  16. Value Interpolation Values are interpolated linearly between the ends of two edges and then again between the edges This is good enough for most properties but it is not correct When interpolating textures the error is apparent

  17. Perspective Correct Textures The solution to this is to interpolate [u/w, v/w, 1/w] Then u/w / 1/w = u Can be done every couple steps to improve performance with less significant visual errors

Related


More Related Content

giItT1WQy@!-/#