DNA Calib 1.1
Project brief
Public Member Functions | Protected Attributes | List of all members
dnac::ReaderImpl< TReaderBase > Class Template Reference

#include <ReaderImpl.h>

Inheritance diagram for dnac::ReaderImpl< TReaderBase >:
Inheritance graph
Collaboration diagram for dnac::ReaderImpl< TReaderBase >:
Collaboration graph

Public Member Functions

 ReaderImpl (MemoryResource *memRes_)
 
StringView getName () const override
 
Archetype getArchetype () const override
 
Gender getGender () const override
 
std::uint16_t getAge () const override
 
std::uint32_t getMetaDataCount () const override
 
StringView getMetaDataKey (std::uint32_t index) const override
 
StringView getMetaDataValue (const char *key) const override
 
TranslationUnit getTranslationUnit () const override
 
RotationUnit getRotationUnit () const override
 
CoordinateSystem getCoordinateSystem () const override
 
std::uint16_t getLODCount () const override
 
std::uint16_t getDBMaxLOD () const override
 
StringView getDBComplexity () const override
 
StringView getDBName () const override
 
std::uint16_t getGUIControlCount () const override
 
StringView getGUIControlName (std::uint16_t index) const override
 
std::uint16_t getRawControlCount () const override
 
StringView getRawControlName (std::uint16_t index) const override
 
std::uint16_t getJointCount () const override
 
StringView getJointName (std::uint16_t index) const override
 
std::uint16_t getJointIndexListCount () const override
 
ConstArrayView< std::uint16_t > getJointIndicesForLOD (std::uint16_t lod) const override
 
std::uint16_t getJointParentIndex (std::uint16_t index) const override
 
std::uint16_t getBlendShapeChannelCount () const override
 
StringView getBlendShapeChannelName (std::uint16_t index) const override
 
std::uint16_t getBlendShapeChannelIndexListCount () const override
 
ConstArrayView< std::uint16_t > getBlendShapeChannelIndicesForLOD (std::uint16_t lod) const override
 
std::uint16_t getAnimatedMapCount () const override
 
StringView getAnimatedMapName (std::uint16_t index) const override
 
std::uint16_t getAnimatedMapIndexListCount () const override
 
ConstArrayView< std::uint16_t > getAnimatedMapIndicesForLOD (std::uint16_t lod) const override
 
std::uint16_t getMeshCount () const override
 
StringView getMeshName (std::uint16_t index) const override
 
std::uint16_t getMeshIndexListCount () const override
 
ConstArrayView< std::uint16_t > getMeshIndicesForLOD (std::uint16_t lod) const override
 
std::uint16_t getMeshBlendShapeChannelMappingCount () const override
 
MeshBlendShapeChannelMapping getMeshBlendShapeChannelMapping (std::uint16_t index) const override
 
ConstArrayView< std::uint16_t > getMeshBlendShapeChannelMappingIndicesForLOD (std::uint16_t lod) const override
 
Vector3 getNeutralJointTranslation (std::uint16_t index) const override
 
ConstArrayView< float > getNeutralJointTranslationXs () const override
 
ConstArrayView< float > getNeutralJointTranslationYs () const override
 
ConstArrayView< float > getNeutralJointTranslationZs () const override
 
Vector3 getNeutralJointRotation (std::uint16_t index) const override
 
ConstArrayView< float > getNeutralJointRotationXs () const override
 
ConstArrayView< float > getNeutralJointRotationYs () const override
 
ConstArrayView< float > getNeutralJointRotationZs () const override
 
ConstArrayView< std::uint16_t > getGUIToRawInputIndices () const override
 
ConstArrayView< std::uint16_t > getGUIToRawOutputIndices () const override
 
ConstArrayView< float > getGUIToRawFromValues () const override
 
ConstArrayView< float > getGUIToRawToValues () const override
 
ConstArrayView< float > getGUIToRawSlopeValues () const override
 
ConstArrayView< float > getGUIToRawCutValues () const override
 
std::uint16_t getPSDCount () const override
 
ConstArrayView< std::uint16_t > getPSDRowIndices () const override
 
ConstArrayView< std::uint16_t > getPSDColumnIndices () const override
 
ConstArrayView< float > getPSDValues () const override
 
std::uint16_t getJointRowCount () const override
 
std::uint16_t getJointColumnCount () const override
 
ConstArrayView< std::uint16_t > getJointVariableAttributeIndices (std::uint16_t lod) const override
 
std::uint16_t getJointGroupCount () const override
 
ConstArrayView< std::uint16_t > getJointGroupLODs (std::uint16_t jointGroupIndex) const override
 
ConstArrayView< std::uint16_t > getJointGroupInputIndices (std::uint16_t jointGroupIndex) const override
 
ConstArrayView< std::uint16_t > getJointGroupOutputIndices (std::uint16_t jointGroupIndex) const override
 
ConstArrayView< float > getJointGroupValues (std::uint16_t jointGroupIndex) const override
 
ConstArrayView< std::uint16_t > getJointGroupJointIndices (std::uint16_t jointGroupIndex) const override
 
ConstArrayView< std::uint16_t > getBlendShapeChannelLODs () const override
 
ConstArrayView< std::uint16_t > getBlendShapeChannelOutputIndices () const override
 
ConstArrayView< std::uint16_t > getBlendShapeChannelInputIndices () const override
 
ConstArrayView< std::uint16_t > getAnimatedMapLODs () const override
 
ConstArrayView< std::uint16_t > getAnimatedMapInputIndices () const override
 
ConstArrayView< std::uint16_t > getAnimatedMapOutputIndices () const override
 
ConstArrayView< float > getAnimatedMapFromValues () const override
 
ConstArrayView< float > getAnimatedMapToValues () const override
 
ConstArrayView< float > getAnimatedMapSlopeValues () const override
 
ConstArrayView< float > getAnimatedMapCutValues () const override
 
std::uint32_t getVertexPositionCount (std::uint16_t meshIndex) const override
 
Position getVertexPosition (std::uint16_t meshIndex, std::uint32_t vertexIndex) const override
 
ConstArrayView< float > getVertexPositionXs (std::uint16_t meshIndex) const override
 
ConstArrayView< float > getVertexPositionYs (std::uint16_t meshIndex) const override
 
ConstArrayView< float > getVertexPositionZs (std::uint16_t meshIndex) const override
 
std::uint32_t getVertexTextureCoordinateCount (std::uint16_t meshIndex) const override
 
TextureCoordinate getVertexTextureCoordinate (std::uint16_t meshIndex, std::uint32_t textureCoordinateIndex) const override
 
ConstArrayView< float > getVertexTextureCoordinateUs (std::uint16_t meshIndex) const override
 
ConstArrayView< float > getVertexTextureCoordinateVs (std::uint16_t meshIndex) const override
 
std::uint32_t getVertexNormalCount (std::uint16_t meshIndex) const override
 
Normal getVertexNormal (std::uint16_t meshIndex, std::uint32_t normalIndex) const override
 
ConstArrayView< float > getVertexNormalXs (std::uint16_t meshIndex) const override
 
ConstArrayView< float > getVertexNormalYs (std::uint16_t meshIndex) const override
 
ConstArrayView< float > getVertexNormalZs (std::uint16_t meshIndex) const override
 
std::uint32_t getFaceCount (std::uint16_t meshIndex) const override
 
ConstArrayView< std::uint32_t > getFaceVertexLayoutIndices (std::uint16_t meshIndex, std::uint32_t faceIndex) const override
 
std::uint32_t getVertexLayoutCount (std::uint16_t meshIndex) const override
 
VertexLayout getVertexLayout (std::uint16_t meshIndex, std::uint32_t layoutIndex) const override
 
ConstArrayView< std::uint32_t > getVertexLayoutPositionIndices (std::uint16_t meshIndex) const override
 
