Schott's Documentation/Contribution

GASP Dynamic Additive Overlay (DAO) - Project Manual

This manual consolidates information about the GASP Dynamic Additive Overlay (DAO) project, an Unreal Engine template, based on video descriptions and transcripts from the UnrealDevOp channel. It covers the project overview, core components, data assets, item management, animation layers, implementation details, project setup, version history, tools, and additional tips.

Table of Contents

  1. Project Overview & Philosophy 1.1. Developer Resources 1.2. Educational Purpose & Licensing 1.3. Evolving Project 1.4. Data-Driven Approach 1.5. Dynamic Additive Overlay (DAO) System 1.6. Motion Matching Integration 1.7. Replication 1.8. Project Management & Access

  2. Initial Project Setup

  3. Core Character & Animation Blueprints 3.1. CBP_SandboxCharacter_DAO (Character Blueprint) 3.2. ABP_SandboxCharacter_DAO (Main Animation Blueprint)

  4. Data Assets & Configuration 4.1. Primary Data Assets (PDAs) for Items/Actions 4.2. Data Assets for Layering (PDA_OverlayLayering) 4.3. Data Assets for Live Retargeting (PDA_LiveRetargeting_Settings, DA_HOS_IK_Offset) 4.4. Chooser Tables (CHT_...) 4.5. Gameplay Tags (GT_...)

  5. Item & Slot Management 5.1. AC_HeldObject_Master & AC_Gun (Actor Components) 5.2. BP_HeldObjects_Master (Base Item Actor) 5.3. AC_SlotManager (Actor Component on CBP_SandboxCharacter_DAO) 5.4. BP_Slot_Master (Base Slot Actor)

  6. Specialized Animation Layers & Poses 6.1. Linked Anim Layers (ALI_...) 6.2. Control Rig Poses (CR_..., various pose assets PA_...) 6.3. Pose Drivers & Corrective Animations

  7. Implementation Guide 7.1. Project Summary 7.2. Main Classes & Blueprints (Implementation Context) 7.3. Key Feature Implementation Locations & Video References

  8. Version Updates & Key Changes (Chronological) (Includes versions 1.49 down to 1.24) The Following are Missing:

  9. Detailed Mechanics (Integrated from Video Reference Guide) 9.1. Item and Held Objects System (AC_HeldObject_Master, AC_Gun) 9.2. Slot and Holster System (AC_SlotManager) 9.3. Animation and Layering System 9.4. Character Setup & Retargeting 9.5. Specific Gameplay Mechanics

  10. Tools & External Software

  11. Additional Topics and Tips

1. Project Overview & Philosophy

The GASP Dynamic Additive Overlay (DAO) project by UnrealDevOp is an advanced character animation and interaction system for Unreal Engine, built upon the Game Animation Sample Project (GASP) and its motion matching capabilities. It emphasizes a highly data-driven architecture using Data Assets, Chooser Tables, and Gameplay Tags to manage character states, animation layering, item handling (weapons, flashlights, etc.), and live retargeting for diverse character anatomies. Key features include a custom dynamic additive overlay system for realistic weapon holding during movement, a precise aim offset system (including distance-based compensation), a robust item slot and holstering mechanism, and progressively implemented network replication.

1.1. Developer Resources

1.2. Educational Purpose & Licensing

  • Description: The project is primarily intended as an educational tool to demonstrate advanced animation techniques within Unreal Engine, particularly building upon the Game Animation Sample Project (GASP). While educational, it's released under an MIT license, which is generally permissive. However, the creator has implemented a EULA via Ko-fi that requires attribution (credit via a BSD 3-Clause style notice) if used in a compiled game, and restricts reselling the source code.

  • Key Video: "Unreal Engine 5; GASP-DAO (Major Changes And Why)" (discusses the move to Ko-fi and the EULA).

1.3. Evolving Project

  • Description: The creator consistently emphasizes that GASP-DAO is an actively evolving project. Features are frequently added, refactored, and improved. This means that specific Blueprint setups, variable names, or even entire sub-systems might change between versions. Users should expect this and refer to the latest overview videos for the most current information.

  • Key Videos: This is a recurring theme in most update overview videos (e.g., "Unreal Engine 5 - GASP DAO (Update 1.10)", "Unreal Engine 5; GASP DAO (v1.3x) series", etc.).

