PerSolverFieldSystem.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "Field/FieldSystem.h"
#include "Field/FieldSystemTypes.h"
#include "Chaos/PBDPositionConstraints.h"
#include "Chaos/Defines.h"
 
class FPerSolverFieldSystem
{
public:
 
    CHAOS_API void FieldParameterUpdateCallback(
        Chaos::FPBDRigidsSolver* InSolver, 
        Chaos::FPBDPositionConstraints& PositionTarget,
        TMap<int32, int32>& TargetedParticles);
 
    CHAOS_API void FieldForcesUpdateCallback(
        Chaos::FPBDRigidsSolver* RigidSolver);
 
    CHAOS_API void ComputeFieldRigidImpulse(const Chaos::FReal SolverTime);
 
    CHAOS_API void ComputeFieldLinearImpulse(const Chaos::FReal SolverTime);
 
    CHAOS_API void AddTransientCommand(const FFieldSystemCommand& FieldCommand);
 
    CHAOS_API void AddPersistentCommand(const FFieldSystemCommand& FieldCommand);
 
    CHAOS_API void RemoveTransientCommand(const FFieldSystemCommand& FieldCommand);
 
    CHAOS_API void RemovePersistentCommand(const FFieldSystemCommand& FieldCommand);
 
    TArray<FFieldSystemCommand>& GetTransientCommands() { return TransientCommands; }
 
    const TArray<FFieldSystemCommand>& GetTransientCommands() const { return TransientCommands; }
 
    TArray<FFieldSystemCommand>& GetPersistentCommands() { return PersistentCommands; }
 
    const TArray<FFieldSystemCommand>& GetPersistentCommands() const { return PersistentCommands; }
 
    static CHAOS_API void GetRelevantParticleHandles(
        TArray<Chaos::FGeometryParticleHandle*>& ParticleHandles,
        const Chaos::FPBDRigidsSolver* RigidSolver,
        const EFieldResolutionType ResolutionType);
 
    static CHAOS_API void GetFilteredParticleHandles(
        TArray<Chaos::FGeometryParticleHandle*>& ParticleHandles,
        const Chaos::FPBDRigidsSolver* RigidSolver,
        const EFieldFilterType FilterType,
        const EFieldObjectType ObjectType);
 
    bool IsEmpty() const { return (TransientCommands.Num() == 0) && (PersistentCommands.Num() == 0); }
 
    const TArray<FVector>& GetSamplePositions() const { return ExecutionDatas.SamplePositions; }
 
    TArray<FVector>& GetSamplePositions() { return ExecutionDatas.SamplePositions; }
 
    const TArray<FFieldContextIndex>& GetSampleIndices() const { return ExecutionDatas.SampleIndices; }
 
    TArray<FFieldContextIndex>& GetSampleIndices() { return ExecutionDatas.SampleIndices; }
 
    TArray<FVector>& GetOutputResults(const EFieldCommandOutputType OutputType) { return ExecutionDatas.FieldOutputs[(uint8)OutputType]; }
 
    const TArray<FVector>& GetOutputResults(const EFieldCommandOutputType OutputType) const { return ExecutionDatas.FieldOutputs[(uint8)OutputType]; }
 
private:
 
    CHAOS_API void FieldForcesUpdateInternal(
        Chaos::FPBDRigidsSolver* RigidSolver,
        TArray<FFieldSystemCommand>& Commands, 
        const bool IsTransient);
 
    CHAOS_API void FieldParameterUpdateInternal(
        Chaos::FPBDRigidsSolver* RigidSolver,
        Chaos::FPBDPositionConstraints& PositionTarget,
        TMap<int32, int32>& PositionTargetedParticles,
        TArray<FFieldSystemCommand>& Commands, 
        const bool IsTransient);
 
    FFieldExecutionDatas ExecutionDatas;
 
    TArray<FFieldSystemCommand> TransientCommands;
 
    TArray<FFieldSystemCommand> PersistentCommands;
};