SkinWeightVertexBuffer.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "RenderResource.h"
#include "StaticMeshVertexData.h"
#include "GPUSkinPublicDefs.h"
#include "SkeletalMeshTypes.h"
#include "GPUSkinVertexFactory.h"
#include "UObject/AnimObjectVersion.h"
 
class FStaticMeshVertexDataInterface;
struct FSoftSkinVertex;
 
typedef uint8 FBoneIndex8;
typedef uint16 FBoneIndex16;
 
template <bool bExtraBoneInfluences, typename BoneIndexType>
struct TLegacySkinWeightInfo
{
    enum
    {
        NumInfluences = bExtraBoneInfluences ? EXTRA_BONE_INFLUENCES : MAX_INFLUENCES_PER_STREAM,
    };
    BoneIndexType   InfluenceBones[NumInfluences];
    uint8           InfluenceWeights[NumInfluences];
 
    friend FArchive& operator<<(FArchive& Ar, TLegacySkinWeightInfo& I)
    {
        Ar.UsingCustomVersion(FAnimObjectVersion::GUID);
        // serialize bone index and weight arrays in order
        // this is required when serializing as bulk data memory (see TArray::BulkSerialize notes)
        for (uint32 InfluenceIndex = 0; InfluenceIndex < NumInfluences; InfluenceIndex++)
        {
            if (Ar.IsLoading() && Ar.CustomVer(FAnimObjectVersion::GUID) < FAnimObjectVersion::IncreaseBoneIndexLimitPerChunk)
            {
                // Older versions use uint8 bone indices
                uint8 BoneIndex = 0;
                Ar << BoneIndex;
                I.InfluenceBones[InfluenceIndex] = BoneIndex;
            }
            else
            {
                Ar << I.InfluenceBones[InfluenceIndex];
            }
        }
 
        for (uint32 InfluenceIndex = 0; InfluenceIndex < NumInfluences; InfluenceIndex++)
        {
            Ar << I.InfluenceWeights[InfluenceIndex];
        }
 
        return Ar;
    }
};
 
struct FSkinWeightInfo
{
    FBoneIndexType  InfluenceBones[MAX_TOTAL_INFLUENCES];
    uint16          InfluenceWeights[MAX_TOTAL_INFLUENCES];
};
 
struct FSkinWeightRHIInfo
{
    FBufferRHIRef DataVertexBufferRHI;
    FBufferRHIRef LookupVertexBufferRHI;
};
 
class FSkinWeightLookupVertexBuffer : public FVertexBuffer
{
public:
    ENGINE_API FSkinWeightLookupVertexBuffer();
 
    ENGINE_API FSkinWeightLookupVertexBuffer(const FSkinWeightLookupVertexBuffer& Other);
 
    ENGINE_API ~FSkinWeightLookupVertexBuffer();
 
    ENGINE_API FSkinWeightLookupVertexBuffer& operator=(const FSkinWeightLookupVertexBuffer& Other);
 
    ENGINE_API void CleanUp();
 
    bool IsLookupDataValid() const;
 
    const uint8* GetLookupData() const
    {
        return Data;
    }
 
    uint8* GetLookupData()
    {
        return Data;
    }
 
    void Init(uint32 InNumVertices);
 
    friend FArchive& operator<<(FArchive& Ar, FSkinWeightLookupVertexBuffer& VertexBuffer);
 
    void SerializeMetaData(FArchive& Ar);
    ENGINE_API void SetMetaData(uint32 InNumVertices);
    void CopyMetaData(const FSkinWeightLookupVertexBuffer& Other);
 
    // FRenderResource interface.
    virtual void InitRHI(FRHICommandListBase& RHICmdList) override;
    virtual void ReleaseRHI() override;
 
    virtual FString GetFriendlyName() const override
    { return TEXT("SkeletalMesh Vertex Weights Lookup"); }
 
    inline uint32 GetNumVertices() const
    { return NumVertices; }
 
    inline uint32 GetStride() const
    { return sizeof(uint32); }
 
    inline uint32 GetVertexDataSize() const
    { return NumVertices * GetStride(); }
 
    // @param guaranteed only to be valid if the vertex buffer is valid
    FRHIShaderResourceView* GetSRV() const
    { return SRVValue; }
 
    void SetNeedsCPUAccess(bool bInNeedsCPUAccess)
    { bNeedsCPUAccess = bInNeedsCPUAccess; }
 
    bool GetNeedsCPUAccess() const
    { return bNeedsCPUAccess; }
 
    FBufferRHIRef CreateRHIBuffer(FRHICommandListBase& RHICmdList);
 
    void InitRHIForStreaming(FRHIBuffer* IntermediateBuffer, FRHIResourceReplaceBatcher& Batcher);
    void ReleaseRHIForStreaming(FRHIResourceReplaceBatcher& Batcher);
 