1.4. Data-Driven Approach

  • Description: A cornerstone of GASP-DAO is its heavily data-driven architecture. This primarily involves:

    • Primary Data Assets (PDAs): Used to store configurations for items, weapons, IK offsets, layering settings, etc. (e.g., PDA_ActionData_Weapon, PDA_HeldObjectSettings).

    • Chooser Tables: Unreal Engine's Chooser system is used extensively to select appropriate Data Assets at runtime based on context (e.g., character type, equipped item, character state). This allows for dynamic selection of animation sets, IK settings, and more.

    • Gameplay Tags: Widely used for identifying states (character states, item states, stances), item types, and as keys in maps within Data Assets (e.g., for selecting montages or IK offsets).

  • Purpose: This approach promotes flexibility, reduces hardcoding, makes it easier to add new content (characters, weapons) with varied behaviors, and manage complex interactions.

  • Key Videos: "GASP DAO V1.47 (Item Handling System)" (excellent example for item and character data), "UE 5; GASP-DAO Breakdown - Part 1 (v1.24)" (general data asset usage), "Unreal Engine 5; GASP DAO (V1.31 Overview)" (Chooser usage for Live Retargeting assets).

1.5. Dynamic Additive Overlay (DAO) System

1.6. Motion Matching Integration

  • Description: The entire system is built upon and enhances Unreal Engine's Motion Matching, as provided in the Game Animation Sample Project (GASP). Familiarity with GASP's core motion matching principles is beneficial.

  • Key Videos: This is foundational to almost all videos. "Unreal Engine 5 - ALS vs Motion Matching (Performance Profiling)" discusses performance aspects.

1.7. Replication

  • Description: Network replication for multiplayer has been progressively added and refined. Initial versions might have had limited replication. Features like item handling, aiming states, traversal, and projectile spawning have seen specific replication updates. The creator sometimes used plugins like SmoothSync for testing but these are not included in the project.

  • Key Videos: "Unreal Engine 5; GASP DAO (v1.33 Overview)" (mentions traversal replication refactor), "Unreal Engine 5; GASP DAO (v1.25 Overview)" (discusses aim offset replication, projectile replication with SmoothSync for testing), "GASP_DynamicAdditiveOverlay(1.37)" (Distance Based AO replication, ItemsInHand replication refactor).

1.8. Project Management & Access

  • GitHub Repository:

    • Details: The GASP-DAO project was moved to a GitHub repository to facilitate version control, updates, and community access. Initially, it was a private repo, then public using Git LFS (Large File Storage) for larger assets. Later, the project was refactored to reduce overall size and remove the dependency on LFS, making it more accessible. The setup process involves cloning the DAO repo and then copying over files from a base Game Animation Sample Project.

    • Key Videos: "Unreal Engine 5; GASP DAO (New GitHub Repo)", "Unreal Engine 5; GASP DAO (GitHub Setup)", "Unreal Engine 5; Gasp-DAO (v1.40 Overview)" (new setup process without LFS).

  • Ko-fi:

    • Details: Used for distributing project files (both direct downloads and repo access) and for users to support the project's development. The creator implemented a paywall and EULA via Ko-fi for legal protection and to ensure attribution.

    • Key Videos: This is mentioned in the description of almost all recent videos as the source for project files. "Unreal Engine 5; GASP-DynamicAdditiveOverlay (Major Changes And Why)" explains the move to Ko-fi.

2. Initial Project Setup

The initial project setup, especially when using the GitHub repository, involves the following steps:

  1. Clone the Repository:

    • Use GitHub Desktop or the command line to clone the repository: https://github.com/JC0NN0R/GASP-DynamicAdditiveOverlay.

    • Note: The project might use Git LFS (Large File Storage). Ensure Git LFS is installed.

  2. Create a Base GASP Project (Game Animation Sample Project):

    • In the Epic Games Launcher, create a new "Game Animation Sample Project" using the compatible engine version (e.g., UE 5.x, check project specifics for exact version).

  3. Copy GASP Files to Cloned Repository:

    • Copy the contents of the newly created GASP project folder into the cloned repository folder.

    • Attention: When copying, if prompted to replace files in the Config folder, DO NOT REPLACE the files in the cloned repository. The cloned repository's Config files contain DAO-specific settings like Gameplay Tags.

  4. Project Configuration in Unreal Engine:

    • Open the .uproject file from the cloned repository.

    • World Settings: Set the Default Pawn Class to CBP_SandboxCharacter_DAO (located in Content/DAO/CharData/ or similar).

    • Gameplay Tags: Verify in Edit > Project Settings > Gameplay Tags that the DAO tag tables are loaded (e.g., GT_DAOHeldObjectStatesStances, GT_MetaHumanTags). If not, add them. Tables are usually in Content/DAO/Blueprints/Data/GameplayTags/ or character-specific data folders.

    • Virtual Bones (for UEFN Mannequin):

      • Open the Skeletal Mesh of UEFN_Mannequin (usually in Content/Characters/UEFN_Mannequin/Meshes/).

      • Add the following Virtual Bones if they don't exist:

        • VB foot_root (Source: root, Target: root)

        • VB foot_l (Source: foot_l, Target: foot_l)

        • VB foot_r (Source: foot_r, Target: foot_r)

        • VB hand_r (Source: hand_l, Target: hand_r)

        • VB hand_l (Source: hand_r, Target: hand_l)

    • Sockets (for Retargeted/MetaHuman Characters):

      • For custom characters (MetaHumans, Character Creator, etc.), add a socket named HeldObject_R to the right-hand bone (e.g., hand_r) and HeldObject_L to the left-hand bone (hand_l). The transforms of these sockets can be adjusted in the character-specific LiveRetargeting Data Asset.

    • NavMesh: Add a Nav Mesh Bounds Volume to your level for AI and some movement mechanics to function correctly.

