MorphTarget.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "UObject/Object.h"
#include "PackedNormal.h"
#include "Rendering/MorphTargetVertexCodec.h"
#include "Serialization/MemoryArchive.h"
 
#include "MorphTarget.generated.h"
 
class USkeletalMesh;
class UStaticMesh;
 
struct FMorphTargetDelta
{
    FVector3f           PositionDelta = FVector3f::ZeroVector;
 
    FVector3f           TangentZDelta = FVector3f::ZeroVector;
 
    uint32          SourceIdx = std::numeric_limits<uint32>::max();
 
    friend FArchive& operator<<(FArchive& Ar, FMorphTargetDelta& V)
    {
        if ((Ar.UEVer() < VER_UE4_MORPHTARGET_CPU_TANGENTZDELTA_FORMATCHANGE) && Ar.IsLoading())
        {
            FDeprecatedSerializedPackedNormal TangentZDelta_DEPRECATED;
            Ar << V.PositionDelta << TangentZDelta_DEPRECATED << V.SourceIdx;
            V.TangentZDelta = TangentZDelta_DEPRECATED;
        }
        else
        {
            Ar << V.PositionDelta << V.TangentZDelta << V.SourceIdx;
        }
        return Ar;
    }
};
 
#if !WITH_EDITOR
struct FMorphTargetCompressedLODModel
{
    TArray<UE::MorphTargetVertexCodec::FDeltaBatchHeader> PackedDeltaHeaders;
    TArray<uint32> PackedDeltaData;
    float PositionPrecision = 0.0f;
    float TangentPrecision = 0.0f;
};
#endif
 
 
class FMorphTargetDeltaIterator
{
public:
    FMorphTargetDeltaIterator() = default;
    FMorphTargetDeltaIterator(const FMorphTargetDeltaIterator&) = default;
    FMorphTargetDeltaIterator(FMorphTargetDeltaIterator&&) = default;
    FMorphTargetDeltaIterator& operator=(const FMorphTargetDeltaIterator&) = default;
 
    // Support the minimal functionality required for a ranged-for.
    [[nodiscard]] const FMorphTargetDelta& operator*() const 
    {
        return CurrentDelta;
    }
    
    [[nodiscard]] const FMorphTargetDelta* operator->() const
    {
        return &CurrentDelta;
    }
    
    FMorphTargetDeltaIterator& operator++()
    {
        Advance();
        return *this;
    }
 
    [[nodiscard]] bool AtEnd() const
    {
        return Token == InvalidToken;
    }
    
private:
    static constexpr uint64 InvalidToken = std::numeric_limits<uint64>::max(); 
    friend class UMorphTarget;
 
    FMorphTargetDeltaIterator(
        TConstArrayView<FMorphTargetDelta> InRawDeltas
        ) :
        Token(0),
        RawDeltas(InRawDeltas)
    {
        Advance();
    }
#if !WITH_EDITOR
    FMorphTargetDeltaIterator(
        const FMorphTargetCompressedLODModel& InCompressedDeltas 
        ) :
        Token(0),
        CompressedDelta(&InCompressedDeltas)
    {
        if (!InCompressedDeltas.PackedDeltaHeaders.IsEmpty() && !InCompressedDeltas.PackedDeltaData.IsEmpty())
        {
            Advance();
        }
        else
        {
            Clear();
        }
    }
#endif
    
    void Advance()
    {
        if (!RawDeltas.IsEmpty())
        {
            if (Token < RawDeltas.Num())
            {
                CurrentDelta = RawDeltas[static_cast<int32>(Token++)];
            }
            else
            {
                Clear();
            }
        }
#if !WITH_EDITOR
        else if (!CompressedDelta || !IterativeDecode(Token, CompressedDelta->PackedDeltaHeaders, CompressedDelta->PackedDeltaData, CompressedDelta->PositionPrecision, CompressedDelta->TangentPrecision, CurrentDelta))
        {
            // If the decode failed, we're either at the end, or the data is invalid. Stop any further decoding.
            Clear();
        }
#endif
    }
 
    void Clear()
    {
        Token = InvalidToken;
        RawDeltas = {};
#if !WITH_EDITOR
        CompressedDelta = nullptr;
#endif
    }
 
    uint64 Token = InvalidToken;
    TConstArrayView<FMorphTargetDelta> RawDeltas;
#if !WITH_EDITOR
    const FMorphTargetCompressedLODModel* CompressedDelta = nullptr;
#endif
    FMorphTargetDelta CurrentDelta;
};
 
 
struct FMorphTargetLODModel
{
    TArray<FMorphTargetDelta> Vertices;
 
    int32 NumVertices = 0;
 
