1. Week 15 - Friday
CS361

2. Last time
What did we talk about last time?
Review up to Exam 2

3. Questions?

4. Project 4

5. Review

6. Polygonal Techniques

7. Tessellation
Surfaces often need to be tessellated, broken down into polygons
The surfaces can be
Convex polygons
More complicated polygons
3D surfaces made out of complicated polygons

8. Triangulation
For most graphics hardware, polygons must be triangulated into component triangles
"Bowties" have to be converted into triangles, perhaps making a guess about what the modeler meant
The literature contains many triangulation algorithms including the O(n2) ear clipping algorithm

9. Edge cracking and T-vertices
Splines are often used to generate curved surfaces
Turning the splines into polygons can cause two surfaces to have cracks between them, called edge cracking
Edge stitching makes sure all vertices on a shared edge between surfaces are shared as well
Shading is also an issue for T-vertices
Triangles that share edges should share all the same vertices too

10. Triangle fans, strips, and meshes
In order to reuse data, we can break groups of triangles into fans, strips, and meshes
A triangle fan has a center vertex shared by all triangles
A triangle strip is similar to a triangle fan except that the triangles do not all share a common vertex
For a closed surface, a triangle mesh can be more efficient than either fans or strips

11. Vertex buffers
Meshes are generally sent as a vertex buffer and an index buffer
They are a generic way to store model data in a contiguous chunk of memory
The memory could be:
A list of points
A list of line segments
A polyline
A triangle list
A triangle fan
A triangle strip
The size of a vertex is called the stride
If you do not want to repeat information in the vertex buffer, you can use an index buffer to specify which vertices from the vertex buffer to use

12. Simplification
Mesh simplification is a way of reducing polygon count while preserving appearance
Three common kinds:
Static – make several models of different complexity and choose the right one
Dynamic – generate models on the fly, allowing for a continuous spectrum of level of detail (LOD)
View-dependent – change based on the particular view

13. Dynamic simplification
Use edge collapses
Merge two vertices into one
There are different strategies for determining which edge to collapse, but we usually look for a "low cost" edge
There are different strategies for determining cost…
Some edges should not be collapsed
If it causes a surface's normal to flip
If it causes edges to cross

14. Intersection Test Methods

15. Ray
A ray r(t) is defined by an origin point o and a direction vector d
d is usually normalized
Negative t values are behind the starting point of the ray and don't count
Since d is normalized, positive t values give the distance of the point from o
It is also common to store l, the maximum distance along the ray we want to look

16. Surface
An implicit surface is one described by a vector equation where any point on the surface has a value of 0
f(p) = f(px, py, pz) = 0
Implicit sphere: f(p) = px2 + py2 + pz2 - r2 = 0
An explicit surface is one parameterized by two parameters
Explicit sphere:

17. Axis-aligned bounding box
An axis-aligned bounding box (AABB) (also known as a rectangular box) is a box whose faces have normals pointing the same way as the x, y, and z axes
It's just a non-rotated box in 3 space
It can be defined with two points (lower corner and upper corner)

18. Oriented bounding box
An oriented bounding box (OBB) is an AABB that has been arbitrarily rotated
It can be described by
A center point bc
Three normalized vectors bu, bv, and bw giving the side directions of the box
And half-lengths (from center to wall) huB, hvB, and hwB

19. k-DOP
A k discrete oriented polytope (k-DOP) has k/2 normalized normals ni
For each ni, there are two values dimin and dimax which defines a slab Si that is the volume between the two planes
The k-DOP is the intersections of all the slabs

20. Separating axis test
For two arbitary, convex, disjoint polyhedra A and B, there exists a separating axis where the projections of the polyhedra are also disjoint
Furthermore, there is an axis that is orthogonal to (making the separating plane parallel to)
A face of A or
A face of B or
An edge from each polyhedron (take the cross product)
This definition of polyhedra is general enough to include triangles and line segments

21. Creating Bounding Volumes

22. AABB and k-DOPs An AABB is the easiest A k-DOP is not much harder
Take the minimum and maximum points in each axis and, BOOM, you've got an AABB
A k-DOP is not much harder
Take the minimum and maximum values in each of the k/2 axes and use those to define the slabs
You have to have axes in mind ahead of time

23. Bounding spheres Not as simple as you might think One approach: Or:
Make an AABB and use the center and diagonal of the corners to make your sphere
Or:
Make the AABB and do another pass through the vertices, taking the one furthest from the center as the radius
There are other more complicated ideas