ConstArrayView< std::uint32_t > getVertexLayoutTextureCoordinateIndices (std::uint16_t meshIndex) const override
 
ConstArrayView< std::uint32_t > getVertexLayoutNormalIndices (std::uint16_t meshIndex) const override
 
std::uint16_t getMaximumInfluencePerVertex (std::uint16_t meshIndex) const override
 
std::uint32_t getSkinWeightsCount (std::uint16_t meshIndex) const override
 
ConstArrayView< float > getSkinWeightsValues (std::uint16_t meshIndex, std::uint32_t vertexIndex) const override
 
ConstArrayView< std::uint16_t > getSkinWeightsJointIndices (std::uint16_t meshIndex, std::uint32_t vertexIndex) const override
 
std::uint16_t getBlendShapeTargetCount (std::uint16_t meshIndex) const override
 
std::uint16_t getBlendShapeChannelIndex (std::uint16_t meshIndex, std::uint16_t blendShapeTargetIndex) const override
 
std::uint32_t getBlendShapeTargetDeltaCount (std::uint16_t meshIndex, std::uint16_t blendShapeTargetIndex) const override
 
Delta getBlendShapeTargetDelta (std::uint16_t meshIndex, std::uint16_t blendShapeTargetIndex, std::uint32_t deltaIndex) const override
 
ConstArrayView< float > getBlendShapeTargetDeltaXs (std::uint16_t meshIndex, std::uint16_t blendShapeTargetIndex) const override
 
ConstArrayView< float > getBlendShapeTargetDeltaYs (std::uint16_t meshIndex, std::uint16_t blendShapeTargetIndex) const override
 
ConstArrayView< float > getBlendShapeTargetDeltaZs (std::uint16_t meshIndex, std::uint16_t blendShapeTargetIndex) const override
 
ConstArrayView< std::uint32_t > getBlendShapeTargetVertexIndices (std::uint16_t meshIndex, std::uint16_t blendShapeTargetIndex) const override
 
void unload (DataLayer layer) override
 
- Public Member Functions inherited from dnac::BaseImpl
MemoryResource * getMemoryResource ()
 

Protected Attributes

DenormalizedData< TReaderBase > cache
 
- Protected Attributes inherited from dnac::BaseImpl
MemoryResource * memRes
 
DNA dna
 

Additional Inherited Members

- Protected Member Functions inherited from dnac::BaseImpl
 BaseImpl (MemoryResource *memRes_)
 
 ~BaseImpl ()=default
 
 BaseImpl (const BaseImpl &)=delete
 
BaseImpl & operator= (const BaseImpl &)=delete
 
 BaseImpl (BaseImpl &&rhs)=delete
 
BaseImpl & operator= (BaseImpl &&)=delete
 

Constructor & Destructor Documentation

◆ ReaderImpl()

template<class TReaderBase >
dnac::ReaderImpl< TReaderBase >::ReaderImpl ( MemoryResource *  memRes_)
inlineexplicit
176 : BaseImpl{memRes_}, cache{memRes_} {
177}
dnac::BaseImpl::BaseImpl
BaseImpl(MemoryResource *memRes_)
Definition: dnacalib/dna/BaseImpl.h:12
dnac::ReaderImpl::cache
DenormalizedData< TReaderBase > cache
Definition: dnacalib/dna/ReaderImpl.h:166

Member Function Documentation

◆ getAge()

template<class TReaderBase >
std::uint16_t dnac::ReaderImpl< TReaderBase >::getAge
inlineoverride
203 {
204 return dna.descriptor.age;
205}
dna
Definition: BinaryStreamReader.h:10

◆ getAnimatedMapCount()

template<class TReaderBase >
std::uint16_t dnac::ReaderImpl< TReaderBase >::getAnimatedMapCount
inlineoverride
356 {
357 return static_cast<std::uint16_t>(dna.definition.animatedMapNames.size());
358}

◆ getAnimatedMapCutValues()

template<class TReaderBase >
ConstArrayView< float > dnac::ReaderImpl< TReaderBase >::getAnimatedMapCutValues
inlineoverride
659 {
660 const auto& cutValues = dna.behavior.animatedMaps.conditionals.cutValues;
661 return {cutValues.data(), cutValues.size()};
662}

◆ getAnimatedMapFromValues()

template<class TReaderBase >
ConstArrayView< float > dnac::ReaderImpl< TReaderBase >::getAnimatedMapFromValues
inlineoverride
641 {
642 const auto& fromValues = dna.behavior.animatedMaps.conditionals.fromValues;
643 return {fromValues.data(), fromValues.size()};
644}

◆ getAnimatedMapIndexListCount()

template<class TReaderBase >
std::uint16_t dnac::ReaderImpl< TReaderBase >::getAnimatedMapIndexListCount
inlineoverride
370 {
371 return dna.definition.lodAnimatedMapMapping.getIndexListCount();
372}

◆ getAnimatedMapIndicesForLOD()

template<class TReaderBase >
ConstArrayView< std::uint16_t > dnac::ReaderImpl< TReaderBase >::getAnimatedMapIndicesForLOD ( std::uint16_t  lod) const
inlineoverride
375 {
376 return dna.definition.lodAnimatedMapMapping.getIndices(lod);
377}

◆ getAnimatedMapInputIndices()

template<class TReaderBase >
ConstArrayView< std::uint16_t > dnac::ReaderImpl< TReaderBase >::getAnimatedMapInputIndices
inlineoverride
629 {
630 const auto& inputIndices = dna.behavior.animatedMaps.conditionals.inputIndices;
631 return {inputIndices.data(), inputIndices.size()};
632}

◆ getAnimatedMapLODs()

template<class TReaderBase >
ConstArrayView< std::uint16_t > dnac::ReaderImpl< TReaderBase >::getAnimatedMapLODs
inlineoverride
623 {
624 const auto& lods = dna.behavior.animatedMaps.lods;
625 return {lods.data(), lods.size()};
626}

◆ getAnimatedMapName()

template<class TReaderBase >
StringView dnac::ReaderImpl< TReaderBase >::getAnimatedMapName ( std::uint16_t  index) const
inlineoverride
361 {
362 if (index < dna.definition.animatedMapNames.size()) {
363 const auto& animatedMapName = dna.definition.animatedMapNames[index];
364 return {animatedMapName.data(), animatedMapName.size()};
365 }
366 return {};
367}

◆ getAnimatedMapOutputIndices()

template<class TReaderBase >
ConstArrayView< std::uint16_t > dnac::ReaderImpl< TReaderBase >::getAnimatedMapOutputIndices
inlineoverride
635 {
636 const auto& outputIndices = dna.behavior.animatedMaps.conditionals.outputIndices;
637 return {outputIndices.data(), outputIndices.size()};
638}

◆ getAnimatedMapSlopeValues()

template<class TReaderBase >
ConstArrayView< float > dnac::ReaderImpl< TReaderBase >::getAnimatedMapSlopeValues
inlineoverride
653 {
654 const auto& slopeValues = dna.behavior.animatedMaps.conditionals.slopeValues;
655 return {slopeValues.data(), slopeValues.size()};
656}

◆ getAnimatedMapToValues()

template<class TReaderBase >
ConstArrayView< float > dnac::ReaderImpl< TReaderBase >::getAnimatedMapToValues
inlineoverride
647 {
648 const auto& toValues = dna.behavior.animatedMaps.conditionals.toValues;
649 return {toValues.data(), toValues.size()};
650}

◆ getArchetype()

template<class TReaderBase >
Archetype dnac::ReaderImpl< TReaderBase >::getArchetype
inlineoverride
193 {
194 return static_cast<Archetype>(dna.descriptor.archetype);
195}
dna::Archetype
Archetype
Definition: Descriptor.h:7

