PORTFOLIO / RESUME

Github repository

Download Build

• C++
• DirectX11
• HLSL
• Autodesk Maya
• Photoshop

Wii File Formats Research

I delved deep into romhacking & emulation forums and found out about the intricacies of the Wii file formats, giving me the tools & ability to understand and manipulate the specific data needed for this project. This specific game was never documented throughly so I had to go through some trial & error as I explored the assets structure.

Animation & Model Repair in Maya

During the assets export process I encountered several issues with smoothing groups, missing backfaces and animations that were not behaving as intended, not looping correctly or containing incorrect rotations on some bones due to bone scaling. Using Autodesk Maya I adressed these issues. I manually fixed many of the animations and remade a few simple ones from scartch in Maya (Flowers animations), as well as animated some assets by code using solutions such as sign waves. (Bushes/Bomb squishing, Butterflys flight).

HLSL Shader Programming

In an attempt to create a polished result that's true to the original game, I ran into several challenges, mostly involving draw order & transparency. While I used a particle system for the central explosion, I created an animated diffuse shader for the spreading ground explosions, and sampled the opacity map in order to render accurate real-time shadows for the butterflies who are made out of two animated quads. (improved on the original game that had butterflys, but not real-time shadows for them!)

Post-Process Levels Adjustment

When setting up the scene, I was using the Levels tools in photoshop to match the graphics it to the original game, then instead of playing with the light values in the scene, I opted to create a Post-Process Levels shader in HLSL to help me reach the exact result I got from Photoshop.

Pixel Shader's clip() Function

Draw order situations can often become complex, especially when transparency is involved. A prominent example of this in my game was with the bushes. To solve the issue, I utilized the clip() function of the pixel shader. This function allowed me to effectively manage complicated transparency draw order situations, ensuring that each bush was rendered in its correct order without any visual artifacts, against it's own submeshes as well as other bushes.

Animation Blending

Incorporating smooth transitions between animations is crucial for a natural game experience. For this, I implemented an AnimationBlender class, designed to manage and execute seamless transitions between animation clips. Here's a more in-depth look into the technical aspects of it:

• Initialization: The class is initialized with a reference to a ModelAnimator. This animator handles the current animation state, and the blender utilizes it to transition from one animation to the next.
• Starting a Blend: When transitioning to a new animation, the StartBlend function is invoked. It stores the current animation clip and its progress, marking the beginning of a blending phase.
• Blend Update: As the game progresses, the Update function ensures that the blending happens smoothly over time. It calculates a blend factor based on the elapsed time and the predefined blend duration. By using this factor, the function then interpolates between the ending frame of the previous animation and the starting frame of the new one.
• Interpolated Key Retrieval: The GetInterpolatedKey function fetches an interpolated animation keyframe based on the given time. It determines the two closest keyframes (before and after the given time) and interpolates between their bone transforms.
• Blending Completion: Once the blending process surpasses its designated duration, the Update function sets the new animation clip as the active one in the animator, ending the blending phase.

Dynamic Split-Screen for Co-Op

Since the point of this project was a Graphics Programming exercise, I would first add another player, then set up two RenderTargets, one for each horizontal half of the screen and have the screen dynamically split when one player goes off the edge of the screen. When both players are back in view (in terms of screenspace distance), I would simple render the main camera back to the backbuffer again. The desired effect would be a polished & dynamic split screen.

Vs. Battle Mode

I would add 4-Player versus mode, utilizing the already present controllers & keyboard support.

Proper SoundManager class

Sound wasn't the focus of this exercise, but I would like to add better sound effects as well as a proper SoundManager class. Right now sounds were added last minute using SDL and are very hacky.