3. Core Character & Animation Blueprints

3.1. CBP_SandboxCharacter_DAO (Character Blueprint)

  • Role: The primary player character Blueprint. It inherits from GASP's SandboxCharacter (or a similar base) and is responsible for:

    • Input handling (Enhanced Input Actions).

    • Managing character states via Gameplay Tags (e.g., HeldObjectState, StanceState, DAO.HeldObject.State.Rifle, DAO.HeldObject.Stance.Aim).

    • Initiating actions like firing, reloading, equipping/holstering items, traversal, and contextual animations.

    • Communicating necessary data to the ABP_SandboxCharacter_DAO (e.g., IsAiming, CurrentHeldObjectStateTagContainer).

    • Managing the AC_SlotManager component for item inventory/holstering.

    • Handling replication for character states and actions.

    • Calculating and applying Distance Based Aim Offset (DBAO).

    • It's the central hub for character-related logic.

  • Location: Content/DAO/CharData/CBP_SandboxCharacter_DAO.uasset (or similar path, may vary slightly by version)

  • Key Features to Edit/Implement Here:

    • Input Actions: (Located in Content/Input/) Mapped in IMC_Sandbox_DAO. Logic for these actions (e.g., switching weapons, firing, aiming, interacting) is implemented in the Event Graph of CBP_SandboxCharacter_DAO.

    • Held Object/Weapon Logic: Switching weapons, managing HeldObjectState (Gameplay Tag), initiating fire/reload. Replication of held object states.

    • Live Retargeting Setup (for this character type): While individual character assets have their own IK Retargeters, CBP_SandboxCharacter_DAO (and its children) manage which PDA_LiveRetargeting_Settings or DA_HOS_IK_Offset Data Assets are used based on the equipped item, stance, and character type (often via Choosers).

    • Traversal Logic: Initiating GASP's traversal system and handling item auto-holster/equip during traversal.

    • Contextual Animations: Initiating and managing contextual animation scenes (e.g., pistol pickup, takedowns).

    • Distance Based Aim Offset (DBAO) Calculation: Logic for calculating the DBAO is in this BP.

  • Key Video References (General):

3.2. ABP_SandboxCharacter_DAO (Main Animation Blueprint)

4. Data Assets & Configuration

Central to DAO's data-driven design.

4.1. Primary Data Assets (PDAs) for Items/Actions (e.g., PDA_ActionData_Weapon, PDA_ItemCharData, DA_AD_Weapon_M9)

  • Location: Various subfolders under Content/DAO/Blueprints/Data/, Content/DAO/Characters/[CharType]/Data/, or Content/DAO/Blueprints/HeldObjects/[WeaponName]/Data/. Older versions might have Content/DAO/Blueprints/Data/ActionData/.

  • Role: Store configuration for weapons, items, and actions. This includes:

    • Skeletal Mesh for the weapon.

    • ItemID (Gameplay Tag identifying the item).

    • LinkedAnimLayerClass (e.g., ALI_Pistol_DAO).

    • Animation Montages (equip, unequip, fire, reload) looked up by Gameplay Tags.

    • HeldObjectOffset settings (offsets for hand placement, often per stance, leading to DA_HOS_IK_Offset assets).

    • Define item properties, animation montages (equip, unequip, fire, reload), linked anim layers, and character-specific IK offsets.

  • Editing: Modify these to change weapon meshes, animations, or character-specific holding offsets.

  • Key Videos: "UE 5; GASP-DAO Breakdown - Part 1 (v1.24)" (Action Data, 00:27:27), "GASP DAO V1.47 (Item Handling System)" (Item Char Data and Choosers).

4.2. Data Assets for Layering (PDA_OverlayLayering, e.g., PDA_OverlayLayering_Rifle_IdleAim)

