Launch Portfolio

Hand Pose Editor – Simplifying VR Hand Pose Creation in Unreal Engine

As part of my graduation internship at Vertigo Games, I designed and developed a custom Hand Pose Editor (HPE) plugin for Unreal Engine.

The tool addressed production challenges in creating static VR hand poses by replacing slow, error-prone workflows with intuitive, in-editor posing, significantly improving iteration speed and consistency.

Technical Details
  • Engine: Unreal Engine
  • Programming Language: C++ and Blueprints
  • Tools: Control Rig, Sequencer, Slate UI
  • Development Timeline: 5 months
  • Team Size: 30+ people

Sound Design for Cinematic Experience

As the lead sound designer for the Cinematic Experience project, I created and implemented high-quality audio that aligned with the narrative tone, gameplay pacing, and emotional depth.

From immersive soundscapes to precise effects, my work enhanced the interactive and cinematic elements of the project.

Key Contributions (Sound Design)
  • Immersive Soundscapes:
  • “Designed atmospheric audio to establish mood, tension, and spatial depth, ensuring each scene felt dynamic and emotionally engaging.”
  • Custom Sound Effects:
  • “Created and processed unique sound effects for interactions, environmental events, and cinematic sequences.”
  • Cinematic Audio Alignment:
  • “Tailored layered sound effects to match narrative pacing and emphasize critical moments in cinematic sequences.”
  • Unreal Engine Audio Integration:
  • “Implemented 3D spatial audio and attenuation zones for realism, ensuring precise alignment of soundscapes and effects with player actions and cinematic timing.”
  • Optimization and Performance:
  • “Optimized audio for memory and runtime efficiency while maintaining high-quality playback.”
Achievements
  • Enhanced Player Immersion:
  • Delivered soundscapes and effects that deepened emotional engagement and strengthened the cinematic tone.
  • Seamless Integration:
  • Integrated custom audio to align perfectly with gameplay and narrative pacing.
  • Optimized Audio Pipeline:
  • Balanced high-quality audio with efficient performance in Unreal Engine.
  • Physics and Movement Refinement:
  • Enhanced snowboarding physics for precise handling, with mechanics tailored to dynamic slopes and environmental factors.
  • Iterative Design through Feedback:
  • Conducted user testing to refine terrain variety, hazard placement, and overall difficulty for a balanced and engaging experience.
  • Procedural Map Tools:
  • Built tools for procedural map generation, enabling rapid prototyping of track layouts.
Challenges and Solutions
  • Synchronizing Audio with Timing:
  • Ensured precise alignment of sound effects with animations by leveraging Unreal Engine’s timeline tools and audio markers.
  • Balancing Narrative and Gameplay Audio:
  • Iteratively refined soundscapes to maintain emotional consistency while avoiding overwhelming visual or interactive elements.
  • Avoiding Repetition:
  • Introduced sound variations and random pitch adjustments to keep repetitive effects engaging and dynamic.
Technical Details
  • Engine: Unreal Engine
  • Programming Tools: Blueprints & Sequencer
  • Development Timeline: 5 months
  • Team Size: 7 people

Motion Capture Sync Tool

The Motion Capture Sync Tool empowers developers and animators to seamlessly synchronize body and facial motion capture data, enhancing precision and efficiency in Unreal Engine workflows.

By automatically managing frame offsets, this tool brings cinematic quality to real-time gameplay and animations, transforming the storytelling potential for interactive media.

Key Features:
  • Real-time frame synchronization between Xsens MVN (body) and Live Link Face (facial) data.
  • Remote start/stop functionality for MVN recordings directly within Unreal Engine.
  • Multi-frame rate support, including 240 FPS for body capture and 60 FPS for facial capture.
  • Minimal post-processing needs, reducing manual adjustment time.
  • User-friendly interface for streamlined operation.
Development Highlights:
  • Frame Synchronization Solution: Leveraged NTP-based time code fetching for frame-perfect alignment.
  • Remote Control Integration: Enabled remote control via the Xsens MVN Remote Control API for smoother recording management.
  • User Interface Design: Created an intuitive interface to reduce learning curve and facilitate ease of use.
