PhysicalMaterials.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "Chaos/Core.h"
#include "Chaos/Defines.h"
#include "Chaos/Framework/Handles.h"
 
namespace Chaos
{
    using FMaterialArray = THandleArray<FChaosPhysicsMaterial>;
    using FChaosMaterialHandle = FMaterialArray::FHandle;
    using FChaosConstMaterialHandle = FMaterialArray::FConstHandle;
    using FMaterialMaskArray = THandleArray<FChaosPhysicsMaterialMask>;
    using FChaosMaterialMaskHandle = FMaterialMaskArray::FHandle;
    using FChaosConstMaterialMaskHandle = FMaterialMaskArray::FConstHandle;
 
    struct FMaterialHandle
    {
        // Get should be only called on the Game Thread, instead use GetInternal on Physics Thread
        CHAOS_API FChaosPhysicsMaterial* Get() const;
        CHAOS_API FChaosPhysicsMaterial* GetInternal(const THandleArray<FChaosPhysicsMaterial>* const SimMaterials) const;
        FChaosMaterialHandle InnerHandle;
 
        // IsValid should be only called on the Game Thread, instead use IsValidInternal on Physics Thread
        bool IsValid() const { return Get() != nullptr; }
        bool IsValidInternal(const THandleArray<FChaosPhysicsMaterial>* const SimMaterials) const { return GetInternal(SimMaterials) != nullptr; }
        void Reset() { InnerHandle = FChaosMaterialHandle(); }
 
        friend bool operator ==(const FMaterialHandle& A, const FMaterialHandle& B) { return A.InnerHandle == B.InnerHandle; }
 
        friend FArchive& operator <<(FArchive& Ar, FMaterialHandle& Value) { Ar << Value.InnerHandle; return Ar; }
    };
 
    struct FConstMaterialHandle
    {
        CHAOS_API const FChaosPhysicsMaterial* Get() const;
        FChaosConstMaterialHandle InnerHandle;
 
        bool IsValid() const { return Get() != nullptr; }
 
        friend bool operator ==(const FConstMaterialHandle& A, const FConstMaterialHandle& B) { return A.InnerHandle == B.InnerHandle; }
 
        friend FArchive& operator <<(FArchive& Ar, FConstMaterialHandle& Value) { Ar << Value.InnerHandle; return Ar; }
    };
 
    struct FMaterialMaskHandle
    {
        CHAOS_API FChaosPhysicsMaterialMask* Get() const;
        FChaosMaterialMaskHandle InnerHandle;
 
        bool IsValid() const { return Get() != nullptr; }
 
        friend bool operator ==(const FMaterialMaskHandle& A, const FMaterialMaskHandle& B) { return A.InnerHandle == B.InnerHandle; }
 
        friend FArchive& operator <<(FArchive& Ar, FMaterialMaskHandle& Value) { Ar << Value.InnerHandle; return Ar; }
    };
 
    struct FConstMaterialMaskHandle
    {
        CHAOS_API const FChaosPhysicsMaterialMask* Get() const;
        FChaosConstMaterialMaskHandle InnerHandle;
 
        bool IsValid() const { return Get() != nullptr; }
 
        friend bool operator ==(const FConstMaterialMaskHandle& A, const FConstMaterialMaskHandle& B) { return A.InnerHandle == B.InnerHandle; }
 
        friend FArchive& operator <<(FArchive& Ar, FConstMaterialMaskHandle& Value) { Ar << Value.InnerHandle; return Ar; }
    };
 
    DECLARE_MULTICAST_DELEGATE_OneParam(FOnMaterialCreated, FMaterialHandle);
    DECLARE_MULTICAST_DELEGATE_OneParam(FOnMaterialDestroyed, FMaterialHandle);
    DECLARE_MULTICAST_DELEGATE_OneParam(FOnMaterialUpdated, FMaterialHandle);
 
    DECLARE_MULTICAST_DELEGATE_OneParam(FOnMaterialMaskCreated, FMaterialMaskHandle);
    DECLARE_MULTICAST_DELEGATE_OneParam(FOnMaterialMaskDestroyed, FMaterialMaskHandle);
    DECLARE_MULTICAST_DELEGATE_OneParam(FOnMaterialMaskUpdated, FMaterialMaskHandle);
 
    using FMaterialCreatedDelegate = FOnMaterialCreated::FDelegate;
    using FMaterialDestroyedDelegate = FOnMaterialDestroyed::FDelegate;
    using FMaterialUpdatedDelegate = FOnMaterialUpdated::FDelegate;
 
    using FMaterialMaskCreatedDelegate = FOnMaterialMaskCreated::FDelegate;
    using FMaterialMaskDestroyedDelegate = FOnMaterialMaskDestroyed::FDelegate;
    using FMaterialMaskUpdatedDelegate = FOnMaterialMaskUpdated::FDelegate;
 
    class FPhysicalMaterialManager
    {
    public:
 
        static CHAOS_API FPhysicalMaterialManager& Get();
 
        CHAOS_API FMaterialHandle Create();
        CHAOS_API FMaterialMaskHandle CreateMask();
 
        CHAOS_API void Destroy(FMaterialHandle InHandle);
        CHAOS_API void Destroy(FMaterialMaskHandle InHandle);
 
        CHAOS_API FChaosPhysicsMaterial* Resolve(FChaosMaterialHandle InHandle) const;
        CHAOS_API const FChaosPhysicsMaterial* Resolve(FChaosConstMaterialHandle InHandle) const;
 
        CHAOS_API FChaosPhysicsMaterialMask* Resolve(FChaosMaterialMaskHandle InHandle) const;
        CHAOS_API const FChaosPhysicsMaterialMask* Resolve(FChaosConstMaterialMaskHandle InHandle) const;
 
        CHAOS_API void UpdateMaterial(FMaterialHandle InHandle);
        CHAOS_API void UpdateMaterialMask(FMaterialMaskHandle InHandle);
 
        UE_DEPRECATED(5.1, "GetMasterMaterials_External is deprecated, please use GetPrimaryMaterials_External instead")
        CHAOS_API const THandleArray<FChaosPhysicsMaterial>& GetMasterMaterials_External() const;
        UE_DEPRECATED(5.1, "GetMasterMaterialMasks_External is deprecated, please use GetPrimaryMaterialMasks_External instead")
        CHAOS_API const THandleArray<FChaosPhysicsMaterialMask>& GetMasterMaterialMasks_External() const;
 
        CHAOS_API const THandleArray<FChaosPhysicsMaterial>& GetPrimaryMaterials_External() const;
        CHAOS_API const THandleArray<FChaosPhysicsMaterialMask>& GetPrimaryMaterialMasks_External() const;
 
        FOnMaterialUpdated OnMaterialUpdated;
        FOnMaterialCreated OnMaterialCreated;
        FOnMaterialDestroyed OnMaterialDestroyed;
 
        FOnMaterialMaskUpdated OnMaterialMaskUpdated;
        FOnMaterialMaskCreated OnMaterialMaskCreated;
        FOnMaterialMaskDestroyed OnMaterialMaskDestroyed;
 
    private:
 
        static constexpr int32 InitialCapacity = 4;
 
        FPhysicalMaterialManager();
 
        THandleArray<FChaosPhysicsMaterial> Materials;
 
        THandleArray<FChaosPhysicsMaterialMask> MaterialMasks;
 
        mutable FRWLock MaterialsLock;
        mutable FRWLock MaterialMasksLock;
    };
}