874 lines
31 KiB
C++
874 lines
31 KiB
C++
// Copyright Epic Games, Inc. All Rights Reserved.
|
|
|
|
#include "RigLogicDNAReader.h"
|
|
|
|
#include <tdm/TDM.h>
|
|
|
|
RigLogicDNAReader::RigLogicDNAReader(const dna::Reader* DNAReader) : Reader{DNAReader}, Values{}, Key{CachedDataKey::None}, Id{}
|
|
{
|
|
}
|
|
|
|
// Header
|
|
std::uint16_t RigLogicDNAReader::getFileFormatGeneration() const
|
|
{
|
|
return Reader->getFileFormatGeneration();
|
|
}
|
|
std::uint16_t RigLogicDNAReader::getFileFormatVersion() const
|
|
{
|
|
return Reader->getFileFormatVersion();
|
|
}
|
|
|
|
// Descriptor
|
|
dna::StringView RigLogicDNAReader::getName() const
|
|
{
|
|
return Reader->getName();
|
|
}
|
|
dna::Archetype RigLogicDNAReader::getArchetype() const
|
|
{
|
|
return Reader->getArchetype();
|
|
}
|
|
dna::Gender RigLogicDNAReader::getGender() const
|
|
{
|
|
return Reader->getGender();
|
|
}
|
|
std::uint16_t RigLogicDNAReader::getAge() const
|
|
{
|
|
return Reader->getAge();
|
|
}
|
|
std::uint32_t RigLogicDNAReader::getMetaDataCount() const
|
|
{
|
|
return Reader->getMetaDataCount();
|
|
}
|
|
dna::StringView RigLogicDNAReader::getMetaDataKey(std::uint32_t index) const
|
|
{
|
|
return Reader->getMetaDataKey(index);
|
|
}
|
|
dna::StringView RigLogicDNAReader::getMetaDataValue(const char* key) const
|
|
{
|
|
return Reader->getMetaDataValue(key);
|
|
}
|
|
dna::TranslationUnit RigLogicDNAReader::getTranslationUnit() const
|
|
{
|
|
return Reader->getTranslationUnit();
|
|
}
|
|
dna::RotationUnit RigLogicDNAReader::getRotationUnit() const
|
|
{
|
|
return Reader->getRotationUnit();
|
|
}
|
|
dna::CoordinateSystem RigLogicDNAReader::getCoordinateSystem() const
|
|
{
|
|
return Reader->getCoordinateSystem();
|
|
}
|
|
std::uint16_t RigLogicDNAReader::getLODCount() const
|
|
{
|
|
return Reader->getLODCount();
|
|
}
|
|
std::uint16_t RigLogicDNAReader::getDBMaxLOD() const
|
|
{
|
|
return Reader->getDBMaxLOD();
|
|
}
|
|
dna::StringView RigLogicDNAReader::getDBComplexity() const
|
|
{
|
|
return Reader->getDBComplexity();
|
|
}
|
|
dna::StringView RigLogicDNAReader::getDBName() const
|
|
{
|
|
return Reader->getDBName();
|
|
}
|
|
|
|
// Definition
|
|
std::uint16_t RigLogicDNAReader::getGUIControlCount() const
|
|
{
|
|
return Reader->getGUIControlCount();
|
|
}
|
|
dna::StringView RigLogicDNAReader::getGUIControlName(std::uint16_t index) const
|
|
{
|
|
return Reader->getGUIControlName(index);
|
|
}
|
|
std::uint16_t RigLogicDNAReader::getRawControlCount() const
|
|
{
|
|
return Reader->getRawControlCount();
|
|
}
|
|
dna::StringView RigLogicDNAReader::getRawControlName(std::uint16_t index) const
|
|
{
|
|
return Reader->getRawControlName(index);
|
|
}
|
|
std::uint16_t RigLogicDNAReader::getJointCount() const
|
|
{
|
|
return Reader->getJointCount();
|
|
}
|
|
dna::StringView RigLogicDNAReader::getJointName(std::uint16_t index) const
|
|
{
|
|
return Reader->getJointName(index);
|
|
}
|
|
std::uint16_t RigLogicDNAReader::getJointIndexListCount() const
|
|
{
|
|
return Reader->getJointIndexListCount();
|
|
}
|
|
dna::ConstArrayView<std::uint16_t> RigLogicDNAReader::getJointIndicesForLOD(std::uint16_t lod) const
|
|
{
|
|
return Reader->getJointIndicesForLOD(lod);
|
|
}
|
|
std::uint16_t RigLogicDNAReader::getJointParentIndex(std::uint16_t index) const
|
|
{
|
|
return Reader->getJointParentIndex(index);
|
|
}
|
|
std::uint16_t RigLogicDNAReader::getBlendShapeChannelCount() const
|
|
{
|
|
return Reader->getBlendShapeChannelCount();
|
|
}
|
|
dna::StringView RigLogicDNAReader::getBlendShapeChannelName(std::uint16_t index) const
|
|
{
|
|
return Reader->getBlendShapeChannelName(index);
|
|
}
|
|
std::uint16_t RigLogicDNAReader::getBlendShapeChannelIndexListCount() const
|
|
{
|
|
return Reader->getBlendShapeChannelIndexListCount();
|
|
}
|
|
dna::ConstArrayView<std::uint16_t> RigLogicDNAReader::getBlendShapeChannelIndicesForLOD(std::uint16_t lod) const
|
|
{
|
|
return Reader->getBlendShapeChannelIndicesForLOD(lod);
|
|
}
|
|
std::uint16_t RigLogicDNAReader::getAnimatedMapCount() const
|
|
{
|
|
return Reader->getAnimatedMapCount();
|
|
}
|
|
dna::StringView RigLogicDNAReader::getAnimatedMapName(std::uint16_t index) const
|
|
{
|
|
return Reader->getAnimatedMapName(index);
|
|
}
|
|
std::uint16_t RigLogicDNAReader::getAnimatedMapIndexListCount() const
|
|
{
|
|
return Reader->getAnimatedMapIndexListCount();
|
|
}
|
|
dna::ConstArrayView<std::uint16_t> RigLogicDNAReader::getAnimatedMapIndicesForLOD(std::uint16_t lod) const
|
|
{
|
|
return Reader->getAnimatedMapIndicesForLOD(lod);
|
|
}
|
|
std::uint16_t RigLogicDNAReader::getMeshCount() const
|
|
{
|
|
return Reader->getMeshCount();
|
|
}
|
|
dna::StringView RigLogicDNAReader::getMeshName(std::uint16_t index) const
|
|
{
|
|
return Reader->getMeshName(index);
|
|
}
|
|
std::uint16_t RigLogicDNAReader::getMeshIndexListCount() const
|
|
{
|
|
return Reader->getMeshIndexListCount();
|
|
}
|
|
dna::ConstArrayView<std::uint16_t> RigLogicDNAReader::getMeshIndicesForLOD(std::uint16_t lod) const
|
|
{
|
|
return Reader->getMeshIndicesForLOD(lod);
|
|
}
|
|
std::uint16_t RigLogicDNAReader::getMeshBlendShapeChannelMappingCount() const
|
|
{
|
|
return Reader->getMeshBlendShapeChannelMappingCount();
|
|
}
|
|
dna::MeshBlendShapeChannelMapping RigLogicDNAReader::getMeshBlendShapeChannelMapping(std::uint16_t index) const
|
|
{
|
|
return Reader->getMeshBlendShapeChannelMapping(index);
|
|
}
|
|
dna::ConstArrayView<std::uint16_t> RigLogicDNAReader::getMeshBlendShapeChannelMappingIndicesForLOD(std::uint16_t lod) const
|
|
{
|
|
return Reader->getMeshBlendShapeChannelMappingIndicesForLOD(lod);
|
|
}
|
|
dna::Vector3 RigLogicDNAReader::getNeutralJointTranslation(std::uint16_t index) const
|
|
{
|
|
const auto Xs = getNeutralJointTranslationXs();
|
|
const auto Ys = getNeutralJointTranslationYs();
|
|
const auto Zs = getNeutralJointTranslationZs();
|
|
return dna::Vector3{Xs[index], Ys[index], Zs[index]};
|
|
}
|
|
dna::ConstArrayView<float> RigLogicDNAReader::getNeutralJointTranslationXs() const
|
|
{
|
|
CacheNeutralJointTranslations();
|
|
ensureMsgf(Values.Num() % 3 == 0, TEXT("Invalid neutral joint translations in DNA reader cache."));
|
|
const auto Count = Values.Num() / 3u;
|
|
return {Values.GetData() + 0 * Count, Count};
|
|
}
|
|
dna::ConstArrayView<float> RigLogicDNAReader::getNeutralJointTranslationYs() const
|
|
{
|
|
CacheNeutralJointTranslations();
|
|
ensureMsgf(Values.Num() % 3 == 0, TEXT("Invalid neutral joint translations in DNA reader cache."));
|
|
const auto Count = Values.Num() / 3u;
|
|
return {Values.GetData() + 1 * Count, Count};
|
|
}
|
|
dna::ConstArrayView<float> RigLogicDNAReader::getNeutralJointTranslationZs() const
|
|
{
|
|
CacheNeutralJointTranslations();
|
|
ensureMsgf(Values.Num() % 3 == 0, TEXT("Invalid neutral joint translations in DNA reader cache."));
|
|
const auto Count = Values.Num() / 3u;
|
|
return {Values.GetData() + 2 * Count, Count};
|
|
}
|
|
dna::Vector3 RigLogicDNAReader::getNeutralJointRotation(std::uint16_t index) const
|
|
{
|
|
const auto Xs = getNeutralJointRotationXs();
|
|
const auto Ys = getNeutralJointRotationYs();
|
|
const auto Zs = getNeutralJointRotationZs();
|
|
return dna::Vector3{Xs[index], Ys[index], Zs[index]};
|
|
}
|
|
dna::ConstArrayView<float> RigLogicDNAReader::getNeutralJointRotationXs() const
|
|
{
|
|
CacheNeutralJointRotations();
|
|
ensureMsgf(Values.Num() % 3 == 0, TEXT("Invalid neutral joint rotations in DNA reader cache."));
|
|
const auto Count = Values.Num() / 3u;
|
|
return {Values.GetData() + 0 * Count, Count};
|
|
}
|
|
dna::ConstArrayView<float> RigLogicDNAReader::getNeutralJointRotationYs() const
|
|
{
|
|
CacheNeutralJointRotations();
|
|
ensureMsgf(Values.Num() % 3 == 0, TEXT("Invalid neutral joint rotations in DNA reader cache."));
|
|
const auto Count = Values.Num() / 3u;
|
|
return { Values.GetData() + 1 * Count, Count };
|
|
}
|
|
dna::ConstArrayView<float> RigLogicDNAReader::getNeutralJointRotationZs() const
|
|
{
|
|
CacheNeutralJointRotations();
|
|
ensureMsgf(Values.Num() % 3 == 0, TEXT("Invalid neutral joint rotations in DNA reader cache."));
|
|
const auto Count = Values.Num() / 3u;
|
|
return { Values.GetData() + 2 * Count, Count };
|
|
}
|
|
|
|
// Behavior
|
|
dna::ConstArrayView<std::uint16_t> RigLogicDNAReader::getGUIToRawInputIndices() const
|
|
{
|
|
return Reader->getGUIToRawInputIndices();
|
|
}
|
|
dna::ConstArrayView<std::uint16_t> RigLogicDNAReader::getGUIToRawOutputIndices() const
|
|
{
|
|
return Reader->getGUIToRawOutputIndices();
|
|
}
|
|
dna::ConstArrayView<float> RigLogicDNAReader::getGUIToRawFromValues() const
|
|
{
|
|
return Reader->getGUIToRawFromValues();
|
|
}
|
|
dna::ConstArrayView<float> RigLogicDNAReader::getGUIToRawToValues() const
|
|
{
|
|
return Reader->getGUIToRawToValues();
|
|
}
|
|
dna::ConstArrayView<float> RigLogicDNAReader::getGUIToRawSlopeValues() const
|
|
{
|
|
return Reader->getGUIToRawSlopeValues();
|
|
}
|
|
dna::ConstArrayView<float> RigLogicDNAReader::getGUIToRawCutValues() const
|
|
{
|
|
return Reader->getGUIToRawCutValues();
|
|
}
|
|
std::uint16_t RigLogicDNAReader::getPSDCount() const
|
|
{
|
|
return Reader->getPSDCount();
|
|
}
|
|
dna::ConstArrayView<std::uint16_t> RigLogicDNAReader::getPSDRowIndices() const
|
|
{
|
|
return Reader->getPSDRowIndices();
|
|
}
|
|
dna::ConstArrayView<std::uint16_t> RigLogicDNAReader::getPSDColumnIndices() const
|
|
{
|
|
return Reader->getPSDColumnIndices();
|
|
}
|
|
dna::ConstArrayView<float> RigLogicDNAReader::getPSDValues() const
|
|
{
|
|
return Reader->getPSDValues();
|
|
}
|
|
std::uint16_t RigLogicDNAReader::getJointRowCount() const
|
|
{
|
|
return Reader->getJointRowCount();
|
|
}
|
|
std::uint16_t RigLogicDNAReader::getJointColumnCount() const
|
|
{
|
|
return Reader->getJointColumnCount();
|
|
}
|
|
dna::ConstArrayView<std::uint16_t> RigLogicDNAReader::getJointVariableAttributeIndices(std::uint16_t lod) const
|
|
{
|
|
return Reader->getJointVariableAttributeIndices(lod);
|
|
}
|
|
std::uint16_t RigLogicDNAReader::getJointGroupCount() const
|
|
{
|
|
return Reader->getJointGroupCount();
|
|
}
|
|
dna::ConstArrayView<std::uint16_t> RigLogicDNAReader::getJointGroupLODs(std::uint16_t jointGroupIndex) const
|
|
{
|
|
return Reader->getJointGroupLODs(jointGroupIndex);
|
|
}
|
|
dna::ConstArrayView<std::uint16_t> RigLogicDNAReader::getJointGroupInputIndices(std::uint16_t jointGroupIndex) const
|
|
{
|
|
return Reader->getJointGroupInputIndices(jointGroupIndex);
|
|
}
|
|
dna::ConstArrayView<std::uint16_t> RigLogicDNAReader::getJointGroupOutputIndices(std::uint16_t jointGroupIndex) const
|
|
{
|
|
return Reader->getJointGroupOutputIndices(jointGroupIndex);
|
|
}
|
|
dna::ConstArrayView<float> RigLogicDNAReader::getJointGroupValues(std::uint16_t jointGroupIndex) const
|
|
{
|
|
CacheJointGroup(jointGroupIndex);
|
|
return {Values.GetData(), static_cast<std::size_t>(Values.Num())};
|
|
}
|
|
dna::ConstArrayView<std::uint16_t> RigLogicDNAReader::getJointGroupJointIndices(std::uint16_t jointGroupIndex) const
|
|
{
|
|
return Reader->getJointGroupJointIndices(jointGroupIndex);
|
|
}
|
|
dna::ConstArrayView<std::uint16_t> RigLogicDNAReader::getBlendShapeChannelLODs() const
|
|
{
|
|
return Reader->getBlendShapeChannelLODs();
|
|
}
|
|
dna::ConstArrayView<std::uint16_t> RigLogicDNAReader::getBlendShapeChannelInputIndices() const
|
|
{
|
|
return Reader->getBlendShapeChannelInputIndices();
|
|
}
|
|
dna::ConstArrayView<std::uint16_t> RigLogicDNAReader::getBlendShapeChannelOutputIndices() const
|
|
{
|
|
return Reader->getBlendShapeChannelOutputIndices();
|
|
}
|
|
dna::ConstArrayView<std::uint16_t> RigLogicDNAReader::getAnimatedMapLODs() const
|
|
{
|
|
return Reader->getAnimatedMapLODs();
|
|
}
|
|
dna::ConstArrayView<std::uint16_t> RigLogicDNAReader::getAnimatedMapInputIndices() const
|
|
{
|
|
return Reader->getAnimatedMapInputIndices();
|
|
}
|
|
dna::ConstArrayView<std::uint16_t> RigLogicDNAReader::getAnimatedMapOutputIndices() const
|
|
{
|
|
return Reader->getAnimatedMapOutputIndices();
|
|
}
|
|
dna::ConstArrayView<float> RigLogicDNAReader::getAnimatedMapFromValues() const
|
|
{
|
|
return Reader->getAnimatedMapFromValues();
|
|
}
|
|
dna::ConstArrayView<float> RigLogicDNAReader::getAnimatedMapToValues() const
|
|
{
|
|
return Reader->getAnimatedMapToValues();
|
|
}
|
|
dna::ConstArrayView<float> RigLogicDNAReader::getAnimatedMapSlopeValues() const
|
|
{
|
|
return Reader->getAnimatedMapSlopeValues();
|
|
}
|
|
dna::ConstArrayView<float> RigLogicDNAReader::getAnimatedMapCutValues() const
|
|
{
|
|
return Reader->getAnimatedMapCutValues();
|
|
}
|
|
|
|
// Geometry
|
|
std::uint32_t RigLogicDNAReader::getVertexPositionCount(std::uint16_t meshIndex) const
|
|
{
|
|
return Reader->getVertexPositionCount(meshIndex);
|
|
}
|
|
dna::Position RigLogicDNAReader::getVertexPosition(std::uint16_t meshIndex, std::uint32_t vertexIndex) const
|
|
{
|
|
return Reader->getVertexPosition(meshIndex, vertexIndex);
|
|
}
|
|
dna::ConstArrayView<float> RigLogicDNAReader::getVertexPositionXs(std::uint16_t meshIndex) const
|
|
{
|
|
return Reader->getVertexPositionXs(meshIndex);
|
|
}
|
|
dna::ConstArrayView<float> RigLogicDNAReader::getVertexPositionYs(std::uint16_t meshIndex) const
|
|
{
|
|
return Reader->getVertexPositionYs(meshIndex);
|
|
}
|
|
dna::ConstArrayView<float> RigLogicDNAReader::getVertexPositionZs(std::uint16_t meshIndex) const
|
|
{
|
|
return Reader->getVertexPositionZs(meshIndex);
|
|
}
|
|
std::uint32_t RigLogicDNAReader::getVertexTextureCoordinateCount(std::uint16_t meshIndex) const
|
|
{
|
|
return Reader->getVertexTextureCoordinateCount(meshIndex);
|
|
}
|
|
dna::TextureCoordinate RigLogicDNAReader::getVertexTextureCoordinate(std::uint16_t meshIndex, std::uint32_t textureCoordinateIndex) const
|
|
{
|
|
return Reader->getVertexTextureCoordinate(meshIndex, textureCoordinateIndex);
|
|
}
|
|
dna::ConstArrayView<float> RigLogicDNAReader::getVertexTextureCoordinateUs(std::uint16_t meshIndex) const
|
|
{
|
|
return Reader->getVertexTextureCoordinateUs(meshIndex);
|
|
}
|
|
dna::ConstArrayView<float> RigLogicDNAReader::getVertexTextureCoordinateVs(std::uint16_t meshIndex) const
|
|
{
|
|
return Reader->getVertexTextureCoordinateVs(meshIndex);
|
|
}
|
|
std::uint32_t RigLogicDNAReader::getVertexNormalCount(std::uint16_t meshIndex) const
|
|
{
|
|
return Reader->getVertexNormalCount(meshIndex);
|
|
}
|
|
dna::Normal RigLogicDNAReader::getVertexNormal(std::uint16_t meshIndex, std::uint32_t normalIndex) const
|
|
{
|
|
return Reader->getVertexNormal(meshIndex, normalIndex);
|
|
}
|
|
dna::ConstArrayView<float> RigLogicDNAReader::getVertexNormalXs(std::uint16_t meshIndex) const
|
|
{
|
|
return Reader->getVertexNormalXs(meshIndex);
|
|
}
|
|
dna::ConstArrayView<float> RigLogicDNAReader::getVertexNormalYs(std::uint16_t meshIndex) const
|
|
{
|
|
return Reader->getVertexNormalYs(meshIndex);
|
|
}
|
|
dna::ConstArrayView<float> RigLogicDNAReader::getVertexNormalZs(std::uint16_t meshIndex) const
|
|
{
|
|
return Reader->getVertexNormalZs(meshIndex);
|
|
}
|
|
std::uint32_t RigLogicDNAReader::getVertexLayoutCount(std::uint16_t meshIndex) const
|
|
{
|
|
return Reader->getVertexLayoutCount(meshIndex);
|
|
}
|
|
dna::VertexLayout RigLogicDNAReader::getVertexLayout(std::uint16_t meshIndex, std::uint32_t layoutIndex) const
|
|
{
|
|
return Reader->getVertexLayout(meshIndex, layoutIndex);
|
|
}
|
|
dna::ConstArrayView<std::uint32_t> RigLogicDNAReader::getVertexLayoutPositionIndices(std::uint16_t meshIndex) const
|
|
{
|
|
return Reader->getVertexLayoutPositionIndices(meshIndex);
|
|
}
|
|
dna::ConstArrayView<std::uint32_t> RigLogicDNAReader::getVertexLayoutTextureCoordinateIndices(std::uint16_t meshIndex) const
|
|
{
|
|
return Reader->getVertexLayoutTextureCoordinateIndices(meshIndex);
|
|
}
|
|
dna::ConstArrayView<std::uint32_t> RigLogicDNAReader::getVertexLayoutNormalIndices(std::uint16_t meshIndex) const
|
|
{
|
|
return Reader->getVertexLayoutNormalIndices(meshIndex);
|
|
}
|
|
std::uint32_t RigLogicDNAReader::getFaceCount(std::uint16_t meshIndex) const
|
|
{
|
|
return Reader->getFaceCount(meshIndex);
|
|
}
|
|
dna::ConstArrayView<std::uint32_t> RigLogicDNAReader::getFaceVertexLayoutIndices(std::uint16_t meshIndex, std::uint32_t faceIndex) const
|
|
{
|
|
return Reader->getFaceVertexLayoutIndices(meshIndex, faceIndex);
|
|
}
|
|
std::uint16_t RigLogicDNAReader::getMaximumInfluencePerVertex(std::uint16_t meshIndex) const
|
|
{
|
|
return Reader->getMaximumInfluencePerVertex(meshIndex);
|
|
}
|
|
std::uint32_t RigLogicDNAReader::getSkinWeightsCount(std::uint16_t meshIndex) const
|
|
{
|
|
return Reader->getSkinWeightsCount(meshIndex);
|
|
}
|
|
dna::ConstArrayView<float> RigLogicDNAReader::getSkinWeightsValues(std::uint16_t meshIndex, std::uint32_t vertexIndex) const
|
|
{
|
|
return Reader->getSkinWeightsValues(meshIndex, vertexIndex);
|
|
}
|
|
dna::ConstArrayView<std::uint16_t> RigLogicDNAReader::getSkinWeightsJointIndices(std::uint16_t meshIndex, std::uint32_t vertexIndex) const
|
|
{
|
|
return Reader->getSkinWeightsJointIndices(meshIndex, vertexIndex);
|
|
}
|
|
std::uint16_t RigLogicDNAReader::getBlendShapeTargetCount(std::uint16_t meshIndex) const
|
|
{
|
|
return Reader->getBlendShapeTargetCount(meshIndex);
|
|
}
|
|
std::uint16_t RigLogicDNAReader::getBlendShapeChannelIndex(std::uint16_t meshIndex, std::uint16_t blendShapeTargetIndex) const
|
|
{
|
|
return Reader->getBlendShapeChannelIndex(meshIndex, blendShapeTargetIndex);
|
|
}
|
|
std::uint32_t RigLogicDNAReader::getBlendShapeTargetDeltaCount(std::uint16_t meshIndex, std::uint16_t blendShapeTargetIndex) const
|
|
{
|
|
return Reader->getBlendShapeTargetDeltaCount(meshIndex, blendShapeTargetIndex);
|
|
}
|
|
dna::Delta RigLogicDNAReader::getBlendShapeTargetDelta(std::uint16_t meshIndex, std::uint16_t blendShapeTargetIndex, std::uint32_t deltaIndex) const
|
|
{
|
|
return Reader->getBlendShapeTargetDelta(meshIndex, blendShapeTargetIndex, deltaIndex);
|
|
}
|
|
dna::ConstArrayView<float> RigLogicDNAReader::getBlendShapeTargetDeltaXs(std::uint16_t meshIndex, std::uint16_t blendShapeTargetIndex) const
|
|
{
|
|
return Reader->getBlendShapeTargetDeltaXs(meshIndex, blendShapeTargetIndex);
|
|
}
|
|
dna::ConstArrayView<float> RigLogicDNAReader::getBlendShapeTargetDeltaYs(std::uint16_t meshIndex, std::uint16_t blendShapeTargetIndex) const
|
|
{
|
|
return Reader->getBlendShapeTargetDeltaYs(meshIndex, blendShapeTargetIndex);
|
|
}
|
|
dna::ConstArrayView<float> RigLogicDNAReader::getBlendShapeTargetDeltaZs(std::uint16_t meshIndex, std::uint16_t blendShapeTargetIndex) const
|
|
{
|
|
return Reader->getBlendShapeTargetDeltaZs(meshIndex, blendShapeTargetIndex);
|
|
}
|
|
dna::ConstArrayView<std::uint32_t> RigLogicDNAReader::getBlendShapeTargetVertexIndices(std::uint16_t meshIndex, std::uint16_t blendShapeTargetIndex) const
|
|
{
|
|
return Reader->getBlendShapeTargetVertexIndices(meshIndex, blendShapeTargetIndex);
|
|
}
|
|
|
|
// Machine Learned Behavior
|
|
std::uint16_t RigLogicDNAReader::getMLControlCount() const
|
|
{
|
|
return Reader->getMLControlCount();
|
|
}
|
|
dna::StringView RigLogicDNAReader::getMLControlName(std::uint16_t index) const
|
|
{
|
|
return Reader->getMLControlName(index);
|
|
}
|
|
std::uint16_t RigLogicDNAReader::getNeuralNetworkCount() const
|
|
{
|
|
return Reader->getNeuralNetworkCount();
|
|
}
|
|
std::uint16_t RigLogicDNAReader::getNeuralNetworkIndexListCount() const
|
|
{
|
|
return Reader->getNeuralNetworkIndexListCount();
|
|
}
|
|
dna::ConstArrayView<std::uint16_t> RigLogicDNAReader::getNeuralNetworkIndicesForLOD(std::uint16_t lod) const
|
|
{
|
|
return Reader->getNeuralNetworkIndicesForLOD(lod);
|
|
}
|
|
std::uint16_t RigLogicDNAReader::getMeshRegionCount(std::uint16_t meshIndex) const
|
|
{
|
|
return Reader->getMeshRegionCount(meshIndex);
|
|
}
|
|
dna::StringView RigLogicDNAReader::getMeshRegionName(std::uint16_t meshIndex, std::uint16_t regionIndex) const
|
|
{
|
|
return Reader->getMeshRegionName(meshIndex, regionIndex);
|
|
}
|
|
dna::ConstArrayView<std::uint16_t> RigLogicDNAReader::getNeuralNetworkIndicesForMeshRegion(std::uint16_t meshIndex, std::uint16_t regionIndex) const
|
|
{
|
|
return Reader->getNeuralNetworkIndicesForMeshRegion(meshIndex, regionIndex);
|
|
}
|
|
dna::ConstArrayView<std::uint16_t> RigLogicDNAReader::getNeuralNetworkInputIndices(std::uint16_t netIndex) const
|
|
{
|
|
return Reader->getNeuralNetworkInputIndices(netIndex);
|
|
}
|
|
dna::ConstArrayView<std::uint16_t> RigLogicDNAReader::getNeuralNetworkOutputIndices(std::uint16_t netIndex) const
|
|
{
|
|
return Reader->getNeuralNetworkOutputIndices(netIndex);
|
|
}
|
|
std::uint16_t RigLogicDNAReader::getNeuralNetworkLayerCount(std::uint16_t netIndex) const
|
|
{
|
|
return Reader->getNeuralNetworkLayerCount(netIndex);
|
|
}
|
|
dna::ActivationFunction RigLogicDNAReader::getNeuralNetworkLayerActivationFunction(std::uint16_t netIndex, std::uint16_t layerIndex) const
|
|
{
|
|
return Reader->getNeuralNetworkLayerActivationFunction(netIndex, layerIndex);
|
|
}
|
|
dna::ConstArrayView<float> RigLogicDNAReader::getNeuralNetworkLayerActivationFunctionParameters(std::uint16_t netIndex, std::uint16_t layerIndex) const
|
|
{
|
|
return Reader->getNeuralNetworkLayerActivationFunctionParameters(netIndex, layerIndex);
|
|
}
|
|
dna::ConstArrayView<float> RigLogicDNAReader::getNeuralNetworkLayerBiases(std::uint16_t netIndex, std::uint16_t layerIndex) const
|
|
{
|
|
return Reader->getNeuralNetworkLayerBiases(netIndex, layerIndex);
|
|
}
|
|
dna::ConstArrayView<float> RigLogicDNAReader::getNeuralNetworkLayerWeights(std::uint16_t netIndex, std::uint16_t layerIndex) const
|
|
{
|
|
return Reader->getNeuralNetworkLayerWeights(netIndex, layerIndex);
|
|
}
|
|
|
|
// RBFBehaviorReader methods
|
|
std::uint16_t RigLogicDNAReader::getRBFPoseCount() const
|
|
{
|
|
return Reader->getRBFPoseCount();
|
|
}
|
|
dna::StringView RigLogicDNAReader::getRBFPoseName(std::uint16_t poseIndex) const
|
|
{
|
|
return Reader->getRBFPoseName(poseIndex);
|
|
}
|
|
dna::ConstArrayView<std::uint16_t> RigLogicDNAReader::getRBFPoseJointOutputIndices(std::uint16_t poseIndex) const
|
|
{
|
|
return Reader->getRBFPoseJointOutputIndices(poseIndex);
|
|
}
|
|
dna::ConstArrayView<std::uint16_t> RigLogicDNAReader::getRBFPoseBlendShapeChannelOutputIndices(std::uint16_t poseIndex) const
|
|
{
|
|
return Reader->getRBFPoseBlendShapeChannelOutputIndices(poseIndex);
|
|
}
|
|
dna::ConstArrayView<std::uint16_t> RigLogicDNAReader::getRBFPoseAnimatedMapOutputIndices(std::uint16_t poseIndex) const
|
|
{
|
|
return Reader->getRBFPoseAnimatedMapOutputIndices(poseIndex);
|
|
}
|
|
dna::ConstArrayView<float> RigLogicDNAReader::getRBFPoseJointOutputValues(std::uint16_t poseIndex) const
|
|
{
|
|
CacheRBFPoseJointOutputValues(poseIndex);
|
|
return {RBFValues.GetData(), static_cast<std::size_t>(RBFValues.Num())};
|
|
}
|
|
float RigLogicDNAReader::getRBFPoseScale(std::uint16_t poseIndex) const
|
|
{
|
|
return Reader->getRBFPoseScale(poseIndex);
|
|
}
|
|
std::uint16_t RigLogicDNAReader::getRBFPoseControlCount() const
|
|
{
|
|
return Reader->getRBFPoseControlCount();
|
|
}
|
|
dna::StringView RigLogicDNAReader::getRBFPoseControlName(std::uint16_t poseControlIndex) const
|
|
{
|
|
return Reader->getRBFPoseControlName(poseControlIndex);
|
|
}
|
|
dna::ConstArrayView<std::uint16_t> RigLogicDNAReader::getRBFPoseInputControlIndices(std::uint16_t poseIndex) const
|
|
{
|
|
return Reader->getRBFPoseInputControlIndices(poseIndex);
|
|
}
|
|
dna::ConstArrayView<std::uint16_t> RigLogicDNAReader::getRBFPoseOutputControlIndices(std::uint16_t poseIndex) const
|
|
{
|
|
return Reader->getRBFPoseOutputControlIndices(poseIndex);
|
|
}
|
|
dna::ConstArrayView<float> RigLogicDNAReader::getRBFPoseOutputControlWeights(std::uint16_t poseIndex) const
|
|
{
|
|
return Reader->getRBFPoseOutputControlWeights(poseIndex);
|
|
}
|
|
std::uint16_t RigLogicDNAReader::getRBFSolverCount() const
|
|
{
|
|
return Reader->getRBFSolverCount();
|
|
}
|
|
std::uint16_t RigLogicDNAReader::getRBFSolverIndexListCount() const
|
|
{
|
|
return Reader->getRBFSolverIndexListCount();
|
|
}
|
|
dna::ConstArrayView<std::uint16_t> RigLogicDNAReader::getRBFSolverIndicesForLOD(std::uint16_t lod) const
|
|
{
|
|
return Reader->getRBFSolverIndicesForLOD(lod);
|
|
}
|
|
dna::StringView RigLogicDNAReader::getRBFSolverName(std::uint16_t solverIndex) const
|
|
{
|
|
return Reader->getRBFSolverName(solverIndex);
|
|
}
|
|
dna::ConstArrayView<std::uint16_t> RigLogicDNAReader::getRBFSolverRawControlIndices(std::uint16_t solverIndex) const
|
|
{
|
|
return Reader->getRBFSolverRawControlIndices(solverIndex);
|
|
}
|
|
dna::ConstArrayView<std::uint16_t> RigLogicDNAReader::getRBFSolverPoseIndices(std::uint16_t solverIndex) const
|
|
{
|
|
return Reader->getRBFSolverPoseIndices(solverIndex);
|
|
}
|
|
dna::ConstArrayView<float> RigLogicDNAReader::getRBFSolverRawControlValues(std::uint16_t solverIndex) const
|
|
{
|
|
CacheRBFSolverRawControlValues(solverIndex);
|
|
return {Values.GetData(), static_cast<std::size_t>(Values.Num())};
|
|
}
|
|
dna::RBFSolverType RigLogicDNAReader::getRBFSolverType(std::uint16_t solverIndex) const
|
|
{
|
|
return Reader->getRBFSolverType(solverIndex);
|
|
}
|
|
float RigLogicDNAReader::getRBFSolverRadius(std::uint16_t solverIndex) const
|
|
{
|
|
return Reader->getRBFSolverRadius(solverIndex);
|
|
}
|
|
dna::AutomaticRadius RigLogicDNAReader::getRBFSolverAutomaticRadius(std::uint16_t solverIndex) const
|
|
{
|
|
return Reader->getRBFSolverAutomaticRadius(solverIndex);
|
|
}
|
|
float RigLogicDNAReader::getRBFSolverWeightThreshold(std::uint16_t solverIndex) const
|
|
{
|
|
return Reader->getRBFSolverWeightThreshold(solverIndex);
|
|
}
|
|
dna::RBFDistanceMethod RigLogicDNAReader::getRBFSolverDistanceMethod(std::uint16_t solverIndex) const
|
|
{
|
|
return Reader->getRBFSolverDistanceMethod(solverIndex);
|
|
}
|
|
dna::RBFNormalizeMethod RigLogicDNAReader::getRBFSolverNormalizeMethod(std::uint16_t solverIndex) const
|
|
{
|
|
return Reader->getRBFSolverNormalizeMethod(solverIndex);
|
|
}
|
|
dna::RBFFunctionType RigLogicDNAReader::getRBFSolverFunctionType(std::uint16_t solverIndex) const
|
|
{
|
|
return Reader->getRBFSolverFunctionType(solverIndex);
|
|
}
|
|
dna::TwistAxis RigLogicDNAReader::getRBFSolverTwistAxis(std::uint16_t solverIndex) const
|
|
{
|
|
return Reader->getRBFSolverTwistAxis(solverIndex);
|
|
}
|
|
|
|
// JointBehaviorMetadataReader methods
|
|
dna::TranslationRepresentation RigLogicDNAReader::getJointTranslationRepresentation(std::uint16_t jointIndex) const
|
|
{
|
|
return Reader->getJointTranslationRepresentation(jointIndex);
|
|
}
|
|
dna::RotationRepresentation RigLogicDNAReader::getJointRotationRepresentation(std::uint16_t jointIndex) const
|
|
{
|
|
return Reader->getJointRotationRepresentation(jointIndex);
|
|
}
|
|
dna::ScaleRepresentation RigLogicDNAReader::getJointScaleRepresentation(std::uint16_t jointIndex) const
|
|
{
|
|
return Reader->getJointScaleRepresentation(jointIndex);
|
|
}
|
|
|
|
// TwistSwingBehaviorReader methods
|
|
std::uint16_t RigLogicDNAReader::getTwistCount() const
|
|
{
|
|
return Reader->getTwistCount();
|
|
}
|
|
dna::TwistAxis RigLogicDNAReader::getTwistSetupTwistAxis(std::uint16_t twistIndex) const
|
|
{
|
|
return Reader->getTwistSetupTwistAxis(twistIndex);
|
|
}
|
|
dna::ConstArrayView<std::uint16_t> RigLogicDNAReader::getTwistInputControlIndices(std::uint16_t twistIndex) const
|
|
{
|
|
return Reader->getTwistInputControlIndices(twistIndex);
|
|
}
|
|
dna::ConstArrayView<std::uint16_t> RigLogicDNAReader::getTwistOutputJointIndices(std::uint16_t twistIndex) const
|
|
{
|
|
return Reader->getTwistOutputJointIndices(twistIndex);
|
|
}
|
|
dna::ConstArrayView<float> RigLogicDNAReader::getTwistBlendWeights(std::uint16_t twistIndex) const
|
|
{
|
|
return Reader->getTwistBlendWeights(twistIndex);
|
|
}
|
|
std::uint16_t RigLogicDNAReader::getSwingCount() const
|
|
{
|
|
return Reader->getSwingCount();
|
|
}
|
|
dna::TwistAxis RigLogicDNAReader::getSwingSetupTwistAxis(std::uint16_t swingIndex) const
|
|
{
|
|
return Reader->getSwingSetupTwistAxis(swingIndex);
|
|
}
|
|
dna::ConstArrayView<std::uint16_t> RigLogicDNAReader::getSwingInputControlIndices(std::uint16_t swingIndex) const
|
|
{
|
|
return Reader->getSwingInputControlIndices(swingIndex);
|
|
}
|
|
dna::ConstArrayView<std::uint16_t> RigLogicDNAReader::getSwingOutputJointIndices(std::uint16_t swingIndex) const
|
|
{
|
|
return Reader->getSwingOutputJointIndices(swingIndex);
|
|
}
|
|
dna::ConstArrayView<float> RigLogicDNAReader::getSwingBlendWeights(std::uint16_t swingIndex) const
|
|
{
|
|
return Reader->getSwingBlendWeights(swingIndex);
|
|
}
|
|
|
|
// Reader
|
|
void RigLogicDNAReader::unload(dna::DataLayer Layer)
|
|
{
|
|
ensureMsgf(false, TEXT("Assets are not unloadable"));
|
|
}
|
|
|
|
void RigLogicDNAReader::CacheNeutralJointTranslations() const
|
|
{
|
|
if (Key == CachedDataKey::NeutralJointTranslations)
|
|
{
|
|
// Already cached
|
|
return;
|
|
}
|
|
|
|
const auto Xs = Reader->getNeutralJointTranslationXs();
|
|
const auto Ys = Reader->getNeutralJointTranslationYs();
|
|
const auto Zs = Reader->getNeutralJointTranslationZs();
|
|
Values.Reset(Xs.size() + Ys.size() + Zs.size());
|
|
Values.Append(Xs.data(), Xs.size());
|
|
Values.Append(Ys.data(), Ys.size());
|
|
Values.Append(Zs.data(), Zs.size());
|
|
for (std::size_t YIndex = Xs.size(); YIndex < (Xs.size() + Ys.size()); ++YIndex)
|
|
{
|
|
Values[YIndex] = -Values[YIndex];
|
|
}
|
|
Key = CachedDataKey::NeutralJointTranslations;
|
|
}
|
|
|
|
void RigLogicDNAReader::CacheNeutralJointRotations() const
|
|
{
|
|
if (Key == CachedDataKey::NeutralJointRotations)
|
|
{
|
|
// Already cached
|
|
return;
|
|
}
|
|
|
|
const auto Xs = Reader->getNeutralJointRotationXs();
|
|
const auto Ys = Reader->getNeutralJointRotationYs();
|
|
const auto Zs = Reader->getNeutralJointRotationZs();
|
|
Values.Reset(Xs.size() + Ys.size() + Zs.size());
|
|
Values.Append(Xs.data(), Xs.size());
|
|
Values.Append(Ys.data(), Ys.size());
|
|
Values.Append(Zs.data(), Zs.size());
|
|
for (std::size_t XIndex = 0; XIndex < Xs.size(); ++XIndex)
|
|
{
|
|
Values[XIndex] = -Values[XIndex];
|
|
}
|
|
for (std::size_t ZIndex = (Xs.size() + Ys.size()); ZIndex < (Xs.size() + Ys.size() + Zs.size()); ++ZIndex)
|
|
{
|
|
Values[ZIndex] = -Values[ZIndex];
|
|
}
|
|
Key = CachedDataKey::NeutralJointRotations;
|
|
}
|
|
|
|
void RigLogicDNAReader::CacheJointGroup(std::uint16_t JointGroupIndex) const
|
|
{
|
|
if ((Key == CachedDataKey::JointGroup) && (Id == JointGroupIndex))
|
|
{
|
|
// Already cached
|
|
return;
|
|
}
|
|
|
|
const auto InputIndices = Reader->getJointGroupInputIndices(JointGroupIndex);
|
|
const auto OutputIndices = Reader->getJointGroupOutputIndices(JointGroupIndex);
|
|
const auto ColCount = InputIndices.size();
|
|
const auto RowCount = OutputIndices.size();
|
|
const auto OriginalValues = Reader->getJointGroupValues(JointGroupIndex);
|
|
|
|
Values.Reset(OriginalValues.size());
|
|
Values.Append(OriginalValues.data(), OriginalValues.size());
|
|
for (std::size_t Row = 0; Row < RowCount; ++Row)
|
|
{
|
|
static constexpr auto JointAttrCount = 9;
|
|
const auto RelAttrIndex = OutputIndices[Row] % JointAttrCount;
|
|
// Translation Ys, Rotation Xs and Rotation Zs only need to be flipped
|
|
if ((RelAttrIndex == 1) || (RelAttrIndex == 3) || (RelAttrIndex == 5))
|
|
{
|
|
for (std::size_t Col = 0; Col < ColCount; ++Col)
|
|
{
|
|
Values[Row * ColCount + Col] = -Values[Row * ColCount + Col];
|
|
}
|
|
}
|
|
}
|
|
|
|
Key = CachedDataKey::JointGroup;
|
|
Id = JointGroupIndex;
|
|
}
|
|
|
|
void RigLogicDNAReader::CacheRBFPoseJointOutputValues(std::uint16_t PoseIndex) const
|
|
{
|
|
if ((Key == CachedDataKey::RBFPoseJointOutputValues) && (Id == PoseIndex))
|
|
{
|
|
// Already cached
|
|
return;
|
|
}
|
|
|
|
const auto OutputIndices = Reader->getRBFPoseJointOutputIndices(PoseIndex);
|
|
const auto OriginalValues = Reader->getRBFPoseJointOutputValues(PoseIndex);
|
|
const auto RowCount = OutputIndices.size();
|
|
const auto ColCount = (RowCount == 0) ? 0 : OriginalValues.size() / RowCount;
|
|
|
|
RBFValues.Reset(OriginalValues.size());
|
|
RBFValues.Append(OriginalValues.data(), OriginalValues.size());
|
|
for (std::size_t Row = 0; Row < RowCount; ++Row)
|
|
{
|
|
static constexpr auto JointAttrCount = 9;
|
|
const auto RelAttrIndex = OutputIndices[Row] % JointAttrCount;
|
|
// Translation Ys, Rotation Xs and Rotation Zs only need to be flipped
|
|
if ((RelAttrIndex == 1) || (RelAttrIndex == 3) || (RelAttrIndex == 5))
|
|
{
|
|
for (std::size_t Col = 0; Col < ColCount; ++Col)
|
|
{
|
|
RBFValues[Row * ColCount + Col] = -RBFValues[Row * ColCount + Col];
|
|
}
|
|
}
|
|
}
|
|
|
|
Key = CachedDataKey::RBFPoseJointOutputValues;
|
|
Id = PoseIndex;
|
|
}
|
|
|
|
void RigLogicDNAReader::CacheRBFSolverRawControlValues(std::uint16_t SolverIndex) const
|
|
{
|
|
if ((Key == CachedDataKey::RBFSolverRawControlValues) && (Id == SolverIndex))
|
|
{
|
|
// Already cached
|
|
return;
|
|
}
|
|
|
|
const auto SolverDistanceMethod = Reader->getRBFSolverDistanceMethod(SolverIndex);
|
|
const auto RawControlValues = Reader->getRBFSolverRawControlValues(SolverIndex);
|
|
|
|
Values.Reset(RawControlValues.size());
|
|
Values.Append(RawControlValues.data(), RawControlValues.size());
|
|
if (SolverDistanceMethod != dna::RBFDistanceMethod::Euclidean)
|
|
{
|
|
ensureMsgf(Values.Num() % 4 == 0, TEXT("DNA RBF Solver Raw Control Value count invalid"));
|
|
for (std::size_t Offset = 0; Offset < Values.Num(); Offset += 4)
|
|
{
|
|
const tdm::fquat PoseRotationInDNASpace{Values[Offset + 0], Values[Offset + 1], Values[Offset + 2], Values[Offset + 3]};
|
|
const tdm::frad3 PoseRotationInDNASpaceEuler = PoseRotationInDNASpace.euler<tdm::rot_seq::zyx>();
|
|
// Flip sign on X and Z axes
|
|
const tdm::frad3 PoseRotationInUESpaceEuler{-PoseRotationInDNASpaceEuler[0], PoseRotationInDNASpaceEuler[1], -PoseRotationInDNASpaceEuler[2]};
|
|
const tdm::fquat PoseRotationInUESpace{PoseRotationInUESpaceEuler, tdm::rot_seq::zyx};
|
|
Values[Offset + 0] = PoseRotationInUESpace.x;
|
|
Values[Offset + 1] = PoseRotationInUESpace.y;
|
|
Values[Offset + 2] = PoseRotationInUESpace.z;
|
|
Values[Offset + 3] = PoseRotationInUESpace.w;
|
|
}
|
|
}
|
|
|
|
Key = CachedDataKey::RBFSolverRawControlValues;
|
|
Id = SolverIndex;
|
|
}
|
|
|
|
void RigLogicDNAReader::destroy(dna::Reader* Pointer)
|
|
{
|
|
}
|