[ADD] Display post process material on screen with radius depending on damages amount taken over time

Source/LegumeMix/Private/Player/LMPlayer.cpp

@@ -28,9 +28,16 @@ ALMPlayer::ALMPlayer()
 	SpreadStream = FRandomStream(FMath::Rand());
 	HealthComponent = CreateDefaultSubobject<ULMHealthComponent>(TEXT("HealthComponent"));
 
-	HitPeriodLengthInSeconds = 0.f;
-	TimeElapsedSinceLastDamageInSeconds = 0.f;
+	HitPeriodLengthInSeconds = 15.f;
+	bHitPeriodInProgress = false;
+	TimeOfTheLastDamage = 0.f;
+	HealthAtTheCurrentHitPeriodBeginning = 100.f;
 	CumulatedDamagesOnCurrentHitPeriod = 0.f;
+	PlayerViewOcclusionPercent = 0.f;
+	NextPlayerViewOcclusionPercent = 0.f;
+	PlayerViewOcclusionPercent = 0.f;
+	AlphaLerpForPlayerViewOcclusionPercent = 0.f;
+	
 }
 
 void ALMPlayer::BeginPlay()
@@ -41,9 +48,41 @@ void ALMPlayer::BeginPlay()
 
 	GetCamera()->SetFieldOfView(ULMUserSettings::GetLegumixUserSettings()->FieldOfView);
 
-
+	HealthComponent->OnHealthChanged.AddDynamic(this, &ALMPlayer::SetDisplayDamageParameters);
 }
 
+void ALMPlayer::Tick(float DeltaTime)
+{
+	if(bHitPeriodInProgress == true)
+	{
+		double TimeElapsedSinceLastDamage = GetWorld()->GetTimeSeconds() - TimeOfTheLastDamage;
+		if(TimeElapsedSinceLastDamage > HitPeriodLengthInSeconds)
+		{
+			if(bHitPeriodInProgress == true)
+			{
+				bHitPeriodInProgress = false;
+				PlayerViewOcclusionPercent = NextPlayerViewOcclusionPercent;
+				NextPlayerViewOcclusionPercent = 0.f;
+				AlphaLerpForPlayerViewOcclusionPercent = 0.f;
+				TimeOfTheLastDamage = 0.f;
+				CumulatedDamagesOnCurrentHitPeriod = 0.f;
+			}
+		}
+	}
+	
+	if(PlayerViewOcclusionPercent != NextPlayerViewOcclusionPercent)
+	{
+		AlphaLerpForPlayerViewOcclusionPercent = FMath::Clamp(AlphaLerpForPlayerViewOcclusionPercent + DeltaTime, 0, 1);
+		PlayerViewOcclusionPercent = FMath::Lerp(PlayerViewOcclusionPercent, NextPlayerViewOcclusionPercent, AlphaLerpForPlayerViewOcclusionPercent);
+		DamageDynamicMaterialInstance->SetScalarParameterValue("PlayerViewOcclusionPercent", PlayerViewOcclusionPercent);	
+	}
+	else if(PlayerViewOcclusionPercent == NextPlayerViewOcclusionPercent)
+	{
+		AlphaLerpForPlayerViewOcclusionPercent = 0;
+	}
+}
+
+
 bool ALMPlayer::PickUpAmmo(ALMAmmo* Ammo)
 {
 	if (GEngine)
@@ -163,3 +202,25 @@ USkeletalMeshComponent* ALMPlayer::GetArms()
 	return ArmsMesh;
 }
 
+void ALMPlayer::SetDisplayDamageParameters(float Health, float Damage)
+{
+	if (bHitPeriodInProgress == false)
+	{
+		HealthAtTheCurrentHitPeriodBeginning = Health;
+		bHitPeriodInProgress  = true;
+	}
+	TimeOfTheLastDamage = GetWorld()->GetTimeSeconds();
+	CumulatedDamagesOnCurrentHitPeriod += Damage;
+	SetPlayerViewOcclusionPercent();
+}
+
+
+
+void ALMPlayer::SetPlayerViewOcclusionPercent()
+{
+	AlphaLerpForPlayerViewOcclusionPercent = 0;
+	PlayerViewOcclusionPercent = NextPlayerViewOcclusionPercent;
+	NextPlayerViewOcclusionPercent = CumulatedDamagesOnCurrentHitPeriod / HealthAtTheCurrentHitPeriodBeginning;
+}
+
+

Source/LegumeMix/Public/Player/LMHealthComponent.h

