Scotty 3D | Mysite

Scotty3D Implementation – Computer Graphics

Project Overview:
Scotty3D is a 3D modeling, rendering, and animation package similar to Blender, but designed as an educational framework for implementing core graphics algorithms. As part of my Computer Graphics coursework at Carnegie Mellon University, I worked on completing fundamental components of the pipeline, including rasterization, path-tracing rendering, mesh editing, animation (skeleton kinematics, skinning), and particle simulation.

Technical Skills Gained:

Computer Graphics Algorithms: Understanding and implementing core graphics techniques such as ray tracing, rasterization, and mesh processing.
C++ Shader Programming: Worked extensively with C++ for low-level graphics computations.
Linear Algebra & Computational Geometry: Applied matrix transformations, quaternions, and numerical optimization in skeletal animation and mesh editing.

This project deepened my understanding of real-time and offline rendering techniques and gave me hands-on experience with fundamental 3D graphics concepts used in game engines and animation software.

🔗 Scotty3D Public Repository

Scene Transformations

Implemented transformation functions to convert geometry between object and world space:

local_to_world() and world_to_local() return 4×4 transformation matrices.
Supports scaling, rotation, and translation in matrix composition order.
Ensures correct positioning of models in the scene for rasterization.

✅ Enables accurate geometric transformations for all rasterized objects.

Line Rasterization

Implemented line drawing using a pixel-accurate rasterization method:

Used Bresenham’s algorithm for efficient line stepping.
Followed diamond exit rule to match GPU rasterization standards.

✅ Accurately draws wireframes and edge outlines.

Triangle Rasterization

Implemented triangle rasterization using bounding box and top-left rule to determine fragment coverage:

Used edge functions to perform point-in-triangle tests.
Interpolated per-fragment attributes using barycentric coordinates.
Supported both screen-space and perspective-correct interpolation for color, depth, and texture coordinates.

✅ Produces accurate fragment coverage and supports correct texture mapping under perspective.

Depth Testing and Blending

Added support for visibility and transparency:

Depth testing with a Depth_Less() function to discard occluded fragments.
Alpha blending via Blend_Add() and Blend_Over() to support semi-transparent surfaces.

✅ Enables multi-layer composition and realistic object overlap.

Mipmap & Texture Sampling

Implemented mipmap generation and multilevel texture sampling:

Calculated texture LOD based on screen-space derivatives.
Used nearest and bilinear filtering for magnification.
Used trilinear sampling for smooth minification across mip levels.

✅ Prevents aliasing and preserves detail across zoom levels.

Supersampling Anti-Aliasing (SSAA)

Implemented 8×8 supersampling for anti-aliasing:

Generated multiple subpixel samples per pixel.
Averaged results into a single final pixel color.

✅ Smooths jagged edges and improves overall image quality.

Camera Rays

Implemented camera ray generation for backward path tracing. Rays are shot from the camera through each pixel into the scene to estimate incoming radiance.

Calculated primary rays from a perspective pinhole camera model using screen-space coordinates and field of view.
These rays form the basis for recursively tracing paths through the scene.
Each pixel accumulates light by averaging multiple samples per pixel (spp) to reduce noise and aliasing.

✅ Resulting images correctly visualize surface normals and shading response.

Ray-Object Intersection

Implemented support for both triangle and sphere intersections:

Triangles: Used the Möller-Trumbore algorithm, solving a linear system with Cramer's Rule to compute barycentric coordinates and hit distance t.
Spheres: Used an analytical quadratic solution based on the ray-sphere intersection formula.

BVH Acceleration (Surface Area Heuristic)

Implemented support for both triangle and sphere intersections:

Built a Bounding Volume Hierarchy (BVH) using a top-down recursive approach with Surface Area Heuristic (SAH) for optimal splitting:
Calculated the bounding box of each primitive and node.
Chose the splitting axis with largest extent, sorted primitives along it.
Used a sweep algorithm to compute left/right bounding boxes in one pass and minimize expected cost.
Leaf nodes are created when primitive count falls below threshold or when no further cost reduction is possible.

✅ Significantly improves ray-scene intersection performance and scales well for complex geometry.

BVH Traversal

Implemented recursive ray-BVH intersection:

At each node, test ray-box intersection first to quickly reject empty space.
Recurse into left/right children depending on intersection order.
Leaf nodes test all contained primitives using the corresponding intersection function.

✅ Enables early termination and reduces the number of intersection tests per ray by orders of magnitude.

Path Tracing Core (Recursive Integrator)

Implemented recursive Monte Carlo path tracer with global illumination:

At each hit point, sampled the BSDF to generate a new ray.
Computed incoming radiance recursively and weighted it by the BSDF and cosine term.
Used Russian roulette for path termination beyond a depth threshold, conserving energy.
Accumulated radiance over multiple bounces to simulate realistic light transport.

✅ Clean separation of sampling, evaluation, and PDF logic allows easy extension for new BSDFs.

BVH

Traversal

Materials (BSDF Models)

Implemented physically-based BSDFs:

Lambertian (diffuse): Scattered rays uniformly over hemisphere; used cosine-weighted sampling and evaluated BRDF as constant albedo/π.
Mirror: Perfect reflection using the law of reflection.
Refract: Used Snell’s Law; handled total internal reflection when necessary.
Glass: Combined reflection and refraction. Used Schlick's approximation to compute Fresnel reflectance, sampling directions probabilistically.

✅ Each BSDF is treated as a delta distribution and integrated into a modular shading pipeline.

Direct and Indirect Lighting

Implemented direct lighting by sampling directions toward area lights and testing visibility using shadow rays.
Implemented indirect lighting by recursively sampling the BSDF and tracing reflected or refracted rays to accumulate bounced light.

✅ Area lights are triangle emitters that produce realistic soft shadows.
✅ Combined direct and indirect lighting enables global illumination and reduces noise in final render.

Environment Light (HDR Lighting)

Added support for infinite environment lighting using HDR maps:

Converted equirectangular HDR environment map into sampling distribution.
Precomputed per-pixel importance by multiplying pixel brightness and spherical area.
Built marginal and conditional CDFs for importance sampling directions over the sphere.
Applied Jacobian determinant to correct the PDF when transforming from image space to 3D directions.

✅ Enables realistic lighting from panoramic skies and complex environments.

MeshEdit operations utilize a pointer-based Halfedge_Mesh structure, where elements are dynamically managed. In essence, Halfedge function like a linked list, allowing efficient traversal and access to mesh components. For more details, refer to the documentation.

Local Operations

Flip Edge

Collapse Edge

Split Edge

Extrude Face

Global Operations

Triangulate

Catmull-Clark Subdivision

Linear Subdivision

Loop Subdivision

Regina Xia

Scotty3D Implementation – Computer Graphics

FASHION

Scotty3D Implementation – Computer Graphics

​