Draw Refactoring Notes - Revision history

Luomu at 22:50, 13 April 2013

2013-04-13T22:50:43Z

Luomu: A: so depth testing between geopatches will work

2012-09-11T14:42:55Z

A: so depth testing between geopatches will work

Luomu: Cull note

2012-09-11T13:11:32Z

Cull note

Luomu at 12:52, 11 September 2012

2012-09-11T12:52:14Z

Luomu at 12:51, 11 September 2012

2012-09-11T12:51:04Z

Luomu at 12:48, 11 September 2012

2012-09-11T12:48:53Z

Luomu: /* Early Z */

2012-09-11T12:45:44Z

‎Early Z

Luomu: Created page with "The main goal is the correct drawing of transparent objects. This is also a nice chance to get rid of the fixed function matrix stack operations. Transparent objects include: * ..."

2012-09-11T12:44:36Z

Created page with "The main goal is the correct drawing of transparent objects. This is also a nice chance to get rid of the fixed function matrix stack operations. Transparent objects include: * ..."

New page

The main goal is the correct drawing of transparent objects. This is also a nice chance to get rid of the fixed function matrix stack operations.

Transparent objects include:
* ship thrusters
* light billboards
* lasers
* shield effects
* glass cockpits
* planet rings
* star halos

Theory:

# Do a collection pass and collect all objects to "bins" or "buckets"
# Depth write on, depth testing on. Sort and draw opaque objects, preferably front to back
# Depth write off, depth testing on. Sort and draw transparent objects, back to front

Pass camera to all renderable objects:

void Thing::Render(Camera* camera, ...) {
//calculate transformations etc.
//instead of immediate drawing, add Graphic objects to be drawn later
camera->opaqueBucket.Add(Graphic(...))
camera->transBucket.Add(Graphic(...))
}

Step 2 will not work, since bodies are currently drawn back to front. After drawing distant planets, or when shaders are off, the depth buffer is cleared (question: why not turn off depth write instead?). If this is still necessary to do, object drawing needs to be separated into two phases (after Background is drawn):

# Draw far objects: planets and their rings, stars. Depth will be cleared during this.
# Draw closer objects: cities, ships, lasers

== Notes for optimization ==

A smarter structure will also allow for some optimizations - someday.

=== State sorting ===

Objects can be sorted by material or material properties. When everything uses Materials the Renderer will avoid some state switches by comparing material pointers. Example: thrusters all use the same material.

=== Early Z ===
In theory, depth testing can be done as soon as a vertex shader finishes. This can avoid running costly fragment shaders for invisible fragments. However Pioneer cannot benefit from this since all fragment shaders calculate a custom depth - the shader needs to be fully run before the final depth is known. It's not too bad, since we don't have that much overdraw - mostly the player is seeing black space.

In any case, the problem can be worked around with a Z prepass - render all objects using a shader that only does the depth calculation, then turn depth write off and draw the objects again with the usual fragment shader (but without gl_FragDepth).

=== Batching ===

To reduce the number of glDraw* calls, simple objects (thrusters, effect quads) can be batched into a temporary vertex buffer (check identical materials again), and then drawn at once. Note thrusters, lasers are additively blended and do not have to be individually sorted.

← Older revision		Revision as of 22:50, 13 April 2013
Line 48:		Line 48:

	To reduce the number of glDraw* calls, simple objects (thrusters, effect quads) can be copied into temporary vertex buffers (check identical materials again), and then drawn at once. Note thrusters, lasers are additively blended and do not have to be individually sorted.		To reduce the number of glDraw* calls, simple objects (thrusters, effect quads) can be copied into temporary vertex buffers (check identical materials again), and then drawn at once. Note thrusters, lasers are additively blended and do not have to be individually sorted.
		+
		+	== New notes (2013) ==
		+
		+	Planets mix opaque and transparent geometry. Since zbuffer is cleared after rendering a faraway planet, the planet's surface, rings and atmosphere need to be rendered in one go.
		+
		+	Models may mix opaque and transparent geometry. Such models need to be therefore drawn twice, with the appropriate node masks used during draw traversal. A special visitor should be used to update the nodemasks to prevent unnecessary traversal as high as possible (matrix transform with transparent children should be marked transparent).

← Older revision		Revision as of 12:52, 11 September 2012
Line 47:		Line 47:
	=== Batching ===		=== Batching ===

−	To reduce the number of glDraw* calls, simple objects (thrusters, effect quads) can be ~~batched~~ into a temporary vertex ~~buffer~~ (check identical materials again), and then drawn at once. Note thrusters, lasers are additively blended and do not have to be individually sorted.	+	To reduce the number of glDraw* calls, simple objects (thrusters, effect quads) can be copied into temporary vertex buffers (check identical materials again), and then drawn at once. Note thrusters, lasers are additively blended and do not have to be individually sorted.

@@ Line 16: / Line 16: @@
 # Depth write off, depth testing on. Sort and draw transparent objects, back to front
-Step 2 will not work, since bodies are currently drawn back to front. After drawing distant planets, or when shaders are off, the depth buffer is cleared (question: why not turn off depth write instead?). If this is still necessary to do, object drawing needs to be separated into two phases (after Background is drawn):
+Step 2 will not work, since bodies are currently drawn back to front. After drawing distant planets, or when shaders are off, the depth buffer is cleared. If this is still necessary to do, object drawing needs to be separated into two phases (after Background is drawn):
 # Draw far objects: planets and their rings, stars. Depth will be cleared during this.

@@ Line 12: / Line 12: @@
 Theory:
-# Do a collection pass and collect all objects to "bins" or "buckets"
+# Do a collection pass, frustum cull and collect all objects to "bins" or "buckets"
 # Depth write on, depth testing on. Sort and draw opaque objects, preferably front to back
 # Depth write off, depth testing on. Sort and draw transparent objects, back to front
@@ Line 25: / Line 25: @@
   void Body::Render(Camera* camera, ...) {
      //instead of immediate drawing, add Graphic objects to be drawn later
-     //can transformations be calculated here?
+     //calculate transformations here
      camera->opaqueBucket.Add(Graphic(...))
      camera->transBucket.Add(Graphic(...))

@@ Line 15: / Line 15: @@
 # Depth write on, depth testing on. Sort and draw opaque objects, preferably front to back
 # Depth write off, depth testing on. Sort and draw transparent objects, back to front
 Pass camera to all renderable objects:
-  void Thing::Render(Camera* camera, ...) {
+  void Body::Render(Camera* camera, ...) {
      //calculate transformations etc.
      //instead of immediate drawing, add Graphic objects to be drawn later
@@ Line 24: / Line 29: @@
      camera->transBucket.Add(Graphic(...))
+  }
 == Notes for optimization ==

@@ Line 42: / Line 42: @@
 In any case, the problem can be worked around with a Z prepass - render all objects using a shader that only does the depth calculation, then turn depth write off and draw the objects again with the usual fragment shader (but without gl_FragDepth).
 === Batching ===
 To reduce the number of glDraw* calls, simple objects (thrusters, effect quads) can be batched into a temporary vertex buffer (check identical materials again), and then drawn at once. Note thrusters, lasers are additively blended and do not have to be individually sorted.