DatasmithUtils.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
#pragma once
 
#include "Containers/Array.h"
#include "Containers/ContainerAllocationPolicies.h"
#include "Containers/Map.h"
#include "Containers/Set.h"
#include "Containers/UnrealString.h"
#include "DatasmithDefinitions.h"
#include "HAL/CriticalSection.h"
#include "HAL/PlatformCrt.h"
#include "Math/Matrix.h"
#include "Math/Transform.h"
#include "Math/UnrealMathSSE.h"
#include "Math/Vector.h"
#include "Misc/EnumClassFlags.h"
#include "Templates/SharedPointer.h"
 
#include <stdint.h>
 
#define UE_API DATASMITHCORE_API
 
class FDatasmithMesh;
class IDatasmithActorElement;
class IDatasmithScene;
struct FMeshDescription;
struct FRawMesh;
 
class FDatasmithUtils
{
public:
    static UE_API void SanitizeNameInplace(FString& InString);
    static UE_API FString SanitizeName(FString InString);
    static UE_API FString SanitizeObjectName(FString InString);
    static UE_API FString SanitizeFileName(FString InString);
 
    static UE_API void SanitizeStringInplace(FString& InString);
 
    static UE_API int32 GetEnterpriseVersionAsInt();
    static UE_API FString GetEnterpriseVersionAsString(bool bWithChangelist=false);
 
    static UE_API float GetDatasmithFormatVersionAsFloat();
    static UE_API int32 GetDatasmithFormatVersionAsInt();
    static UE_API FString GetDatasmithFormatVersionAsString();
 
    static UE_API const TCHAR* GetFileExtension();
 
    static UE_API void GetCleanFilenameAndExtension(const FString& InFilePath, FString& OutFilename, FString& OutExtension);
 
    static UE_API const TCHAR* GetLongAppName();
    static UE_API const TCHAR* GetShortAppName();
 
    static UE_API float AreaTriangle3D(const FVector3f& v0, const FVector3f& v1, const FVector3f& v2);
 
    enum class EModelCoordSystem : uint8
    {
        ZUp_LeftHanded,
        ZUp_RightHanded,
        YUp_LeftHanded,
        YUp_RightHanded,
        ZUp_RightHanded_FBXLegacy,
    };
 
    template<typename VecType>
    static void ConvertVectorArray(EModelCoordSystem ModelCoordSys, TArray<VecType>& Array)
    {
        switch (ModelCoordSys)
        {
        case EModelCoordSystem::YUp_LeftHanded:
            for (VecType& Vector : Array)
            {
                Vector.Set(Vector[2], Vector[0], Vector[1]);
            }
            break;
 
        case EModelCoordSystem::YUp_RightHanded:
            for (VecType& Vector : Array)
            {
                Vector.Set(-Vector[2], Vector[0], Vector[1]);
            }
            break;
 
        case EModelCoordSystem::ZUp_RightHanded:
            for (VecType& Vector : Array)
            {
                Vector.Set(-Vector[0], Vector[1], Vector[2]);
            }
            break;
 
        case EModelCoordSystem::ZUp_RightHanded_FBXLegacy:
            for (VecType& Vector : Array)
            {
                Vector.Set(Vector[0], -Vector[1], Vector[2]);
            }
            break;
 
        case EModelCoordSystem::ZUp_LeftHanded:
        default:
            break;
        }
    }
 
    template<typename VecType>
    static VecType ConvertVector(EModelCoordSystem ModelCoordSys, const VecType& V)
    {
        switch (ModelCoordSys)
        {
        case EModelCoordSystem::YUp_LeftHanded:
            return VecType(V[2], V[0], V[1]);
 
        case EModelCoordSystem::YUp_RightHanded:
            return VecType(-V[2], V[0], V[1]);
 
        case EModelCoordSystem::ZUp_RightHanded:
            return VecType(-V[0], V[1], V[2]);
 
        case EModelCoordSystem::ZUp_RightHanded_FBXLegacy:
            return VecType(V[0], -V[1], V[2]);
 
        case EModelCoordSystem::ZUp_LeftHanded:
        default:
            return VecType(V[0], V[1], V[2]);
        }
    }
 
