How To Add a Weapon Skin

This guide explains how to create a new weapon skin using BP_DA_Weapon_Skins, hook it into the weapon’s inventory DataAsset, configure modification skins, and set up icon textures for all modification combinations.

---

1. Overview

Weapon skins are configured through DataAssets that inherit from BP_DA_Weapon_Skins, which itself derives from BP_DA_Skins.
BP_DA_Skins holds shared visual parameters (materials, icons), while BP_DA_Weapon_Skins adds weapon‑specific configuration, including ModificationSkins.

To make a skin fully functional, you need to:

1. Create a BP_DA_Weapon_Skins DataAsset with proper naming.
2. Configure base skin parameters (BP_DA_Skins fields).
3. Fill ModificationSkins for all weapon modifications.
4. Generate inventory icons using the Icons Generator and build Texture2DArray assets.
5. Assign icon fields in the skin DataAsset.
6. Register the skin in the weapon’s inventory DataAsset (SimpleVisualizationSkins array).

---

2. Naming and Asset Types

2.1. DataAsset naming convention

For weapon skin DataAssets, use the following naming pattern:

• DA_Skin_<WeaponAbbreviation>_<SkinName>

Examples:

• DA_Skin_AK74_RedDragon
• DA_Skin_M4_BlackGold

This makes it easy to search by weapon abbreviation and clearly separates skins from other DataAssets.

2.2. Core classes involved

• BP_DA_Skins
  Base skin DataAsset, contains generic skin parameters (materials, icon textures, etc.).

• BP_DA_Weapon_Skins (inherits from BP_DA_Skins)
  Weapon‑specific skin DataAsset. Includes:

  • All BP_DA_Skins fields (materials, icons, etc.).
  • ModificationSkins – per‑modification material setup, auto‑filled via scripted action.

• Inventory‑type DataAsset of the weapon
  Contains SimpleVisualizationSkins array where all weapon skins for this weapon are registered.

• Icons Generator actors and maps

  • BP_EngineWeaponIconGener on L_RecordWeapons map (see icon-generators system doc).

• Temporary helper DataAsset

  • DA_TrashContainer – global temporary container used to assemble icon Texture2DArray. Its Texture array can be overwritten freely.

---

3. BP_DA_Skins Parameters (Base Skin)

BP_DA_Weapon_Skins inherits all fields from BP_DA_Skins. You should understand and fill these first.

3.1. Abbreviation

Field: Abbreviation
Short, unique skin identifier (string). Used by icon generators and scripted actions to find and organize icons.
Examples:

• AK74_RD
• M4_BG

Make sure abbreviations are unique per skin.

3.2. InteractActorMaterials

Field: InteractActorMaterials (TArray<UMaterialInterface>)
List of materials applied to the StaticMesh component of the interact actor (world representation of the weapon, pick‑up mesh).

Typical usage:

• When the weapon is lying in the world as a pickup actor, this array defines which materials are applied to its static mesh component under this skin.

3.3. Connect Object

Field: Connect Object (TMap<int32, TArray<UMaterialInterface>>)
Maps skeletal mesh component indices to arrays of materials for Connect actors, such as BP_Connect_Weapon.

Default for BP_Connect_Weapon:

• Index 0 – MainSkeletalMeshComponent
• Index 1 – SecondSkeletalMeshComponent

Filling rules:

• Single skeletal mesh weapon
  • Only MainSkeletalMeshComponent is used.
    
  • Add entry:
    • Key 0 → materials for MainSkeletalMeshComponent.
• Dual skeletal mesh weapon (e.g. sword + shield where Second Skeletal Mesh in BP_Melee_W_Master_Clar is not empty)
  • Add both entries:
    • Key 0 → materials for MainSkeletalMeshComponent
      
    • Key 1 → materials for SecondSkeletalMeshComponent

3.4. Connect To Body Object

Field: Connect To Body Object (TMap<int32, TArray<UMaterialInterface>>)
Same idea as Connect Object, but for back weapon actors like:

• BP_WeaponBack
• BP_DoubleWeaponBack

Filling rules:

• Single back weapon actor (BP_WeaponBack)
  • Use key 0 → materials for the back weapon mesh.
• Double back weapon actor (BP_DoubleWeaponBack)
  • Use keys 0 and 1 for the two back meshes, mirroring the logic in Connect Object.

3.5. Icon fields