Technical Specs:
  • Unreal Engine Compatibility: 5.3.2 and above
  • Operating System: Windows
  • Required Plugins: Xsens MVN Live Link, Live Link Face, Xsens MVN Animate/Analyze
Installation & Usage:
  • Download the tool from the Epic Marketplace (Fab.com).
  • Configure motion capture hardware and open the tool in Unreal Engine to set frame rates and start recording.

Snowboard Mayhem (Extended Edition)

Snowboard Mayhem (Extended Edition) elevates the original arcade snowboarding game into an endlessly replayable adventure.
Featuring real-time procedural terrain generation, dynamic hazards, and refined gameplay mechanics, this solo-developed project demonstrates mastery of Unreal Engine’s tools for gameplay programming and optimization.

Official Report
Key Features (Gameplay Highlights)
  • Endless Procedural Terrain:
  • “Navigate infinite snowy slopes generated in real-time, with terrain adapting dynamically to gameplay progression.”
  • Dynamic Environmental Challenges:
  • “Dodge avalanches, navigate icy patches, and endure snowstorms as you carve through treacherous landscapes.”
  • Physics-Driven Snowboarding:
  • “Enjoy realistic snowboarding mechanics, fine-tuned for handling steep slopes, jumps, and dynamic hazards.”
  • Replayable Gameplay:
  • “Every session offers a fresh experience with procedurally varied slopes, randomized hazards, and evolving challenges.”
  • Immersive Atmosphere:
  • “Experience lifelike snow effects, dynamic lighting, and environmental audio that bring the slopes to life.”
Development Highlights (Technical Contributions)
  • Advanced Procedural Terrain Generation:
  • Implemented spline-based and noise-driven systems for adaptive terrain generation, ensuring seamless transitions and varied gameplay.
  • Environmental Hazard Systems:
  • Designed interactive hazards like avalanches and icy patches using Niagara particle systems and dynamic placement algorithms.
  • Performance Optimization:
  • Developed spawning and despawning logic for procedural assets to manage memory usage and maintain consistent frame rates.
  • Physics and Movement Refinement:
  • Enhanced snowboarding physics for precise handling, with mechanics tailored to dynamic slopes and environmental factors.
  • Iterative Design through Feedback:
  • Conducted user testing to refine terrain variety, hazard placement, and overall difficulty for a balanced and engaging experience.
  • Procedural Map Tools:
  • Built tools for procedural map generation, enabling rapid prototyping of track layouts.
Challenges Overcome
  • Ensuring Seamless Terrain Transitions:
  • Resolved visible seams in procedural terrain using fine-tuned mesh generation and material blending techniques.
  • Balancing Procedural Variety with Performance:
  • Optimized asset spawning and despawning with batching and level-of-detail strategies to maintain high performance.
  • Hazard Integration and Fairness:
  • Balanced the impact of dynamic hazards like avalanches to ensure they remained challenging yet enjoyable.
Technical Details
  • Engine: Unreal Engine
  • Programming Languages: Blueprints
  • Development Timeline: 1 month + 5 months (Original)
  • Developer: Solo project

Snowboard Mayhem

Snowboard Mayhem is a solo-developed arcade snowboarding game built in Unreal Engine.
With dynamic procedural environments, physics-based mechanics, and immersive audio-visuals, the game offers a fresh challenge every run.
Developed over five months, it showcases mastery of gameplay programming and procedural content generation.

Key Features (Gameplay Highlights)
  • Physics-Driven Snowboarding:
  • “Experience realistic movement tailored to slopes, with fine-tuned physics for gravity, friction, and collision response.”
  • Procedural Slopes:
  • “Navigate procedurally generated terrains filled with forests, fences, and jumps, ensuring a unique experience every time.”
  • Dynamic Obstacles and AI Interaction:
  • “Face off against AI-controlled skiers and environmental hazards like avalanches and rolling snowballs.”
  • Immersive Atmosphere:
  • “Feel the thrill with dynamic weather effects, particle systems for snow kick-up, and immersive soundscapes.”
  • Replayability:
  • “Each run offers varied terrain and challenges, encouraging players to refine their skills and push for higher scores.”