    UE_API FTransform static ConvertTransform(EModelCoordSystem SourceCoordSystem, const FTransform& LocalTransform);
 
    template<typename Type>
    static UE::Math::TMatrix<Type> GetSymmetricMatrix(const UE::Math::TVector<Type>& Origin, const UE::Math::TVector<Type>& Normal)
    {
        using namespace UE::Math;
        //Calculate symmetry matrix
        //(Px, Py, Pz) = normal
        // -Px*Px + Pz*Pz + Py*Py  |  - 2 * Px * Py           |  - 2 * Px * Pz
        // - 2 * Py * Px           |  - Py*Py + Px*Px + Pz*Pz |  - 2 * Py * Pz
        // - 2 * Pz * Px           |  - 2 * Pz * Py           |  - Pz*Pz + Py*Py + Px*Px
 
        TVector<Type> LocOrigin = Origin;
 
        Type NormalXSqr = Normal.X * Normal.X;
        Type NormalYSqr = Normal.Y * Normal.Y;
        Type NormalZSqr = Normal.Z * Normal.Z;
 
        TMatrix<Type> OSymmetricMatrix;
        OSymmetricMatrix.SetIdentity();
        TVector<Type> Axis0(-NormalXSqr + NormalZSqr + NormalYSqr, -2 * Normal.X * Normal.Y, -2 * Normal.X * Normal.Z);
        TVector<Type> Axis1(-2 * Normal.Y * Normal.X, -NormalYSqr + NormalXSqr + NormalZSqr, -2 * Normal.Y * Normal.Z);
        TVector<Type> Axis2(-2 * Normal.Z * Normal.X, -2 * Normal.Z * Normal.Y, -NormalZSqr + NormalYSqr + NormalXSqr);
        OSymmetricMatrix.SetAxes(&Axis0, &Axis1, &Axis2);
 
        TMatrix<Type> SymmetricMatrix;
        SymmetricMatrix.SetIdentity();
 
        //Translate to 0, 0, 0
        LocOrigin *= -1.;
        SymmetricMatrix.SetOrigin(LocOrigin);
 
        SymmetricMatrix *= OSymmetricMatrix;
 
        //Translate to original position
        LocOrigin *= -1.;
        TMatrix<Type> OrigTranslation;
        OrigTranslation.SetIdentity();
        OrigTranslation.SetOrigin(LocOrigin);
        SymmetricMatrix *= OrigTranslation;
 
        return SymmetricMatrix;
    }
};
 
class FDatasmithMeshUtils
{
    static bool ToRawMesh(const FDatasmithMesh& Mesh, FRawMesh& RawMesh, bool bValidateRawMesh = true);
 
public:
    enum EUvGenerationPolicy
    {
        Ignore, // do not generate a default UV. Conversion fails when no UV is available
        GenerateBox, // generate a Box UV mapping on the resulting MeshDescription (see also FStaticMeshOperations::GenerateBoxUV)
    };
    static UE_API bool ToMeshDescription(FDatasmithMesh& DsMesh, FMeshDescription& MeshDescription, EUvGenerationPolicy UvGen=EUvGenerationPolicy::Ignore);
 
    static UE_API bool IsUVChannelValid(const FDatasmithMesh& DsMesh, const int32 Channel);
 
    static UE_API void CreateDefaultUVsWithLOD(FDatasmithMesh& Mesh);
 
    static UE_API void ExtractVertexPositions(const FMeshDescription& Mesh, TArray<FVector3f>& OutPositions);
};
 
enum class EDSTextureUtilsError : int32
{
    NoError = 0,
    FileNotFound = -1,
    InvalidFileType = -2,
    FileReadIssue = -3,
    InvalidData = -4,
    FreeImageNotFound = -5,
    FileNotSaved = -6,
    ResizeFailed = -7,
};
 
enum class EDSResizeTextureMode
{
    NoResize,
    NearestPowerOfTwo,
    PreviousPowerOfTwo,
    NextPowerOfTwo
};
 
class FDatasmithTextureUtils
{
public:
    static UE_API bool CalculateTextureHash(const TSharedPtr<class IDatasmithTextureElement>& TextureElement);
    static UE_API void CalculateTextureHashes(const TSharedPtr<class IDatasmithScene>& Scene);
};
 