Fields:

• Icons Regular Resolution (Texture2DArray)
  Array of icons for this skin in normal resolution.

• Icons Custom Resolution (Texture2DArray)
  Array of icons for this skin in a custom resolution (used if you need non‑standard icon sizes).

• Icon Regular Resolution (Texture2D)
  Single icon texture in regular resolution.

• Icon Custom Resolution (Texture2D)
  Single icon texture in custom resolution.

These fields are filled after you generate icons and assemble Texture2DArray assets (see Section 6).

---

4. Creating BP_DA_Weapon_Skins

Step 1. Create the DataAsset

1. In Content Browser, right‑click → Miscellaneous → Data Asset.

2. Select BP_DA_Weapon_Skins as the parent class.

3. Name the new asset following the convention:

   • DA_Skin_<WeaponAbbreviation>_<SkinName>

   Example:

   • DA_Skin_AK74_RedDragon

Step 2. Fill basic skin parameters

Open the newly created DA_Skin_... and fill base BP_DA_Skins fields:

1. Abbreviation
   • Enter a short, unique code matching your naming (e.g. AK74_RD).
2. InteractActorMaterials
   • Add materials that should be applied to the StaticMesh of the interact actor for this skin.
3. Connect Object
   • If the weapon uses a single skeletal mesh component (only MainSkeletalMeshComponent):
     • Add key 0 → materials for MainSkeletalMeshComponent.
   • If the weapon uses two components (MainSkeletalMeshComponent + SecondSkeletalMeshComponent):
     • Add key 0 → materials for MainSkeletalMeshComponent.
     • Add key 1 → materials for SecondSkeletalMeshComponent.
4. Connect To Body Object
   • For BP_WeaponBack:
     • Add key 0 → materials for the back weapon mesh.
   • For BP_DoubleWeaponBack:
     • Add keys 0 and 1, just like in Connect Object.

At this point the skin will work for world / connect / back actors in terms of materials, but will still miss icons and modification‑specific materials.

---

5. Filling ModificationSkins (Before Icon Generation)

ModificationSkins is a parameter of BP_DA_Weapon_Skins that stores per‑modification material overrides.
It is auto‑filled based on a concrete weapon clarification DataAsset and can then be customized.

Step‑by‑step

1. In Content Browser, select your DA_Skin_... DataAsset.

2. Right‑click on it → ScriptedAssetActions → Skins → Fill Modifications With Default Materials.

3. In the popup dialog, specify the concrete weapon Clarification DataAsset instance for which this skin is intended (not the base class), for example:

   • A specific firearm clar asset like DA_CL_AK74_01 (a child of BPFireWMasterClar / BPWeaponMasterClar).
   • A specific melee clar asset like DA_CL_SwordShield_01 (a child of BPMeleeWMasterClar).

4. Click OK.
   The ModificationSkins field of your DA_Skin_... is now populated with entries for each weapon modification, using default materials taken from that exact weapon clar asset.

5. Open ModificationSkins in the DataAsset and customize materials per modification:

   • For each modification entry you can override which materials will be applied when this skin is active and that modification is equipped (e.g. different color for silencer, scope, etc.).

Filling ModificationSkins before icon generation is recommended, so the visual state used in icon captures matches the final per‑modification materials.

---

6. Generating Icons and Building Texture2DArrays

Weapon skin icons are generated via the Icons Generator, not Character Assistant.

6.1. Generate icons using Icons Generator

1. Open map L_RecordWeapons.

2. In the level, find the BP_EngineWeaponIconGener actor.

3. Set parameters of the generator:

   • Target Data – weapon BP_ItemData for which you are generating icons.
   • SkinData – your DA_Skin_... (the weapon skin you created).
   • Any resolution settings (UseCustomResolution, CustomResolutionSize) as described in the icon-generators doc.

4. Adjust the Camera #1 component in the scene so the weapon fits into view.

5. Press UpdateCameraSettings on BP_EngineWeaponIconGener to sync the capture camera.

6. Press Play, wait 3–4 seconds, and let the generator capture all needed icon textures for this weapon + skin combination (including modifications if your pipeline supports that in one run).

Repeat for other skins if needed.

6.2. Fill temporary array via scripted action

Once icons are generated and visible in Content Browser:

1. In Content Browser, select all generated icon textures for this weapon skin (make sure the selection includes all modification variants and only those textures).