Development Highlights (Technical Contributions)
  • Advanced Snowboarder Physics:
  • Built a physics-based movement system using Unreal Engine’s Character Movement Component and C++ for realistic snowboarding behavior.
  • Procedural Content Generation:
  • Created spline-based systems for dynamic terrain generation, populating slopes with randomized obstacles and decorative elements.
  • AI Behavior and Obstacles:
  • Programmed AI-controlled skiers with reactive behaviors and integrated dynamic hazards like avalanches and rolling snowballs.
  • Audio-Visual Effects:
  • Implemented particle effects using Niagara for snow kick-up and weather, paired with dynamic lighting and atmospheric soundscapes.
  • UI Design and Gameplay Flow:
  • Designed interactive menus, HUD elements, and score-tracking systems for a polished player experience.
  • Procedural Map Tools:
  • Built tools for procedural map generation, enabling rapid prototyping of track layouts.
Challenges Overcome
  • Terrain-Based Physics Instability:
  • Resolved terrain detection and speed fluctuation issues with raycasting and optimized collision response logic.
  • Performance Optimization for PCG:
  • Reduced computational load by batching assets and implementing level-of-detail (LOD) scaling for procedurally generated elements.
  • Blueprint-to-C++ Transition:
  • Streamlined complex Blueprint systems by refactoring core logic into scalable, reusable C++ functions.
Technical Details
  • Engine: Unreal Engine
  • Programming Languages: C++ and Blueprints
  • Development Timeline: 5 months
  • Developer: Solo project

Traingineers

Traingineers is a Mixed Reality (MR) educational application developed to make physics engaging and interactive.
Available in the store, the game allows users to build train tracks, experiment with physics-based challenges, and explore real-time train dynamics in a fully immersive environment.
As part of a 15-20 member team at Capitola Digital B.V., I contributed as a game programmer, focusing on core gameplay mechanics, physics systems, and usability improvements for MR.

Official Report
Official Report
Traingineers on Meta
Key Features (Gameplay Highlights)
  • Build and Experiment with Train Tracks:
  • “Create custom track layouts by snapping inventory items seamlessly into predefined slots.”
  • Dynamic Physics Challenges:
  • “Solve puzzles involving train derailment, wagon configurations, and track adjustments to understand key physics principles.”
  • Immersive MR Gameplay:
  • “Interact with trains and tracks in real-time using Oculus Quest hardware, offering an intuitive and engaging experience.”
  • Save and Replay Functionality:
  • “Capture and save progress with an asynchronous save system, ensuring smooth gameplay.”
  • Realistic Train Behavior:
  • “Experience accurate physics, from curve derailments to the interaction between light and heavy wagons.”
Development Highlights (Technical Contributions)
  • Snappable Inventory System:
  • Designed a snapping mechanism for placing items on tracks, ensuring precise placement and intuitive controls in MR.
  • Physics-Based Challenge Scenes:
  • Developed train derailment mechanics, including speed and angle calculations for realistic curve behavior.
  • Train Controller Integration:
  • Configured Oculus hardware for seamless MR interactions, including pose detection and intuitive controls.
  • Preview Snapshot Feature:
  • Implemented a memory-efficient snapshot tool for capturing scenes and optimizing visual previews.
  • Asynchronous Save System:
  • Built a save system to record user progress without disrupting gameplay or UI responsiveness.
Challenges Overcome
  • Physics for Train Derailment:
  • Resolved derailment logic challenges by incorporating speed thresholds and angle calculations, ensuring realistic behavior across varying track layouts.
  • Seamless Snapping Mechanism:
  • Overcame technical hurdles to ensure smooth snapping and interaction between inventory items and the environment.
  • Hardware Interaction:
  • Configured Oculus Quest controllers to handle user poses and interactions fluidly, enabling an intuitive MR experience.
Technical Details
  • Engine: Unity
  • Programming Languages: C#
  • Hardware: Oculus Quest Pro & Quest 2
  • Development Timeline: 5 months
  • Team Size: ~15-20 people

Seaside Monster Cup

Seaside Monster Cup is a family-friendly split-screen kart racing game where players race as unique monster karts, each with their own special abilities.
Featuring vibrant seaside tracks, dynamic power-ups, and chaotic multiplayer fun, the game is designed for engaging, replayable entertainment for players of all ages.

