Jeremy Phillippe's Game Development Portfolio

Overview

A Quake 2 model viewer built in Swift and using the Metal graphics API that serves as both a technical showcase and learning project. The viewer can load, animate and display classic Quake 2 character models with dynamic lighting, shadows and texture mapping. This project expanded on earlier work with Quake 1 models while exploring modern graphics programming concepts and shader development.

Features:

• MD2 model loading and rendering
• PCX texture loading and mapping
• Smooth animation interpolation
• Dynamic lighting system
• Interactive camera controls
• Real-time shadows
• Runs on macOS, iOS/iPadOS, and tvOS

Key Challenges & Solutions

Model Loading & Rendering

• Implemented MD2 file format parsing with support for vertex positions, texture coordinates, and animations
• Optimized rendering using indexed primitives to reduce vertex count from 1656 to 494 unique vertices
• Added support for model skinning with multiple texture variants

Animation System

• Created smooth animation interpolation between keyframes
• Implemented animation state management for playing/pausing and speed control
• Added support for cycling through multiple animation sequences

Lighting & Effects

• Developed dynamic lighting with support for multiple light types (point, spot, directional)
• Created ambient lighting and material systems
• Real-time shadow mapping

User Interface

• Built camera controls for model rotation and zoom
• Added animation and skin selection controls
• Implemented basic UI for displaying current animation/skin info

Lessons Learned

• Graphics pipeline and shader programming fundamentals
• 3D geometry construction and optimization techniques
• Lighting models and shadow calculation
• Texture mapping and UV coordinates
• Winding orders
• Real-time rendering optimization

Overview

A 3D game that evolved from a planned Wolfenstein 3D-style game into a six degrees of freedom (6DOF) game inspired by Descent. Originally developed in Swift using SceneKit and GameplayKit, later reimplemented in Godot Engine for broader platform support. The project provided deep experience with game engine architecture, 3D modelling, and AI systems while demonstrating the tradeoffs between different development frameworks.

Features:

• 6DOF movement system with gamepad/keyboard/mouse controls
• Enemy AI with state-based behavior
• Interactive environment (doors, keys, portals)
• Particle-based weapon systems
• Physics-based collision detection
• Customizable enemy teams and behaviours
• Custom 3D models and level design

Development Progression

Phase 1: Initial Prototyping in SceneKit

• Implemented basic 6DOF movement system
• Created test environments for prototyping
• Added physics and collision detection
• Developed initial weapon systems

Phase 2: Door System Development

• Created modular door system with multiple opening animations
• Implemented trigger zones for door activation
• Developed key card system for locked doors

Phase 3: Enemy Development

• Designed and implemented enemy AI
• Created team-based combat system along with colour variations of materials for models allowing for red, green, and blue teams
• Developed particle weapon effects for enemies
• Implemented damage and destruction systems

Phase 4: Level Design & Integration

• Created custom level geometry
• Integrated Quake community maps
• Implemented texture and lighting systems
• Added debug logging system

Phase 5: Final Implementation

• Created menu system
• Implemented win/lose conditions
• Enhanced particle effects
• Added sound effects and feedback systems

Phase 6: Godot Reimplementation

Reimplemented core gameplay in Godot Engine to expand the platform support beyond that of Apple's ecosystem.

• Improved physics and collision detection
• More sophisticated particle effects
• Physical projectiles with collision detection
• Enhanced explosion effects
• Improved enemy AI pathfinding
• Better scene management
• Better asset pipeline
• Built-in debugging tools
• Cross-platform support
• Faster iteration time
• Animated water texture via a Godot Visual Shader that varies the UV coordinates over time

Key Technical Achievements

• Custom model creation and animation in Blender
• Complex physics-based movement system
• Team-based AI combat system
• Modular door and trigger system
• Advanced particle effects
• Debug logging system

Lessons Learned

Game Engine Architecture

• Entity, Component, System design
• Collision/contact system
• Particle Systems
• The 3D coordinate system Apple uses for SceneKit is not the same as the 3D coordinate system used by GameplayKit's NavigationAgent3D
• Moderation in the number of weapon systems

Graphics Concepts

• Surface Normals
• Materials and textures
• Physics Based Rendering and their corresponding textures
• Seamless texture design
• Shader programming