◆ getBlendShapeChannelCount()

template<class TReaderBase >
std::uint16_t dnac::ReaderImpl< TReaderBase >::getBlendShapeChannelCount
inlineoverride
332 {
333 return static_cast<std::uint16_t>(dna.definition.blendShapeChannelNames.size());
334}

◆ getBlendShapeChannelIndex()

template<class TReaderBase >
std::uint16_t dnac::ReaderImpl< TReaderBase >::getBlendShapeChannelIndex ( std::uint16_t  meshIndex,
std::uint16_t  blendShapeTargetIndex 
) const
inlineoverride
903 {
904 const auto& meshes = dna.geometry.meshes;
905 if ((meshIndex < meshes.size()) && (blendShapeTargetIndex < meshes[meshIndex].blendShapeTargets.size())) {
906 return meshes[meshIndex].blendShapeTargets[blendShapeTargetIndex].blendShapeChannelIndex;
907 }
908 return {};
909}

◆ getBlendShapeChannelIndexListCount()

template<class TReaderBase >
std::uint16_t dnac::ReaderImpl< TReaderBase >::getBlendShapeChannelIndexListCount
inlineoverride
346 {
347 return dna.definition.lodBlendShapeMapping.getIndexListCount();
348}

◆ getBlendShapeChannelIndicesForLOD()

template<class TReaderBase >
ConstArrayView< std::uint16_t > dnac::ReaderImpl< TReaderBase >::getBlendShapeChannelIndicesForLOD ( std::uint16_t  lod) const
inlineoverride
351 {
352 return dna.definition.lodBlendShapeMapping.getIndices(lod);
353}

◆ getBlendShapeChannelInputIndices()

template<class TReaderBase >
ConstArrayView< std::uint16_t > dnac::ReaderImpl< TReaderBase >::getBlendShapeChannelInputIndices
inlineoverride
611 {
612 const auto& inputIndices = dna.behavior.blendShapeChannels.inputIndices;
613 return {inputIndices.data(), inputIndices.size()};
614}

◆ getBlendShapeChannelLODs()

template<class TReaderBase >
ConstArrayView< std::uint16_t > dnac::ReaderImpl< TReaderBase >::getBlendShapeChannelLODs
inlineoverride
605 {
606 const auto& lods = dna.behavior.blendShapeChannels.lods;
607 return {lods.data(), lods.size()};
608}

◆ getBlendShapeChannelName()

template<class TReaderBase >
StringView dnac::ReaderImpl< TReaderBase >::getBlendShapeChannelName ( std::uint16_t  index) const
inlineoverride
337 {
338 if (index < dna.definition.blendShapeChannelNames.size()) {
339 const auto& blendShapeName = dna.definition.blendShapeChannelNames[index];
340 return {blendShapeName.data(), blendShapeName.size()};
341 }
342 return {};
343}

◆ getBlendShapeChannelOutputIndices()

template<class TReaderBase >
ConstArrayView< std::uint16_t > dnac::ReaderImpl< TReaderBase >::getBlendShapeChannelOutputIndices
inlineoverride
617 {
618 const auto& outputIndices = dna.behavior.blendShapeChannels.outputIndices;
619 return {outputIndices.data(), outputIndices.size()};
620}

◆ getBlendShapeTargetCount()

template<class TReaderBase >
std::uint16_t dnac::ReaderImpl< TReaderBase >::getBlendShapeTargetCount ( std::uint16_t  meshIndex) const
inlineoverride
894 {
895 if (meshIndex < dna.geometry.meshes.size()) {
896 return static_cast<std::uint16_t>(dna.geometry.meshes[meshIndex].blendShapeTargets.size());
897 }
898 return {};
899}

Referenced by dnac::RotateCommand::Impl::rotateBlendShapeTargetDeltas(), and dnac::ScaleCommand::Impl::scaleBlendShapeTargetDeltas().

◆ getBlendShapeTargetDelta()

template<class TReaderBase >
Delta dnac::ReaderImpl< TReaderBase >::getBlendShapeTargetDelta ( std::uint16_t  meshIndex,
std::uint16_t  blendShapeTargetIndex,
std::uint32_t  deltaIndex 
) const
inlineoverride
924 {
925 const auto& meshes = dna.geometry.meshes;
926 if ((meshIndex < meshes.size()) && (blendShapeTargetIndex < meshes[meshIndex].blendShapeTargets.size()) &&
927 (deltaIndex < meshes[meshIndex].blendShapeTargets[blendShapeTargetIndex].deltas.size())) {
928 const auto& deltas = meshes[meshIndex].blendShapeTargets[blendShapeTargetIndex].deltas;
929 return {deltas.xs[deltaIndex], deltas.ys[deltaIndex], deltas.zs[deltaIndex]};
930 }
931 return {};
932}

◆ getBlendShapeTargetDeltaCount()

template<class TReaderBase >
std::uint32_t dnac::ReaderImpl< TReaderBase >::getBlendShapeTargetDeltaCount ( std::uint16_t  meshIndex,
std::uint16_t  blendShapeTargetIndex 
) const
inlineoverride
913 {
914 const auto& meshes = dna.geometry.meshes;
915 if ((meshIndex < meshes.size()) && (blendShapeTargetIndex < meshes[meshIndex].blendShapeTargets.size())) {
916 return static_cast<std::uint32_t>(meshes[meshIndex].blendShapeTargets[blendShapeTargetIndex].deltas.xs.size());
917 }
918 return {};
919}

◆ getBlendShapeTargetDeltaXs()

template<class TReaderBase >
ConstArrayView< float > dnac::ReaderImpl< TReaderBase >::getBlendShapeTargetDeltaXs ( std::uint16_t  meshIndex,
std::uint16_t  blendShapeTargetIndex 
) const
inlineoverride
936 {
937 const auto& meshes = dna.geometry.meshes;
938 if ((meshIndex < meshes.size()) && (blendShapeTargetIndex < meshes[meshIndex].blendShapeTargets.size())) {
939 const auto& xDeltas = meshes[meshIndex].blendShapeTargets[blendShapeTargetIndex].deltas.xs;
940 return {xDeltas.data(), xDeltas.size()};
941 }
942 return {};
943}

Referenced by dnac::SetBlendShapeTargetDeltasCommand::Impl::computeBlendShapeTargetDeltas(), dnac::RotateCommand::Impl::rotateBlendShapeTargetDeltas(), and dnac::ScaleCommand::Impl::scaleBlendShapeTargetDeltas().

◆ getBlendShapeTargetDeltaYs()

template<class TReaderBase >
ConstArrayView< float > dnac::ReaderImpl< TReaderBase >::getBlendShapeTargetDeltaYs ( std::uint16_t  meshIndex,
std::uint16_t  blendShapeTargetIndex 
) const
inlineoverride
947 {
948 const auto& meshes = dna.geometry.meshes;
949 if ((meshIndex < meshes.size()) && (blendShapeTargetIndex < meshes[meshIndex].blendShapeTargets.size())) {
950 const auto& yDeltas = meshes[meshIndex].blendShapeTargets[blendShapeTargetIndex].deltas.ys;
951 return {yDeltas.data(), yDeltas.size()};
952 }
953 return {};
954}

Referenced by dnac::SetBlendShapeTargetDeltasCommand::Impl::computeBlendShapeTargetDeltas(), dnac::RotateCommand::Impl::rotateBlendShapeTargetDeltas(), and dnac::ScaleCommand::Impl::scaleBlendShapeTargetDeltas().

◆ getBlendShapeTargetDeltaZs()