4.3. Data Assets for Live Retargeting (PDA_LiveRetargeting_Settings, DA_HOS_IK_Offset, e.g., DA_HOS_IK_Offset_MetaHumanTall_M9_Aim)

  • Location: Typically character-specific, e.g., Content/DAO/Characters/MetaHumans/Rigs/[CharName]/HeldObjects/[WeaponName]/ or within broader Data Asset folders.

  • Role:

    • PDA_LiveRetargeting_Settings: Stores IK chain adjustments (FK, IK, Speed Planting) for live retargeted characters.

    • DA_HOS_IK_Offset: Stores the precise X,Y,Z location and Pitch,Yaw,Roll rotation offsets for the character's hands (L/R) for a specific weapon in a specific stance. Fine-tuned using the in-game debug widget.

  • Editing: Crucial for correcting hand placement and aim for different characters using the same animations.

  • Key Videos: "Unreal Engine 5 - GASP DAO (Update 1.08 Live Retargeting)", "Unreal Engine 5; GASP DAO (v1.21 Overview)" (Data Asset Hand Correction Overview, 07:47), "Unreal Engine 5; GASP DAO (v1.3x) (Custom Character Setup)".

4.4. Chooser Tables (CHT_...)

  • Location: Content/DAO/Blueprints/Data/Choosers/ (main ones), or character-specific data folders.

  • Role: Dynamically select Data Assets at runtime. For example, a Chooser selects the correct PDA_OverlayLayering based on current character state (e.g., HeldObjectState, Stance, IsMoving). Another Chooser selects the correct PDA_LiveRetargeting_Settings or DA_HOS_IK_Offset based on character type and equipped item.

  • Editing: Modify Choosers to change which Data Assets are loaded for specific contexts.

  • Key Videos:

4.5. Gameplay Tags (GT_...)

  • Location: Managed in Project Settings and stored as Data Table assets (e.g., GT_DAO_States, GT_MetaHumanTags) usually in Content/DAO/Blueprints/Data/GameplayTags/ (or similar, project settings also manage these). Tags are often organized into separate tables.

  • Role: Identify states (character states, item states, stances like DAO.HeldObject.State.Rifle, DAO.HeldObject.Stance.Aim), item types, character types, and serve as keys in Data Asset maps.

  • Editing: Add new tags in Project Settings or by editing the Data Table assets.

  • Key Videos: "UE 5; GASP-DAO Breakdown - Part 1 (v1.24)" (Gameplay Tags, 00:34:53), "Unreal Engine 5; GASP DAO (v1.38 Overview)" (Gameplay Tags separated into tables, Tag separation).

5. Item & Slot Management

5.1. AC_HeldObject_Master & AC_Gun (Actor Components)

  • Location: Content/DAO/Blueprints/HeldObjects/Components/ (or similar).

  • Role: These components are attached to item Blueprints.

    • AC_HeldObject_Master: Base component for all equippable/interactable items. Manages ItemID (Gameplay Tag), DisplayName, attachment socket names, physics replication, and the core equip/unequip event-driven logic via Montage Notifies. Fires events for equip/unequip lifecycle.

    • AC_Gun: Child/Inherits from AC_HeldObject_Master, adds firearm-specific logic like firing and reloading.

  • Editing: Extend these to add new item types or modify core item behaviors. The actual equip/unequip montage logic is largely driven by this component interacting with the AC_SlotManager.

  • Key Videos:

5.2. BP_HeldObjects_Master (Base Item Actor)

  • Location: Content/DAO/Blueprints/HeldObjects/BP_HeldObjects_Master.uasset (or similar).

  • Role: The base/Parent Blueprint class for all physical pickupable item actors in the world (weapons, flashlights). Must have a PrimitiveComponent (Static or Skeletal Mesh) as its root for proper physics and pickup. It includes the AC_HeldObject_Master component.

  • Editing: Create children of this BP for new items.

  • Key Videos:

5.3. AC_SlotManager (Actor Component on CBP_SandboxCharacter_DAO)

  • Location: Attached to CBP_SandboxCharacter_DAO. Can also be found in Content/DAO/Blueprints/Components/AC_SlotManager.uasset (or similar).

  • Role: Manages item slots (holsters) on the character. Handles attaching/detaching items and Slot Actors to character sockets. Defines which items can go into which slots using Gameplay Tags. Manages the character's item slots, attachment of items to these slots, and the logic for drawing and holstering items.

  • Editing: Configure ItemSlots array in CBP_SandboxCharacter_DAO's AC_SlotManager component details to define new holsters or attachment points.

  • Key Videos:

5.4. BP_Slot_Master (Base Slot Actor)

  • Location: Content/DAO/Blueprints/HeldObjects/Slots/BP_Slot_Master.uasset (or similar).

  • Role: Parent/Base Blueprint class for visual holsters or attachment points that are themselves actors in the world (and can be picked up from v1.38+). These are attached to the character by AC_SlotManager and items are then attached to these BP_Slot_Master instances. Contains an AC_HeldObject_SlotActor component.

  • Editing: Create children of this for new holster types.

  • Key Videos: "Unreal Engine 5; GASP-DAO (Slot Actor Setup Explained)".

6. Specialized Animation Layers & Poses

6.1. Linked Anim Layers (ALI_..., e.g., ALI_Pistol_DAO, ALI_Rifle_DAO)

  • Role: Specialized Animation Blueprint Layers that provide item-specific animation logic (state machines for idle, locomotion, aiming, firing) that gets linked into the main ABP_SandboxCharacter_DAO. Child ALI classes can be created for specific weapons to override poses.

  • Location: Content/DAO/Character/Animations/LinkedAnimLayers/ (or weapon-specific subfolders, may be item-specific).

  • Editing: Duplicate and modify these to create animation sets for new weapon types or to customize existing ones.

  • Key Video References:

6.2. Control Rig Poses (CR_..., various pose assets PA_...)

  • Location: Poses are often stored near their related animations or in dedicated "Poses" folders (e.g., Content/DAO/Character/Animations/UEFN/Poses/).

  • Role: Control Rigs (e.g., CR_UEFN_Mannequin_Body) are used within Sequencer to create/modify static poses. These are then baked into single-frame animation sequences or PoseAsset files. Used for idle stances, aiming poses, Aim Offset poses, etc.

  • Editing: Use Sequencer with the appropriate Control Rig to create or adjust poses.

  • Key Videos: "Unreal Engine 5 - GASP DAO; Adding States (Part 1)" (modifying one-handed poses), "Unreal Engine 5; GASP DAO - Fixing Animations For Custom Guns" (modifying rifle poses).

6.3. Pose Drivers & Corrective Animations

  • Location: Often part of a Post Process AnimBP (e.g., ABP_CorrectivePoseDriver_Metahuman). PoseAsset files store the target poses.

  • Role: Used to drive corrective bone adjustments based on the rotation of a source bone (e.g., forearm twist based on hand rotation) to improve deformation.

  • Editing: Modify the PoseAsset or the PoseDriver node settings in the Post Process AnimBP.

  • Key Videos: "Unreal Engine 5; Post Process Corrective Bone Pose Drivers".

7. Implementation Guide

7.1. Project Summary

The GASP Dynamic Additive Overlay (DAO) project by UnrealDevOp is an advanced character animation and interaction system for Unreal Engine, built upon the Game Animation Sample Project (GASP) and its motion matching capabilities. It emphasizes a highly data-driven architecture using Data Assets, Chooser Tables, and Gameplay Tags to manage character states, animation layering, item handling (weapons, flashlights, etc.), and live retargeting for diverse character anatomies. Key features include a custom dynamic additive overlay system for realistic weapon holding during movement, a precise aim offset system (including distance-based compensation), a robust item slot and holstering mechanism, and progressively implemented network replication. The project is intended for educational purposes but has evolved into a comprehensive template suitable for third-person action games.

7.2. Main Classes & Blueprints (Implementation Context)

This section lists the primary Blueprints and assets involved in the DAO system, reiterating their roles in the context of implementation. For full details on each, refer to their respective sections earlier in this document.

  1. CBP_SandboxCharacter_DAO (Character Blueprint): Central logic for input, state management, item interaction, traversal, contextual animations, replication, and DBAO.

  2. ABP_SandboxCharacter_DAO (Main Animation Blueprint): Drives Motion Matching, Dynamic Additive Overlay, Aim Offset, IK, montages, and links to ALI_....

  3. ALI_... (Linked Anim Layers): Item-specific animation logic (state machines, poses).

  4. AC_SlotManager (Actor Component): Manages character item slots, holstering, and item attachment.

  5. AC_HeldObject_Master & AC_Gun (Actor Components): Attached to items; manage item ID, attachment, physics, equip/unequip events (AC_HeldObject_Master), and firearm logic (AC_Gun).

  6. BP_HeldObjects_Master (Actor Blueprint): Base class for all physical item actors.

  7. BP_Slot_Master (Actor Blueprint): Base class for visual holster actors.

  8. Primary Data Assets (PDA_...) & Data Assets (DA_...): Define item properties, animation montages, layering settings, IK offsets, etc.

  9. Chooser Tables (CHT_...): Dynamically select Data Assets at runtime.

  10. Gameplay Tag Tables (GT_...): Define Gameplay Tags for states, item types, etc.