Key Features (Gameplay Highlights)
  • Monster-Themed Racing:
  • “Choose from a variety of quirky monster karts, each with its own unique design and special power-ups.”
  • Dynamic Power-Ups:
  • “Use strategic power-ups like Fire Bullets, Jelly Trails, and Frozen Walls to gain an edge and sabotage your opponents.”
  • Split-Screen Multiplayer:
  • “Enjoy local co-op or competitive racing with friends and family in engaging split-screen mode.”
  • Vibrant Tracks:
  • “Race across colorful, seaside-inspired tracks filled with ramps, shortcuts, and interactive hazards.”
  • Replayability:
  • “Experience endless fun with varied maps, unique monster abilities, and power-up combinations.”
Development Highlights (Technical Contributions)
  • Kart Movement System:
  • Implemented smooth and responsive kart movement, including drifting and boost mechanics, using Unity’s physics engine.
  • Power-Up System:
  • Designed the modular power-up system, enabling unique effects for each monster kart and easy balancing during playtests.
  • Split-Screen Input System:
  • Developed the input system for seamless multiplayer gameplay using Unity’s Input System.
  • Dynamic UI and HUD:
  • Programmed key UI elements, including character selection, leaderboards, minimaps, and power-up tracking.
  • Cinemachine Camera Integration:
  • Optimized split-screen cameras with Cinemachine for clear and dynamic player tracking.
  • Procedural Map Tools:
  • Built tools for procedural map generation, enabling rapid prototyping of track layouts.
Challenges Overcome
  • Power-Up Balancing:
  • Iteratively balanced power-ups to ensure fair yet impactful gameplay, incorporating feedback from extensive playtesting.
  • Split-Screen Optimization:
  • Optimized rendering and data structures to maintain smooth performance for multiple players in split-screen mode.
  • Accessibility and Fun:
  • Adjusted controls, visuals, and map layouts based on feedback from playtests with younger players to ensure intuitive and fun gameplay.
Technical Details
  • Engine: Unity
  • Programming Languages: C#
  • Development Timeline: 8 weeks
  • Team: 7 members (Sole Programmer)

Toy Room Showdown

Toy Room Showdown is a 2v2 multiplayer party game that pits teams against each other in a vibrant, trap-filled maze.
Players control a wind-up toy and a kid, combining strategy and coordination to complete objectives and sabotage opponents.
Designed for quick, chaotic fun, this game keeps players engaged with its dynamic traps, unique movement mechanics, and team-based gameplay.

Key Features (Gameplay Highlights)
  • Team-Based Gameplay:
  • “Work with your teammate to complete objectives while outsmarting your opponents in a competitive 2v2 match.”
  • Dynamic Traps:
  • “Interact with falling blocks, speeding trains, and cash registers to disrupt your opponents while navigating the maze.”
  • Unique Control Mechanics:
  • “Control wind-up toys using phone accelerometers for precise movement and activate traps using intuitive touch controls.”
  • Replayable Maps:
  • “Explore a colorful toyroom maze with dynamic paths and traps, offering endless strategic possibilities and replayability.”
  • Chaotic Fun:
  • “Blend strategy with lighthearted chaos, where every match feels like a new adventure.”
Development Highlights (Technical Contributions)
  • Trap System Synchronization:
  • Programmed real-time synchronization for traps like falling blocks and moving trains across all players using Photon Networking.
  • Accelerometer-Based Wind-Up Toy Movement:
  • Designed a movement system utilizing phone accelerometers, allowing players to adjust speed and direction dynamically, including sprinting mechanics.
  • Multiplayer System:
  • Developed stable networking with Photon, ensuring smooth communication between players for roles, traps, and objectives.
  • Cooldown Mechanics:
  • Implemented trap cooldowns to maintain game balance and prevent spamming.
  • Game Optimization:
  • Optimized gameplay systems for smooth performance, managing networked interactions and trap logic efficiently.
Challenges Overcome
  • Synchronizing real-time trap interactions across multiple players required efficient use of Photon RPCs to ensure seamless gameplay.
  • Developing accelerometer-based movement presented challenges in precision, which were addressed with iterative testing and calibration.