Development Pipeline

• Optimizing an asset pipeline between Blender and SceneKit using a custom Python exporter to include level metadata e.g. lighting and door properties (which opening mode, if a key is required, always locked)
• Level Design

3D Technical Skills

• Quaternions and other matrix manipulation
• slerp and lerp for handling rotations smoothly

Overview

A prototype first-person investigation game developed in Godot Engine where players investigate insurance claims involving supernatural events. Built using COGITO's first-person framework for core mechanics and Synty Studios' assets for environment creation, the project focused on rapid prototyping and system integration.

Features:

• First-person investigation mechanics
• Environmental interaction system
• Simple inventory system
• Detailed urban environment using Synty assets

Development Progression

Phase 1: Environment & Atmosphere

• Created initial parking structure environment
• Implemented basic vehicle models
• Added environmental details and lighting
• Developed atmosphere and mood setting

Phase 2: Core Mechanics

• Implemented basic inventory system
• Created interaction prompts
• Added item pickup mechanics

Phase 3: Support Systems

• Added remote support character interface that barks when near a clue
• Integrated Synty Studio assets
• Implemented clue placement system

Technical Achievements & Learnings

• First project using Godot 4
• First-person interaction system development
• Prototype-focused development approach

Lessons Learned

• Pre-made assets significantly accelerate development compared to custom modeling
• Importance of exploring existing solutions before building custom ones
• Advanced Godot scripting patterns and practices
• Value of rapid prototyping for game concept validation

Overview

A first-person shooter prototype developed following GameDev.tv tutorials, leveraging Synty Studio's city assets and a Godot Engine project template. The project served as a technical exploration of FPS mechanics, enemy AI, animation systems, and scene management. Through clean scene separation and modular design, the project demonstrated rapid prototyping capabilities while establishing reusable foundations for future game development.

Core Systems:

• First-person shooter mechanics
• Enemy AI using Godot's Navigation system
• Animation state machine using AnimationTree
• Weapon feedback systems (visual, audio)
• Scene management and modularity

Development Progression

Phase 1: Core Systems

• Implemented FPS mechanics
• Created weapon systems
• Integrated Synty city assets
• Added sound effects and feedback

Phase 2: Enemy AI & Animation

• Integrated Mixamo character models and animations
• Implemented AnimationTree state system
• Created enemy spawn system
• Developed pathfinding behaviors

Technical Achievements

• Modular scene architecture
• Animation state machine implementation
• Navigation and pathfinding systems
• Weapon feedback systems
• Custom viewport rendering

Lessons Learned

• Importance of modular scene design
• Weapon feel through combined feedback (visual, audio, physics)
• Benefits of animation libraries and auto-rigging tools
• Viewport management for weapon models to prevent clipping into other close objects
• Decal system implementation
• Sound design impact on game feel
• Pathfinding systems and how they interact with collision objects or meshes

The project served as a technical foundation for future development, demonstrating the effectiveness of combining existing assets with custom systems while maintaining clean re-useable architecture.

Overview

A first-person magic combat game where players use spells and abilities to battle waves of enemies while collecting upgrades. Built in Godot Engine, featuring two distinct environments with unique objectives.

Core Features

• First-person spellcasting with wand and two cooldown abilities (Frost Nova, Chain Lightning)
• Upgrade system using currency from defeated enemies
• Two environments: Dark mystical island and bright Mediterranean coast
• Wave-based combat and totem-charging objectives
• Advanced enemy AI with pathfinding and varied attack patterns

Key Systems

• Combat system with hitscan and projectile spells
• Enemy state machine with Mixamo animations
• Navigation mesh for AI pathfinding
• Particle effects for spell impacts
• Persistent upgrade system
• Custom logging with player messaging
• Water shader with wave simulation

Technical Achievements

• Integrated Mixamo animation system with state machines
• Implemented skeleton-based hit detection
• Created reusable interaction framework
• Developed totem charging mechanic with decay
• Added wave spawn system with dynamic positioning

Development Progression

Phase 1: Initial Environment & Systems

• Implemented terrain system with water simulation
• Created basic movement and combat mechanics
• Added spell effect system
• Developed initial enemy AI

Phase 2: Combat & Abilities

