Recommended Technical Features

We suggest referring to this document while working on both Project 6: Final Project Gear Up and Project 7: Final Project. See the instructions in each handout for more info on what we're looking for.

Feature Tracks: Below, we group related features into tracks. Features in tracks can build on each other, so you should implement them in order. Some features depend on features in other tracks, and these dependencies are listed in the tables below.

This list is by no means exhaustive! You are welcome to implement features not listed here, but please discuss them with a TA or the professor first, so we can determine an appropriate point value.

Feature Point Values: Each feature has a star rating (⭐) indicating its relative difficulty and point value. Each star corresponds to 20 points, so the point values for features are as follows:

• ⭐ : 20 points
• ⭐⭐ : 40 points
• ⭐⭐⭐ : 60 points
• ⭐⭐⭐⭐ : 80 points
• ⭐⭐⭐⭐⭐ : 100 points

Generic

Depth Buffers

Depth buffers store per-pixel depth information to determine which objects are in front of others. OpenGL computes a depth buffer by default, as long as GL_DEPTH_TEST is enabled. For this feature, you'll need to store that depth buffer in a texture that can be accessed in shaders.

G-Buffers

G-buffers (short for Geometry Buffers) store multiple per-pixel attributes such as normals, albedo, and material properties, enabling deferred shading for efficient lighting calculations.

Camera Effects

Ray Traced Depth of Field

Tracing rays from non-pinhole camera (i.e. a lens with finite aperture) to simulate realistic defocus blur effects.

Screen Space Depth of Field

Mimicking depth of field effects as a screen space post-processing effect by blurring pixels based on their depth relative to the focal plane.

Lens Assemblies

Simulating physically realistic camera lenses by tracing rays through multiple lens elements to capture effects like distortion and chromatic aberration.

Ray Traced Motion Blur

Tracing rays over a time interval to simulate motion blur for fast-moving objects or camera motion.

Screen Space Motion Blur

Applying motion blur as a screen space post-processing effect by blurring pixels based on the velocity of the objects they cover. Per pixel velocity can be written to two channels of a G-buffer.

Camera Paths

Allow the camera to move along predefined splines or curves. Useful for cinematic shots and cutscenes.

Lighting Pipeline

Deferred Lighting

Calculates lighting in screen space after geometry rendering, allowing effecient handling of many lights.

Ray Traced Ambient Occlusion

Use ray tracing from surface points to determine what percentage visible/occluded they are. This percentage is used to modulate the ambient term in the lighting equation, leading to realistic darkening in corners and crevices.

Screen Space Ambient Occlusion

Approximate ambient occlusion using depth information in screen space. Much faster than ray traced ambient occlusion but less accurate.

Screen Space Bloom

Emphasize bright light sources by adding a glow around them. The glow is created by blurring bright areas of the image and compositing them back to the original image.

Shadows

Shadow Mapping

Create shadows by rendering the scene from the light’s perspective into a depth map, then using these depths to check whether points visible from the camera are blocked from seeing the light.

Shadow Volumes

Create hard-edged shadows extruding silhouette edges from meshes to create volumes representing shadowed regions of space. Can be implemented efficiently in OpenGL using the stencil buffer.

Realtime Soft Shadows

Soften the edges of shadows by using multiple pixels in the shadow map to determine how much a point is shadowed. Also known as Percentage Closer Filtering (PCF).

Ray Traced Soft Shadows

Compute soft shadows by tracing multiple shadow rays from a surface point to an area light source.

Image-based Lighting

Wrap your scene in an environment map and treat it as a giant area light source to create realistic ambient lighting and reflections.

Volumetrics

Realtime Fog

Add atmospheric haze based on distance from the camera.

Crepuscular Rays

Crepuscular rays (colloquially known as "god rays") are the visible light shafts that form when sunlight passes through gaps in clouds or other obstacles. These can be simulated efficiently in real-time using screen-space techniques.

Volume Ray Tracing