template<class TReaderBase >
ConstArrayView< float > dnac::ReaderImpl< TReaderBase >::getBlendShapeTargetDeltaZs ( std::uint16_t  meshIndex,
std::uint16_t  blendShapeTargetIndex 
) const
inlineoverride
958 {
959 const auto& meshes = dna.geometry.meshes;
960 if ((meshIndex < meshes.size()) && (blendShapeTargetIndex < meshes[meshIndex].blendShapeTargets.size())) {
961 const auto& zDeltas = meshes[meshIndex].blendShapeTargets[blendShapeTargetIndex].deltas.zs;
962 return {zDeltas.data(), zDeltas.size()};
963 }
964 return {};
965}

Referenced by dnac::SetBlendShapeTargetDeltasCommand::Impl::computeBlendShapeTargetDeltas(), dnac::RotateCommand::Impl::rotateBlendShapeTargetDeltas(), and dnac::ScaleCommand::Impl::scaleBlendShapeTargetDeltas().

◆ getBlendShapeTargetVertexIndices()

template<class TReaderBase >
ConstArrayView< std::uint32_t > dnac::ReaderImpl< TReaderBase >::getBlendShapeTargetVertexIndices ( std::uint16_t  meshIndex,
std::uint16_t  blendShapeTargetIndex 
) const
inlineoverride
970 {
971 const auto& meshes = dna.geometry.meshes;
972 if ((meshIndex < meshes.size()) && (blendShapeTargetIndex < meshes[meshIndex].blendShapeTargets.size())) {
973 const auto& vertexIndices = meshes[meshIndex].blendShapeTargets[blendShapeTargetIndex].vertexIndices;
974 return {vertexIndices.data(), vertexIndices.size()};
975 }
976 return {};
977}

Referenced by dnac::SetBlendShapeTargetDeltasCommand::Impl::computeBlendShapeTargetDeltas().

◆ getCoordinateSystem()

template<class TReaderBase >
CoordinateSystem dnac::ReaderImpl< TReaderBase >::getCoordinateSystem
inlineoverride
243 {
244 return {
245 static_cast<Direction>(dna.descriptor.coordinateSystem.xAxis),
246 static_cast<Direction>(dna.descriptor.coordinateSystem.yAxis),
247 static_cast<Direction>(dna.descriptor.coordinateSystem.zAxis)
248 };
249}
dna::Direction
Direction
Definition: Descriptor.h:32

◆ getDBComplexity()

template<class TReaderBase >
StringView dnac::ReaderImpl< TReaderBase >::getDBComplexity
inlineoverride
262 {
263 return {dna.descriptor.complexity.data(), dna.descriptor.complexity.size()};
264}

◆ getDBMaxLOD()

template<class TReaderBase >
std::uint16_t dnac::ReaderImpl< TReaderBase >::getDBMaxLOD
inlineoverride
257 {
258 return dna.descriptor.maxLOD;
259}

◆ getDBName()

template<class TReaderBase >
StringView dnac::ReaderImpl< TReaderBase >::getDBName
inlineoverride
267 {
268 return {dna.descriptor.dbName.data(), dna.descriptor.dbName.size()};
269}

◆ getFaceCount()

template<class TReaderBase >
std::uint32_t dnac::ReaderImpl< TReaderBase >::getFaceCount ( std::uint16_t  meshIndex) const
inlineoverride
789 {
790 if (meshIndex < dna.geometry.meshes.size()) {
791 return static_cast<std::uint32_t>(dna.geometry.meshes[meshIndex].faces.size());
792 }
793 return 0u;
794}

◆ getFaceVertexLayoutIndices()

template<class TReaderBase >
ConstArrayView< std::uint32_t > dnac::ReaderImpl< TReaderBase >::getFaceVertexLayoutIndices ( std::uint16_t  meshIndex,
std::uint32_t  faceIndex 
) const
inlineoverride
798 {
799 const auto& meshes = dna.geometry.meshes;
800 if ((meshIndex < meshes.size()) && (faceIndex < meshes[meshIndex].faces.size())) {
801 const auto& layoutIndices = meshes[meshIndex].faces[faceIndex].layoutIndices;
802 return {layoutIndices.data(), layoutIndices.size()};
803 }
804 return {};
805}

◆ getGender()

template<class TReaderBase >
Gender dnac::ReaderImpl< TReaderBase >::getGender
inlineoverride
198 {
199 return static_cast<Gender>(dna.descriptor.gender);
200}
dna::Gender
Gender
Definition: Descriptor.h:16

◆ getGUIControlCount()

template<class TReaderBase >
std::uint16_t dnac::ReaderImpl< TReaderBase >::getGUIControlCount
inlineoverride
272 {
273 return static_cast<std::uint16_t>(dna.definition.guiControlNames.size());
274}

◆ getGUIControlName()

template<class TReaderBase >
StringView dnac::ReaderImpl< TReaderBase >::getGUIControlName ( std::uint16_t  index) const
inlineoverride
277 {
278 if (index < dna.definition.guiControlNames.size()) {
279 const auto& guiControlName = dna.definition.guiControlNames[index];
280 return {guiControlName.data(), guiControlName.size()};
281 }
282 return {};
283}

◆ getGUIToRawCutValues()

template<class TReaderBase >
ConstArrayView< float > dnac::ReaderImpl< TReaderBase >::getGUIToRawCutValues
inlineoverride
508 {
509 const auto& cutValues = dna.behavior.controls.conditionals.cutValues;
510 return {cutValues.data(), cutValues.size()};
511}

◆ getGUIToRawFromValues()

template<class TReaderBase >
ConstArrayView< float > dnac::ReaderImpl< TReaderBase >::getGUIToRawFromValues
inlineoverride
490 {
491 const auto& fromValues = dna.behavior.controls.conditionals.fromValues;
492 return {fromValues.data(), fromValues.size()};
493}

◆ getGUIToRawInputIndices()

template<class TReaderBase >
ConstArrayView< std::uint16_t > dnac::ReaderImpl< TReaderBase >::getGUIToRawInputIndices
inlineoverride
478 {
479 const auto& inputIndices = dna.behavior.controls.conditionals.inputIndices;
480 return {inputIndices.data(), inputIndices.size()};
481}

◆ getGUIToRawOutputIndices()

template<class TReaderBase >
ConstArrayView< std::uint16_t > dnac::ReaderImpl< TReaderBase >::getGUIToRawOutputIndices
inlineoverride
484 {
485 const auto& outputIndices = dna.behavior.controls.conditionals.outputIndices;
486 return {outputIndices.data(), outputIndices.size()};
487}

◆ getGUIToRawSlopeValues()

template<class TReaderBase >
ConstArrayView< float > dnac::ReaderImpl< TReaderBase >::getGUIToRawSlopeValues
inlineoverride
502 {
503 const auto& slopeValues = dna.behavior.controls.conditionals.slopeValues;
504 return {slopeValues.data(), slopeValues.size()};
505}

◆ getGUIToRawToValues()

template<class TReaderBase >
ConstArrayView< float > dnac::ReaderImpl< TReaderBase >::getGUIToRawToValues
inlineoverride
496 {
497 const auto& toValues = dna.behavior.controls.conditionals.toValues;
498 return {toValues.data(), toValues.size()};
499}

◆ getJointColumnCount()

template<class TReaderBase >
std::uint16_t dnac::ReaderImpl< TReaderBase >::getJointColumnCount
inlineoverride
542 {
543 return dna.behavior.joints.colCount;
544}

◆ getJointCount()

template<class TReaderBase >
std::uint16_t dnac::ReaderImpl< TReaderBase >::getJointCount
inlineoverride
300 {
301 return static_cast<std::uint16_t>(dna.definition.jointNames.size());
302}

Referenced by dnac::RotateCommand::Impl::rotateNeutralJoints(), and dnac::TranslateCommand::Impl::translateNeutralJoints().

◆ getJointGroupCount()