7.3. Key Feature Implementation Locations & Video References

Here's a breakdown of where to edit/implement features and relevant tutorial videos:

1. Animation Layering (Dynamic Additive Overlay)

2. Aim Offset System

  • Description: Allows the character to aim up, down, left, and right independently of their movement direction. Includes Universal AO (shared poses) and Custom AO (weapon-specific poses), and Distance Based Aim Offset (DBAO).

  • Where to Edit/Implement:

    • Logic & Calculation: ABP_SandboxCharacter_DAO (calculates yaw/pitch, applies to spine/blendspace), CBP_SandboxCharacter_DAO (DBAO calculation, setting aim values).

    • Poses: Aim Offset poses (e.g., AO_Pistol_Aim_U, AO_Pistol_Aim_LDRD) created in Sequencer using Control Rig, often stored as single-frame animations or within PoseAsset files. The Universal AO poses are usually in Content/DAO/Character/Animations/UEFN/AimOffset/UniversalAimOffset/.

    • Data Assignment: Custom AO poses are assigned in the child ALI_... (Linked Anim Layer) for the specific weapon (see GASP_DynamicAdditiveOverlay(1.43)). DBAO toggle in CBP_SandboxCharacter_DAO details.

  • Video References:

3. Item & Weapon Handling (Equip, Holster, Fire, Reload)

  • Description: System for managing how the character picks up, equips, uses, and holsters items.

  • Where to Edit/Implement:

    • Core Logic: AC_HeldObject_Master (base item behavior), AC_Gun (firing/reloading), AC_SlotManager (holstering/drawing logic on character).

    • Initiation: CBP_SandboxCharacter_DAO (handles input to trigger equip, fire, reload, drop).

    • Animation Montages: Defined in item-specific Data Assets (e.g., DA_AD_Weapon_M9). Create new montages for new actions.

    • Montage Notifies: Events like AttachHandR, DetachHandR within montages trigger state changes in AC_HeldObject_Master.

  • Video References:

4. Live Retargeting & Character Setup

  • Description: System for adapting UEFN Mannequin animations to characters with different anatomies (e.g., MetaHumans, CC4 characters) at runtime.

  • Where to Edit/Implement:

    • IK Retargeter Asset: Each character type needs an IKRetargeter asset (e.g., IKR_UEFNtoMetaHuman). Edit this to define bone chains and basic retargeting settings.

    • Character Blueprint: Child of CBP_SandboxCharacter_DAO. Assigns its specific IKRetargeter asset in Class Defaults. Assigns its unique Gameplay Tag.

    • Live Retargeting Data Assets (DA_HOS_IK_Offset_...): Store hand IK offsets (translation/rotation) for this character, per weapon, per stance. Crucial for precise hand placement. These are selected by a Chooser Table (e.g., CHT_m_med_nrw_IKRetargeting for a medium normal weight male MetaHuman) in the character's Blueprint.

    • Live Retargeting Debug Widget: Found in Content/DAO/Blueprints/Widgets/WBP_LiveRetargeting_DebugTool (or similar). Used in-game to adjust and copy/paste DA_HOS_IK_Offset values.

  • Video References:

5. Hand IK ("Procedural Offset Hack")

  • Description: Ensures the character's off-hand stays correctly on two-handed weapons, or main hand on one-handed weapons if precise dynamic adjustment is needed.

  • Where to Edit/Implement:

    • AnimBP Logic: ABP_SandboxCharacter_DAO (TwoBoneIK nodes targeting Virtual Bones like VB hand_r). The "Procedural Offset Hack" calculates the EffectorLocation for these IK nodes in the Character Blueprint's Tick/EventGraph to avoid thread desync.

    • Virtual Bones: Must be created on the character's skeleton.

    • Enable/Disable: Via animation curves (EnableHandLIK, EnableHandRIK, DisableHandIK, DisableIK) in montages or specific animation states.

  • Video References:

6. Traversal System

  • Description: Mantling, vaulting, climbing using GASP's contextual system.

  • Where to Edit/Implement:

    • Initiation: CBP_SandboxCharacter_DAO (handles input, triggers traversal).

    • Auto Holster/Equip: Logic within CBP_SandboxCharacter_DAO and AC_SlotManager to automatically put away/retrieve items during traversal.

  • Video References:

7. Contextual Animations (Pickups, Takedowns)

  • Description: Synchronized interactions between characters or characters and objects.

  • Where to Edit/Implement:

    • Scene Assets: ContextualAnimScene asset (defines roles, animations, entry points). ContextualAnimRole asset (defines participant roles).

    • Initiation & Logic: CBP_SandboxCharacter_DAO (queries scene, moves character, starts scene).

    • Animations: Custom animations/montages created (e.g., using QuickMagic, Cascador, or manually in Sequencer).

  • Video References:

    • Pistol Pickup: "Unreal Engine 5; Pistol Pickup Part 1, 2, 3, 4"

    • Takedown: "Unreal Engine 5; Player Take Down Part 1, 2"

8. Replication

  • Description: Making the system work in a networked multiplayer environment.

  • Where to Edit/Implement:

    • Character States: CBP_SandboxCharacter_DAO (replicating HeldObjectState, IsAiming, TraversalResult via RepNotifies).

    • RPCs: Client-to-Server RPCs in CBP_SandboxCharacter_DAO for actions like firing, equipping. Multicast RPCs for cosmetic events.

    • Item Physics & State: AC_HeldObject_Master (physics replication), AC_SlotManager (replicating slot states, item attachments).

  • Video References:

9. Custom Poses & Animations

8. Version Updates & Key Changes (Chronological)

This section details significant changes and features introduced in various versions of the GASP-DAO project. Refer to the specific "Update Overview" videos for each version for more in-depth explanations.

  • Key Videos for this section: All videos titled "Update Overview," "Overview," or "HotPatch Overview" (e.g., "GASP DAO V1.44 (Update Overview)", "Unreal Engine 5; Gasp-DAO V1.45 (Overview)", "Unreal Engine 5; GASP-DAO v1.49 (Corruptionā„Bug Fix)").

Version 1.49 (Corruption/Bug Fix)

Version 1.48

  • Foot Locking Reintroduced: Addressed synchronization issues between OffsetRootBone and Turn In Place animations.

  • Rifle: Attachments moved to the front, character sockets added, and an animation montage created.

  • Pistols: Left/Right hand equips reworked for smoother blending.

  • Flashlight: Equip montage created.

  • AC_HeldObject_Master:

    • Fixed delayed attachment issue when dual wielding that caused stuttering on live retargeted characters.

    • Fixed a bug in montage interruption that didn't consider primary and secondary item montages.

  • CBP_SandboxCharacter_DAO:

    • Fixed a bug when switching characters that generated errors (items are now destroyed).

    • Fixed an issue where traversal interruptions (e.g., reloading during equip) prevented auto-equip.

    • Added AreItemsBeingHandled interface function to check if items are being equipped before allowing reload/fire montages.

  • AC_Gun: Logic to prevent reload from being interrupted by fire montages or other reloads; logic to avoid interrupting equips.

  • Linked Anim Layers: Now cache MainAnim values instead of direct property access calls to prevent null reference warnings during initialization.

Version 1.47 (Item Handling System)

  • AC_HeldObject_Master: Stores data related to item handling.

    • Item ID and Display Name (latter not actively used but present for custom UI).

    • Aim Socket Name: Used to determine the origin of the aim trace.

    • GetItemCharData function (from BPI_Items) must be overridden in child classes to provide character-specific data for the item.

  • Montages and Gameplay Tags: Animation montages (equip, unequip, etc.) are fetched from a Data Asset using Gameplay Tags for efficiency.

  • Exclude Weapon Bones: Metadata curve in montages to prevent GASP's overlay logic from affecting weapon bones during specific animations.

  • Disable Hand IK: Metadata curve to disable hand IK during montages where the animation already positions the hand correctly, avoiding unwanted blending.

  • Montage Notify: Used to trigger events at specific points in a montage (e.g., Attach_Hand, Attach_Hand_L).

  • AC_Gun: Component for weapon logic.

    • AO Debug Tool: Tool for visualizing aim offsets (green line for screen center, blue line for weapon barrel).

  • Projectile Aim Rotation: By default, projectiles follow the weapon barrel's rotation. Can be configured to follow camera rotation (with caveats regarding accuracy due to third-person camera offset).

  • Distance-Based Aim Offset: Mechanism to compensate for third-person camera offset, making aiming accurate relative to the screen center, regardless of distance.

Version 1.46 (Item System Refactor)

  • Pickup Logic: Moved to a Trace system in CBP_SandboxCharacter_DAO.

  • AC_SlotManager: Explicit actor casting removed; uses direct function calls on item actor components.

  • AC_HeldObject_Master: Most item logic moved to this component. Choosers remain in item Blueprints due to reference limitations.

  • AC_HeldObject_SlotActor: Additional logic specific to slot actors.

  • AC_Gun: Component for weapon firing and reloading logic.

  • BP_HeldObjects_Master: Refactored to use components and have a PrimitiveComponent as its root for better collision and physics replication.

  • PDA_ItemData: Removed; ItemID is now in AC_HeldObject_Master.

