Conversation

Notices

1. Adrian Cochrane (alcinnz@floss.social)'s status on Saturday, 04-Mar-2023 04:32:15 JST Adrian Cochrane

   Throughout the history of computer graphics there's 2 main 3D graphics techniques used: depth-buffering & raytracing. Until relatively recently depth-buffering, today's topic, was more popular.

   Because depth-buffering's easier to hardware parallalize!

   Basically it consists of the steps:

   1. Matrix-transform all points
   2. Light each point
   3. Cull offscreen & backfacing triangles
   4. Interpolate within each triangle
   5. Finalize "fragment" pixel colours
   6. Select frontmost pixel for output

   1/4

   • Adrian Cochrane (alcinnz@floss.social)'s status on Saturday, 04-Mar-2023 04:39:30 JST Adrian Cochrane

     in reply to

     Most of the magic of depth-buffered 3D graphics comes the 16 numbers in it's matrix transform! Covering the vertex's position in it's object, The object's position in the world, the camera's position in the world, & the camera's lens. Placing the virtual camera at the center of the virtual universe, incorporating perspective.

     Meanwhile we approximate how much each "diffuse", "speculative" (via exponentiation), & omnipresent "ambiant" lightsource contributes to the vertex's lighting.

     2/4

   • Adrian Cochrane (alcinnz@floss.social)'s status on Saturday, 04-Mar-2023 04:46:53 JST Adrian Cochrane

     in reply to

     In OpenGL you can substitute that logic for a GLSL "vertex shader"!

     Now that we know where everything is discarding offscreen, as well as optionally backfacing (since they're typically obscured by frontfacing triangles), triangles we can drastically cut down the workload to approximately the number of output pixels.

     Before interpolating the vertex-shader's output within each triangle, either via the bounding-box or it's longest side. Ofcourse offscreen pixels would be discarded.

     3/4!

   • Adrian Cochrane (alcinnz@floss.social)'s status on Saturday, 04-Mar-2023 04:52:25 JST Adrian Cochrane

     in reply to

     In OpenGL you can insert a GLSL "fragment shader" here to finalize output colours. Often this involves little more than looking up a pixel from a "texture" image to output. Though you can move lighting computation here, treating the triangles as approximating a smooth surface.

     Or you could stick with gradients.

     Finally a "depth-buffer" is consulted to select the frontmost fragment pixel to output, if it hasn't been outputted already. This is the trickiest step to parallelize.

     4/4 Fin today!