1. CSG and Raytracing
CPSC 407

2. What is CSG? Computational Solid Geometry Volume Representation
Very powerful modeling paradigm
Difficult to render CSG models

3. Volumes, Not Surfaces
CSG modeling tools allow a user to apply Boolean operations to volumes
Union, Intersection, Difference
Only works with volumes
Closed surfaces can be interpreted as volumes…
In 3D, a volume is bounded by a surface
In 2D, the boundary is a curve

4. Volumes are Half-Spaces
We can think of volumes as half-spaces
Each primitive divides space into a set of points inside the volume, and a set of points outside
The sets of points are infinitely dense
Now our Boolean operations are set operations on these sets of points

5. Simple 3D Half-Spaces Sphere Cylinder Cone Torus Box Plane
Plane is tricky - it splits space into two infinite half-spaces
Note that the cylinder and cone are capped. This is not necessary
In fact, you can use an infinite cylinder and two planes to make a capped cylinder
Infinite cylinders are easier to implement
You can also get a box from 6 planes…

6. Boolean CSG Operations
Union
Addition, A Ú B
Intersection
A Ù B
Difference
Subtraction, A – B, A Ù not B
Difference is not commutative

7. A more complicated example
Difference of:
Intersection of Sphere and Cube
Union of 3 Cylinders - =

8. Raytracing CSG Objects
Need a data structure to describe primitives and operations
Binary CSG
Binary tree
Leaf nodes are primitives
Interior nodes are Boolean operations

9. Binary Tree Example

10. Ray Intervals Define a ray as a set of points (r+td)
r is eye point
d is the direction of the ray
t is the scalar distance along the ray
For now, assume that a primitive is convex
A ray (r+td) intersects a convex primitive at most 2 times
Let’s say the ray enters the primitive at distance t1 and leaves at distance t2
Now we can define an interval [t1, t2] along the ray that is inside the primitive
Note: for planes, the interval is either [a,inf] or [inf,b]

11. CSG Operations on Intervals
Assume we have intervals A = [a1,b1] and B = [a2,b2], and we want to combine them with a CSG operation
There are 5 cases to check for each operation:
No Overlap:
Partial Overlap:
Full Overlap:

12. CSG Union on 2 Intervals Remember, Union is A or B
In the no-overlap case, we return the two intervals
The rest of the cases produce one interval, [min(a1,a2), max(b1,b2)]

13. CSG Intersection on 2 Intervals
Remember, Intersection is A and B
In the no-overlap case, we return no intervals
The rest of the cases produce one interval, [max(a1,a2), min(b1,b2)]

14. CSG Difference on 2 Intervals
Remember, Difference is A and not B
The order is important!
Here we have 5 cases:
Return { [a1,b1] }
Return { [0,0] }
Return { [a1,a2], [b2,b1] }
Return { [a1,a2] }
Return { [b2,b1] }

15. Lists of intervals Complex volumes are not convex
A ray may intersect the volume more than once
Instead of a single interval, we get a set of them
We want to combine interval sets S1 and S2 with a Boolean CSG operation
Brute force algorithm:
For each interval Ai in S1, apply the appropriate 2-interval operation with each interval Bj from S2
Return the list of new intervals
This algorithm is O(N2). O(NlogN) algorithms do exist
I’m not certain the list of new intervals will be unique. You may have to check if any overlap, and combine them.

16. Binary CSG Tree Traversal
Depth-first traversal of the tree
At each primitive node, pass back the list of intervals along the ray that intersect the primitive
At each Boolean node, combine the two child lists and pass back the new set of intervals
The intersection point is at (r+td), where t is the lower value of the first interval in the list returned from the root node of the tree

17. Materials and Normals for CSG
Need to determine normal at intersection point
Need tertiary information with intervals
Either object pointers or normals themselves
Note that normals are reversed for subtracted objects
Correct material properties at intersection point are debatable…
Some people take material properties at intersection point
Others prefer to define material properties for the entire CSG object as a whole

18. Additional CSG Bits
It is possible to partially implement CSG without doing a full CSG tree
This is how I did difference objects in my raytracer
Blob’s notes have a different CSG algorithm
His algorithm looks like it might be more efficient, but it requires a point inside/outside test
Very difficult for arbitrary triangle meshes

19. General Raytracing Bits

20. Common bugs Wrong direction for eye rays
Make sure they are going into the scene
Taking the wrong intersection point
Ray intersects with a sphere twice, make sure you use the closer intersection!
Incorrect direction for reflected rays
Sending the reflected ray into the object
Total Internal Reflection in refraction
Get a sqrt(< 0) in the formula for refracted ray direction
In this case, ray reflects instead of refracting

21. Numerical Error Self-Intersection due to Numerical Error
Produces ‘surface dirt’ – black speckles on otherwise smooth objects
Throw away intersections close to intersection point
Bad if you have very thin objects
Throw away any other intersections with current object
Assumes objects are convex!!! (not so for CSG, torus)
Avoid by moving a small distance along the normal at the intersection point before casting secondary rays
Bad for thin objects again, but probably the simplest method

22. Transforming Normals
I’m assuming you are implementing object transformations as described in Blob’s Notes
He explains how to transform the intersection point from object space to world space
He doesn’t explain how to transform normals
Tutorial on my website:

23. Shadow Cache
Assumption: the last object that was hit by a shadow feeler is likely to be the one hit the next time
So test it first
For shadow feelers, it doesn’t matter if it’s the closest object (not so for reflection!)
Shadow feelers are usually a large part of the cost of rendering a scene, so this is a big speedup that is relatively simple to implement

24. WWW Material http://fuzzyphoton.tripod.com/index.htm