24. Geometric probability
The relative probability that a random point is inside an object is proportional to the object's volume
However, the relative probability that a random ray intersects an object is proportional to its surface area

25. Intersection Methods

26. Ray/sphere intersection
We can write the implicit sphere equation as f(p) = ||p – c|| – r = 0
p is any point on the surface
c is the center
r is the radius
By substituting in r(t) for p, we can eventually get the equation t2 + 2tb + c = 0, where b = d • (o – c) and c = (o – c) •(o – c) – r2
If the discriminant is negative, the ray does not hit the sphere, otherwise, we can compute the location(s) where it does

27. Optimized ray/sphere
Looking at it geometrically, we can optimize the test
Find the vector from the ray origin to the center of the sphere l = c – 0
Find the squared length l2 = l • l
If l2 < r2, then o is in the sphere, intersect!
If not, project l onto d: s = l • d
If s < 0, then the ray points away from the sphere, reject
Otherwise, use the Pythagorean theorem to find the squared distance from the sphere center to the projection: m2 = l2 – s2
If m2 > r2, the ray will miss, otherwise it hits

28. Slabs method for ray/box
First find the t value where the ray intersects each plane
The box is made up of 3 slabs
Find the min t and max t for each slab
The final tmin is the max of all the tmin values
The final tmax is the min of all the tmax values
If tmin ≤ tmax, the ray intersects the box, otherwise it does not
The idea can be extended to frustums and k-DOPs

29. Line segment/box overlap test
This method uses the separating axis test and only works for AABBs and line segments
The AABB has its center at (0,0,0) and size half vector h
The line segment is defined by center c and half vector w
If |ci| > wi + hi for any i x,y,z then disjoint
There is another test for each axis that is the cross product of the x, y, and z axis and w
If any test passes, then disjoint
Only if all tests fail, then overlap

30. Triangle representation
One way to represent a triangle is with barycentric coordinates
For triangles, barycentric coordinates are weights that describe where in the triangle you are, relative to the three vertices
These weights are commonly labeled u, v, and w and have the following properties
u ≥ 0, v ≥ 0, w ≥ 0 and u + v + w ≤ 1

31. Ray triangle intersection
We represent a point f(u,v) on a triangle with the following explicit formula
f(u,v) = (1 – u – v)p0 + up1 + vp2
Then, setting the ray equal to this equation gives
o + td = (1 – u – v)p0 + up1 + vp2
This is simply a vector representation of three equations with three unknowns
If the solution has a positive t, and u and v between 0 and 1, it's an intersection

32. Plane/box intersection
Simplest idea: Plug all the vertices of the box into the plane equation n • x + d = 0
If you get positive and negative values, then the box is above and below the plane, intersection!
There are more efficient ways that can be done by projecting the box onto the plane

33. Sphere/sphere intersection
Sphere/sphere is the easiest
Is the distance between their centers bigger than the sum of their radii?
If yes, they are disjoint
If no, they overlap r2 r1 c2 c1

34. AABB/AABB intersection
We test each dimension to see if the min of one box is greater than the max of other or vice versa
If that's ever true, they're disjoint
If it's never true, they overlap
intersect(A, B ) {
for i in x,y,z
if(aimin > bimax or bimin > aimax )
return DISJOINT
return OVERLAP }

35. Line/line intersection
We will only look at the 2D problem, but the book has discussion of 3D lines as well
For a 2D vector (x, y), we define its perp dot product (x, y) = (-y, x)
Thus, we can work through the equations of a line (only the path to the value of s is shown)
r1(s) = r2(t)
o1 + sd1 = o2 + td2
sd1 • d2 = (o2 – o1) • d2
s = ((o2 – o1) • d2) / d1 • d2

36. Collision Detection

37. Collision detection
There are three important pieces to collision handling:
Collision detection
Did these objects collide?
Collision determination
When and where did these objects collide exactly?
Collision response
What happens as a result of the collision?

38. Collision detection with rays
Rather than try to test complex models for collision with an environment, we can use representative rays instead
Perhaps one ray for each wheel of a car
A positive ray distance means space between the objects
A negative ray distance means collision
A zero ray distance means the objects are merely touching
It's essentially a ray tracing problem

39. BSP trees
Binary space partitioning trees (BSP trees) are a common way of dividing space hierarchically
For axis-aligned BSPs, one axis is chosen and a perpendicular plane is generated to divide the box
This process is repeatedly recursively until some criteria (like 3 or fewer objects per division) is reached
BSPs can also be split by choosing polygons to divide the world (usually done so to make a perfectly balanced tree)
BSPs are good for static scenes (moving objects can cause huge portions of the tree to be recreated)

