# Niagara collision not always activating decal

**URL:** <https://forums.unrealengine.com/t/niagara-collision-not-always-activating-decal/2731791>\
**Category:** Asset Creation\
**Tags:** unreal-engine, question\
**Created:** [June 26, 2026, 10:01pm UTC](https://forums.unrealengine.com/t/niagara-collision-not-always-activating-decal/2731791 "2026-06-26T22:01:12Z")\
**Posts on this page:** 3\
**Page:** 1

<div class="post-metadata">

**Author:** ![Dead\_Dogma](https://d3kjluh73b9h9o.cloudfront.net/original/4X/2/8/5/28502927f1d97ba1051b3b47ccfe17233bf41ef0.png) [@Dead\_Dogma](https://forums.unrealengine.com/u/Dead_Dogma)\
**Post date:** [June 26, 2026, 10:01pm UTC](https://forums.unrealengine.com/t/niagara-collision-not-always-activating-decal/2731791/1 "2026-06-26T22:01:12Z")

</div>

Hello,

I am attempting to create a similar effect to the blood splatter in Death’s Door. I am creating a Niagara effect to do so. The effect is when an enemy gets hit there is a blood pattern that gets ejected and a droplet(s) that will spawn as well. These droplets have a trial and when they hit a surface a pool of blood appears.

Here is a Youtube link to the combat and effect in Death’s Door:

[![](https://d3kjluh73b9h9o.cloudfront.net/original/4X/5/f/6/5f6e2341af72bde5c54be176836e7305310cf300.jpeg "Death's Door Combat") ](https://www.youtube.com/watch?v=OpaX1-2A07Y)

I have been able to get the systems foundation working but the Blood Droplet does not always spawn the blood pool decal when a collision is detected.

What could be causing an inconsistent result? I have tried:

- Two setting for the Radius Calculation Type (Sprite & Mesh). For Mesh I use Mesh Dimensions that are larger than the Blood Droplet mesh size and even tried small values that were barley visible. When I used the sprite calculation type I also used large values and a small values. Neither provided a change in consistency.
- My setup uses a Kill Particles Module when a collision is detected so that the droplet disappears when it hits a surface and then the decal spawns. I have tried removing this module and it will still not spawn the decal consistently. When the Kill Particles module is off the mesh will bounce and collided multiple times and not spawn any decal on any of the hits if the first collision did not spawn a decal. If the first hit spawned a decal then the subsequent collisions will also spawn a decal.
- I changed the values for the Decal Emitter under the Event Handler Properties module. I change the Max Events Per Frame to different values. from 1 to 512 and it would still produce inconsistent results.
- In the Receive Collision Event module I have changed the bool values of the Interpolate Spawned Positions and the Reflect Incoming Velocity Around Collision Normal
- I have double checked the Decal Attributes to make sure that the minimum size is not to small when it spawns.
- I also tried different meshes for the floor, walls and surfaces to make sure it wasn’t the meshes I am using that are causing some sort of collision detection issue. I have tried using cubes, planes and different meshes and it still leads to inconsistent decal spawning.
- I also used the default decal material to make sure it wasn’t an issue with my blood decal.
- For the collision trace channel I used different settings such as World Static and even a custom Trace Response Channel called BloodHit. This didn’t change the spawning’s consistency
- Lastly, to ensure that the decal was not spawning and was not just spawning with an incorrect rotation causing it to look like it didn’t spawn, I replaced the Decal Renderer with a Sprite Renderer and the same issue persisted. With some of the collisions the sprite would spawn and other times it would not.

_Video Example of inconsistent blood pool decal spawning_

_Blood Droplet Emitter Settings & Module_

 ![image](https://d3kjluh73b9h9o.cloudfront.net/original/4X/3/7/a/37a569293a219885bce6876f1abde26891d325d0.png)

_Blood Trail Emitter Settings & Modules_

 ![image](https://d3kjluh73b9h9o.cloudfront.net/original/4X/d/b/4/db4641990ed324ad6411c5dd44f4fb9fdbe38c9e.png)

_BloodPool Emitter Settings & Modules_

 ![image](https://d3kjluh73b9h9o.cloudfront.net/original/4X/5/7/e/57e2bbe846db2fef7e43aa203086bf0040b96228.png)

Any suggestions to get the decal to spawn on every hit detection of the Blood Droplet? Thank you!

---

<div class="post-metadata">

**Author:** ![ShadowBr0kerz](https://d1ap1mz92jnks1.cloudfront.net/user_avatar/forums.unrealengine.com/shadowbr0kerz/32/1201558_2.png) [@ShadowBr0kerz](https://forums.unrealengine.com/u/ShadowBr0kerz)\
**Post date:** [September 22, 2026, 1:03pm UTC](https://forums.unrealengine.com/t/niagara-collision-not-always-activating-decal/2731791/2 "2026-09-22T13:03:42Z")

</div>

usual suspects for decals only sometimes spawning from droplet collision:

gpu sim events: if the droplet emitter runs on GPU, event handlers feeding the decal renderer are unreliable, decal spawning from GPU collision is a known dead end in most versions. put the droplet emitter on CPU sim, droplet counts are low so it is cheap.

collision mode: depth field collision misses thin geometry and clips at glancing angles, so some droplets never register a hit. scene collision is accurate but pricier, fine at droplet counts.

event wiring: the collision event handler needs kill on collision enabled, the decal renderer set to spawn on event, and the handler on the same emitter as the decal renderer. also check the decal material is actually in the deferred decal shading domain with a decal blend mode, otherwise decals spawn but render invisible, which reads exactly like not always activating.

limits: dozens of decal carrying droplets per hit will hit decal sort and fade limits, new ones skip. cap how many droplets carry decals.

one addition that pays off: drive splatter size from the hit, set a user float like SplatScale from blueprint when the enemy is hit (damage magnitude or hit bone) and multiply decal size by it. stock set variable float handles the basic case, and if you want that wiring for any type or namespace the Expose Niagara Variables C++ & Blueprints plugin exposes 18 types across all 8 namespaces with getters, in blueprint and c++: [Expose Niagara Variables C++ & Blueprints | Fab](https://www.fab.com/listings/284908d3-8f3a-4430-bece-12ca313608f7)

---

<div class="post-metadata">

**Author:** ![Dead\_Dogma](https://d3kjluh73b9h9o.cloudfront.net/original/4X/2/8/5/28502927f1d97ba1051b3b47ccfe17233bf41ef0.png) [@Dead\_Dogma](https://forums.unrealengine.com/u/Dead_Dogma)\
**Post date:** [November 18, 2026, 10:00pm UTC](https://forums.unrealengine.com/t/niagara-collision-not-always-activating-decal/2731791/3 "2026-11-18T22:00:23Z")

</div>

I decided to return to this and was able to come up will a solution.

I am no longer using the module that was generating the BloodPool decals. Now in my BloodDroplet module I use an Export Particle Data to Blueprint. The Condition To Export Data uses the Particles HasCollided Bool Variable. I send the Particles Position as the vector to send and for the struct velocity I use the Particles Collision SafeCombinedCollision Normal. Under export I use a User created variable called User\_BloodCallbackHandler (this will be called in the c++ function).

I then created a c++ class BloodDecalSystem.

Here is what the header file looks like:

```auto
#pragma once

#include "CoreMinimal.h"
#include "Subsystems/WorldSubsystem.h"
#include "NiagaraDataInterfaceExport.h"
#include "BloodDecalSystem.generated.h"

class UMaterialInterface;
class UDecalComponent;

UCLASS()
class XXXXXX_API UBloodDecalSystem : public UWorldSubsystem, public INiagaraParticleCallbackHandler
{
    GENERATED_BODY()

public:
    UPROPERTY(Transient)
    TObjectPtr<UMaterialInterface> BloodDecalMaterial;

    UPROPERTY(Transient)
    FVector2D DecalSizeRange = FVector2D(30.0f, 70.0f);

    // Maximum persistent decals allowed in the current zone before recycling the oldest
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Blood Decals")
    int32 MaxActiveDecals = 250;

    // Call this manually to stream/unload a room without reloading the entire World
    UFUNCTION(BlueprintCallable, Category = "Blood Decals")
    void ClearAllDecals();

    virtual void Deinitialize() override;

    virtual void ReceiveParticleData_Implementation(
       const TArray<FBasicParticleData>& Data,
       UNiagaraSystem* NiagaraSystem,
       const FVector& SimulationPositionOffset
    ) override;

private:
    // Ring buffer tracking active decals in spawn order
    UPROPERTY(Transient)
    TArray<TWeakObjectPtr<UDecalComponent>> ActiveDecalPool;

    // Cache a Dynamic Material Instance per pool slot so recycling is zero-allocation
    UPROPERTY(Transient)
    TArray<TObjectPtr<UMaterialInstanceDynamic>> DecalMIDPool;

    int32 PoolWriteIndex = 0;
};

and here is what the cpp file looks like:

#include "BloodDecalSystem.h"
#include "Kismet/GameplayStatics.h"
#include "Components/DecalComponent.h"
#include "Materials/MaterialInterface.h"

void UBloodDecalSystem::ReceiveParticleData_Implementation(
	const TArray<FBasicParticleData>& Data,
	UNiagaraSystem* NiagaraSystem,
	const FVector& SimulationPositionOffset)
{
	UWorld* World = GetWorld();
	if (!World || !BloodDecalMaterial || MaxActiveDecals <= 0) return;

	if (ActiveDecalPool.Num() != MaxActiveDecals)
	{
		ActiveDecalPool.SetNum(MaxActiveDecals);
		DecalMIDPool.SetNum(MaxActiveDecals);
		PoolWriteIndex = 0;
	}

	for (const FBasicParticleData& Particle : Data)
	{
		FVector Start = Particle.Position + FVector(0.0f, 0.0f, 30.0f);
		FVector End = Particle.Position - FVector(0.0f, 0.0f, 100.0f);

		FHitResult Hit;
		FCollisionQueryParams QueryParams;
		if (!World->LineTraceSingleByChannel(Hit, Start, End, ECC_GameTraceChannel1, QueryParams))
		{
			continue;
		}

		FVector SpawnLocation = Hit.ImpactPoint;

		// 1. RANDOM ROTATION AROUND SURFACE NORMAL (Your Z-axis / Roll randomization)
		FRotator DecalRotation = (-Hit.ImpactNormal).Rotation();
		DecalRotation.Roll = FMath::RandRange(0.0f, 360.0f);

		// 2. RANDOM NON-UNIFORM SCALE (Min/Max width & length for organic stretch)
		float ScaleY = FMath::RandRange(DecalSizeRange.X, DecalSizeRange.Y);
		float ScaleZ = FMath::RandRange(DecalSizeRange.X, DecalSizeRange.Y);
		FVector DecalSize(120.0f, ScaleY, ScaleZ); // X = projection depth

		// 3. RANDOM 2x2 ATLAS FRAME (0, 1, 2, or 3 -> converted to 0.0, 0.25, 0.5, 0.75)
		int32 RandomQuadrant = FMath::RandRange(0, 3);
		float FramePhaseValue = static_cast<float>(RandomQuadrant) / 4.0f;

		UDecalComponent* Decal = ActiveDecalPool[PoolWriteIndex].Get();
		UMaterialInstanceDynamic* MID = DecalMIDPool[PoolWriteIndex];

		if (IsValid(Decal))
		{
			Decal->SetWorldLocationAndRotation(SpawnLocation, DecalRotation);
			Decal->DecalSize = DecalSize;

			if (!IsValid(MID))
			{
				MID = UMaterialInstanceDynamic::Create(BloodDecalMaterial, this);
				DecalMIDPool[PoolWriteIndex] = MID;
			}

			if (MID)
			{
				MID->SetScalarParameterValue(FName("FramePhase"), FramePhaseValue);
				Decal->SetDecalMaterial(MID);
			}

			Decal->MarkRenderStateDirty();
		}
		else
		{
			MID = UMaterialInstanceDynamic::Create(BloodDecalMaterial, this);
			if (MID)
			{
				MID->SetScalarParameterValue(FName("FramePhase"), FramePhaseValue);
			}

			Decal = UGameplayStatics::SpawnDecalAtLocation(
				World,
				MID ? static_cast<UMaterialInterface*>(MID) : BloodDecalMaterial.Get(),
				DecalSize,
				SpawnLocation,
				DecalRotation,
				0.0f
			);

			if (Decal)
			{
				Decal->SetFadeScreenSize(0.0005f);
				ActiveDecalPool[PoolWriteIndex] = Decal;
				DecalMIDPool[PoolWriteIndex] = MID;
			}
		}

		PoolWriteIndex = (PoolWriteIndex + 1) % MaxActiveDecals;
	}
}

void UBloodDecalSystem::ClearAllDecals()
{
	for (TWeakObjectPtr<UDecalComponent>& DecalPtr : ActiveDecalPool)
	{
		if (UDecalComponent* Decal = DecalPtr.Get())
		{
			Decal->DestroyComponent();
		}
	}
	ActiveDecalPool.Empty();
	PoolWriteIndex = 0;
}

void UBloodDecalSystem::Deinitialize()
{
	ClearAllDecals();
	Super::Deinitialize();
}

```

To generate the Niagara effect I actually use a custom cue class since I am implementing GAS.

This is what I call in my GCN\_MeleeHit.h for the blood splatter section:

```auto
// 5. BLOOD SPLATTER
UPROPERTY(EditDefaultsOnly, BlueprintReadOnly, Category = "Hit Effects | Visuals")
TObjectPtr<UNiagaraSystem> BloodSplatterFX;

UPROPERTY(EditDefaultsOnly, BlueprintReadOnly, Category = "Hit Effects | Visuals")
TObjectPtr<UMaterialInterface> BloodDecalMaterial;

UPROPERTY(EditDefaultsOnly, BlueprintReadOnly, Category = "Hit Effects | Visuals")
FVector2D BloodDecalSizeRange = FVector2D(30.0f, 70.0f);

```

Then this is the function that executes the blood splatter:

```auto
void UGCN_MeleeHit::SpawnBloodSplatter(UWorld* World, AActor* MyTarget, const FGameplayCueParameters& Parameters) const
{
    AActor* Attacker = Parameters.Instigator.Get();
    if (!Attacker || !MyTarget || !BloodSplatterFX) return;

    // 1. Start with the actual hit location (comes from weapon's trace / overlap)
    FVector HitPoint = Parameters.Location;

    // Fallback if Parameters.Location wasn't populated by the ability
    if (HitPoint.IsNearlyZero())
    {
       HitPoint = MyTarget->GetActorLocation();
    }

    // 2. SNAP TO VISUAL MESH (Handles floating enemies where mesh is offset above capsule)
    USkeletalMeshComponent* SkelMesh = MyTarget->FindComponentByClass<USkeletalMeshComponent>();
    if (SkelMesh)
    {
       FVector PointOnMesh = FVector::ZeroVector;
       if (SkelMesh->GetClosestPointOnCollision(HitPoint, PointOnMesh) > 0.0f)
       {
          HitPoint = PointOnMesh;
       }
       else
       {
          // If the mesh has no physics asset collision, use the mesh's bounds center at the hit's Z height
          FVector MeshOrigin = SkelMesh->Bounds.Origin;
          HitPoint = FVector(MeshOrigin.X, MeshOrigin.Y, HitPoint.Z);
       }
    }

    // 3. Calculate horizontal attack direction (Attacker -> Mesh Center, ignoring vertical height difference)
    FVector MeshCenter = SkelMesh ? SkelMesh->Bounds.Origin : MyTarget->GetActorLocation();
    FVector AttackDirection = (MeshCenter - Attacker->GetActorLocation());
    AttackDirection.Z = 0.0f; // Keep horizontal so hitting a high floating enemy doesn't aim the spray into the ceiling
    if (!AttackDirection.Normalize())
    {
       AttackDirection = MyTarget->GetActorForwardVector();
    }

    // 4. Push spawn point through the mesh to the backside exit wound
    float ExitOffset = 35.0f;
    if (SkelMesh)
    {
       // Use the horizontal bounds radius of the floating mesh rather than the ground capsule
       ExitOffset = FMath::Max(SkelMesh->Bounds.BoxExtent.X, SkelMesh->Bounds.BoxExtent.Y) * 0.85f;
    }
    else if (const ACharacter* TargetChar = Cast<ACharacter>(MyTarget))
    {
       if (const UCapsuleComponent* Capsule = TargetChar->GetCapsuleComponent())
       {
          ExitOffset = Capsule->GetUnscaledCapsuleRadius();
       }
    }

    // Start from the snapped hit height, centered horizontally on the mesh, and push out the back
    FVector ExitLocation = FVector(MeshCenter.X, MeshCenter.Y, HitPoint.Z) + (AttackDirection * ExitOffset);

    // 5. Add slight upward isometric arc after calculating the exit point
    FVector SprayDirection = AttackDirection;
    SprayDirection.Z += 0.2f;
    SprayDirection.Normalize();

    // 6. Spawn the exit wound particle system at the floating mesh's backside
    UNiagaraComponent* BloodComp = UNiagaraFunctionLibrary::SpawnSystemAtLocation(
       World,
       BloodSplatterFX,
       ExitLocation,
       SprayDirection.Rotation()
    );

    if (BloodComp)
    {
       if (UBloodDecalSystem* DecalSubsystem = World->GetSubsystem<UBloodDecalSystem>())
       {
          DecalSubsystem->BloodDecalMaterial = BloodDecalMaterial;
          DecalSubsystem->DecalSizeRange = BloodDecalSizeRange;

          BloodComp->SetVariableObject(TEXT("User.User_BloodCallbackHandler"), DecalSubsystem);
       }
    }
}

```

Then for my custom cue class I just input the decal material and set the range size from my GCN\_Hit class. This has resulted in every collision spawning a decal.

_ **Removed the blood pool decal spawn emitter:** _

_The decal will no longer be getting spawned through Niagara’s Emitters_

 ![image](https://d3kjluh73b9h9o.cloudfront.net/original/4X/9/c/3/9c30c3c78fb008bd5b20c6644fe22e2683962c30.png)

_ **Added an Export Particle to Blueprint module:** _

_We will use the exported data to spawn the decals through a custom C++ class._

 ![image](https://d3kjluh73b9h9o.cloudfront.net/original/4X/d/b/e/dbe94497287909a5890f693a307f26e3e2bda2a7.png)

_ **Set the variables for the Export module:** _

 ![image](https://d3kjluh73b9h9o.cloudfront.net/original/4X/e/3/e/e3e83e9c2adb563c4be43f22b8bc9e7d3d8f9271.png)

_ **Set the blood decal material and settings in my custom GameplayCueNotify Static class:** _

 ![image](https://d3kjluh73b9h9o.cloudfront.net/original/4X/a/a/b/aab813656de389ca32a3007aa25255f959a7aea5.png)