Technical Details
  • Engine: Unity
  • Programming Languages: C#
  • Networking: Photon Networking
  • Development Timeline: 2 weeks
  • Team: 7 members (Sole Programmer)

Scribble Tales

Scribble Tales is a 2-player cooperative storytelling game designed for kids and parents to bond through reading and drawing.
By alternating roles, players create their own illustrated storybook while fostering creativity, teamwork, and a love for storytelling.

Key Features (Gameplay Highlights)
  • Collaborative Storytelling:
  • “Two players—one reads aloud, the other draws—working together to bring the story to life.”
  • Dynamic Gameplay Phases:
  • “Switch seamlessly between reading segments and drawing scenes, balancing engagement for both players.”
  • Customizable Storybook:
  • “Create a unique illustrated storybook that’s saved as a keepsake at the end of each game.”
  • Child-Friendly Design:
  • “Designed for children aged 6-9, with intuitive UI and gameplay that encourages creativity and teamwork.”
  • Educational Fun:
  • “Promotes literacy and artistic expression in an interactive, rewarding experience.”
Development Highlights (Technical Contributions)
  • Text Animation System:
  • Developed smooth animations for story text to enhance immersion and guide the reading phase.
  • File-Based Story Loading:
  • Implemented a system to dynamically load story content from files, allowing easy updates and scalability for new books.
  • Timer Mechanics:
  • Designed a timer system to pace reading and drawing phases, ensuring balanced and engaging gameplay.
  • Optimization:
  • Streamlined code to improve performance and stability across the reading and drawing phases.
Challenges Overcome
  • Balancing gameplay roles was a key challenge. To ensure equal engagement, I implemented a timer system that structured gameplay flow, keeping both players involved throughout the session.
  • Scaling the game for new stories required a modular system, achieved through file-based content management for seamless updates.
Technical Details
  • Engine: Unity
  • Programming Languages: C#
  • Development Timeline: 2 weeks
  • Team: 6 members (Sole Programmer)

Binny The Binman

The 3D Exploration Quest Game puts players in a vibrant urban setting where they need to clean the town out of trash.
With an interactive quest system and advanced AI mechanics, the game challenges players to complete tasks in a bustling, fully realized cityscape.

Key Features (Gameplay Highlights)
  • Environmental Restoration Gameplay:
  • "Engage in a mission to clean up a polluted city by collecting trash, recycling waste, and visibly improving the urban environment."
  • Dynamic Task System:
  • "Complete a variety of objectives, from picking up litter to delivering collected waste to recycling centers, with real-time task updates and visual feedback."
  • Dual Interaction Modes:
  • "Switch between walking to interact with smaller items and driving a truck to transport larger loads and complete delivery tasks."
  • Immersive City Environment:
  • "Navigate a living urban setting filled with AI-driven pedestrians, bikes, and vehicles, creating a bustling, interactive atmosphere."
  • World-Space UI Integration:
  • "Track your progress and tasks using intuitive, in-world UI elements like task markers and contextual action buttons."
  • Impactful Visual Feedback:
  • "Watch the city transform as pollution levels decrease and clean areas emerge, rewarding players with a sense of accomplishment."
Development Highlights (Technical Contributions)
  • AI System:
  • Developed an AI system leveraging NavMesh for pathfinding and a node-based logic system to simulate realistic, dynamic movement for pedestrians, bikes, and vehicles.
  • Task System:
  • Implemented a robust task system that dynamically updates based on player actions, integrating interactable world-space UI elements for seamless feedback.
  • State Switching:
  • Programmed state transitions allowing players to shift between pedestrian and vehicle control modes, adapting gameplay to the player's role in the city environment.
  • UI and Feedback Loop:
  • Designed intuitive UI elements with in-world feedback systems, such as task indicators and contextual buttons, to guide the player naturally through the game.
Challenges Overcome
  • As my first major Unity project, I faced the challenge of creating a realistic AI movement system. By combining NavMesh pathfinding with a node-based approach and introducing randomization, I was able to achieve fluid, believable AI behavior that became the highlight of the game.
Technical Details
  • Engine: Unity
  • Programming Languages: C#
  • Development Timeline: 2 weeks
  • Team: 6 members (Sole Programmer)