enum class ETransformChannelComponents : uint8
{
    None = 0x00,
    X    = 0x01,
    Y    = 0x02,
    Z    = 0x04,
    All  = X | Y | Z,
};
ENUM_CLASS_FLAGS(ETransformChannelComponents);
 
class FDatasmithAnimationUtils
{
public:
    static UE_API ETransformChannelComponents GetChannelTypeComponents(EDatasmithTransformChannels Channels, EDatasmithTransformType TransformType);
 
    static UE_API EDatasmithTransformChannels SetChannelTypeComponents(ETransformChannelComponents Components, EDatasmithTransformType TransformType);
};
 
class FDatasmithSceneUtils
{
public:
    static UE_API TArray<TSharedPtr<class IDatasmithCameraActorElement>> GetAllCameraActorsFromScene(const TSharedPtr<class IDatasmithScene>& Scene);
    static UE_API TArray<TSharedPtr<class IDatasmithLightActorElement>> GetAllLightActorsFromScene(const TSharedPtr<class IDatasmithScene>& Scene);
    static UE_API TArray<TSharedPtr<class IDatasmithMeshActorElement>> GetAllMeshActorsFromScene(const TSharedPtr<class IDatasmithScene>& Scene);
    static UE_API TArray<TSharedPtr<class IDatasmithCustomActorElement>> GetAllCustomActorsFromScene(const TSharedPtr<class IDatasmithScene>& Scene);
 
    using TActorHierarchy = TArray<TSharedPtr<class IDatasmithActorElement>, TInlineAllocator<8>>;
    static UE_API bool FindActorHierarchy(const IDatasmithScene* Scene, const TSharedPtr<IDatasmithActorElement>& ToFind, TActorHierarchy& OutHierarchy);
 
    static UE_API bool IsMaterialIDUsedInScene(const TSharedPtr<class IDatasmithScene>& Scene, const TSharedPtr<class IDatasmithMaterialIDElement>& MaterialElement);
    static UE_API bool IsPostProcessUsedInScene(const TSharedPtr<class IDatasmithScene>& Scene, const TSharedPtr<class IDatasmithPostProcessElement>& PostProcessElement);
 
    static UE_API void CleanUpScene(TSharedRef<class IDatasmithScene> Scene, bool bRemoveUnused = false);
};
 
class FDatasmithUniqueNameProviderBase
{
public:
    FDatasmithUniqueNameProviderBase() = default;
    UE_API FDatasmithUniqueNameProviderBase(const FDatasmithUniqueNameProviderBase& Other);
    UE_API FDatasmithUniqueNameProviderBase(FDatasmithUniqueNameProviderBase&& Other);
 
    virtual ~FDatasmithUniqueNameProviderBase() = default;
 
    UE_API FDatasmithUniqueNameProviderBase* operator=(const FDatasmithUniqueNameProviderBase& Other);
    UE_API FDatasmithUniqueNameProviderBase* operator=(FDatasmithUniqueNameProviderBase&& Other);
 
    UE_API FString GenerateUniqueName(const FString& BaseName, int32 CharBudget=INT32_MAX);
 
    virtual void AddExistingName(const FString& Name) = 0;
 
    virtual void RemoveExistingName(const FString& Name) = 0;
 
    UE_API virtual void Clear();
 
protected:
 
    virtual bool Contains(const FString& Name) = 0;
 
private:
    TMap<FString, int32> FrequentlyUsedNames;
    mutable FCriticalSection CriticalSection;
};
 
class FDatasmithUniqueNameProvider : public FDatasmithUniqueNameProviderBase
{
public:
    using Super = FDatasmithUniqueNameProviderBase;
 
    void Reserve( int32 NumberOfName ) { KnownNames.Reserve(NumberOfName); }
 
    virtual void AddExistingName(const FString& Name) override { KnownNames.Add(Name); }
    virtual void RemoveExistingName(const FString& Name) override { KnownNames.Remove(Name); }
 
    virtual void Clear() override { Super::Clear(); KnownNames.Empty(); }
 
protected:
    virtual bool Contains(const FString& Name) override { return KnownNames.Contains(Name); }
 
private:
    TSet<FString> KnownNames;
};
 
#undef UE_API