2. Right‑click on the selection → ScriptedAssetActions → Skins → Fill Generated Icons To Temp Array.

3. In the popup:

   • Select the inventory‑type DataAsset of the weapon (the same weapon you generated icons for).

4. Confirm the action.

Result:

• The script writes the selected textures into the Texture array of DA_TrashContainer in a strict, expected order.
• This order is crucial because icon selection at runtime uses the array index (slice index) to match weapon + modification configuration.

6.3. Build the Texture2DArray

1. Open DA_TrashContainer DataAsset.

2. Find the Texture array – it now contains all icon textures in correct order.

3. Select all entries in the Texture array and copy them to clipboard (Ctrl+C).

4. Create a new Texture2DArray (e.g. via Add New → Materials & Textures → Texture2DArray).

5. Open the Texture2DArray and locate the SourceTextures field.

6. Paste the textures from clipboard into SourceTextures (Ctrl+V).

7. Save the Texture2DArray.

You can repeat this process to create:

• One Texture2DArray for regular resolution, and
• Another Texture2DArray for custom resolution (if you generated a separate set of icons with a different resolution).

DA_TrashContainer is global and is used only as a temporary buffer. It is safe to overwrite its Texture array for each new skin or weapon.

6.4. Assign icon fields in DA_Skin

Open your DA_Skin_... again and assign icon fields:

1. Icons Regular Resolution
   • Assign the Texture2DArray built from the regular‑resolution icons.
2. Icons Custom Resolution
   • Assign the Texture2DArray built from the custom‑resolution icons (if used).
3. Icon Regular Resolution
   • Assign a single Texture2D icon (for example, the default or main view) – you can reuse one of the textures used in the regular array.
4. Icon Custom Resolution
   • Assign a single Texture2D icon in custom resolution (optional, used where needed by UI).

All modification combinations will now use slices of the Texture2DArray based on index, so the order established by Fill Generated Icons To Temp Array must be preserved.

---

7. Hooking the Skin into the Weapon Inventory DataAsset

To make the skin visible and selectable in the game, it must be registered in the weapon’s inventory‑type DataAsset.

Step‑by‑step

1. Open the weapon’s inventory‑type DataAsset (the one that inherits from BPIIMaster or its children and is used by the weapon in inventory).

2. Find the array:

   • SimpleVisualizationSkins

3. Add your DA_Skin_... (weapon skin DataAsset) to SimpleVisualizationSkins.

Now the weapon:

• Knows about this skin as one of its visualization skins.
• Can use this skin in UI, inventory, and runtime weapon actor visualization.
• Can retrieve the correct materials and icons (including per‑modification icons) via the BP_DA_Weapon_Skins and Texture2DArray configuration.

---

8. Sanity Checklist

Before committing the new skin, verify:

• Naming
  • DA_Skin_<WeaponAbbreviation>_<SkinName> is used consistently.
  • Abbreviation in DA_Skin_... is unique and matches what you expect in icon generators.
• Materials
  • InteractActorMaterials are correctly set for world interact actors.
  • Connect Object:
    • Key 0 always maps to materials for MainSkeletalMeshComponent.
    • Key 1 is present only if SecondSkeletalMeshComponent is actually used.
  • Connect To Body Object:
    • For BP_WeaponBack, only key 0 is used.
    • For BP_DoubleWeaponBack, keys 0 and 1 are correctly filled.
• ModificationSkins
  • Fill Modifications With Default Materials was run for the correct concrete weapon clar DataAsset (not the abstract master class).
  • ModificationSkins entries exist for all needed modifications and have sensible material overrides.
• Icons
  • Icons were generated using BP_EngineWeaponIconGener with correct Target Data and SkinData.
  • Fill Generated Icons To Temp Array was run with all relevant textures selected and the correct weapon inventory DataAsset chosen.
  • DA_TrashContainer.Texture was copied into Texture2DArray.SourceTextures without changing the order.
  • Icons Regular Resolution / Icons Custom Resolution point to valid Texture2DArray assets.
  • Icon Regular Resolution / Icon Custom Resolution point to valid Texture2D icons.
• Inventory registration
  • Your DA_Skin_... is added to the weapon’s inventory DataAsset in SimpleVisualizationSkins.

If all items in this checklist are satisfied, the new weapon skin should be fully functional in inventory, in world, on the character’s back, and across all weapon modifications.