1. Pipelines are for Whimps Raycasting, Raytracing, and Hardcore Rendering

2. Ray Casting Definition Time There are two definitions of Ray Casting The Old and the New The old was related to 3D games back in the Wolfenstein / Doom 1 Era. Where gameplay was on a 2D platform The New definition is: – Non Recursive Ray Tracing

3. Ray Tracing http://www.flipcode.com/archives/Raytracing_Topics_Techniques-Part_1_Introduction.shtml Glass Ball

4. Rays from the Sun or from the Screen Rays could be programmed to work in either direction We choose from the screen to the Light – Only X x Y Pixels to trace From the Light we would need to emulate Millions of Rays to find the few thousand that reach the screen

5. Our Rays

6. Center of Projection (0,0)

7. Viewport (0,0) Screen Clipping Planes

8. Into World Coordinates (0,0) Screen Clipping Planes

9. Getting Each Initial Ray Origin = (0,0,0) Direction = ScreenX,screenY, zMin – ScreenX, ScreenY are the float locations of each pixel in projected world coordinates – zMin is the plane on which the screen exists

10. Materials Surfaces must have their Material Properties set – Diffuse, Reflective, Emissive, and Colour need to be considered

11. For Each Pixel (the main Raytrace loop) For each pixel { Construct ray from camera through pixel Find first primitive hit by ray Determine colour at intersection point Draw colour to pixel Buffer }

12. Intersections The simplest way is to loop through all your primitives (All Polygons) – If the Polygon Normal DOT RayDirection(Cos Theta) < 0 // Face is opposite to Ray Ignore – Now we can Intersect the Ray with the Polygon – Or Intersect the Ray with the Polygons Plane

13. Ray / Polygon Intersection p0, p1 and p2 are verts of the triangle point(u,v) = (1-u-v)*p0 + u*p1 + v*p2 U > 0 V > 0 U + V <= 1.0

14. Line Representation point(t) = p + t * d t is any point on the line p is a known point on the line D is the direction vector Combined: p + t * d = (1-u-v) * p0 + u * p1 + v * p2 A Point on the line (p + t * d) which Is part of the triangle [(1-u-v) * p0 + u * p1 + v * p2]

15. http://www.lighthouse3d.com/opengl/maths/index.php?raytriint

16. Intersections Suck! http://local.wasp.uwa.edu.au/~pbourke/geom etry/planeline/ http://local.wasp.uwa.edu.au/~pbourke/geom etry/planeline/ http://www.netcomuk.co.uk/~jenolive/vect18 c.html http://www.netcomuk.co.uk/~jenolive/vect18 c.html http://softsurfer.com/Archive/algorithm_0104 /algorithm_0104B.htm#Line- Plane%20Intersection http://softsurfer.com/Archive/algorithm_0104 /algorithm_0104B.htm#Line- Plane%20Intersection http://members.tripod.com/~Paul_Kirby/vect or/Vplanelineint.html http://members.tripod.com/~Paul_Kirby/vect or/Vplanelineint.html

17. Intersecting a Plane A point on the Plane = p1 Plane Normal = n. Ray = p(t) = e + td P(t) = Point on Ray E = Origin D = Direction Vector t = [(P1 – e). n]/ d.n

18. World / Object Coordiantes We need to translate the Ray into Object Coordinates / Vice Versa to get this to work Ray = p(t) = e + td Ray = Inv (Object->World)e + t Inv (Object- >World)d

19. After Finding the Intersecting Plane You need a simple way to check for a hit or miss If your Object has a bounding box this can be achieved through a line check

20. Miss Conditions

22. Hit Conditions

23. For Other Shaped Flat Polygons An Even Number of Intersections with the Outside of the Polygon means a Miss An Odd Number of Intersections means a Hit

24. Task List for Ray Casting 1)Create a vector for each Pixel on the screen a)From the Origin of the Camera Matrix (0,0,0) b)That intersects with a Pixel in the screen 2)Use this Vector to create a trace through the World a)From the Zmin to the Zmax Clipping Volume b)UnProjected into World Coordinates 3)Intersect the trace with every object in the world

25. 4)When the ray hits an Object we need to check how the pixel should be lit a)Check if the Ray has a direct view to each of the lights in the scene b)calculate the input from each light. c)Color the pixel based on the lighting and surface properties

26. One extra task for Ray Casting After Intersection Calculate the reflective Vector – Dot Product of Ray and Surface Normal Then cast a new Ray – This continues in a recursive fashion untill: A ray heads off into the universe A ray hits a light We reach our maximum recursion level

27. How we would like to be able to calculate light

28. Conservation of Energy A Physics-Based Approach to Lighting – Surfaces will absorb some light, and reflect some light – Any surfaces may also be light emitting – Creating a large simultaneous equation can solve the light distribution (I mean LARGE) – The light leaving a point is the sum of the light emitted + the sum of all reflected light

29. Don’t Scream (loudly)

30. The Rendering Equation http://en.wikipedia.org/wiki/Rendering_equation Light Leaving Point X in direction  Light Emitted by Point X in direction  Integral over the Input Hemisphere Bidirectional reflective function (BDRF) in the direction  from direction  ’ Light toward Point X from direction  ’ Attenuation of inward light related to incidence angle

31. The Monte Carlo Method Repeated Random Sampling Deterministic Algorithms may be unfeasibly complex (light)