    void GetWeightOffsetAndInfluenceCount(uint32 VertexIndex, uint32& OutWeightOffset, uint32& OutInfluenceCount) const;
    void SetWeightOffsetAndInfluenceCount(uint32 VertexIndex, uint32 WeightOffset, uint32 InfluenceCount);
 
protected:
    // guaranteed only to be valid if the vertex buffer is valid
    FShaderResourceViewRHIRef SRVValue;
 
private:
    void ResizeBuffer(uint32 InNumVertices);
 
    ENGINE_API void AllocateData();
 
    bool bNeedsCPUAccess;
 
    FStaticMeshVertexDataInterface* LookupData;
 
    uint8* Data;
 
    uint32 NumVertices;
 
    static const EPixelFormat PixelFormat = PF_R32_UINT;
    static const uint32 PixelFormatStride = 4;
};
 
template<typename VertexDataType>
class FSkinWeightVertexData : public TStaticMeshVertexData<VertexDataType>
{
public:
    FSkinWeightVertexData(bool InNeedsCPUAccess = false)
        : TStaticMeshVertexData<VertexDataType>(InNeedsCPUAccess)
    {
    }
};
 
class FSkinWeightDataVertexBuffer : public FVertexBuffer
{
public:
    ENGINE_API FSkinWeightDataVertexBuffer();
 
    ENGINE_API FSkinWeightDataVertexBuffer(const FSkinWeightDataVertexBuffer& Other);
 
    ENGINE_API ~FSkinWeightDataVertexBuffer();
 
    ENGINE_API FSkinWeightDataVertexBuffer& operator=(const FSkinWeightDataVertexBuffer& Other);
 
    ENGINE_API void CleanUp();
 
    ENGINE_API void Init(uint32 InNumWeights, uint32 InNumVertices);
 
    friend FArchive& operator<<(FArchive& Ar, FSkinWeightDataVertexBuffer& VertexBuffer);
 
    void SerializeMetaData(FArchive& Ar);
    ENGINE_API void SetMetaData(uint32 InNumVertices, uint32 InMaxBoneInfluences, bool bInUse16BitBoneIndex, bool bInUse16BitBoneWeight);
    void CopyMetaData(const FSkinWeightDataVertexBuffer& Other);
 
    // FRenderResource interface.
    ENGINE_API virtual void InitRHI(FRHICommandListBase& RHICmdList) override;
    ENGINE_API virtual void ReleaseRHI() override;
 
    virtual FString GetFriendlyName() const override 
    { return TEXT("SkeletalMesh Vertex Weights Data"); }
 
    inline uint32 GetNumVertices() const
    { return NumVertices; }
 
    inline uint32 GetNumBoneWeights() const
    { return NumBoneWeights; }
 
    inline uint32 GetBoneIndexByteSize() const
    { return (Use16BitBoneIndex() ? sizeof(FBoneIndex16) : sizeof(FBoneIndex8)); }
 
    inline uint32 GetBoneWeightByteSize() const
    {
        return Use16BitBoneWeight() ? sizeof(uint16) : sizeof(uint8);
    }
 
    inline uint32 GetBoneIndexAndWeightByteSize() const
    {
        return GetBoneIndexByteSize() + GetBoneWeightByteSize(); 
    }
 
    inline uint32 GetConstantInfluencesVertexStride() const
    { return GetBoneIndexAndWeightByteSize() * MaxBoneInfluences; }
 
    inline uint32 GetConstantInfluencesBoneWeightsOffset() const
    { return GetBoneIndexByteSize() * MaxBoneInfluences; }
 
    inline uint32 GetVertexDataSize() const
    { return NumBoneWeights * GetBoneIndexAndWeightByteSize(); }
 
    // @param guaranteed only to be valid if the vertex buffer is valid
    FRHIShaderResourceView* GetSRV() const
    { return SRVValue; }
 
    inline void SetNeedsCPUAccess(bool bInNeedsCPUAccess)
    { bNeedsCPUAccess = bInNeedsCPUAccess; }
 
    inline bool GetNeedsCPUAccess() const
    { return bNeedsCPUAccess; }
 
    inline bool GetVariableBonesPerVertex() const
    { return bVariableBonesPerVertex; }
 
    ENGINE_API void SetMaxBoneInfluences(uint32 InMaxBoneInfluences);
 
    inline uint32 GetMaxBoneInfluences() const
    { return MaxBoneInfluences; }
 
    inline void SetUse16BitBoneIndex(bool bInUse16BitBoneIndex)
    { bUse16BitBoneIndex = bInUse16BitBoneIndex; }
 
    inline bool Use16BitBoneIndex() const
    { return bUse16BitBoneIndex; }
    
