MorphTargetVertexCodec.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "Containers/BitArray.h"
#include "Containers/ContainersFwd.h"
#include "Math/IntVector.h"
 
struct FMorphTargetDelta;
class UMorphTarget;
class FDefaultBitArrayAllocator;
 
 
namespace UE::MorphTargetVertexCodec
{
 
constexpr uint32 BatchSizeBits = 6u;
constexpr uint32 BatchSize = 1u << BatchSizeBits;
 
constexpr uint32 NumBatchHeaderDwords = 10u;
 
 
struct FQuantizedDelta
{
    FIntVector  Position;
    FIntVector  TangentZ;
    uint32      Index;
 
    bool operator==(const FQuantizedDelta&) const = default; 
};
 
struct FDeltaBatchHeader
{
    uint32      DataOffset;
    uint32      NumElements;
 
    bool        bTangents;
    int8        IndexBits;
    Math::TIntVector3<int8> PositionBits;
    Math::TIntVector3<int8> TangentZBits;
    
    uint32      IndexMin;
    FIntVector  PositionMin;
    FIntVector  TangentZMin;
 
    bool operator==(const FDeltaBatchHeader&) const = default; 
 
    friend FArchive& operator<<(FArchive& Ar, FDeltaBatchHeader& InHeader)
    {
        Ar << InHeader.DataOffset;
        Ar << InHeader.NumElements;
        Ar << InHeader.bTangents;
        Ar << InHeader.IndexBits;
        Ar << InHeader.PositionBits;
        Ar << InHeader.TangentZBits;
        Ar << InHeader.IndexMin;
        Ar << InHeader.PositionMin;
        Ar << InHeader.TangentZMin;
        
        return Ar;
    }
};
 
 
inline float ComputePositionPrecision(float InTargetPositionErrorTolerance)
{
    constexpr float UnrealUnitPerMeter = 100.0f;
    return InTargetPositionErrorTolerance * 2.0f * 1e-6f * UnrealUnitPerMeter;  // * 2.0 because correct rounding guarantees error is at most half of the cell size.
}
 
inline float ComputeTangentPrecision()
{
    return 1.0f / 2048.0f;  // Object scale irrelevant here. Let's assume ~12bits per component is plenty.
}
 
ENGINE_API void Encode(
    TConstArrayView<FMorphTargetDelta> InMorphDeltas,
    const TBitArray<>* InVertexNeedsTangents,
    const float InPositionPrecision,
    const float InTangentZPrecision,
    TArray<FDeltaBatchHeader>& OutBatchHeaders,
    TArray<uint32>& OutCompressedVertices
    );
 
ENGINE_API void Decode(
    TConstArrayView<FDeltaBatchHeader> InBatchHeaders,
    TConstArrayView<uint32> InCompressedVertices,
    const float InPositionPrecision,
    const float InTangentZPrecision,
    TArray<FMorphTargetDelta>& OutMorphDeltas
    );
 
ENGINE_API bool IterativeDecode(
    uint64& InOutNextItemToken,
    TConstArrayView<FDeltaBatchHeader> InBatchHeaders,
    TConstArrayView<uint32> InCompressedVertices,
    const float InPositionPrecision,
    const float InTangentZPrecision,
    FMorphTargetDelta& OutMorphTargetDelta
    );
 
ENGINE_API void ReadHeader(FDeltaBatchHeader& OutBatchHeader, const TArrayView<const uint32> InData);
 
ENGINE_API void WriteHeader(const FDeltaBatchHeader& InBatchHeader, TArrayView<uint32> OutData);
 
ENGINE_API void WriteQuantizedDeltas(
    TConstArrayView<FQuantizedDelta> InQuantizedDeltas, 
    const FDeltaBatchHeader& InBatchHeader, 
    TArrayView<uint32> OutData
    );
 
ENGINE_API void ReadQuantizedDeltas(
    TArrayView<FQuantizedDelta> OutQuantizedDeltas, 
    const FDeltaBatchHeader& InBatchHeader, 
    TConstArrayView<uint32> InData
    );
 
ENGINE_API uint32 CalculateBatchDwords(const FDeltaBatchHeader& BatchHeader);
 
ENGINE_API void QuantizeDelta(
    const FMorphTargetDelta& InDelta, 
    const bool bInNeedsTangent, 
    FQuantizedDelta& OutQuantizedDelta, 
    const float InPositionPrecision, 
    const float InTangentZPrecision
    );
 
/* Dequantize FMorphTargetDelta using the given precision. */
ENGINE_API void DequantizeDelta(
    FMorphTargetDelta& OutDelta, 
    const bool bInNeedsTangent, 
    const FQuantizedDelta& InQuantizedDelta, 
    const float InPositionPrecision, 
    const float InTangentZPrecision
    );
 
}