ParticleModuleParameterDynamic.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreMinimal.h"
#include "UObject/ObjectMacros.h"
#include "Particles/ParticleModule.h"
#include "Distributions/DistributionFloatConstant.h"
#include "Particles/Parameter/ParticleModuleParameterBase.h"
#include "ParticleEmitterInstances.h"
#include "Particles/ParticleSystemComponent.h"
#include "ParticleModuleParameterDynamic.generated.h"
 
class UInterpCurveEdSetup;
class UParticleEmitter;
class UParticleLODLevel;
class UParticleModuleTypeDataBase;
 
UENUM()
enum EEmitterDynamicParameterValue : int
{
    EDPV_UserSet,
    EDPV_AutoSet,
    EDPV_VelocityX,
    EDPV_VelocityY,
    EDPV_VelocityZ,
    EDPV_VelocityMag,
    EDPV_MAX,
};
 
USTRUCT()
struct FEmitterDynamicParameter
{
    GENERATED_USTRUCT_BODY()
 
    
    UPROPERTY(Category=EmitterDynamicParameter, VisibleAnywhere)
    FName ParamName;
 
    UPROPERTY(EditAnywhere, Category=EmitterDynamicParameter)
    uint32 bUseEmitterTime:1;
 
    UPROPERTY(EditAnywhere, Category=EmitterDynamicParameter)
    uint32 bSpawnTimeOnly:1;
 
    UPROPERTY(EditAnywhere, Category=EmitterDynamicParameter)
    TEnumAsByte<enum EEmitterDynamicParameterValue> ValueMethod;
 
    UPROPERTY(EditAnywhere, Category=EmitterDynamicParameter)
    uint32 bScaleVelocityByParamValue:1;
 
    UPROPERTY(EditAnywhere, Category=EmitterDynamicParameter)
    struct FRawDistributionFloat ParamValue;
 
 
    FEmitterDynamicParameter()
        : bUseEmitterTime(false)
        , bSpawnTimeOnly(false)
        , ValueMethod(0)
        , bScaleVelocityByParamValue(false)
    {
    }
    FEmitterDynamicParameter(FName InParamName, uint32 InUseEmitterTime, TEnumAsByte<enum EEmitterDynamicParameterValue> InValueMethod, UDistributionFloatConstant* InDistribution)
        : ParamName(InParamName)
        , bUseEmitterTime(InUseEmitterTime)
        , bSpawnTimeOnly(false)
        , ValueMethod(InValueMethod)
        , bScaleVelocityByParamValue(false)
    {
        ParamValue.Distribution = InDistribution;
    }
 
};
 
UCLASS(editinlinenew, hidecategories=Object, MinimalAPI, meta=(DisplayName = "Dynamic"))
class UParticleModuleParameterDynamic : public UParticleModuleParameterBase
{
    GENERATED_UCLASS_BODY()
 
    
    UPROPERTY(EditAnywhere, editfixedsize, Category=ParticleModuleParameterDynamic)
    TArray<struct FEmitterDynamicParameter> DynamicParams;
 
    UPROPERTY()
    int32 UpdateFlags;
 
    UPROPERTY()
    uint32 bUsesVelocity:1;
 
    void InitializeDefaults();
 
    //Begin UObject Interface
    virtual void    PostLoad() override;
#if WITH_EDITOR
    virtual void    PostEditChangeProperty(FPropertyChangedEvent& PropertyChangedEvent) override;
#endif // WITH_EDITOR
    virtual void    PostInitProperties() override;
    //~ Begin UObject Interface
 
    //~ Begin UParticleModule Interface
    virtual void    Spawn(const FSpawnContext& Context) override;
    virtual void    Update(const FUpdateContext& Context) override;
    virtual uint32  RequiredBytes(UParticleModuleTypeDataBase* TypeData) override;
    virtual void SetToSensibleDefaults(UParticleEmitter* Owner) override;
    virtual void    GetCurveObjects(TArray<FParticleCurvePair>& OutCurves) override;
    virtual bool WillGeneratedModuleBeIdentical(UParticleLODLevel* SourceLODLevel, UParticleLODLevel* DestLODLevel, float Percentage) override
    {
        // The assumption is that at 100%, ANY module will be identical...
        // (Although this is virtual to allow over-riding that assumption on a case-by-case basis!)
        return true;
    }
    virtual void GetParticleSysParamsUtilized(TArray<FString>& ParticleSysParamList) override;
    virtual void GetParticleParametersUtilized(TArray<FString>& ParticleParameterList) override;
    virtual void RefreshModule(UInterpCurveEdSetup* EdSetup, UParticleEmitter* InEmitter, int32 InLODLevel) override;
    //~ End UParticleModule Interface
 
    void SpawnEx(const FSpawnContext& Context, struct FRandomStream* InRandomStream);
    
    virtual void UpdateParameterNames(UMaterialInterface* InMaterialInterface);
 
    
    inline float GetParameterValue(const FContext& Context, FEmitterDynamicParameter& InDynParams, FBaseParticle& Particle, FParticleEmitterInstance* Owner, struct FRandomStream* InRandomStream)
    {
        float ScaleValue = 1.0f;
        float DistributionValue = 1.0f;
        switch (InDynParams.ValueMethod)
        {
        case EDPV_VelocityX:
            ScaleValue = Particle.Velocity.X;
            break;
        case EDPV_VelocityY:
            ScaleValue = Particle.Velocity.Y;
            break;
        case EDPV_VelocityZ:
            ScaleValue = Particle.Velocity.Z;
            break;
        case EDPV_VelocityMag:
            ScaleValue = Particle.Velocity.Size();
            break;
        default:
            //case EDPV_UserSet:
            //case EDPV_AutoSet:
            break;
        }
 
        if ((InDynParams.bScaleVelocityByParamValue == true) || (InDynParams.ValueMethod == EDPV_UserSet))
        {
            float TimeValue = InDynParams.bUseEmitterTime ? Owner->EmitterTime : Particle.RelativeTime;
            DistributionValue = InDynParams.ParamValue.GetValue(TimeValue, Context.GetDistributionData(), InRandomStream);
        }
 
        return DistributionValue * ScaleValue;
    }
 
    inline float GetParameterValue_UserSet(const FContext& Context, FEmitterDynamicParameter& InDynParams, FBaseParticle& Particle, FParticleEmitterInstance* Owner, struct FRandomStream* InRandomStream)
    {
        return InDynParams.ParamValue.GetValue(InDynParams.bUseEmitterTime ? Owner->EmitterTime : Particle.RelativeTime, Context.GetDistributionData(), InRandomStream);
    }
 
    virtual void UpdateUsageFlags();
 
    virtual bool CanTickInAnyThread() override;
};