This is not a Step-by-Step beginner's tutorial, I will try to keep the language concise regarding the steps we'll follow in hopes that people will know what to search for if they find themselves confused by certain functionalities. This guide assumes you already have some familiarity with the tools, and have followed the steps outlined in the two articles below. It will not cover adding assets into the game itself:

A guide for Multiple Material Meshes and Adding your outfit armour for Shepard as a new asset by padme4000

I will be using Blender 3.4, but everything here should also apply to 4.0+. Keyboard shortcuts will be written in brackets, for example: [Ctrl+A].

Quick and Sloppy Glossary:

Term	Definition	Notes / Examples
Render	The process of generating a final image from a 3D scene.	In Blender, you can render using Eevee (real-time) or Cycles (offline, physically accurate). In games, rendering happens in real-time during gameplay.
Texture Baking	The process of generating textures from complex meshes and materials.	Baking allows games to display complex effects efficiently. Example: AO baking creates shadowed corners in a texture to save memory on engine calculating it dynamically.
Shader	Baseline program that controls and calculates how a surface reacts to light.	Shaders define visual effects like reflection, transparency, glow, or surface detail. In Blender, shaders are built with nodes in the Shader Editor.
Material	The combination of textures, shaders, and settings that define a surface’s appearance.	Materials tell a model if it looks like metal, skin, cloth, etc., including roughness, colour, and reflectivity.
Texture Mask	A black-and-white or grayscale image that controls where an effect or material applies.	White = affected; Black = unaffected. Example: A mask could make paint appear only on certain armour parts or have the material pull skin colour.
Texture Map	A texture or image that stores data for a specific purpose in rendering.	Examples: Diffuse/Base Colour Map, Normal Map, Roughness Map, AO Map. Maps define surface colour, lighting, shininess, and shadows.

(Skip this step if you already know how to set up game assets in Blender to preview animations.)

• Import a vanilla mesh into Blender. This will act as your reference later. Choose something simple rather than a full body armour so the T-pose is clearly visible. For this guide, I’m using HMM_ARM_CTHb_MDL and HMM_HED_PROSheppard_MDL for a human male port.

• In the Outliner, right-click → New Collection. Name it something like reference, vanilla, or anything you’ll remember later.

• Select everything [A] and drag everything into the collection.

• Delete the armature of the head mesh [Delete].

• Attach the head to the body skeleton by selecting the head mesh and, in the Modifier Properties tab, assigning the body armature.

• With the mesh selected, right-click in the viewport and choose Shade Smooth. This will become relevant later.

• Select the head mesh and switch to Weight Paint mode.
       In Object Data Properties, delete every vertex group except:
       – Head
       – Neck
       – Neck1
       – Chest2 (if applicable)

• With Head vertex group selected, use the Gradient tool to paint the head fully red from the neck up.

Before	After

I’ll go into the specifics of weighting later. For now, this step prevents facial deformation issues when importing animations for testing, since the game pulls facial animation data from FaceFX.

• At this point, the base reference setup is complete. Save a copy of this file, you can reuse it later when working on additional assets.

• Import the mesh you want to port. The exact process depends on the file format; if Blender doesn’t support it natively, you’ll need a plugin. I'm using an outfit from ghostrunner for this tutorial.

• Before you change anything, go into Edit Mode, Select → Select All by Trait → Non-Manifold [Shift+Ctrl+Alt+M]

	Edit Mode → Select → Select All by Trait → Non-Manifold This selects boundary edges, internal faces, and odd geometry.
	Mark the selected edges sharp [Ctrl+E] This marks the selected edges Sharp.

• Still in Edit Mode, Select All [A] and Merge [M] → By Distance. On the bottom left corner set the Merge Distance to 0.0001 m

• Repeat this for each separate mesh if applicable. You can select multiple objects and edit them together in Edit Mode. These steps prevent tearing later when modifying the mesh while preserving sharp-edge data.

• Since the imported asset already has a functional skeleton, we’ll use it to position the mesh over the reference. Select the custom armour’s armature and switch to Pose Mode.

• Enable X-Axis Mirror and pose the asset over the reference. Take your time here, most of the heavy lifting should happen in this step.