32. Metropolis Light Transport A directed approach to simplifying the BDRF Still considered a Monte Carlo Method It directs the randomness considering more samples from directions with a higher impact on the point being assessed

33. BDRF Tracing http://graphics.stanford.edu/papers/metro/

34. Metropolis Light Transport http://graphics.stanford.edu/papers/metro/

35. Radiosity Simplifying the Rendering Equation by making all surfaces perfectly diffuse reflectors This simplifies the BDRF function

36. Parallel Rendering (Rendering Farms) There are Three major Type Definitions – Sort-First – Sort-Middle – Sort-Last These are just the outlines, in reality things need to be customised based on technical limitations / requirements

37. Sort-Middle Application Sort Geometry (Vertex Shading) Geometry (Vertex Shading) Geometry (Vertex Shading) Fragments (Pixel Shading) Fragments (Pixel Shading) Fragments (Pixel Shading) Display Fragments (Pixel Shading) Geometry (Vertex Shading)

38. Sort-Middle Pros – The number of Vertex Processors is independent of the Number of Pixel Processors Cons – Normal Maps may mess with Polygons on overlap areas – Correcting Aliasing between Display Tiles (RenderMan??) – Requires specific hardware – Rendering may not be balanced between Display Tiles

39. Sort-Last Application Composite Geometry (Vertex Shading) Geometry (Vertex Shading) Geometry (Vertex Shading) Fragments (Pixel Shading) Fragments (Pixel Shading) Fragments (Pixel Shading) Display Fragments (Pixel Shading) Geometry (Vertex Shading)

40. Sort-Last Pros – Can be easily created from networked PCs Cons – Each Vertex Processor requires a Pixel Processor – Unsorted Geometry means each Pixel Processor must carry a full-size frame buffer Limited scalability – Composing the image requires integrating X frame buffers considering X Z-Buffers

41. Sort-Last Compositing can be done more efficiently (memory requirements) utilising a binary tree approach – May lead to idle processors Another approach is a Binary Swap architecture – Large Data Bus usage

42. Sort-First Application Sort Geometry (Vertex Shading) Geometry (Vertex Shading) Geometry (Vertex Shading) Fragments (Pixel Shading) Fragments (Pixel Shading) Fragments (Pixel Shading) Display Fragments (Pixel Shading) Geometry (Vertex Shading)

43. Sort-First Pros – Pixel Processors only need a tile of the display buffer – Can be created utilising PC hardware – Infinitely Scalable Cons – We are sorting Primitives BEFORE they are translated into projected space!!! This requires some overhead – Polygons crossing tiles will be sent to both pipelines – An error backup could consider a bus to move incorrectly sorted polygons to the correct render queue (Transparency causes issues here!) – Correcting Aliasing between Display Tiles – Rendering may not be balanced between Display Tiles

44. Parallel Processing Techniques Conclusively – Sort-Middle is for expensive hardware – Sort-Last is limited by scalability – Sort-First requires careful consideration on implementation Sort First / Sort Last COULD be run on a Cloud – Bandwidth?? – Security?? – What happens when you max the cloud??

45. Image Based Rendering Geometric Upscaling! The process of getting 3D information out of 2D image(s) – Far outside our scope, but interesting in Research

46. RenderMan https://renderman.pixar.com/

47. RenderMan / Reyes Reyes (Renders Everything You Ever Saw) RenderMan is an implementation of Reyes – Reyes was developed by two staff at the ‘Lucasfilm's Computer Graphics Research Group’ now known as Pixar! – RenderMan is Pixar’s current implementation of the Reyes Architecture

48. The Goals of Reyes Model Complexity / Diversity Shading Complexity Minimal Ray Tracing Speed Image Quality (Artefacts are Unacceptable) Flexibility – Reyes was designed so that new technology could be incorporated without an entire re- implementation

49. The Functionality of Reyes / RenderMan Objects (Polygons and Curves) are divided into Micro Polygons as needed – A Micro Polygon is a typically smaller than a pixel – In Reyes Micro Polygons are quadrilaterals – Flat shading all the Quads gives an excellent representation of shading These quads allow Reyes to use a Vector Based Rendering Approach – This allows simple Parallelism

50. Bound – Bounding Boxes Split – Geometry Culling & Partials Dice – Polygons into grids of Micro Polygons Shade – Shading Functions are applied to the Micro Polygons Functions used are Independent of Reyes Bust – Do Bounding and Visibility checking on each Micro Polygon Sample (Hide) – Generate the Render based on the remaining Micro Polygons

51. The Reyes Pipeline http://en.wikipedia.org/wiki/File:Reyes-pipeline.gif

52. Interesting Facts Some Frames take 90 hours!!! (1/24 th of a second of footage) On average Frames take 6 hours to render!!!! 6 * 24 = 1 second = 144 Hours – About 2 years for a 2 hour Movie!!

53. Licensing $3500 us per Server $2000us – 3500us per Client Machine Far cheaper than I expected!

54. References http://en.wikipedia.org/wiki/Reyes_rendering http://en.wikipedia.org/wiki/Rendering_equatio n http://www.steckles.com/reyes1.html http://www.flipcode.com/archives/Raytracing_T opics_Techniques-Part_1_Introduction.shtml http://www.lighthouse3d.com/opengl/maths/in dex.php?raytriint