    int32 NumBaseMeshVerts = 0;
    
    TArray<int32> SectionIndices;
 
    bool bGeneratedByEngine = false;
 
    FString SourceFilename;
    
    FMorphTargetLODModel() = default;
 
    friend FArchive& operator<<(FArchive& Ar, FMorphTargetLODModel& M);
 
    void Reset()
    {
        Vertices.Reset();
        NumVertices = 0;
        NumBaseMeshVerts = 0;
        SectionIndices.Reset();
        // since engine cleared it, we mark as engine generated
        // this makes it clear to clear up later
        bGeneratedByEngine = true;
        SourceFilename.Empty();
    }
};
 
 
#if WITH_EDITOR
struct FFinishBuildMorphTargetData
{
public:
    virtual ~FFinishBuildMorphTargetData()
    {}
    
    ENGINE_API virtual void LoadFromMemoryArchive(FMemoryArchive & Ar);
    
    ENGINE_API virtual void ApplyEditorData(USkeletalMesh * SkeletalMesh, bool bIsSerializeSaving) const;
    
protected:
    bool bApplyMorphTargetsData = false;
    TMap<FName, TArray<FMorphTargetLODModel>> MorphLODModelsPerTargetName;
    };
#endif
 
UCLASS(hidecategories=Object, MinimalAPI)
class UMorphTarget
    : public UObject
{
    GENERATED_UCLASS_BODY()
 
public:
 
    UPROPERTY(AssetRegistrySearchable)
    TObjectPtr<class USkeletalMesh> BaseSkelMesh;
 
    virtual const TArray<FMorphTargetLODModel>& GetMorphLODModels() const { return MorphLODModels; }
 
    virtual TArray<FMorphTargetLODModel>& GetMorphLODModels() { return MorphLODModels; }
 
protected:
    TArray<FMorphTargetLODModel>    MorphLODModels;
#if !WITH_EDITOR
    TArray<FMorphTargetCompressedLODModel> CompressedLODModels;
#endif
    
public:
 
#if WITH_EDITOR
    UE_DEPRECATED(5.7, "Use the TConstArrayView version of GetMorphTargetDelta instead.")
    ENGINE_API virtual const FMorphTargetDelta* GetMorphTargetDelta(int32 LODIndex, int32& OutNumDeltas) const;
 
    ENGINE_API virtual TConstArrayView<FMorphTargetDelta> GetMorphTargetDeltas(int32 LODIndex) const;
    
#endif
 
    ENGINE_API virtual FMorphTargetDeltaIterator GetDeltaIteratorForLOD(int32 LODIndex) const;
 
    ENGINE_API virtual int32 GetNumDeltasForLOD(int32 LODIndex) const;
    
    ENGINE_API virtual bool HasDataForLOD(int32 LODIndex) const;
    
    ENGINE_API virtual bool HasDataForSection(int32 LODIndex, int32 SectionIndex) const;
    
    ENGINE_API virtual bool HasValidData() const;
    ENGINE_API virtual void EmptyMorphLODModels();
 
    ENGINE_API virtual bool IsCustomImported(int32 LODIndex) const;
    ENGINE_API virtual const FString& GetCustomImportedSourceFilename(int32 LODIndex) const;
    ENGINE_API virtual void SetCustomImportedSourceFilename(int32 LODIndex, const FString& InSourceFilename);
 
    ENGINE_API virtual bool IsGeneratedByEngine(int32 LODIndex) const;
    ENGINE_API virtual void SetGeneratedByEngine(int32 LODIndex, bool bInGeneratedByEngine);
 
    virtual bool UsesBuiltinMorphTargetCompression() const { return true; }
 
#if WITH_EDITOR
    ENGINE_API virtual void PopulateDeltas(const TArray<FMorphTargetDelta>& Deltas, const int32 LODIndex, const TArray<struct FSkelMeshSection>& Sections, const bool bCompareNormal = false, const bool bGeneratedByReductionSetting = false, const float PositionThreshold = UE_THRESH_POINTS_ARE_NEAR);
    ENGINE_API virtual void RemoveEmptyMorphTargets();
    ENGINE_API virtual TUniquePtr<FFinishBuildMorphTargetData> CreateFinishBuildMorphTargetData() const;
#endif // WITH_EDITOR
 
    //~ UObject interface
 
    ENGINE_API virtual void Serialize(FArchive& Ar) override;
#if WITH_EDITORONLY_DATA
    ENGINE_API static void DeclareCustomVersions(FArchive& Ar, const UClass* SpecificSubclass);
#endif
    ENGINE_API virtual void PostLoad() override;
 
    ENGINE_API virtual void SerializeMemoryArchive(FMemoryArchive& Ar);
};