1 / 58

CS361

Week 15 - Friday. CS361. Last time. What did we talk about last time? Review up to Exam 2. Questions?. Project 4. Review. Polygonal Techniques. Tessellation. Surfaces often need to be tessellated , broken down into polygons The surfaces can be Convex polygons

kyne
Download Presentation

CS361

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript


  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 normalsni • 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 • 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: • 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 and 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,zthen 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

More Related