3D Game Engine

A custom-built component-based 3D game engine featuring real-time physics simulation, forward rendering pipeline, and flexible entity architecture.

📖 Overview

This project is a from-scratch 3D game engine developed in C++11 with OpenGL 3.3, demonstrating proficiency in real-time graphics programming, physics simulation, and game engine architecture. The engine implements industry-standard patterns including an Entity-Component System (ECS), a finite state machine for game states, and a multi-phase physics solver with impulse-based collision resolution.

✨ Key Highlights

• 🎯 Custom Physics Engine — Full rigid body dynamics with OBB collision detection, impulse resolution, and friction
• 🧩 Component-Based Architecture — Flexible ECS pattern enabling modular game object composition
• 💡 Forward Rendering Pipeline — Multi-light shader system supporting directional, point, and spot lights
• 🧠 Memory-Efficient Object Pooling — Pre-allocated entity arrays with deferred creation/deletion queues
• 🔍 Real-Time Debug Visualization — Collision wireframes and object orientation gizmos

🛠️ Tech Stack

🏗️ Architecture

┌──────────────────────────────────────────────────────────────────┐
│                         GameEngine                               │
│  ┌─────────────────────────────────────────────────────────────┐ │
│  │                    GameStateManager                         │ │
│  │  ┌────────────────────────────────────────────────────────┐ │ │
│  │  │                      Level                             │ │ │
│  │  │  ┌──────────────────┐  ┌─────────────────────────────┐ │ │ │
│  │  │  │  PhysicsSystem   │  │      ObjectManager          │ │ │ │
│  │  │  │  ┌────────────┐  │  │  ┌───────────────────────┐  │ │ │ │
│  │  │  │  │ Collision  │  │  │  │     GameObject[]      │  │ │ │ │
│  │  │  │  │ Detection  │  │  │  │  ┌─────────────────┐  │  │ │ │ │
│  │  │  │  ├────────────┤  │  │  │  │   Component[]   │  │  │ │ │ │
│  │  │  │  │  Impulse   │  │  │  │  │ • Transform     │  │  │ │ │ │
│  │  │  │  │  Solver    │  │  │  │  │ • RigidBody     │  │  │ │ │ │
│  │  │  │  ├────────────┤  │  │  │  │ • Collider      │  │  │ │ │ │
│  │  │  │  │ Integration│  │  │  │  │ • Behaviors     │  │  │ │ │ │
│  │  │  │  └────────────┘  │  │  │  └─────────────────┘  │  │ │ │ │
│  │  │  └──────────────────┘  │  └───────────────────────┘  │ │ │ │
│  │  └────────────────────────────────────────────────────────┘ │ │
│  └─────────────────────────────────────────────────────────────┘ │
│  ┌─────────────────────────────────────────────────────────────┐ │
│  │                    Rendering System                         │ │
│  │  Forward Renderer • Shader Management • Model/Mesh Pipeline │ │
│  └─────────────────────────────────────────────────────────────┘ │
└──────────────────────────────────────────────────────────────────┘

🧩 Entity-Component System (ECS)

The engine employs a component-based architecture where game entities (GameObject) are containers for modular components that define behavior and properties:

// Component system uses CRTP pattern for type-safe component identification
class Transform : public Component<TRANSFORM> { ... };
class RigidBody : public Component<RIGIDBODY> { ... };
class Collider  : public Component<COLLIDER>  { ... };

Supported Components

• Transform — Position, rotation, scale with matrix composition
• RigidBody — Mass, velocity, angular velocity, inertia tensors
• Collider — Box, Sphere, Capsule shapes with layer/mask filtering
• ForceAccumulator — Force/impulse/torque application
• CollisionEvents — Callback-based collision event routing
• HUD — 2D overlay rendering component

⚙️ Physics System

A custom rigid body physics engine implementing a 6-phase simulation pipeline:

Physics Features

• 🎲 Collision Shapes: Box (OBB), Sphere, Capsule
• 🏃 Body Types: Static, Dynamic, Kinematic
• 💥 Collision Response: Impulse-based with configurable restitution (bounciness)
• 🧲 Friction Model: Coulomb friction with tangent velocity projection
• 📐 Penetration Resolution: Baumgarte stabilization + positional correction
• 🏷️ Collision Layers: 32-bit layer/mask system for selective collision filtering
• 📊 Inertia Tensors: Auto-computed for boxes and spheres
• 📡 Event System: Enter/Stay/Exit callbacks for collisions and triggers

// Physics update pipeline (called each frame)
void PhysicsSystem::Update(float dt) {
    GatherBodies();          // Phase 1
    IntegrateForces(dt);     // Phase 2
    DetectCollisions();      // Phase 3
    SolveContacts(dt);       // Phase 4
    IntegrateVelocities(dt); // Phase 5
    SyncTransforms();        // Phase 6
}

🎨 Rendering System

A forward rendering pipeline with shader-based lighting using the Blinn-Phong model:

Lighting Types

• ☀️ Directional Light — Sun/ambient illumination
• 💡 Point Lights — Omni-directional with attenuation (up to 4 simultaneous)
• 🔦 Spot Light — Camera-attached flashlight with cutoff angles

Shader System

Rendering Features

• Depth testing with GL_LESS comparison
• Back-face culling for performance
• Normal matrix computation for correct lighting under non-uniform scaling
• Automatic model/shader loading with error reporting

📊 Technical Specifications

✅ Implemented Features

🎮 Controls

🚀 Future Enhancements

• ⬜ Broadphase optimization (spatial hashing / BVH)
• ⬜ Deferred rendering path
• ⬜ Shadow mapping
• ⬜ Skeletal animation support
• ⬜ Audio integration (FMOD ready)
• ⬜ Scene serialization
• ⬜ Editor tools