GRAPHICS & ENGINE SYSTEMS

01. Data-Driven Vulkan ECS Level Loading Engine

Engineered a robust, highly optimized 3D Level Loading & Rendering Runtime Engine utilizing the EnTT Entity Component System (ECS) library and hardware-accelerated Vulkan surfaces.

Bypassed traditional object-oriented game loops to construct a Data-Oriented Design (DOD) workflow where game scenes exist as flat, cache-friendly arrays of components (CPULevel, GeometryData, GPUInstance). Implemented reactive system interceptors using EnTT lifecycles, ensuring that parsing a scene file instantly triggers a cascade of signal functions that stream geometry parameters to optimal GPU memory blocks.

Designed a performance-critical Flyweight Instancing Factory. When runtime entities replicate, the system intercepts resource cloning requests, establishing instances that share a central memory pool containing pre-cached indices and vertex bounds. Packed individual model matrices and material details down through instanced transform buffers to fire high-throughput draw cycles without pipeline stalling.

02. Hardware-Accelerated Vulkan PBR Rendering Engine

Developed a production-grade, bare-metal Vulkan 1.3 Rendering Pipeline from the ground up, implementing full physically-based shading logic directly on GPU hardware kernels.

Architected a high-fidelity shader system (HLSL) running microfacet Cook-Torrance specular BRDF mathematics. The engine processes diffuse Image-Based Lighting (IBL) and specular reflections by loading and sampling from high-dynamic-range cube maps, integrating a pre-computed 2D BRDF Look-Up Table (LUT) to enforce real-time conservation of light energy across dielectric and metallic matrices.

Fully managed the lifecycle of low-level graphics structures, orchestrating allocation matrices across VkPipeline, descriptor pools, uniform buffer blocks, and custom storage views. Integrated asset parsers using the TinyGLTF structure to read raw asset streams, piping vertex maps directly into hardware-bound staging lines without wasting CPU clock cycles.

03. Dynamic Illumination & Shading Software Pipeline

The final software rasterization milestone: a fully textured, single-threaded 3D Stonehenge Environment running pixel-by-pixel entirely on the CPU inside a raw 1D pointer allocation.

Engineered a multi-light illumination processor tracking concurrent ambient, directional, and point light calculations. Implemented inverse-square distance falloff using localized linear and quadratic decay matrices. Computed per-vertex Gouraud Shading using normal vector dot products (NdotL), blending parameters across manual barycentric rasterizer passes.

Optimized the rendering pipeline by introducing a strict Backface Cross-Product Culling check, calculating polygon normal orientations against view vectors to drop hidden meshes before rendering. Integrated custom trigonometric tracking for spherical orbit cameras and generated a procedural 3,000-star coordinate clipping field.

04. Barycentric Rasterization & Depth Occlusion Buffering

Advanced the software engine into solid-geometry processing by constructing mathematical polygon-filling routines that replicate GPU raster logic on raw memory blocks.

Engineered solid triangle fills utilizing Barycentric coordinate planar interpolation. To protect execution performance, the loops compute custom 2D horizontal bounding frames for every asset, bounding pixel tracking strictly to the geometric footprint of the mesh.

Architected a parallel 1D depth-sorting allocation map (Z-Buffer), checking clip depths before executing color overrides to manage element occlusion. Mitigated perspective image warping by developing Perspective-Correct Affine UV Mapping, dividing texture dimensions by homogeneous clip reciprocals (1/w) to secure texture alignment.

05. 3D Projective Mathematics & MVP Pipeline

Laid the fundamental mathematical algorithms required to translate three-dimensional coordinates into flat two-dimensional screen space frames.

Hand-coded a custom 3D vector and matrix math engine including structural implementations for Vec3, Vec4, and Matrix4x4 systems. Coded multi-dimensional matrix transformation algorithms alongside a detailed 4x4 matrix inversion routine derived from determinants and adjugate matrices.

Built a functional Model-View-Projection (MVP) pipeline to shift model arrays through world, camera view, and clip matrices. Executed 4D homogeneous perspective coordinate division loops to map normalized coordinate systems straight to screen-space dimensions. Wrote strict near-plane clip safeguards (w > 0.001f) to intercept visual clipping errors behind the camera path.

06. Parametric Line Rasterization & Structural Wireframes

Progressed from baseline pixel mapping to generating structural visual assets by defining linear geometric vector calculations.

Engineered a custom Parametric Line-Drawing Rasterizer, tracing geometric changes across coordinate axis paths to plot contiguous, unbroken lines without referencing third-party graphics tools. Managed sub-pixel position floats using std::round() loops to map point positions cleanly into discrete buffer spaces, wrapping structural indices via modulo arithmetic loops to close poly-mesh perimeters automatically.

07. Flat Pixel Memory Mapping & Alpha Blit Routines

The underlying layer of the engine architecture: asserting direct command over visual hardware windows by interacting with raw heap blocks without engine abstraction overlays.

Managed a dedicated flat 1D pixel array buffer, writing 2D coordinate-to-1D index translation functions to map memory locations. Implemented bitwise shifting algorithms to translate pixel color streams from storage BGRA setups to runtime ARGB outputs. Created a fast block image transfer (BLIT) sprite engine complete with alpha-blending math to eradicate color outline defects around transparent graphics edges.