template<class TReaderBase >
std::uint16_t dnac::ReaderImpl< TReaderBase >::getJointGroupCount
inlineoverride
555 {
556 return static_cast<std::uint16_t>(dna.behavior.joints.jointGroups.size());
557}

Referenced by dnac::ScaleCommand::Impl::scaleJointBehavior().

◆ getJointGroupInputIndices()

template<class TReaderBase >
ConstArrayView< std::uint16_t > dnac::ReaderImpl< TReaderBase >::getJointGroupInputIndices ( std::uint16_t  jointGroupIndex) const
inlineoverride
569 {
570 if (jointGroupIndex < dna.behavior.joints.jointGroups.size()) {
571 const auto& inputIndices = dna.behavior.joints.jointGroups[jointGroupIndex].inputIndices;
572 return {inputIndices.data(), inputIndices.size()};
573 }
574 return {};
575}

Referenced by dnac::ScaleCommand::Impl::scaleJointBehavior().

◆ getJointGroupJointIndices()

template<class TReaderBase >
ConstArrayView< std::uint16_t > dnac::ReaderImpl< TReaderBase >::getJointGroupJointIndices ( std::uint16_t  jointGroupIndex) const
inlineoverride
596 {
597 if (jointGroupIndex < dna.behavior.joints.jointGroups.size()) {
598 const auto& jointIndices = dna.behavior.joints.jointGroups[jointGroupIndex].jointIndices;
599 return {jointIndices.data(), jointIndices.size()};
600 }
601 return {};
602}

◆ getJointGroupLODs()

template<class TReaderBase >
ConstArrayView< std::uint16_t > dnac::ReaderImpl< TReaderBase >::getJointGroupLODs ( std::uint16_t  jointGroupIndex) const
inlineoverride
560 {
561 if (jointGroupIndex < dna.behavior.joints.jointGroups.size()) {
562 const auto& lods = dna.behavior.joints.jointGroups[jointGroupIndex].lods;
563 return {lods.data(), lods.size()};
564 }
565 return {};
566}

◆ getJointGroupOutputIndices()

template<class TReaderBase >
ConstArrayView< std::uint16_t > dnac::ReaderImpl< TReaderBase >::getJointGroupOutputIndices ( std::uint16_t  jointGroupIndex) const
inlineoverride
578 {
579 if (jointGroupIndex < dna.behavior.joints.jointGroups.size()) {
580 const auto& outputIndices = dna.behavior.joints.jointGroups[jointGroupIndex].outputIndices;
581 return {outputIndices.data(), outputIndices.size()};
582 }
583 return {};
584}

Referenced by dnac::ScaleCommand::Impl::scaleJointBehavior().

◆ getJointGroupValues()

template<class TReaderBase >
ConstArrayView< float > dnac::ReaderImpl< TReaderBase >::getJointGroupValues ( std::uint16_t  jointGroupIndex) const
inlineoverride
587 {
588 if (jointGroupIndex < dna.behavior.joints.jointGroups.size()) {
589 const auto& values = dna.behavior.joints.jointGroups[jointGroupIndex].values;
590 return {values.data(), values.size()};
591 }
592 return {};
593}

Referenced by dnac::ScaleCommand::Impl::scaleJointBehavior().

◆ getJointIndexListCount()

template<class TReaderBase >
std::uint16_t dnac::ReaderImpl< TReaderBase >::getJointIndexListCount
inlineoverride
314 {
315 return dna.definition.lodJointMapping.getIndexListCount();
316}

◆ getJointIndicesForLOD()

template<class TReaderBase >
ConstArrayView< std::uint16_t > dnac::ReaderImpl< TReaderBase >::getJointIndicesForLOD ( std::uint16_t  lod) const
inlineoverride
319 {
320 return dna.definition.lodJointMapping.getIndices(lod);
321}

◆ getJointName()

template<class TReaderBase >
StringView dnac::ReaderImpl< TReaderBase >::getJointName ( std::uint16_t  index) const
inlineoverride
305 {
306 if (index < dna.definition.jointNames.size()) {
307 const auto& jointName = dna.definition.jointNames[index];
308 return {jointName.data(), jointName.size()};
309 }
310 return {};
311}

◆ getJointParentIndex()

template<class TReaderBase >
std::uint16_t dnac::ReaderImpl< TReaderBase >::getJointParentIndex ( std::uint16_t  index) const
inlineoverride
324 {
325 if (index < dna.definition.jointHierarchy.size()) {
326 return dna.definition.jointHierarchy[index];
327 }
328 return std::numeric_limits<std::uint16_t>::max();
329}

Referenced by dnac::RotateCommand::Impl::rotateNeutralJoints(), dnac::ScaleCommand::Impl::scaleNeutralJoints(), and dnac::TranslateCommand::Impl::translateNeutralJoints().

◆ getJointRowCount()

template<class TReaderBase >
std::uint16_t dnac::ReaderImpl< TReaderBase >::getJointRowCount
inlineoverride
537 {
538 return dna.behavior.joints.rowCount;
539}

◆ getJointVariableAttributeIndices()

template<class TReaderBase >
ConstArrayView< std::uint16_t > dnac::ReaderImpl< TReaderBase >::getJointVariableAttributeIndices ( std::uint16_t  lod) const
inlineoverride
547 {
548 if (cache.jointVariableAttributeIndices.getLODCount() == static_cast<std::uint16_t>(0)) {
549 cache.populate(this);
550 }
551 return cache.jointVariableAttributeIndices.getIndices(lod);
552}
dna::LODMapping::getIndices
ConstArrayView< std::uint16_t > getIndices(std::uint16_t lod) const
Definition: dna/LODMapping.cpp:70
dna::LODMapping::getLODCount
std::uint16_t getLODCount() const
Definition: dna/LODMapping.cpp:28
dna::DenormalizedData::jointVariableAttributeIndices
LODMapping jointVariableAttributeIndices
Definition: dna/DenormalizedData.h:16
dna::DenormalizedData::populate
void populate(const Reader *source)
Definition: dna/DenormalizedData.h:24

◆ getLODCount()

template<class TReaderBase >
std::uint16_t dnac::ReaderImpl< TReaderBase >::getLODCount
inlineoverride
252 {
253 return dna.descriptor.lodCount;
254}

Referenced by dnac::CalculateMeshLowerLODsCommand::Impl::findIndicesOfMeshLowerLODs(), and dnac::ClearBlendShapesCommand::Impl::run().

◆ getMaximumInfluencePerVertex()

template<class TReaderBase >
std::uint16_t dnac::ReaderImpl< TReaderBase >::getMaximumInfluencePerVertex ( std::uint16_t  meshIndex) const
inlineoverride
855 {
856 if (meshIndex < dna.geometry.meshes.size()) {
857 return dna.geometry.meshes[meshIndex].maximumInfluencePerVertex;
858 }
859 return {};
860}

◆ getMeshBlendShapeChannelMapping()

template<class TReaderBase >
MeshBlendShapeChannelMapping dnac::ReaderImpl< TReaderBase >::getMeshBlendShapeChannelMapping ( std::uint16_t  index) const
inlineoverride
409 {
410 const auto mapping = dna.definition.meshBlendShapeChannelMapping.get(index);
411 return {mapping.from, mapping.to};
412}

◆ getMeshBlendShapeChannelMappingCount()

template<class TReaderBase >
std::uint16_t dnac::ReaderImpl< TReaderBase >::getMeshBlendShapeChannelMappingCount
inlineoverride
404 {
405 return static_cast<std::uint16_t>(dna.definition.meshBlendShapeChannelMapping.size());
406}

◆ getMeshBlendShapeChannelMappingIndicesForLOD()