40. Multiple objects CD Hierarchies are generally made for static scenes
Then we test against them for collisions with dynamic objects
What about when there are multiple moving objects that might interact with each other?
We work in two phases
Broad phase collision detection
Exact collision detection among candidates

41. Sweep-and-prune Assume everything has an AABB or a bounding sphere
Assume temporal coherence (stuff doesn't move that much over a small amount of time)
On one dimension, we can sort the endpoints of the AABBs
We can quickly throw out objects that cannot possibly intersect
Bubble sort to the rescue!
We could sort everything in O(n log n) every time
Because of temporal coherence, not many end points change order and adaptive sorts work in around O(n)

42. Grids
Another possibility is keeping large grid cells that keep track of which objects or BVs are inside them
Objects that do not share grid cells do not need to be checked for collision
Finding the right grid cell size can be difficult
Spatial hashing can be used as well (mapping to a hash table based on location)

43. Putting it together
Here is an outline of a frame in a typical two-phase CD system

44. Non-photorealistic rendering
Most of the work we've focused on all semester is doing rendering that in some way mirrors the natural world
However, a wide area of rendering is non-photorealistic rendering (NPR)
Goals:
Simplified technical drawings
Simulating artistic styles

45. Toon shading
The most common form of NPR in video games is toon shading
Also called cel shading
The goal is to render 3D models as if they were cartoons
Shading is often done with either a single color or a two tone (color and shading) approach
Then a thick black silhouette is added around edges

46. Coloring
The color is often determined by the dot product n · l (surface normal dot light vector)
If negative, the surface should be darkened
Otherwise, it's some flat color
Or a threshold other than 0 can be used
A more complex system uses a one dimensional texture indexed into with the dot product
Highlight
Normal
Shadow

47. Silhouette edge rendering
The more complicated problem is properly rendering edges with a thick dark line
A number of different edges are of interest
Boundary or border edges are edges where one polygon is not adjacent to any other
Not found in 3D solid objects
A crease, hard, or feature edge is an edge between two polygons that is sharper than some threshold angle
A material edge is an edge between two polygons with different materials
A silhouette edge is when two neighboring polygons face different directions, relative to the eye

48. Procedural geometry silhouetting
Cel shading focuses on rendering silhouette edges
Many of these techniques rely on manipulating back facing polygons
The crossover between front facing and back facing polygons is the silhouette
It's easy to determine which is which
After some manipulation of the backfaces, they are rendered in black

49. z-biased backfaces
If the backfaces are rendered in black without any change, they will be hidden
Before rendering, all backfaces can be translated to be closer to the viewer
Translation can be by
A fixed amount
An amount that takes into account non-linear z-depths
An amount based on the angle of the polygon normal
None of these techniques give uniform thickness lines

50. Triangle fattening
Another approach is to fatten each backface triangle
The slope of the triangle and the distance from the viewer determine the expansion of each edge
It doesn't work well for thin traingles

51. Expanding shell technique
A similar approach is to expand backface vertices along their normals
The expansion amount is proportional to their z-distance
This technique fails for situations like a cube, in which faces with very different normals share vertices

52. Silhouetting by image processing
Rather than using geometry, there is an image processing approach
Render all the normal values or depth values to a buffer and use edge detection algorithms to draw lines where the values change abruptly
Using normal values can find crease edges
This technique works for many cases that failed before
Even GPU generated surfaces are not a problem

53. Other styles NPR techniques are very broad
Many approaches try to recreate hand-drawn or hand-painted styles
Silhouette lines can be drawn as paintbrush strokes of varying thickness
Tonal art maps (TAMs) use palettes of hand-drawn textures to do black and white crosshatch-style shading

54. Line rendering
For CAD programs and other 3D tools, we may want to highlight certain lines or all polygon edges
Rendering polygon edges on top of existing polygons can be a pain
Z-buffer algorithms might hide the lines
In practice, a small bias is usually added to the polygons

55. Hidden lines
For drawing simplified models, we may want to include or exclude the hidden lines
Wireframe is the easiest, since it is just the lines
Hidden-line uses the z-buffer directly
Obscured-line renders twice, rendering z-fail lines in a lighter color
Haloed lines also use the z-buffer, drawing thick white lines first and then black lines on top
Problems happen when lines get too close

56. Upcoming

57. Next time…
There is no next time!

58. Reminders Finish Project 4 Study for the final Due tonight by 11:59pm
11:00am - 2:00pm, Monday, 5/08/2017