Month: November 2025

Taking all the individual performance assets (Mocap data, facial animation, dialogue audio, and subtitles) and assembling them into the final, playable cinematic moments.

1.Building the Performance Sequences

Asset Integration: For every question and action in the script (e.g., Q1A2, T2, T5), I created dedicated Level Sequences.

Layering the Assets: Within each sequence, the MetaHuman character served as the central track. I then layered the following:

Body Animation: The retargeted Mocap data was placed on the Skeletal Mesh track to drive the interrogator’s body movements.

Facial Animation: Dedicated face animation data was added to ensure the character’s lip sync and expressions matched the performance.

Dialogue & Subtitles: The voice audio file was added to the audio track, and corresponding subtitle text was timed precisely to match the dialogue delivery (as seen in the sequencer view with the audio waveform and text boxes).

2.Orchestrating the Master Sequence (The Grand Conductor)

Master Sequence: To control the flow of the entire scene, a Master Sequence was created. This acts as the conductor for the overall interrogation, combining all the smaller Q- and T-sequences.

Event Tracks & Branching: The key feature here is the use of Event Tracks within the Master Sequence.

I use these events to dynamically trigger different animation paths (e.g., jumping from T2 to either Q1A or Q1B logic).

This allows the game’s Blueprint logic (which tracks the player’s choices) to seamlessly tell the Master Sequence which branch of the cinematic to play next, making the entire scene feel continuous despite its underlying non-linear structure.

3.Scene Previsualization

The final result is the fully lit and propped interrogation room (as seen in the screenshots) where the character delivers their lines, complete with props like the lie detector and the documents on the table. This setup is now ready to receive the dynamic instructions from the player choice logic.

int PulseSensorPurplePin = A0;    // Pulse Sensor connected to analog pin A0
int LED = LED_BUILTIN;            // On-board LED
int Threshold = 550;              // Threshold for detecting a heartbeat

int Signal;                       // Holds raw analog reading
bool PulseDetected = false;       // True when a beat is detected
unsigned long lastBeatTime = 0;   // Time (ms) of the last beat
float BPM = 0;                    // Calculated Beats Per Minute

void setup() {
  pinMode(LED, OUTPUT);
  Serial.begin(115200);
}

void loop() {
  // Read the sensor
  Signal = analogRead(PulseSensorPurplePin);

  // Check if signal crosses the threshold upward (beat detected)
  if (Signal > Threshold && !PulseDetected) {
    PulseDetected = true;  // mark that we’re in a beat

    unsigned long currentTime = millis();
    unsigned long delta = currentTime - lastBeatTime;

    if (lastBeatTime > 0) {  // skip first beat (no interval yet)
      BPM = 60000.0 / delta;  // 60000 ms per minute
      Serial.print("BPM: ");
      Serial.println(BPM);
    }

    lastBeatTime = currentTime;
    digitalWrite(LED, HIGH);  // flash LED on beat
  }

  // When signal goes back below threshold, reset for next detection
  if (Signal < Threshold && PulseDetected) {
    PulseDetected = false;
    digitalWrite(LED, LOW);
  }

  // Small non-blocking pause (optional for stability)
  // Just ensures serial output isn’t too fast
  static unsigned long lastPrint = 0;
  if (millis() - lastPrint > 20) {
    //Serial.print("Signal: ");
    //Serial.println(Signal);
    lastPrint = millis();
  }
}

1. Title Screen & Player Choice (UI Design)

More importantly, I finished the initial UI element for the critical first choice. This dialogue box asks the player to select their birthplace (“Please select your birthplace / 請選擇你的出生地”).

2. The Choice Blueprint (Game Logic)

1. Behind that UI button lies the logic blueprint. I’ve implemented the functionality for the UI buttons (the “on click” events).
2. When a player makes a choice, the Blueprint takes the selected option and saves it as a string variable.
3. This variable is stored within a custom Game Instance or Game State class. The critical part is that this class persists across different levels/maps, allowing me to carry the player’s choice from the very first scene all the way to the end.

1.Model Assembly and Prop Placement

I imported and arranged all the custom static mesh assets to define the interrogation space:

Room Structure: The scene is framed by dark walls and a tiled floor, featuring the imposing Chinese characters on the background wall.

Key Props: The centerpiece is the dark wooden Table, upon which key investigative and bureaucratic items are placed:

The Device (implied lie detector/recording unit).

Stacks of official Paper/Documents.

A lone Chair sits opposite the interrogator’s side.

2.Dramatic Lighting and Atmosphere

The lighting design was used to maximize tension and focus attention on the interaction

The Spotlight: The scene is lit almost exclusively by the Desk Lamp (Lamp1), which casts a harsh, focused circle of light onto the table and the papers.

Shadow and Mood: This high-contrast setup plunges the rest of the room into deep shadow, creating an immediate sense of isolation, intimidation, and power imbalance between the brightly lit table and the dark periphery.

Material Focus: The lighting highlights the textures of the old paper documents and the stern face of the MetaHuman Interrogator, ensuring the player’s focus remains on the core elements of the interrogation.

It’s been a mix of technical animation work and some creative character design.

First, I tackled the motion capture retargeting process in Unreal Engine.

I started by setting up the T-pose as a reference for the MetaHuman character, making sure the rig was correctly aligned.

I also used a proxy mesh to help with the initial retargeting setup.

After getting the base pose right, I was able to apply some mocap data. Here’s a shot of the character in a dynamic crouching pose, testing the retargeted animation.