template<class TReaderBase >
ConstArrayView< std::uint16_t > dnac::ReaderImpl< TReaderBase >::getMeshBlendShapeChannelMappingIndicesForLOD ( std::uint16_t  lod) const
inlineoverride
416 {
417 if (cache.meshBlendShapeMappingIndices.getLODCount() == static_cast<std::uint16_t>(0)) {
418 cache.populate(this);
419 }
420 return cache.meshBlendShapeMappingIndices.getIndices(lod);
421}
dna::DenormalizedData::meshBlendShapeMappingIndices
LODMapping meshBlendShapeMappingIndices
Definition: dna/DenormalizedData.h:17

◆ getMeshCount()

template<class TReaderBase >
std::uint16_t dnac::ReaderImpl< TReaderBase >::getMeshCount
inlineoverride
380 {
381 return static_cast<std::uint16_t>(dna.definition.meshNames.size());
382}

Referenced by dnac::RotateCommand::Impl::rotateBlendShapeTargetDeltas(), dnac::RotateCommand::Impl::rotateVertexPositions(), dnac::ClearBlendShapesCommand::Impl::run(), dnac::ScaleCommand::Impl::scaleGeometry(), and dnac::TranslateCommand::Impl::translateVertexPositions().

◆ getMeshIndexListCount()

template<class TReaderBase >
std::uint16_t dnac::ReaderImpl< TReaderBase >::getMeshIndexListCount
inlineoverride
394 {
395 return dna.definition.lodMeshMapping.getIndexListCount();
396}

◆ getMeshIndicesForLOD()

template<class TReaderBase >
ConstArrayView< std::uint16_t > dnac::ReaderImpl< TReaderBase >::getMeshIndicesForLOD ( std::uint16_t  lod) const
inlineoverride
399 {
400 return dna.definition.lodMeshMapping.getIndices(lod);
401}

Referenced by dnac::CalculateMeshLowerLODsCommand::Impl::findIndicesOfMeshLowerLODs().

◆ getMeshName()

template<class TReaderBase >
StringView dnac::ReaderImpl< TReaderBase >::getMeshName ( std::uint16_t  index) const
inlineoverride
385 {
386 if (index < dna.definition.meshNames.size()) {
387 const auto& meshName = dna.definition.meshNames[index];
388 return {meshName.data(), meshName.size()};
389 }
390 return {};
391}

Referenced by dnac::CalculateMeshLowerLODsCommand::Impl::getMeshName().

◆ getMetaDataCount()

template<class TReaderBase >
std::uint32_t dnac::ReaderImpl< TReaderBase >::getMetaDataCount
inlineoverride
208 {
209 return static_cast<std::uint32_t>(dna.descriptor.metadata.size());
210}

◆ getMetaDataKey()

template<class TReaderBase >
StringView dnac::ReaderImpl< TReaderBase >::getMetaDataKey ( std::uint32_t  index) const
inlineoverride
213 {
214 if (index < dna.descriptor.metadata.size()) {
215 const auto& key = std::get<0>(dna.descriptor.metadata[index]);
216 return {key.data(), key.size()};
217 }
218 return {};
219}

◆ getMetaDataValue()

template<class TReaderBase >
StringView dnac::ReaderImpl< TReaderBase >::getMetaDataValue ( const char *  key) const
inlineoverride
222 {
223 for (const auto& data: dna.descriptor.metadata) {
224 if (std::get<0>(data) == key) {
225 const auto& value = std::get<1>(data);
226 return {value.data(), value.size()};
227 }
228 }
229 return {};
230}

◆ getName()

template<class TReaderBase >
StringView dnac::ReaderImpl< TReaderBase >::getName
inlineoverride
188 {
189 return {dna.descriptor.name.data(), dna.descriptor.name.size()};
190}

◆ getNeutralJointRotation()

template<class TReaderBase >
Vector3 dnac::ReaderImpl< TReaderBase >::getNeutralJointRotation ( std::uint16_t  index) const
inlineoverride
451 {
452 const auto& rotations = dna.definition.neutralJointRotations;
453 if (index < rotations.size()) {
454 return {rotations.xs[index], rotations.ys[index], rotations.zs[index]};
455 }
456 return {};
457}

Referenced by dnac::RotateCommand::Impl::rotateNeutralJoints().

◆ getNeutralJointRotationXs()

template<class TReaderBase >
ConstArrayView< float > dnac::ReaderImpl< TReaderBase >::getNeutralJointRotationXs
inlineoverride
460 {
461 const auto& xs = dna.definition.neutralJointRotations.xs;
462 return {xs.data(), xs.size()};
463}

◆ getNeutralJointRotationYs()

template<class TReaderBase >
ConstArrayView< float > dnac::ReaderImpl< TReaderBase >::getNeutralJointRotationYs
inlineoverride
466 {
467 const auto& ys = dna.definition.neutralJointRotations.ys;
468 return {ys.data(), ys.size()};
469}

◆ getNeutralJointRotationZs()

template<class TReaderBase >
ConstArrayView< float > dnac::ReaderImpl< TReaderBase >::getNeutralJointRotationZs
inlineoverride
472 {
473 const auto& zs = dna.definition.neutralJointRotations.zs;
474 return {zs.data(), zs.size()};
475}

◆ getNeutralJointTranslation()

template<class TReaderBase >
Vector3 dnac::ReaderImpl< TReaderBase >::getNeutralJointTranslation ( std::uint16_t  index) const
inlineoverride
424 {
425 const auto& translations = dna.definition.neutralJointTranslations;
426 if (index < translations.xs.size()) {
427 return {translations.xs[index], translations.ys[index], translations.zs[index]};
428 }
429 return {};
430}

Referenced by dnac::RotateCommand::Impl::rotateNeutralJoints(), and dnac::TranslateCommand::Impl::translateNeutralJoints().

◆ getNeutralJointTranslationXs()

template<class TReaderBase >
ConstArrayView< float > dnac::ReaderImpl< TReaderBase >::getNeutralJointTranslationXs
inlineoverride
433 {
434 const auto& xs = dna.definition.neutralJointTranslations.xs;
435 return {xs.data(), xs.size()};
436}

Referenced by dnac::ScaleCommand::Impl::scaleNeutralJoints().

◆ getNeutralJointTranslationYs()

template<class TReaderBase >
ConstArrayView< float > dnac::ReaderImpl< TReaderBase >::getNeutralJointTranslationYs
inlineoverride
439 {
440 const auto& ys = dna.definition.neutralJointTranslations.ys;
441 return {ys.data(), ys.size()};
442}

Referenced by dnac::ScaleCommand::Impl::scaleNeutralJoints().

◆ getNeutralJointTranslationZs()

template<class TReaderBase >
ConstArrayView< float > dnac::ReaderImpl< TReaderBase >::getNeutralJointTranslationZs
inlineoverride
445 {
446 const auto& zs = dna.definition.neutralJointTranslations.zs;
447 return {zs.data(), zs.size()};
448}

Referenced by dnac::ScaleCommand::Impl::scaleNeutralJoints().

◆ getPSDColumnIndices()

template<class TReaderBase >
ConstArrayView< std::uint16_t > dnac::ReaderImpl< TReaderBase >::getPSDColumnIndices
inlineoverride
525 {
526 const auto& columns = dna.behavior.controls.psds.columns;
527 return {columns.data(), columns.size()};
528}

◆ getPSDCount()

template<class TReaderBase >
std::uint16_t dnac::ReaderImpl< TReaderBase >::getPSDCount
inlineoverride
514 {
515 return dna.behavior.controls.psdCount;
516}

◆ getPSDRowIndices()

template<class TReaderBase >
ConstArrayView< std::uint16_t > dnac::ReaderImpl< TReaderBase >::getPSDRowIndices
inlineoverride
519 {
520 const auto& rows = dna.behavior.controls.psds.rows;
521 return {rows.data(), rows.size()};
522}

◆ getPSDValues()