• Implemented hitscan wand weapon with impact effects
• Created two core abilities:
  • Chain lightning with upgradeable target count
  • Freeze effect with modifiable radius
• Added cooldown system
• Developed particle effects for spell impacts

Phase 3: Enemy Implementation

• Integrated Mixamo animations
• Developed state machine for enemy behavior
• Created AnimationTree for smooth transitions
• Implemented NavigationRegion for pathfinding
• Added distinct enemy types:
  • Melee attackers
  • Ranged combat units

Phase 4: Level Design & Objectives

• First Level:
  • Wave-based enemy spawning
  • Enemy elimination objectives
  • Progress tracking
• Second Level:
  • Greek/Roman aesthetic
  • Totem charging mechanic
  • Dynamic enemy spawning based on player position
  • Environmental storytelling

Phase 5: UI & Systems

• Created upgrade system
  • Implemented currency collection
  • Added weapon viewport rendering
  • Developed end-game conditions

Phase 6: Distribution

• Tested out the various project export functions to macOS and Windows
• Worked out various issues that prevented the Windows version from working
• Looked into itch.io's project publishing, setup a unlisted project to see how uploading artifacts/binaries would work
• Published a document explaining the status of the project, it's prototype nature, and what the controls are

Technical Achievements

Animation System

• Integrated Mixamo animations
• Implemented state machine for behavior
• Created smooth animation transitions using AnimationTree

Combat Mechanics

• Developed hitscan weapon system
• Created particle effects for impacts
• Implemented ability cooldown system
• Added upgradeable abilities

AI Systems

• Created navigation mesh for pathfinding
• Implemented different enemy behaviors
• Added wave spawning system
• Developed dynamic spawn points

Level Systems

• Multiple objective types
• Progress tracking
• Environmental hazards

Lessons Learned

• The usefulness of having logging info in the game, to triage issues like bad enemy spawns
• Skeleton based collision for hit detection, allowing for location based target information that is in sync with animations, e.g. can do critical damage on attacks to the head
• Early menu/settings implementation is crucial
• Input system needs initial gamepad support
• Asset reuse through rotation/scale variations pays off
• Initial enemy spawning implementation caused multiple enemy objects to be in the same physical space, Godot Engine resolves this by increasing each object's height until they are no longer colliding, resulting in enemies floating in the sky and gradually pathing down to the player, solved by adding a small amount of displacement to each enemy at spawn so they no longer overlapped

Overview

A space-based incremental game developed in Godot where players must rebuild a Stargate to escape a hostile solar system. Players manage resources, construct facilities, and defend against machine intelligences while exploring a dynamic solar system. The project emphasizes early implementation of core systems like settings, save/load functionality, and proper menu structures based on lessons learned from previous projects.

Core Systems:

• Dynamic solar system simulation with orbital mechanics
• Resource management and facility construction
• Ship movement with realistic thruster effects
• Menu-based interface system with settings
• Save/load functionality
• Customizable audio system with multiple buses

Development Progression

Phase 1: Core Architecture & UI

• Implemented menu system with resolution settings
• Created git-based version tracking system
• Developed audio bus system for sound management
• Added save/load functionality with 10 slots

Phase 2: Solar System & Ship Mechanics

• Created solar system visualization
• Implemented ship movement with particle effects
• Developed star shader system
• Added orbital mechanics and transitions
• Created reaction control system visualization

Phase 3: Resource & Construction Systems

• Implemented four primary resources (Materials, Science, Industry, Energy)
• Created construction system
• Added resource generation mechanics
• Developed interactive building menu

Planned Features

• Anomaly events
• Scalable gameplay lengths (15-60 minutes)
• Strategic defense mechanics

Technical Achievements

• Custom shader system for celestial bodies
• Dynamic particle systems for ship thrusters
• Integrated version control with UI
• Comprehensive settings management
• Modular audio system

Lessons Learned

• Early implementation of core systems (menus, settings, save/load) is crucial
• Git integration can provide useful versioning feedback
• Audio system architecture needs early planning
• Proper serialization needs to be considered from the start
• Input system needs to handle multiple control schemes

Overview

A first-person mech salvage simulator where players methodically dismantle and process decommissioned mechs using specialized tools. Built in Godot Engine, the game features:

