Ray Tracing 1

1. Overview of Ray Tracing

• Definition:

  • A rendering algorithm fundamentally different from polygon rendering (e.g., OpenGL).
  • Traces rays from the camera through each pixel to find intersections with scene geometry.

• Advantages:

  • Produces high-quality rendering with:
    • Correct reflections.
    • Accurate shadows and refractions.
    • Global lighting equations.

• Disadvantages:

  • Inherently slower compared to polygon rendering.
  • Computationally intensive for real-time applications.

---

2. The Basic Ray Tracing Algorithm

• Main Steps:
  1. Spawn Rays:
     • Generate one or more rays per pixel using camera parameters (resolution, field of view, position, etc.).
  2. Trace Rays:
     • Call trace() to find the closest intersection point along the ray.
  3. Shading:
     • Compute lighting at the intersection point with shade().
     • Handle diffuse, specular, ambient contributions.
     • Recurse for reflection and refraction.

---

3. Key Functions

• trace():
  • Determines the closest intersection point and returns the color at that point.
  • Steps:
    1. Call findClosestIntersection() to get the nearest object along the ray.
    2. If no intersection, return the background color.
    3. Otherwise:
       • Compute the intersection point.
       • Calculate the surface normal.
       • Call shade() to compute the color.
• shade():
  • Computes the lighting at the intersection point.
  • Includes:
    • Shadow Rays: Determine if light sources are blocked.
    • Diffuse and Specular Contributions: Based on material properties.
    • Ambient Term: Approximation of global illumination.
    • Reflection and Refraction Rays: Recursive calls to trace().

---

4. Reflection and Refraction

• Reflection Vector:

  • Computed as: $\mathbf{r}=\mathbf{v}-2(\mathbf{n}\cdot \mathbf{v})\mathbf{n}$
  • Where $\mathbf{v}$ is the incident ray and $\mathbf{n}$ is the surface normal.

• Refraction Vector:

  • Derived using Snell’s Law: $\sin ({\theta }_2)/\sin ({\theta }_1)={\eta }_1/{\eta }_2$
  • Simplified using dot products to avoid trigonometric functions: $\mathbf{t}=\eta (\mathbf{i}-(\mathbf{i}\cdot \mathbf{n})\mathbf{n})-\sqrt{1-{\eta }^2(1-(\mathbf{i}\cdot \mathbf{n}{)}^2)}\mathbf{n}$

---

5. Supersampling and Adaptive Sampling

• Supersampling:
  • Evenly distribute multiple rays per pixel.
  • Average the colors to reduce aliasing.
• Adaptive Supersampling:
  • Use an initial sparse sampling pattern (e.g., quincunx).
  • Add more rays only in areas with high color variation.
  • Benefits:
    • Reduces rendering time compared to uniform supersampling.
    • Still limited by the Nyquist theorem.

Color AdaptiveSuperSampling() {

	– Make sure all 5 samples exist

	l (Shoot new rays along diagonal if necessary)

	– Color col = black;

	– For each quad i

	l If the colors of the 2 samples are fairly similar

	– col += (1/4)*(average of the two colors)

	l Else

	– col +=(1/4)* adaptiveSuperSampling(quad[i])

	– return col;

}

---

6. Hardware-Accelerated Ray Tracing

• Techniques:
  • SIMD/SSE/AVX: Perform the same instruction on multiple data points.
  • GPU Acceleration:
    • NVIDIA RTX: Optimized for ray tracing tasks.
    • Ray-AABB and ray-triangle intersections are precomputed.
  • Low-Level Optimizations:
    • Precompute constants for each frame to reduce calculations.
    • Rasterize primary rays for efficiency.

---

7. Temporal Reprojection

• Store the world space position and color for each pixel.
• Reuse samples from previous frames to minimize new ray traces.
• Steps:
  • Pixels without valid samples trace new rays.
  • Pixels with valid samples reuse the closest previous sample.

---

8. Typical Exam Questions

• Core Concepts:
  • Describe the ray tracing algorithm.
  • Compute reflection and refraction vectors.
  • Explain and implement adaptive supersampling.
  • Discuss jittering for aliasing reduction.
• Intersection Tests:
  • Ray/triangle, ray/box (slabs).
• Spatial Data Structures:
  • BVHs, AABSP trees, polygon-aligned BSP trees, octrees/quadtree.

---

Summary of the Ray Tracing Algorithm

1. main() calls trace() for each pixel.
2. trace():
   • Finds the closest intersection using findClosestIntersection().
   • Calls shade() if an object is intersected.
3. shade():
   • Computes lighting (diffuse, specular, ambient).
   • Handles shadow rays.
   • Recursively traces reflection and refraction rays.