CSE3AGT – Zones Portals and Anti-Portals, Fog and Ray Tracing
description
Transcript of CSE3AGT – Zones Portals and Anti-Portals, Fog and Ray Tracing
CSE3AGT – Zones Portals and Anti-Portals, Fog and Ray Tracing
Paul Taylor 2010
Zones, Portals and Anti-Portals
With Pictures!
Zones
• Air-tight areas of your level that constitute different areas.
http://www.hourences.com/book/tutorialszoning.htm
Portals
• These are the windows between your Zones• You can either think of zones as airtight areas,
or pretend to fill them with water
A more effective Zone / Portal combination
Occlusion Planes
• A newer advance in pre-rendering occlusion– This was one of the key technologies that enabled
large open-world games to be created• A plane which is inserted into any object
which is large enough to be a ‘good’ occluder
The Bigger the Better!
Remember what occluders do
Get Creative!
• Don’t forget your ceilings and floors!• You should keep your visible occluders down
to only like 3 or 4
Fog is your friend!
Bonuses
• Much shorter Z-Depth Required before culling• Heavy Fog can be used in situations of high
complexity• Even on a ‘Sunny Clear Day’ with huge draw-
distances, fog can be used to stop pop-in
Negatives
More code in your shaders• Easily offset by the savings in polygonsSome extra possible issues with artefacts• Fatter Vertices
How?
Two Main Methods:• Vertex Based Fog - Cheaper• Table Based Fog (Pixel Fog) - ExpensiveImportant Attributes• Distance (range / plane)• Drop Off (Very similar to lighting!)• Z or W based
Vertex Fog
Functions in a similar way to Per Vertex Colours, or Per Vertex Lighting
Fog values are interpolated across polygons based on Vertex Values
• All the usual per-vertex problems apply here too!
Plane Based Fog
viewpoint
viewpoint
AfterBefore
Object 1(not in Fog)
View Plane
Object 2(in Fog)
Object 1( in Fog)
Object 2(not in Fog)
View Plane
Range
• Ranged based fog has a start and an end– Vertices before the FogStart are unfogged,
Vertices after FogEnd are Completely obscured– A function is used to interpolate from FogStart to
FogEnd• Simplest: Linear Interpolation• More complex: Eg: Exponential, quadratic, etc.
Range Based Fog
AfterBefore
Object 1(not in Fog)
Object 2(in Fog)
viewpoint
Object 1(not in Fog)
Object 2(in Fog)
fog_startt
fog_end
Linear Fog
Exponential Fog (2 types)
• D = distance from viewpoint• Density = Variable from 0.0 to 1.0• The second equation has a steeper gradient
through the middle section
http://msdn.microsoft.com/en-us/library/bb173401%28VS.85%29.aspx
Exponential Fog Curves
Linear Fog
Vertex Based Fog Limitations
Vertex 0f = 1
fog_start
fog_end
Vertex 1f = 0
Interpolated half-way pointf = 0.5
Polygon based Fog & Non Z Objects
• Fail!
A Tessellation Solution
Vertex 0f = 1
fog_start
fog_end
Vertex 1f = 0
Interpolatedf = 0.5
Vertex 2f = 1
Vertex 3f = 0
Z-FogThe most basic Pixel Fog is Z-Fog (Depth-Fog)Things that can go wrong:Tilting on the Y axis results in:
http://cs.gmu.edu/~jchen/cs662/fog.pdf
Why does it happen?
Side View of the previous slide
How can we solve it?
• We could Fix the rotation on the Y axis • Or we could calculate the true distance from
eye to each pixel.• It just so happens that we can get this value
for free (Processing wise, we will need an extra float per vertex)
W-Fog (The DX9 Way)
• What is W?• How do we make sure W exists?• Both these matrices will work perfectly as an
XYZ projection matrix.• Below will create a W = Z * S. not exactly
helpful.• Above will
Incorrect Projection Matrix for Accurate W Based Fog
00000
000000
nQzsQ
cc
M
Correct Projection Matrix for Accurate W based Fog
000
100
000
000
sQzs
Qsc
sc
M
n
W-Fog the DX10 Way
W Fog is easy, we already use world coordinates for vertices in our lighting, so we can just add a float to pass the eye-vertex distance to the pixel shader
Newest Fog Technologies
• Technical Innovations to reduce your visibility!
• If you want to be ‘at the front’ you need to be looking for papers from Google Scholar!– Take each idea you like, figure out how it’s done,
then figure out what you could do better!• The following is from the latest build of the
UDK
Exponential Height Fog
• New kind of global fog with density that decreases with height
• Never creates a hard line (unlike standard fog); supports one layer
• Can specify both "towards the light" and "away from the light" colours
• Rendering cost similar to two layers of constant density height fog
• Can now use different colours for the hemisphere facing the light and vice versa
Constant Density Height Fog
Exponential Height Fog
http://udn.epicgames.com/Three/rsrc/Three/ContentBlog/1ExpResized.jpg
Pipelines are for Chumps
Raycasting and Raytracing
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
Ray Tracing
• http://www.flipcode.com/archives/Raytracing_Topics_Techniques-Part_1_Introduction.shtml
Glass Ball
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
Our Rays
Center of Projection
(0,0)
Viewport
(0,0)
Screen
Clipping Planes
Into World Coordinates
(0,0)
Screen
Clipping Planes
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
Surface Materials
• Surfaces must have their Material Properties set– Diffuse, Reflective, Emissive, and Colour need to
be considered
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
}
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
Ray / Polygon Intersection
p0, p1 and p2 are verts of the trianglepoint(u,v) = (1-u-v)*p0 + u*p1 + v*p2U > 0V > 0U + V <= 1.0
Line Representation
point(t) = p + t * dt is any point on the line p is a known point on the lineD is the direction vectorCombined:p + t * d = (1-u-v) * p0 + u * p1 + v * p2A Point on the line (p + t * d) which Is part of the triangle[(1-u-v) * p0 + u * p1 + v * p2]
• http://www.lighthouse3d.com/opengl/maths/index.php?raytriint
Intersections Suck!
• http://local.wasp.uwa.edu.au/~pbourke/geometry/planeline/
• http://www.netcomuk.co.uk/~jenolive/vect18c.html
• http://softsurfer.com/Archive/algorithm_0104/algorithm_0104B.htm#Line-Plane%20Intersection
• http://members.tripod.com/~Paul_Kirby/vector/Vplanelineint.html
Intersecting a Plane
• A point on the Plane = p1• Plane Normal = n.• Ray = p(t) = e + td
P(t) = Point on RayE = OriginD = Direction Vectort = [(P1 – e) . n]/ d.n
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
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
Miss Conditions
Hit Conditions
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
Task List for Ray Casting
1) Create a vector for each Pixel on the screena) 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 Volumeb) UnProjected into World Coordinates
3) Intersect the trace with every object in the world
4) When the ray hits an Object we need to check how the pixel should be lita) Check if the Ray has a direct view to each of the lights in the sceneb) calculate the input from each light.c) Color the pixel based on the lighting and surface properties
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
How we would like to be able to calculate light
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
Don’t Scream (loudly)
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
The Monte Carlo Method
• Repeated Random Sampling• Deterministic Algorithms may be unfeasibly
complex (light)
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
BDRF Tracing
http://graphics.stanford.edu/papers/metro/
Metropolis Light Transport
http://graphics.stanford.edu/papers/metro/
Radiosity
• Simplifying the Rendering Equation by making all surfaces perfectly diffuse reflectors
• This simplifies the BDRF function
Ray Tracing and the GPU
Adios Larrabee!
• http://www.thinq.co.uk/news/2010/5/26/intel-abandons-discrete-graphics/
DIY CUDA (An Introduction to it!)
• Stolen From NVIDIA_CUDA_Tutorial_No_NDA_Apr08.pdf
*GTX 260 : 192 CUDA Cores
*GTX 260 : 192 CUDA Cores
Perhaps a better example
• This shows the scalability of CUDA arrays
CUDA References to get you going
• http://llpanorama.wordpress.com/cuda-tutorial/
• http://users.ece.gatech.edu/~lanterma/mpg08/
The main CUDA point:
• Compute Shaders follow the same logic• You’ll need to be epic with compute shaders to be
highly desirable in industry• It’ll give you massive credibility in Cluster Software
development– A lot of clusters are moving toward GPU horsepower
• High Performance Computing =– Technical Proficiency– Lots of cash– Games Related Knowledge gives you an extreme edge
over other parallel programmers
DIY Farming by Bungie
• http://www.bungie.net/images/Inside/publications/presentations/Life_on_the_Bungie_Farm.pptx
References
• http://developer.nvidia.com/object/Implementing_Fog_Direct3D.html
• http://www.hourences.com/book/tutorialszoning.htm