The Damage FX Object consists of three essentials pieces:

Damage FX Shader

Let’s look at the basic application of the shader with the base layer which is rendering the initial or untouched mesh, and also the damage layer added by the Damage FX function. The universal example would be FORGE3D/DamageFX/PBR Specular Gloss shader in our case.

The damage is added dynamically upon providing an object space point and non empty value to the shader data array. The shader function will iterate through the available impact points building the required masks given the following values:

These five values are individual per impact point and you can experiment with them in the real-time by launching the example scenes.

Note the default configuration is set to 200 impact points per Damage FX Object. Adding more points over the limit will overwrite existing ones from the beginning of the shader array.

Damage FX Script Component

Assets/FORGE3D/DamageFX/Scripts/DamageFX.cs

In order to control the Damage FX Shader, an instance of the script should be present on each Damage FX Object. The script component handles the data processing for impact spots and fades the heat values over time.

Use DamageFX.Hit() method of the script to add new impacts to the surface of the mesh as shown below:

Here is the simple code snippet that will add the damage point to the Damage FX Object under the mouse cursor on left mouse click:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

public float HitRadius = 0.1f;
 
public float Dirt = 1f;
 
public float Burn = 1f;
 
public float Heat = 1f;
 
public float Clip = 0.7f;
 
private RaycastHit _hitInfo;
 
private void Update()
 
{
 
if (!Input.GetMouseButtonDown(0)) return;
 
var screenRay = Camera.main.ScreenPointToRay(Input.mousePosition);
 
if (!Physics.Raycast(screenRay, out _hitInfo, Mathf.Infinity)) return;
 
var dfx = _hitInfo.collider.GetComponent<DamageFX>();
 
if (dfx != null) dfx.Hit(dfx.transform.InverseTransformPoint(_hitInfo.point), HitRadius, Dirt, Burn, Heat, Clip);
 
}

Colliders

The Damage FX works best with precise colliders that match its mesh geometry, e.g. mesh colliders.

If the distance between the closest mesh point and the collider hitpoint is bigger than the hit radius, then the effect won’t be visible at all. It’s important to provide a properly designed colliders to your Damage FX Objects.

The key is to get the impact from the hitpoint of the raycast against the collider to the original vertex position of the mesh. Sometimes this is not possible, for example, because you want to use the rigid body on the same object which will cause Unity to throw an error. Here’s a workaround to it. Remember, that you can use a convex collider or any number of simplified ones instead, either detach the mesh collider in the Awake(), and move it along each frame. You can also try using any third party tools/assets to help with generating a series of convex colliders covering the mesh.

Depending on the shader, the amount of available material parameters may change, although there are always a number of parameters that added with the Damage FX Function.

You should be already familiar with the Damage FX Script method input values from the previous chapter. In the image example the material values look somewhat identical. There are more parameters though and also two texture samples for damage masks and produced glow. The DamageMap holds the clip and dirt masks, while the HeatMap is used to generate the UV animated effect along the burn edge.

As an addition, there is a Vertex Damage parameter that will offset the geometry points affected by the impact along its normals based on the clipping mask.

You can tile clip and dirt masks by adjusting in values in the inspector, while the heat map should be tiled by the sampler’s x and y instead. It is also important to know that you might want to adjust your tiling when setting a material for a new mesh.

That said, with all the given parameters of the Damage FX Material, you can control its clip, dirt, heat and burn values globally. Keep in mind that the Function input values apply individually per point and based on your global settings in the material of the Damage FX Object.

Damage Map UV2

The DamageMap sampler uses the UV2 channel. Make sure you have a UV2 map on your mesh by Generating a Lightmap UVs in Unity. This option is available in the Mesh Import Settings.

Usually you would want a weapon controller to call the Damage FX Script Component when you hit an object with a weapon. Following this approach to set the look of the damage on the object might become time consuming. There is a more quicker way with the ApplyDamage.cs script which implements all the necessary tools for the task.

If you’re not familiar with this script, just refer to the example scenes.

Notice the Debug Mode checkbox which turns the object itself into a real time impact generator given the values from the user input. Enable the Debug Mode and move it around. Use the hotkeys such as W-S, 1-2 and Space to reset.

Additionally, you can set the Damage FX Script Object Decay Tick Rate and Decay Per Tick to zero to stop the glow from fading.

Damage FX Script Component:

Modify the constant value of the Damage FX Script Component:

Assets/FORGE3D/DamageFX/Scripts/DamageFX.cs

Amplify Creations Shader Editor Users:

Open the DamageFXDistMask function from the Assets/FORGE3D/DamageFX/Shaders/ and change the number of MaxPoints constant matching the number set in the script component. Recompile both Damage FX Functions and all shaders affected by this change.

Modifying shaders by hand:

Open the Damage FX Shader sample and search for the existing number of points in the search field of your favourite editor:

The Damage FX Function can be reused within the Amplify Shader Editor. It fits perfectly into any existing node framework. As you already might know, the function itself is all it requires to add a Damage FX support to your existing shaders. Using it for the first time, please make yourself familiar with the output nodes and where you can connect them.

The Damage FX Function can be reused within the Amplify Shader Editor. It fits perfectly into any existing node framework. As you already might know, the function itself is all it requires to add a Damage FX support to your existing shaders. Using it for the first time, please make yourself familiar with the output nodes and where you can connect them.