• Precision laser cutting tool that allows players to strategically slice mech components into smaller pieces
• Industrial gantry crane system for lifting and transporting heavy mech parts
• Cleaning system to remove grime and restore salvaged components
• Physics-based interactions where cut pieces realistically break apart and can be manipulated
• Industrial hangar environment where players process mechs for salvage
• Custom mesh slicing system that creates clean cuts with proper collision detection

Core Development

3D Model Processing

• Optimized a 3D printable mech model into asset useable in game, created custom mesh names
• Created material system to track component properties (mass, material type) and visual appearance
• Used mesh volume calculations to determine component tonnage for salvage value

Environmental Systems

• Developed customizable grime system, initially attempting shader-based solution before optimizing with decals
• Created physics transition system to convert static objects to dynamic rigid bodies after slicing
• Implemented collision shape reuse system to maintain physical accuracy while optimizing performance

Tool Systems

Laser Cutting Tool

• Developed mesh slicing system that creates clean cuts with proper face generation
• Implemented real-time preview system showing cut location and orientation
• Created physics-based separation of cut components
• Added visual and audio feedback for cutting operations

Cleaning System

• Built cleaning system with particle effects
• Developed grime removal mechanics with progressive cleaning

Crane Control System

• Created gantry crane with physics-based cable system
• Implemented pick-up and drop-off mechanics for heavy components

Environment Development

Industrial Hangar

• Modified Synty Studios hangar asset for salvage operations
• Added external environmental details

Technical Systems

Physics Integration

• Developed system to convert static meshes to dynamic rigid bodies
• Implemented proper mass calculations based on component volume
• Created collision shape generation for cut pieces
• Added physics material properties for realistic behaviour

Tool Management

• Built tool switching system with smooth transitions
• Implemented tool-specific UI elements
• Created cooldown system for tool operations
• Added aim-assist functionality for precise operations

Debug Systems

• Implemented comprehensive logging system
• Created visual debugging tools for physics and collisions
• Added performance monitoring
• Developed state visualization for complex operations

Lessons Learned

• Importance of proper mesh organization for interactive components
• Benefits of decal-based systems over shader solutions for certain effects
• Necessity of robust physics calculations for realistic behaviour
• Benefits of modular design for complex mechanical systems
• Necessity of proper collision layer management
• Value of comprehensive logging for debugging physics interactions

Overview

Space Sweeper is a 3D orbital debris cleanup game developed for a game jam with the theme "Nothing can go wrong..." Players take on the role of a space cleanup technician in the year 2042, when humanity faces the looming threat of Kessler Syndrome - a scenario where space debris collisions create a cascading effect that could trap humanity on Earth for generations. Using specialized tools like the Collector, players must carefully capture and retrieve various types of space debris while navigating hazards like pressurized sections and fragile components that can cause catastrophic failures if mishandled.

Released on itch.io for macOS, Windows, and Linux.

Core Systems:

3D orbital mechanics simulation around Earth Physics-based debris collection using a magnetic grappler Hazard management system with different debris types Mission progression structure with success/failure states Dynamic orbital debris visualization Cinematic sequences for mission outcomes

Development Progression

Phase 1: Core Mechanics & Environment

Implemented Earth and orbital environment with realistic shaders Created star field and celestial body simulation (Earth, Moon) Developed physics-based collector tool with cable mechanics Added debris system with various models and behaviors

Phase 2: Hazard System & Mission Structure

Implemented pressurized and fragile hazard components Created mission structure with objectives and time limits Added cinematic failure sequences showing Kessler Syndrome Developed tutorial system with control instructions

Phase 3: UI and Player Experience

Implemented mission UI with progress tracking Added player feedback systems for tool usage Created mission completion screens with statistics Developed intro/outro sequences with narrative elements

Technical Achievements

Custom Earth shader with day/night cycles and city lights Dynamic cable system for the collector tool with physics interactions Debris management system ensuring optimal performance Comprehensive settings system with audio and display options Mission progression tracking with serialized save data Controller support with input icons

Lessons Learned

Physics-based gameplay requires careful balance between realism and usability Clear instruction is critical for unique control schemes Cinematic sequences add significant narrative impact with minimal resources Early implementation of core game systems (settings, menu, tools) established a solid foundation Mission structure provides clear goals and progression Hazard design creates meaningful risk/reward scenarios