    void SetUse16BitBoneWeight(bool bInUse16BitBoneWeight)
    { bUse16BitBoneWeight = bInUse16BitBoneWeight; }
 
    bool Use16BitBoneWeight() const
    { return bUse16BitBoneWeight; }
    
    
 
    ENGINE_API GPUSkinBoneInfluenceType GetBoneInfluenceType() const;
    ENGINE_API bool GetRigidWeightBone(uint32 VertexWeightOffset, uint32 VertexInfluenceCount, int32& OutBoneIndex) const;
    ENGINE_API uint32 GetBoneIndex(uint32 VertexWeightOffset, uint32 VertexInfluenceCount, uint32 InfluenceIndex) const;
    ENGINE_API void SetBoneIndex(uint32 VertexWeightOffset, uint32 VertexInfluenceCount, uint32 InfluenceIndex, uint32 BoneIndex);
    ENGINE_API uint16 GetBoneWeight(uint32 VertexWeightOffset, uint32 VertexInfluenceCount, uint32 InfluenceIndex) const;
    ENGINE_API void SetBoneWeight(uint32 VertexWeightOffset, uint32 VertexInfluenceCount, uint32 InfluenceIndex, uint16 BoneWeight);
    ENGINE_API void ResetVertexBoneWeights(uint32 VertexWeightOffset, uint32 VertexInfluenceCount);
 
    ENGINE_API void CopyDataFromBuffer(const uint8* InSkinWeightData, uint32 InNumVertices);
 
    FBufferRHIRef CreateRHIBuffer(FRHICommandListBase& RHICmdList);
 
    void InitRHIForStreaming(FRHIBuffer* IntermediateBuffer, FRHIResourceReplaceBatcher& Batcher);
    void ReleaseRHIForStreaming(FRHIResourceReplaceBatcher& Batcher);
 
    bool IsWeightDataValid() const;
 
    const uint8* GetWeightData() const
    {
        return Data;
    }
 
    uint8* GetWeightData()
    {
        return Data;
    }
    
protected:
    // guaranteed only to be valid if the vertex buffer is valid
    FShaderResourceViewRHIRef SRVValue;
 
private:
    void ResizeBuffer(uint32 InNumWeights, uint32 InNumVertices);
 
    EPixelFormat GetPixelFormat() const
    { return bVariableBonesPerVertex ? PF_R8_UINT : PF_R32_UINT; }
 
    uint32 GetPixelFormatStride() const
    { return bVariableBonesPerVertex ? 1 : 4; }
 
    bool bNeedsCPUAccess;
 
    bool bVariableBonesPerVertex;
 
    uint32 MaxBoneInfluences;
 
    bool bUse16BitBoneIndex;
 
    bool bUse16BitBoneWeight;
 
    FStaticMeshVertexDataInterface* WeightData;
 
    uint8* Data;
 
    uint32 NumVertices;
 
    uint32 NumBoneWeights;
 
    ENGINE_API void AllocateData();
};
 
class FSkinWeightVertexBuffer
{
public:
    ENGINE_API FSkinWeightVertexBuffer();
 
    ENGINE_API FSkinWeightVertexBuffer(const FSkinWeightVertexBuffer& Other);
 
    ENGINE_API ~FSkinWeightVertexBuffer();
 
    ENGINE_API FSkinWeightVertexBuffer& operator=(const FSkinWeightVertexBuffer& Other);
 
    ENGINE_API void CleanUp();
 
#if WITH_EDITOR
    ENGINE_API void Init(const TArray<FSoftSkinVertex>& InVertices);
#endif // WITH_EDITOR
 
    ENGINE_API FSkinWeightVertexBuffer& operator=(const TArray<FSkinWeightInfo>& InWeights);
    ENGINE_API void GetSkinWeights(TArray<FSkinWeightInfo>& OutVertices) const;
    ENGINE_API FSkinWeightInfo GetVertexSkinWeights(uint32 VertexIndex) const;
 
    ENGINE_API void CopySkinWeightRawDataFromBuffer(const uint8* InSkinWeightData, uint32 InNumVertices);
 
    ENGINE_API friend FArchive& operator<<(FArchive& Ar, FSkinWeightVertexBuffer& VertexBuffer);
 
    void SerializeMetaData(FArchive& Ar);
    void CopyMetaData(const FSkinWeightVertexBuffer& Other);
 
    inline uint32 GetNumVertices() const
    { return DataVertexBuffer.GetNumVertices(); }
 
    inline uint32 GetVertexDataSize() const
    { return LookupVertexBuffer.GetVertexDataSize() + DataVertexBuffer.GetVertexDataSize(); }
 