If X-Axis Mirror doesn’t work, it’s usually due to bone naming mismatches. This feature relies on strict naming conventions (for example, L_hand_finger_1 / R_hand_finger_1 or left_hand_finger_1 / right_hand_finger_1). You may need to rename bones manually; otherwise, you’ll have to eyeball it.

Things to look out for while posing: Use Local Orientation for more predictable transformations Work from parent to child (waist → shoulders → arms) Don’t hesitate to use Scale and Move if needed Mass Effect's T-Pose has shoulders rolled way back which might look unnatural on rest pose but needs to be replicated for it to look good in game Pay special attention that the joints are aligned at the right place; the mass of the limbs is secondary, the rotation comes first For precise editing, in Edit Mode → Bone Properties → Relations, toggle Connected and Inherit Rotation as needed

If you see deformations like these, do not move on to sculpting yet. These are usually caused by stressed bones. If they can’t be reverted, you may need to fix them vertex-by-vertex in the next step.

• Once the mesh is aligned as closely as possible, select all loose parts in Object Mode → Object → Join. You should now have a single mesh.

• Switch to Sculpt Mode to fine-tune areas that posing didn’t fully cover. This step may not be necessary.

• Use Elastic Deform, enable Y-Axis Mirror, and gently nudge the mesh to better match the reference.

Things to look out for while sculpting: Use Masks for precise edits (e.g., adjusting a pinky without affecting the ring finger). To mask a selected area: Edit Mode → hide selection [H] → switch to Sculpt Mode → Mask → Fill Mask → reveal [Alt+H] You can't reliably change the roll/rotation of limbs here. If there's a mismatch, handle it in the posing step. If the mesh has a neck section, it must fully cover the reference neck to prevent clipping with the head morph.

Masking

Editing