template<class TReaderBase >
ConstArrayView< float > dnac::ReaderImpl< TReaderBase >::getPSDValues
inlineoverride
531 {
532 const auto& values = dna.behavior.controls.psds.values;
533 return {values.data(), values.size()};
534}

◆ getRawControlCount()

template<class TReaderBase >
std::uint16_t dnac::ReaderImpl< TReaderBase >::getRawControlCount
inlineoverride
286 {
287 return static_cast<std::uint16_t>(dna.definition.rawControlNames.size());
288}

◆ getRawControlName()

template<class TReaderBase >
StringView dnac::ReaderImpl< TReaderBase >::getRawControlName ( std::uint16_t  index) const
inlineoverride
291 {
292 if (index < dna.definition.rawControlNames.size()) {
293 const auto& rawControlName = dna.definition.rawControlNames[index];
294 return {rawControlName.data(), rawControlName.size()};
295 }
296 return {};
297}

◆ getRotationUnit()

template<class TReaderBase >
RotationUnit dnac::ReaderImpl< TReaderBase >::getRotationUnit
inlineoverride
238 {
239 return static_cast<RotationUnit>(dna.descriptor.rotationUnit);
240}
dna::RotationUnit
RotationUnit
Definition: Descriptor.h:27

◆ getSkinWeightsCount()

template<class TReaderBase >
std::uint32_t dnac::ReaderImpl< TReaderBase >::getSkinWeightsCount ( std::uint16_t  meshIndex) const
inlineoverride
863 {
864 const auto& meshes = dna.geometry.meshes;
865 if (meshIndex < meshes.size()) {
866 return static_cast<std::uint32_t>(meshes[meshIndex].skinWeights.size());
867 }
868 return {};
869}

◆ getSkinWeightsJointIndices()

template<class TReaderBase >
ConstArrayView< std::uint16_t > dnac::ReaderImpl< TReaderBase >::getSkinWeightsJointIndices ( std::uint16_t  meshIndex,
std::uint32_t  vertexIndex 
) const
inlineoverride
884 {
885 const auto& meshes = dna.geometry.meshes;
886 if ((meshIndex < meshes.size()) && (vertexIndex < meshes[meshIndex].skinWeights.size())) {
887 const auto& jointIndices = meshes[meshIndex].skinWeights[vertexIndex].jointIndices;
888 return {jointIndices.data(), jointIndices.size()};
889 }
890 return {};
891}

◆ getSkinWeightsValues()

template<class TReaderBase >
ConstArrayView< float > dnac::ReaderImpl< TReaderBase >::getSkinWeightsValues ( std::uint16_t  meshIndex,
std::uint32_t  vertexIndex 
) const
inlineoverride
873 {
874 const auto& meshes = dna.geometry.meshes;
875 if ((meshIndex < meshes.size()) && (vertexIndex < meshes[meshIndex].skinWeights.size())) {
876 const auto& weights = meshes[meshIndex].skinWeights[vertexIndex].weights;
877 return {weights.data(), weights.size()};
878 }
879 return {};
880}

◆ getTranslationUnit()

template<class TReaderBase >
TranslationUnit dnac::ReaderImpl< TReaderBase >::getTranslationUnit
inlineoverride
233 {
234 return static_cast<TranslationUnit>(dna.descriptor.translationUnit);
235}
dna::TranslationUnit
TranslationUnit
Definition: Descriptor.h:22

◆ getVertexLayout()

template<class TReaderBase >
VertexLayout dnac::ReaderImpl< TReaderBase >::getVertexLayout ( std::uint16_t  meshIndex,
std::uint32_t  layoutIndex 
) const
inlineoverride
816 {
817 if (meshIndex < dna.geometry.meshes.size()) {
818 const auto& layouts = dna.geometry.meshes[meshIndex].layouts;
819 if (layoutIndex < layouts.size()) {
820 return {layouts.positions[layoutIndex], layouts.textureCoordinates[layoutIndex], layouts.normals[layoutIndex]};
821 }
822 }
823 return {};
824}

◆ getVertexLayoutCount()

template<class TReaderBase >
std::uint32_t dnac::ReaderImpl< TReaderBase >::getVertexLayoutCount ( std::uint16_t  meshIndex) const
inlineoverride
808 {
809 if (meshIndex < dna.geometry.meshes.size()) {
810 return static_cast<std::uint32_t>(dna.geometry.meshes[meshIndex].layouts.positions.size());
811 }
812 return 0u;
813}

◆ getVertexLayoutNormalIndices()

template<class TReaderBase >
ConstArrayView< std::uint32_t > dnac::ReaderImpl< TReaderBase >::getVertexLayoutNormalIndices ( std::uint16_t  meshIndex) const
inlineoverride
846 {
847 if (meshIndex < dna.geometry.meshes.size()) {
848 const auto& normals = dna.geometry.meshes[meshIndex].layouts.normals;
849 return {normals.data(), normals.size()};
850 }
851 return {};
852}

◆ getVertexLayoutPositionIndices()

template<class TReaderBase >
ConstArrayView< std::uint32_t > dnac::ReaderImpl< TReaderBase >::getVertexLayoutPositionIndices ( std::uint16_t  meshIndex) const
inlineoverride
827 {
828 if (meshIndex < dna.geometry.meshes.size()) {
829 const auto& positions = dna.geometry.meshes[meshIndex].layouts.positions;
830 return {positions.data(), positions.size()};
831 }
832 return {};
833}

Referenced by dnac::CalculateMeshLowerLODsCommand::Impl::run().

◆ getVertexLayoutTextureCoordinateIndices()

template<class TReaderBase >
ConstArrayView< std::uint32_t > dnac::ReaderImpl< TReaderBase >::getVertexLayoutTextureCoordinateIndices ( std::uint16_t  meshIndex) const
inlineoverride
837 {
838 if (meshIndex < dna.geometry.meshes.size()) {
839 const auto& textureCoordinated = dna.geometry.meshes[meshIndex].layouts.textureCoordinates;
840 return {textureCoordinated.data(), textureCoordinated.size()};
841 }
842 return {};
843}

Referenced by dnac::CalculateMeshLowerLODsCommand::Impl::run().

◆ getVertexNormal()

template<class TReaderBase >
Normal dnac::ReaderImpl< TReaderBase >::getVertexNormal ( std::uint16_t  meshIndex,
std::uint32_t  normalIndex 
) const
inlineoverride
751 {
752 if (meshIndex < dna.geometry.meshes.size()) {
753 const auto& normals = dna.geometry.meshes[meshIndex].normals;
754 if (normalIndex < normals.size()) {
755 return {normals.xs[normalIndex], normals.ys[normalIndex], normals.zs[normalIndex]};
756 }
757 }
758 return {};
759}

◆ getVertexNormalCount()

template<class TReaderBase >
std::uint32_t dnac::ReaderImpl< TReaderBase >::getVertexNormalCount ( std::uint16_t  meshIndex) const
inlineoverride
743 {
744 if (meshIndex < dna.geometry.meshes.size()) {
745 return static_cast<std::uint32_t>(dna.geometry.meshes[meshIndex].normals.xs.size());
746 }
747 return 0u;
748}

◆ getVertexNormalXs()

template<class TReaderBase >
ConstArrayView< float > dnac::ReaderImpl< TReaderBase >::getVertexNormalXs ( std::uint16_t  meshIndex) const
inlineoverride
762 {
763 if (meshIndex < dna.geometry.meshes.size()) {
764 const auto& xNormals = dna.geometry.meshes[meshIndex].normals.xs;
765 return {xNormals.data(), xNormals.size()};
766 }
767 return {};
768}

◆ getVertexNormalYs()