    void SetNeedsCPUAccess(bool bInNeedsCPUAccess)
    {
        DataVertexBuffer.SetNeedsCPUAccess(bInNeedsCPUAccess);
        LookupVertexBuffer.SetNeedsCPUAccess(bInNeedsCPUAccess);
    }
 
    bool GetNeedsCPUAccess() const
    { return DataVertexBuffer.GetNeedsCPUAccess(); }
 
    void SetMaxBoneInfluences(uint32 InMaxBoneInfluences)
    { DataVertexBuffer.SetMaxBoneInfluences(InMaxBoneInfluences); }
 
    uint32 GetMaxBoneInfluences() const
    { return DataVertexBuffer.GetMaxBoneInfluences(); }
 
    void SetUse16BitBoneIndex(bool bInUse16BitBoneIndex)
    { DataVertexBuffer.SetUse16BitBoneIndex(bInUse16BitBoneIndex); }
 
    bool Use16BitBoneIndex() const
    { return DataVertexBuffer.Use16BitBoneIndex(); }
 
    void SetUse16BitBoneWeight(bool bInUse16BitBoneWeight)
    { DataVertexBuffer.SetUse16BitBoneWeight(bInUse16BitBoneWeight); }
    
    bool Use16BitBoneWeight() const
    { return DataVertexBuffer.Use16BitBoneWeight(); }
    
    uint32 GetBoneIndexByteSize() const
    { return DataVertexBuffer.GetBoneIndexByteSize(); }
 
    uint32 GetBoneWeightByteSize() const
    { return DataVertexBuffer.GetBoneWeightByteSize(); }
    
    uint32 GetBoneIndexAndWeightByteSize() const
    { return DataVertexBuffer.GetBoneIndexAndWeightByteSize(); }
    
    bool GetVariableBonesPerVertex() const
    { return DataVertexBuffer.GetVariableBonesPerVertex(); }
 
    uint32 GetConstantInfluencesVertexStride() const
    { return DataVertexBuffer.GetConstantInfluencesVertexStride(); }
 
    uint32 GetConstantInfluencesBoneWeightsOffset() const
    { return DataVertexBuffer.GetConstantInfluencesBoneWeightsOffset(); }
 
    FSkinWeightDataVertexBuffer* GetDataVertexBuffer()
    { return &DataVertexBuffer; }
    
    const FSkinWeightDataVertexBuffer* GetDataVertexBuffer() const
    { return &DataVertexBuffer; }
 
    const FSkinWeightLookupVertexBuffer* GetLookupVertexBuffer() const
    { return &LookupVertexBuffer; }
 
    FSkinWeightRHIInfo CreateRHIBuffer(FRHICommandListBase& RHICmdList);
 
    ENGINE_API GPUSkinBoneInfluenceType GetBoneInfluenceType() const;
    ENGINE_API void GetVertexInfluenceOffsetCount(uint32 VertexIndex, uint32& VertexWeightOffset, uint32& VertexInfluenceCount) const;
    ENGINE_API bool GetRigidWeightBone(uint32 VertexIndex, int32& OutBoneIndex) const;
    ENGINE_API uint32 GetBoneIndex(uint32 VertexIndex, uint32 InfluenceIndex) const;
    ENGINE_API void SetBoneIndex(uint32 VertexIndex, uint32 InfluenceIndex, uint32 BoneIndex);
    ENGINE_API uint16 GetBoneWeight(uint32 VertexIndex, uint32 InfluenceIndex) const;
    ENGINE_API void SetBoneWeight(uint32 VertexIndex, uint32 InfluenceIndex, uint16 BoneWeight);
    ENGINE_API void ResetVertexBoneWeights(uint32 VertexIndex);
    
    ENGINE_API void RebuildLookupVertexBuffer();
 
    ENGINE_API void SetOwnerName(const FName& OwnerName);
    ENGINE_API void BeginInitResources();
    ENGINE_API void BeginReleaseResources();
    ENGINE_API void ReleaseResources();
 
    void InitRHIForStreaming(const FSkinWeightRHIInfo& RHIInfo, FRHIResourceReplaceBatcher& Batcher)
    {
        DataVertexBuffer.InitRHIForStreaming(RHIInfo.DataVertexBufferRHI, Batcher);
        LookupVertexBuffer.InitRHIForStreaming(RHIInfo.LookupVertexBufferRHI, Batcher);
    }
 
    void ReleaseRHIForStreaming(FRHIResourceReplaceBatcher& Batcher)
    {
        DataVertexBuffer.ReleaseRHIForStreaming(Batcher);
        LookupVertexBuffer.ReleaseRHIForStreaming(Batcher);
    }
 
private:
    FSkinWeightDataVertexBuffer     DataVertexBuffer;
 
    FSkinWeightLookupVertexBuffer   LookupVertexBuffer;
};