Simulate light interaction with volumetric media (like fog, smoke, or clouds) by tracing rays through the volume and accumulating volumetric density along the ray path.

Animation

Kinematic Skeletons

Create a hierarchical structure of connected, articulatable bones to control character movement.

Linear Blend Skinning

Deform a character's mesh based on the transformations of its underlying skeleton using weighted vertex influences.

Inverse Kinematics

Calculate joint angles needed to position an end effector (like a hand or foot) at a desired location, allowing for more intuitive animation control.

Physics

Rigid Body Translation

Simulate solid, non-deformable objects translating under the influence of forces like gravity.

Rigid Body Rotation

Simulate solid, non-deformable objects rotating under the influence of torques.

Rigid Body Constraints

Restrict the movement of rigid bodies to create realistic physical assemblies, such as hinges or chains.

Collision Detection

Determine when simulated objects intersect and apply appropriate responses to prevent inter-penetration.

Spring-Mass Systems

Approximately simulate the motion of deformable objects using a network of point masses connected by springs.

Cloth Simulation

Implement a spring-mass system specifically designed to simulate realistic cloth behavior, including bending and stretching.

Particle Systems

Simulate large numbers of small, independent objects interacting to create effects such as fire, smoke, rain, or sparks.

Realtime Post-Processing

Post-Processing Pipeline

Implement a basic framework to apply a series of image-space effects after rendering the scene. This involves multiple render passes and framebuffer management.

Stylized Filters

Apply non-photorealistic screen-space filters, such as edge detection, to achieve a specific artistic style.

Color Grading

Adjusts image colors to achieve a desired mood or cinematic tone.

Procedural Generation

L-Systems

L-Systems generate recursive, fractal-like structures, often used to model plants and trees.

3D Fractals

Implement a 3D fractal generation algorithm, such as the Mandelbulb or Menger Sponge. You'll need ray marching to visualize these fractals effectively.

Wave Function Collapse

Generate tile-based patterns that are locally similar to a given input example pattern.

Texture Effects

Normal Mapping

Normal Mapping uses a texture to store surface normal perturbations, adding detailed surface features without increasing geometry complexity.

Bump Mapping

Like normal mapping, but uses a height map to simulate surface detail by perturbing surface normals during lighting calculations.

Scrolling Textures

Animate textures over time, often used for moving water, clouds, or conveyor belts.

Geometry

Offline Bezier Surface Tesselation

As a CPU preprocessing step, take a Bezier surface and tessellate it into triangles.

Realtime Surface Tesselation

Dynamically tessellate Bezier surfaces on the GPU using OpenGL tessellation shaders.

Geometry Shaders

Use OpenGL geometry shaders to manipulate and generate geometry on the GPU, such as turning points into billboard quads or densifying particle systems.

Rendering

Instanced Rendering

Instanced Rendering allows rendering many copies of an object efficiently with a single draw call. You'll need to demonstrate your implementation by rendering a scene with a huge number of repeated objects (e.g., a forest of trees) at high framerates.

Acceleration Structures

Acceleration Structures speed up ray tracing by organizing scene geometry for faster intersection tests.

Ray Marching

Render arbitary implicit surfaces (including fractals) by iteratively stepping along rays to find surface intersections.

Sphere Tracing

When your implicit surface is a signed distance field (SDF), you can use sphere tracing to efficiently find ray-surface intersections by taking steps proportional to the distance to the surface.

HDR Rendering

Make all of your lighting calculations use physical units of light intensity, then implement tone mapping to convert the resulting rendered hight-dynamic ranges (HDR) images to low-dynamic range (LDR) for display.

GPU Ray Tracing

There are many different frameworks for this, such as NVIDIA OptiX, DirectX Raytracing (DXR), and Vulkan Ray Tracing; any of these is acceptable.

Portals

Implement portal rendering, where looking through a portal shows a view into another part of the scene.

Please let us know if you find any mistakes, inconsistencies, or confusing language in this or any other CS 1230 document by filling out our anonymous feedback form.