• Once the pose closely matches the reference, proceed to weighting it. While doing this, I strongly recommend opening your reference file in a second Blender window for side-by-side comparison (if you've made a separate file of it during preparation). This is a good point to make a backup save.

• On the Modifier Properties tab of the new asset, apply the existing armature modifier [Ctrl+A]. This bakes the pose into the mesh, you won’t be able to return to the original skeleton after this.

• Add Modifier → Armature → Select the reference armature under Objects

• Switch to Weight Paint mode. In Object Data Properties, you’ll see all vertex groups. Compare them with the reference mesh to understand how they map to Mass Effect bones.

• Rename the groups on the new asset to match the closest reference groups.

Skip renaming and instead use modifiers to combine and subtract weights.

• To do this, you need to have vanilla vertex groups in the mesh. you can add them one by one or Add Modifier → Data Transfer with these settings:

Make sure none of the vertex groups share names between the new asset and the reference before doing this. If that's the case rename the new asset's groups.

• You’ll now have empty vertex groups matching the reference. Use Vertex Weight Mix modifiers to combine or subtract weights until they resemble the reference.

LeftHand	LeftHandIndex1

Combined
Add a New Modifier → Vertex Weight Mix, set Group A to be the reference group and B to be the weights that'll be combined (or subtracted). On Vertex Set select VGroup B and Mix Mod Add or Subtract depending on what you want to do. Add these modifiers until the weights resemble reference's. In the case of the Sample Image, I had to combine all five the LeftHand*1 groups on LeftWrist

Why are we doing this?

     These assets were weighted by professionals early in the pipeline, and that process can’t be realistically reverse engineered. Leveraging existing weights is faster and far more accurate than manual painting, especially if you’re importing multiple armours with swappable parts from the same source.

• Select the reference armature → File → Import → Skeletal Anim (.psa) and load an animation (for example, AM_Cheer01.psa). Now you should be able to preview in real time as you change modifiers or the name of the groups how it looks with animation. For this to work, make sure that the armature modifier is placed at the very end.

• There'll probably be some clipping, there's no way to get rid of them all but these can be fine-tuned by hand. In the armature modifier, next to the drop down icon you'll see On Cage and Edit Mode are untoggled by default, enable them. This way you'll be able to see the animation in Edit Mode and select the clipping areas for wight painting.

Edit Mode	Wight Paint
Isolate the clipping geometry	Enable Vertex Selection

• Now only the selected area will be weight painted.

• If rigid objects (such as buckles or buttons) seem to be stretching and behaving like cloth, select the rigid geometry and then select a vertex somewhere in the middle of it, then copy weights. This will simulate a more solid material.

Without Sharp Edges	With Sharp Edges

• Sharp edges were preserved earlier, but still it's best to double check on Edit Mode to see if there are any changes you'd like to make. Don't need to go overboard with this, UE3's rendering is not robust enough to pick up extremely small details anyway.

• UE3 does not read sharp-edge flags. Instead, it treats mesh boundaries as sharp. Add an Edge Split modifier and disable Angle. This physically splits sharp edges so the engine recognises them.

• Test with multiple animations until you’re satisfied. Once everything looks correct, you can move on to the texture workflow.

RGBA channels are a way of storing multiple pieces of image inside a single texture. Each texture pixel is made up of four separate values: Red (R), Green (G), Blue (B), and Alpha (A). Together, these values describe the colour and transparency of that pixel, with each channel typically stored as a number between 0 and 255.

The RGB channels define the visible colour by mixing red, green, and blue light in different intensities (i.e. a yellow pixel has a value of full red and full green and zero blue (255,255,0)). The Alpha channel usually controls transparency, where lower values mean more transparent and higher values mean more opaque. In real-time graphics and game development, these channels are often reused to store non-colour data (such as roughness, metallic, or masks), making RGBA textures an efficient way to pack multiple material properties into a single image.

RGB Combined	Red Channel	Green Channel	Blue Channel	Alpha

Different games will store different texture types in different channels, there's no industry standard. This section is for learning what to look for, recognising the texture types and their function. Familiarise yourself with how they look so you can pick them out from assets that are packed in various ways.

Base Colour / Albedo	Diffuse	Ambient Occlusion (AO)
The base colour texture defines the surface’s raw colour, without lighting, shadows, or reflections baked in. In physically based rendering (PBR), this map should contain only colour information and no shading. It replaces older “diffuse” maps in modern workflows.	A diffuse texture is similar to base colour but comes from older, non-PBR workflows. It often includes baked lighting, shading, or ambient occlusion. Diffuse maps are still common in legacy engines but are generally avoided in modern games.	The ambient occlusion map adds subtle shadowing in crevices, corners, and areas where light is naturally blocked. It enhances depth and grounding, especially in real-time rendering. AO is often multiplied with the base colour or applied separately in the shader.
Normal	Roughness	Specular
The normal map simulates fine surface detail by altering the direction that light interacts with the surface. It gives the illusion of bumps, grooves, and dents without increasing geometry. Normal maps usually use a bluish colour scheme and store directional data rather than visible colour.	Roughness texture controls how smooth or rough a surface appears. Low roughness values produce sharp, mirror-like reflections, while high values create dull, scattered reflections. This map is a core part of PBR workflows.	A specular map defines how strong and what colour reflections are on a surface. It is commonly used in older or specular-based PBR workflows. In exports from modern games you will likely not find spec maps.
Metallic	Emissive	Transparency / Opacity Mask
Metallic map specifies whether a surface behaves like a metal or a non-metal (dielectric). Metals reflect light differently and inherit their colour from reflections (cubemaps) rather than the base colour. You can recognise these if they're specifically highlighting the metallic parts of the texture.	Emissive (or emission) texture defines areas of a material that emit light visually, such as screens, LEDs, or glowing symbols. Emissive maps are unaffected by scene lighting and can make objects appear self-lit.	Transparency (or opacity) maps control which parts of a surface are see-through. White (or high values) indicate opaque areas, while black (or low values) indicate transparent areas. Masks are commonly used for glass, foliage, and decals. An opacity mask is a binary form of transparency, where pixels are either fully visible or fully invisible. This is commonly used for foliage, fences, or grates, as it is cheaper to render than smooth transparency.
Tint Mask	Phong	Cubemap / Environment Map
Tint mask is used to define which areas of a texture can be recoloured dynamically. Different greyscale or colour regions act as masks that shaders use to apply user-defined or engine-defined colours, commonly used to add customisation. It can work with a pattern texture that applies on top of the Tint Map.	Phong texture is often found in legacy engines or older assets, it multiplies over spec to add a sheen effect. You can recognise it by the area it covers having an iridescent effect over it in the game.	Cubemaps represent the surrounding environment from a single point in space. It consists of six square faces forming a cube, each capturing a view in a different direction (±X, ±Y, ±Z). It works with a reflective texture.

These are the texture types most commonly used in Mass Effect:
– Normal
– Diffuse
– Specular
– Roughness
– Metallic
– Phong
– Emission

Complex materials and effects will be covered later.

Metallic, Phong, and Emission are optional. The others are essential. We will now go over the workflow for converting and compiling different texture types to generate others. I prefer using Photoshop to visualise compiled textures, but in this tutorial (except for normal maps), I will use Blender. Everything done via nodes can be replicated in any image editor of your choice.

(Skip this step if your normal map is a solid pinkish-blue)

In Mass Effect, Normal maps store XYZ axes in the RGB channels.

Let’s assume we have a normal map like this:

RGB Combined	Red Channel	Green Channel	Blue Channel	Alpha

🟥 Red Channel (X axis): Contains side-lit detail, correct as is.

🟩 Green Channel (Y axis): Currently empty; will need data from alpha.

🟦 Blue Channel (Z axis): Stores out-of-surface information, needs to be inverted.

⬛ Alpha: Contains top-down lighting info (Y axis), should be moved to Green Channel.

Blender’s normal baking can be unreliable for this. It’s better to adjust normals in an image editor: Move the alpha to the Green channel, remove the alpha layer, and invert the Blue channel.

Depending on the normal map you have you might have to do different things but this is the logic behind it:
– Red Channel should look lit from sides
– Blue Channel should look lit from top/bottom
– Green Channel should look embossed, and mostly white. Some normals won't have Z axis info at all and it can safely be left completely white.
– Alpha should be either completely white or shouldn't exist at all.

You should end up with textures that look like these:

Assets ported from newer games often only have Base Color, which is too flat and bright for Mass Effect. To generate a proper Diffuse, you will need Ambient Occlusion (AO).

(Skip this if you already have an AO texture)

You will have to bake AO for every material you have.

     – Before you start:
                 Separate any overflowing mesh parts (like skirts, butt flaps, or capes). AO calculates shadows from bump maps and surface normals. If overlapping geometry isn’t separated, it will render the surfaces underneath completely black.
                 Move overlapping UV islands by offset of 1.00 to either side.

• In Shading, drag and drop the normal map texture.

• Set Color Space to Non-Color.

• Add → Vector → Normal Map, and connect it as shown:

• Repeat for all materials. Your asset should now look similar to this:

• Follow this tutorial for baking AO after you've this setup. Remember to hide any separated meshes in the render by clicking the small camera icon next to their layer in the Outliner and make super sure that you've made new texture nodes for every material, and have them selected before baking or it will bake over existing textures.

• Recommended Render Properties for high-quality AO:

If you're not familiar with baking process keep the settings low for testing. Higher settings take longer to bake and if it's a bust it can waste a lot of time.

You should end up with textures that look like these:

• Go to Rendering and set the Render Pass to Diffuse Light.

• Set up your nodes to multiply AO over Base Colour, adjusting curves to make the AO effect stronger or weaker as needed.

Example Node Setup	Base Colour	Base Colour + AO

A slightly more complex setup might look like this. You’ll need to experiment with the nodes and values to create a diffuse texture that resembles Mass Effect materials. Some useful nodes and functions: – Curves: Adjusts brightness/contrast of textures. – Invert: Reverses the colors; can also be done in Curves. – Fac (Factor): Determines how strongly an effect applies. For example, you can apply AO over Base Colour based on Roughness by connecting the texture to the Fac input. – Separate/Combine Color: Splits or recombines RGB channels. – Alpha Straight / Channel-Packed: Options on the texture node for textures that include alpha channels.

• Once satisfied, create a new Image Texture node and bake it. This time, select Diffuse in the Bake dropdown and uncheck Direct and Indirect.

• If you don’t have a specular map, you can usually generate one by inverting Roughness and multiplying AO over it.

• You can also use a desaturated Base Colour, though it’s often unnecessary. Example node setup:

• Bake the same way as the Diffuse map.

• Roughness textures from newer games can usually be used as-is in Mass Effect.

• When testing in-game, adjust curves or levels as needed to match the desired surface feel.

• If you already have a metal mask, treat it the same way as Roughness.

• If not, you can hand-draw a black-and-white metallic mask for the metal areas and overlay Roughness over it.

• Create a mask for areas you want to have sheen and multiply AO over it.

• Emission masks generally work out of the box.

• Mass Effect’s textures tend to be crustier, so adding a slight bloom effect can improve the in-game look.

Materials are what tells the engine what to do with all the textures. When we looked at the packed texture images, we saw different maps were stored in separate channels. A material is what reads them.

There are multiple ways they're packed in Mass Effect, and multiple ways to read them to find which works best for your setup.

Master Material is the base material that tells the engine how to render a mesh.

• In LEX, Master Materials can be identified by (Material) next to their name, or by checking the Metadata tab; Class will be Engine.Material.

• The Scalar, Vector, and Texture parameters a material uses are listed in the material’s Expressions array property.

• To view a parameter name, click the corresponding expression in the material and check its ParameterName.

Choosing the right Master Material depends on its intended purpose. For example, a visor material wouldn’t be suitable for clothing, but it could work for a glass necklace.

Each Master Material can have an assigned USER material, which is a stack of effects the game plays under specific conditions.

• Example: When a player uses a biotic effect, it is applied through the USER material linked to its Master Material.

• If a material doesn’t have a USER material, it will remain in its default state.

• USER materials are pre-compiled for specific Master Materials and are not interchangeable.

• To find them, search the game’s data for [materialname]_USER and ensure the Class is RvrEffectsMaterialUser.

A MaterialInstanceConstant is an instance of a Master Material (or its USER stack) that allows you to override specific parameters like colour, texture, or shininess without editing the original.

• They are more efficient because they reuse the Master Material setup.

• Example: Different outfit can use a single Master Material but have multiple texture variants, decals, or tint colours.

• Note: They can only override properties defined in the Master Material’s Expressions array.

Parameters will be expanded on later

Suppose we need a material with these features: RGB Diffuse (colored diffuse; some tintable materials use grayscale diffuse for paint overlay), Normal, Roughness, Metal, Specular, Phong, Emission, Skin Mask (a masked area tinted by the engine’s skin tone parameter; used for exposed hands/arms in outfits)

• Go to Legendary Explorer → Asset Database → Materials, from the Filter dropdown → Filter Materials → BoolProperty Filters → bUsedWithSkeletalMesh (this bool does what it says on the tin, we can't use materials that are not set to be used on skeletal meshes on skeletal meshes)

• Ignore the EffectsMaterials, try to find something that works on materials named like [ASA/HMM/TUR/QRN/DRL...]_*_MAT

• If you are not familiar with some common materials that are used in the game, you can instead search from the textures. Look for Spec, Spwr and Spec_Stack textures that seem to have some of the maps you are looking for.

• Let's choose 3 materials and pick apart what they do

Master Material: DRL_THN_LGTa_ALT_MAT

MaterialInstanceConstant: DRL_THN_LGTa_ALT_MAT_1a

RGB Diffuse ✔️	Normal ✔️	Roughness ✔️	Specular ✔️	Metal ✔️
DRL_THN_LGTa_ALT_Diff – RGB Channel	DRL_THN_LGTa_ALT_Norm – RGB Channel	DRL_THN_LGTa_ALT_Spec – Green Channel	DRL_THN_LGTa_ALT_Spec – Red Channel	DRL_THN_LGTa_ALT_Diff – Alpha Channel
Phong ❌	Emission ✔️	Skin Mask ❌	Specular Add ➖
N/A	DRL_THN_LGTa_ALT_Spec – Alpha Channel	N/A	DRL_THN_LGTa_ALT_Spec – Blue Channel

Master Material: TNT_MASTER_MAT_USER

MaterialInstanceConstant: HMM_ARM_CTHb_MAT_4a

RGB Diffuse ❌	Normal ✔️	Roughness ✔️	Specular ✔	Metal ❌
N/A	ARM_CTHb_Nav_Norm_Stack – RGB Channel	ARM_CTHb_Diff – Blue Channel	ARM_CTHb_Diff – Green Channel	N/A
Phong ❌	Emission ❌	Skin Mask ✔	Greyscale Diffuse ➖	Tint Mask ➖
N/A	N/A	ARM_CTHb_Diff – Alpha Channel	ARM_CTHb_Diff – Red Channel	ARM_CTHb_Tnt_Mask – RGBA Channel

Master Material: QRN_ARM_TLI_MASTER_MAT

MaterialInstanceConstant: QRN_TLI_LGT_ALT_MAT

RGB Diffuse ✔️	Normal ✔️	Roughness ✔️	Specular ✔	Metal ✔️
PTY_Tali_Bodyb_Diff - RGB Channel	PTY_Tali_Bodyb_Norm - RGB Channel	PTY_Tali_Bodyb_Spec - Red Channel	PTY_Tali_Bodyb_Spec - Green Channel	PTY_Tali_Bodyb_Spec - Alpha Channel
Phong ✔️	Emission ✔️	Skin Mask ❌	Speaker Emission ➖
PTY_Tali_Bodyb_Phong - RGB Channel	PTY_Tali_Bodyb_Diff - Alpha Channel	N/A	PTY_Tali_Bodyb_Spec - Blue Channel

In certain textures you might find blank channels. They might have a utility that's left empty because the asset doesn't need it but to figure out whether they do anything you'd have to test them manually in-game. Some of those might also need proper material overrides to be set in MaterialInstanceConstant to show up. You can check the master material's Expressions array to get a better idea, however some of those are left as None.

There are no materials in LE2 that has all of these capabilities but the last one seem to have most of it. To make it work, we need to separate the materials in the mesh so the skin part can use seperate material.

(Skip this part if you know how to separate mesh materials)

• Open your mesh in Blender.

• In Edit Mode, select the area that has (in this example) skin.

• Go to Material Properties tab and click + to add a new material (name is irrelevant for UDK).

• With skin area selected, click Assign.

• After importing your new mesh to LEX don't forget to add a new material for it on Binary Interpreter's Materials array

• After setting up your mesh and material in your package, repack the textures you have to the appropriate channels for the material you've selected.

• In this tutorial it'll be QRN_ARM_TLI_MASTER_MAT which has texture types packed as follows:

Diff: RGB=Diffuse, Alpha=Emission
Norm: RGB=Normal, Alpha:N/A
Spec: Red=Roughness, Green=Spec, Blue=Speaker Emission, Alpha=Metallic
Phong: RGB=Phong, Alpha=N/A

Below are examples of how Specular, Roughness, Metallic, and Phong values simulate different fabric materials in Mass Effect.

Leather	Suede	Latex	Cotton
Velvet	Silk	Metallic Foil

QRN_ARM_TLI_MASTER_MAT material has the following parameters. Parameter names vary between materials, but overall remain similar enough to understand.

Multi-value parameters, usually RGBA (represented as 255,255,255,1). They are most often used for colours, tints, or multi-channel values like colour masks or emissive colour.

• QRN_ARM_ALL_Emis_Colour_Vector: Colour of the emission.
  
• Phong_Spec_Color: Colour of the sheen.
  
• Spec_Color: Colour of shine - the change is very weak.
  
• cune_map_tint: Tint shift for the cube map. The typo is in the game.

Single numeric values (floats). They are typically used to control intensity or strength, such as roughness, metallic amount, emissive power, opacity, or blend factors.

• QRN_Talk_Scalar: Controls the intensity of the Quarian speaker emission (blue channel of spec stack texture). This effect works with FaceFX and needs to be left 0 unless it's for a quarian.
  
• None: Controls the intensity of emission (alpha channel of diffuse texture).
  
• Phong_Spwr: Clamps Phong strength. Higher values make the sheen more localised(example image: Velvet); lower values spread it out (example image: Silk).
  
• Spec_Add: Adjusts overall specular intensity. Since it affects the entire texture, it’s recommended to leave this at default and modify specular strength in the texture instead.
  
• Spec_Pwr: Clamps specular strength. Higher values concentrate shine in folds; lower values spread it more evenly.
  
• cube_map_intensity: Controls reflection intensity on metallic parts.
  
• fresnel_clamp_value: Fresnel clamp for edge highlights (fake back-lighting). Lower values make edge shine spread out more.

Texture slots that accept texture assets.

• QRN_ARM_ALL_Norm_Stack: Normal map
  
• QRN_ARM_ALL_Spwr_Stack: Specular stack
  
• QRN_ARM_ALL_Diff_Stack: Diffuse stack
  
• CubeMap: Cube map

Phong: Phong texture is a constant on this material. It can't be edited by MaterialInstanceConstant. To use a unique Phong texture for an outfit, you must create a copy of the Master Material and its USER material. For other materials, texture parameters may be editable via overrides.

There are two major tintable Master Materials in LE2, each with different capabilities.

• TNT_ARM_MASTER_MAT - The primary tintable material. It supports multiple tint channels, stripe overlays, and skin masking.

• GTH_TNT_MASTER_MAT - Supports RGB diffuse, emission, and stripe overlays, but is limited to a single tint channel and does not support skin masking.

In this case, I don't have RGB diffuse so I will choose TNT_ARM_MASTER_MAT. If you have RGB diffuse and only need one tint channel you can use GTH_TNT_MASTER_MAT.

• Its textures are packed as follows:

Diff: Red=Diffuse, Green=Specular, Blue=Toughness, Alpha=Skin Mask
Norm: RGB=Normal, Alpha:N/A
Tint: Red=Tint Mask 1, Green=Tint Mask 2, Blue=Tint Mask 3, Alpha=Tint Mask 4 Stripe: Red=Stripe Mask 1, Green=Stripe Mask 2, Blue=Stripe Mask 3, Alpha=Metal

TNT_ARM_MASTER_MAT has following parameters:

Scalar Parameters

• TNT_Desaturation_Scalar: Amplifies desaturation.
  
• TNT_Spec_Control: Specular strength.
  
• CubeMap_Intensity_Scalar: Cube map intensity.

Vector Parameters

• TNT_Param_01: Which channel of the tint mask the first colour will pull from (i.e. 255,0,0,0 will apply the mask packed in Red channel).
  
• TNT_Colour_01: Colour of the area masked by TNT_Param_01.
  
• TNT_Param_02: Which channel of the tint mask the second colour will pull from.
  
• TNT_Colour_02: Colour of the area masked by TNT_Param_02.
  
• TNT_Param_03: Which channel of the tint mask the second colour will pull from.
  
• TNT_Colour_03: Colour of the area masked by TNT_Param_03.
  
• TNT_Colour_04: Colour of the area masked by tint mask's alpha channel.
  
• TNT_Param_Stripe: Which channel of the stripe mask will be used.
  
• TNT_Stripe_Colour: Colour of the area masked by TNT_Param_Stripe.
  
• TNT_Base_Spec: Specular shine colour.
  
• SkinTone: Skin tone colour, remove it from your material override for engine-defined values to apply.
  
• SkinLightScattering: Under glow of the skin tone, remove it from your material override for engine-defined values to apply.

Texture Parameters

• TNT_Stripe: Stripe mask texture.
  
• TNT_Diff_Stack: Diffuse stack texture.
  
• TNT_Tint_Stack: Tint mask texture.
  
• CubeMap: Cube map.
  
• TNT_Norm_Stack: Normal map texture.

Tint is multiplied over the diffuse, and stripe is always applied on top of the tint.

Some materials have special effects that can be used for more advanced setups, these materials won't have diffuse, spec, roughness etc. capabilities and needs the mesh parts to be seperated for use.

What do I mean?

If you look at Avina's material VI_ARM_NKD_Master_Mat you'll see that a lot of funky things going on: There a pulsing lights, scrolling text and transparent surfaces. These can be edited and used for your purposes.

There's a list of some materials in LE2 that can be used with Skeletal Meshes and have special effects: VI_ARM_NKD_Master_Mat DataPadScreen_TEMP_VFX_Mat Visor_Hologram Visor_Alt_Hologram