template<class TReaderBase >
ConstArrayView< float > dnac::ReaderImpl< TReaderBase >::getVertexNormalYs ( std::uint16_t  meshIndex) const
inlineoverride
771 {
772 if (meshIndex < dna.geometry.meshes.size()) {
773 const auto& yNormals = dna.geometry.meshes[meshIndex].normals.ys;
774 return {yNormals.data(), yNormals.size()};
775 }
776 return {};
777}

◆ getVertexNormalZs()

template<class TReaderBase >
ConstArrayView< float > dnac::ReaderImpl< TReaderBase >::getVertexNormalZs ( std::uint16_t  meshIndex) const
inlineoverride
780 {
781 if (meshIndex < dna.geometry.meshes.size()) {
782 const auto& zNormals = dna.geometry.meshes[meshIndex].normals.zs;
783 return {zNormals.data(), zNormals.size()};
784 }
785 return {};
786}

◆ getVertexPosition()

template<class TReaderBase >
Position dnac::ReaderImpl< TReaderBase >::getVertexPosition ( std::uint16_t  meshIndex,
std::uint32_t  vertexIndex 
) const
inlineoverride
673 {
674 if (meshIndex < dna.geometry.meshes.size()) {
675 const auto& positions = dna.geometry.meshes[meshIndex].positions;
676 if (vertexIndex < positions.size()) {
677 return {positions.xs[vertexIndex], positions.ys[vertexIndex], positions.zs[vertexIndex]};
678 }
679 }
680 return {};
681}

◆ getVertexPositionCount()

template<class TReaderBase >
std::uint32_t dnac::ReaderImpl< TReaderBase >::getVertexPositionCount ( std::uint16_t  meshIndex) const
inlineoverride
665 {
666 if (meshIndex < dna.geometry.meshes.size()) {
667 return static_cast<std::uint32_t>(dna.geometry.meshes[meshIndex].positions.xs.size());
668 }
669 return 0u;
670}

Referenced by dnac::SetBlendShapeTargetDeltasCommand::Impl::computeBlendShapeTargetDeltas(), and dnac::CalculateMeshLowerLODsCommand::Impl::run().

◆ getVertexPositionXs()

template<class TReaderBase >
ConstArrayView< float > dnac::ReaderImpl< TReaderBase >::getVertexPositionXs ( std::uint16_t  meshIndex) const
inlineoverride
684 {
685 if (meshIndex < dna.geometry.meshes.size()) {
686 const auto& xPositions = dna.geometry.meshes[meshIndex].positions.xs;
687 return {xPositions.data(), xPositions.size()};
688 }
689 return {};
690}

Referenced by dnac::SetVertexPositionsCommand::Impl::computeVertexPositions(), dnac::RotateCommand::Impl::rotateVertexPositions(), dnac::CalculateMeshLowerLODsCommand::Impl::run(), dnac::ScaleCommand::Impl::scaleVertexPositions(), and dnac::TranslateCommand::Impl::translateVertexPositions().

◆ getVertexPositionYs()

template<class TReaderBase >
ConstArrayView< float > dnac::ReaderImpl< TReaderBase >::getVertexPositionYs ( std::uint16_t  meshIndex) const
inlineoverride
693 {
694 if (meshIndex < dna.geometry.meshes.size()) {
695 const auto& yPositions = dna.geometry.meshes[meshIndex].positions.ys;
696 return {yPositions.data(), yPositions.size()};
697 }
698 return {};
699}

Referenced by dnac::SetVertexPositionsCommand::Impl::computeVertexPositions(), dnac::RotateCommand::Impl::rotateVertexPositions(), dnac::CalculateMeshLowerLODsCommand::Impl::run(), dnac::ScaleCommand::Impl::scaleVertexPositions(), and dnac::TranslateCommand::Impl::translateVertexPositions().

◆ getVertexPositionZs()

template<class TReaderBase >
ConstArrayView< float > dnac::ReaderImpl< TReaderBase >::getVertexPositionZs ( std::uint16_t  meshIndex) const
inlineoverride
702 {
703 if (meshIndex < dna.geometry.meshes.size()) {
704 const auto& zPositions = dna.geometry.meshes[meshIndex].positions.zs;
705 return {zPositions.data(), zPositions.size()};
706 }
707 return {};
708}

Referenced by dnac::SetVertexPositionsCommand::Impl::computeVertexPositions(), dnac::RotateCommand::Impl::rotateVertexPositions(), dnac::CalculateMeshLowerLODsCommand::Impl::run(), dnac::ScaleCommand::Impl::scaleVertexPositions(), and dnac::TranslateCommand::Impl::translateVertexPositions().

◆ getVertexTextureCoordinate()

template<class TReaderBase >
TextureCoordinate dnac::ReaderImpl< TReaderBase >::getVertexTextureCoordinate ( std::uint16_t  meshIndex,
std::uint32_t  textureCoordinateIndex 
) const
inlineoverride
720 {
721 if (meshIndex < dna.geometry.meshes.size()) {
722 const auto& textureCoordinates = dna.geometry.meshes[meshIndex].textureCoordinates;
723 if (textureCoordinateIndex < textureCoordinates.size()) {
724 return {textureCoordinates.us[textureCoordinateIndex], textureCoordinates.vs[textureCoordinateIndex]};
725 }
726 }
727 return {};
728}

◆ getVertexTextureCoordinateCount()

template<class TReaderBase >
std::uint32_t dnac::ReaderImpl< TReaderBase >::getVertexTextureCoordinateCount ( std::uint16_t  meshIndex) const
inlineoverride
711 {
712 if (meshIndex < dna.geometry.meshes.size()) {
713 return static_cast<std::uint32_t>(dna.geometry.meshes[meshIndex].textureCoordinates.us.size());
714 }
715 return 0u;
716}

◆ getVertexTextureCoordinateUs()

template<class TReaderBase >
ConstArrayView< float > dnac::ReaderImpl< TReaderBase >::getVertexTextureCoordinateUs ( std::uint16_t  meshIndex) const
inlineoverride
731 {
732 const auto& uTextureCoordinates = dna.geometry.meshes[meshIndex].textureCoordinates.us;
733 return {uTextureCoordinates.data(), uTextureCoordinates.size()};
734}

Referenced by dnac::CalculateMeshLowerLODsCommand::Impl::run().

◆ getVertexTextureCoordinateVs()

template<class TReaderBase >
ConstArrayView< float > dnac::ReaderImpl< TReaderBase >::getVertexTextureCoordinateVs ( std::uint16_t  meshIndex) const
inlineoverride
737 {
738 const auto& vTextureCoordinates = dna.geometry.meshes[meshIndex].textureCoordinates.vs;
739 return {vTextureCoordinates.data(), vTextureCoordinates.size()};
740}

Referenced by dnac::CalculateMeshLowerLODsCommand::Impl::run().

◆ unload()

template<class TReaderBase >
void dnac::ReaderImpl< TReaderBase >::unload ( DataLayer  layer)
override
980 {
981 if ((layer == DataLayer::All) ||
982 (layer == DataLayer::AllWithoutBlendShapes) ||
983 (layer == DataLayer::Descriptor)) {
984 dna = DNA{memRes};
985 } else if ((layer == DataLayer::Geometry) || (layer == DataLayer::GeometryWithoutBlendShapes)) {
986 dna.unloadGeometry();
987 } else if (layer == DataLayer::Behavior) {
988 dna.unloadBehavior();
989 } else if (layer == DataLayer::Definition) {
990 dna.unloadGeometry();
991 dna.unloadBehavior();
992 dna.unloadDefinition();
993 }
994}
dnac::BaseImpl::memRes
MemoryResource * memRes
Definition: dnacalib/dna/BaseImpl.h:31

Member Data Documentation

◆ cache

template<class TReaderBase >
DenormalizedData<TReaderBase> dnac::ReaderImpl< TReaderBase >::cache
mutableprotected
The documentation for this class was generated from the following file:
Generated by doxygen 1.9.4