@@ -23,6 +23,8 @@ public:
 	void Kill();
 
 public:
+	FORCEINLINE float GetHealth() const { return Health; }
+	
 	/**
 	 * Applies an amount of damage to the component.
 	 * @param Damage The damage to apply the Health to.

Source/LegumeMix/Public/Player/LMPlayer.h

@@ -11,6 +11,7 @@
 class UCameraComponent;
 class ULMWeaponManager;
 class ULMHealthComponent;
+class UMaterialInstanceDynamic;
 class ALMAmmo;
 
 DECLARE_DYNAMIC_MULTICAST_DELEGATE(FOnRequestUnpauseSignature);
@@ -48,6 +49,9 @@ protected:
 	// Called when the game starts or when spawned
 	virtual void BeginPlay() override;
 
+	// Called every frame
+	virtual void Tick(float DeltaTime) override;
+
 public:	
 	UFUNCTION(BlueprintCallable)
 	ULMWeaponManager* GetWeaponManager() { return WeaponManager; }
@@ -113,34 +117,76 @@ private:
 	UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category=Legumix, meta = (AllowPrivateAccess = true))
 	TObjectPtr<ULMHealthComponent> HealthComponent;
 
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=Legumix, meta = (AllowPrivateAccess = true))
+	TObjectPtr<UMaterialInstanceDynamic> DamageDynamicMaterialInstance;
+
 	/**
-	 * Length of the period in which the damages HUD will be displayed on player screen.
+	 * Is a hit period in progress
+	 */
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=Legumix, meta = (AllowPrivateAccess = true))
+	bool bHitPeriodInProgress;
+	
+	/**
+	 * Length of the period in which the damage texture effect will be displayed on player screen.
 	 */
 	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=Legumix, meta = (AllowPrivateAccess = true))
 	double HitPeriodLengthInSeconds;
 	
 	/**
-	 * Time elapsed since last damage taken.
-	 * If it's superior to the HitPeriodLengthInSeconds variable, ends the Hit period
-	 * and so the displaying of damages HUD on player screen
+	 * Time of last damage taken.
+	 * If the time elapsed since is superior to the HitPeriodLengthInSeconds variable, ends the Hit period
+	 * and so the displaying the damage texture effect  on player screen
 	 */
 	UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category=Legumix, meta = (AllowPrivateAccess = true))
-	double TimeElapsedSinceLastDamageInSeconds;
+	double TimeOfTheLastDamage;
 
 	/**
 	 * Cumulated damages taken by the player on the current hit period
-	 * To calculate view occlusion percent for the damage HUD 
+	 * To calculate view occlusion percent for the damage texture effect 
 	 */
 	UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category=Legumix, meta = (AllowPrivateAccess = true))
 	float CumulatedDamagesOnCurrentHitPeriod;
 
 	/**
 	 * Player health at the current hit period beginning
-	 * To calculate view occlusion percent for the damage HUD 
+	 * To calculate view occlusion percent for the damage texture effect 
 	 */
 	UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category=Legumix, meta = (AllowPrivateAccess = true))
 	float HealthAtTheCurrentHitPeriodBeginning;
 
+	/**
+	 * Percent of the player screen occupied with damage texture effect to reach 
+	 */
+	UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category=Legumix, meta = (AllowPrivateAccess = true))
+	float NextPlayerViewOcclusionPercent;
+
+	/**
+	 * Previous percent of the player screen occupied with damage texture effect
+	 * mandatory to make interpolation between this core and the current one
+	 */
+	UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category=Legumix, meta = (AllowPrivateAccess = true))
+	float PlayerViewOcclusionPercent;
+	
+	/**
+	 * Percent of the player screen occupied with damage texture effect 
+	 */
+	UPROPERTY(VisibleAnywhere, BlueprintReadWrite, Category=Legumix, meta = (AllowPrivateAccess = true))
+	float AlphaLerpForPlayerViewOcclusionPercent;
+
+	/**
+	 * Actualize all parameters needed to calculate PlayerViewOcclusionPercent 
+	 */
+	UFUNCTION(BlueprintCallable, Category=PostProcess)
+	void SetDisplayDamageParameters(float Health, float Damage);
+		
+	/**
+	 * Determine Percent of the player screen occupied with damage texture effect 
+	 */
+	UFUNCTION(BlueprintCallable, Category=PostProcess)
+	void SetPlayerViewOcclusionPercent();
+
+
+
 private:
 #if WITH_EDITORONLY_DATA
 	/** If set, bullet debug will be drawn. */