Version 1.45 (Event-Driven Equip/Holster System)

  • Synchronized Equip/Unequip System: Refactored to be event-driven, using Montage Notify Events for better timing and replication.

    • Unequip montages, if not provided, can play the equip montage in reverse.

    • Events like OnMontageAttach and OnMontageEquip are used to synchronize item attachment and state updates.

  • Auto Equip/Unequip in Traversal: Logic to automatically holster and re-equip weapons during and after traversal actions (climbing, vaulting, etc.).

  • Animation Cancelling in Slot Manager: A 2-second window added for auto re-equip after traversal, which can be interrupted by the player. To be improved with animation cancelling in Slot Manager.

Version 1.44 (Update Overview / HotPatch Overview)

  • ABP_SandboxCharacter_DAO: (Note: ABP_Sandbox_DAO might be a typo in source, usually ABP_SandboxCharacter_DAO)

    • Interpolation and Counter-Root Compensation disconnected (temporarily or for adjustment).

    • Offset Root Bone Max Rotation Error set to 89 degrees to limit root bone counter-rotation and prevent excessive foot sliding in extreme rotations.

  • Aim Responsiveness: Significantly improved, but with the side effect of potential foot sliding at larger rotation angles.

  • Reverting Changes: Instructions on how to revert to previous behavior (reconnect Interpolation and Counter-Root Compensation, and adjust Max Rotation Error).

  • Root bone release logic: (From "GASP DAO V1.44 (Update Overview)") for aim responsiveness.

Version 1.43 (Update Overview)

  • Aim Offset:

    • Disabled by default in the Unarmed state.

    • Custom Aim Offsets reintroduced for some weapons/states (e.g., left-hand pistol, flashlight), while others use a universal Aim Offset.

    • Fixed weapon "jerking" issue while aiming by considering the Offset Root Bone.

    • Fixed an issue where there was no control over Aim Offset when linking a layer in an Unarmed state.

    • Aim Offset interpolation refactored.

  • Turn In Place: Fixed a bug causing an 8-frame slide due to a sync issue between OffsetRootBone and Turn In Place animations (when Foot Locking is disabled).

  • AC_SlotManager: Redundant Item Reference parameter removed from HolsterItem function.

  • CBP_SandboxCharacter_DAO: Fixed a bug related to switching weapons by index (number keys) for left-handed items; replication set up.

Version 1.42 (Update Overview)

  • Slot-Specific Equipping: Examples of how to equip items in specific slots (right hand, left hand, dual wield) using new Input Actions.

  • AC_SlotManager: Removed redundant parameter from DrawHolsteredItem; added helper function DrawHolsteredItem_ByIndex.

Version 1.41 (Update Overview)

  • Contextual Anim Scene for Pistol Pickup: Added an example of pistol pickup using the Contextual Animation Scene system.

  • Intro Map: Added an initial map (to be expanded).

  • Unarmed Overlay State Support: DefaultOverlayData now loads data for the unarmed state.

Version 1.40 (Update Overview - Setup)

  • Project Setup: Details on setting up the project from the repository, including copying Game Animation Sample files, verifying Gameplay Tags, and configuring Default Pawn Class.

  • Pickup Items: How to add items to the level and basic pickup/interaction logic.

  • Item Character Data: Explanation of how character-specific data for items is managed via Choosers and Data Assets, using Gameplay Tags.

  • Slot Manager: Introduction to the slot system for holsters and managing equipped items.

Version 1.39 (Update Overview - Hotfix)

  • Slot Manager:

    • FindSlotActorByRef renamed to FindSlotActorConfigurationByRef and fixed (was searching for the reference it already had).

    • Fixed a bug where a replaced Slot Actor would not be attached to a socket.

  • ABP_SandboxCharacter_DAO: Neutral Pose updated to match GASP Idle Pose, improving transitions.

Version 1.38 (Update Overview)

  • Gameplay Tags: Separated into individual Gameplay Tag Tables for better organization and management.

  • BP_Slot_Master: Item slots are now identified via GameplayTag.

  • AC_SlotManager: Pickup function refactored to unify pickup of items and slot actors. Slot actors can now be picked up. Added comments and fixed an invalid reference error when getting attached items from a slot.

  • ABP_SandboxCharacter_DAO: Arm exclusion in Additive Layering reduced to hands to decrease desynchronization at the shoulders.

  • CBP_SandboxCharacter_DAO:

    • Fixed a bug where items holstered before a Traversal were drawn again afterwards.

    • InputActions now display the hotkey in the bubble for easier i... (1 KB left)

PreviousCreating Custom PosesNextBase Features

Last updated