dna::ReaderImpl< TReaderBase > Class Template Reference

#include <ReaderImpl.h>

Inheritance diagram for dna::ReaderImpl< TReaderBase >:

Collaboration diagram for dna::ReaderImpl< TReaderBase >:

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
Public Member Functions inherited from dna::BaseImpl
MemoryResource *	getMemoryResource ()

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

Additional Inherited Members
Protected Member Functions inherited from dna::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 >

dna::ReaderImpl< TReaderBase >::ReaderImpl ( MemoryResource *  memRes_ )

inlineexplicit

                                                                  : BaseImpl{memRes_}, cache{memRes_} {
}

Member Function Documentation

getAge()

template<class TReaderBase >

std::uint16_t dna::ReaderImpl< TReaderBase >::getAge

inlineoverride

                                                         {
    return dna.descriptor.age;
}

getAnimatedMapCount()

template<class TReaderBase >

std::uint16_t dna::ReaderImpl< TReaderBase >::getAnimatedMapCount

inlineoverride

                                                                      {
    return static_cast<std::uint16_t>(dna.definition.animatedMapNames.size());
}

getAnimatedMapCutValues()

template<class TReaderBase >

ConstArrayView< float > dna::ReaderImpl< TReaderBase >::getAnimatedMapCutValues

inlineoverride

                                                                                    {
    const auto& cutValues = dna.behavior.animatedMaps.conditionals.cutValues;
    return {cutValues.data(), cutValues.size()};
}

getAnimatedMapFromValues()

template<class TReaderBase >

ConstArrayView< float > dna::ReaderImpl< TReaderBase >::getAnimatedMapFromValues

inlineoverride

                                                                                     {
    const auto& fromValues = dna.behavior.animatedMaps.conditionals.fromValues;
    return {fromValues.data(), fromValues.size()};
}

getAnimatedMapIndexListCount()

template<class TReaderBase >

std::uint16_t dna::ReaderImpl< TReaderBase >::getAnimatedMapIndexListCount

inlineoverride

                                                                               {
    return dna.definition.lodAnimatedMapMapping.getIndexListCount();
}

getAnimatedMapIndicesForLOD()

template<class TReaderBase >

ConstArrayView< std::uint16_t > dna::ReaderImpl< TReaderBase >::getAnimatedMapIndicesForLOD ( std::uint16_t  lod ) const

inlineoverride

                                                                                                             {
    return dna.definition.lodAnimatedMapMapping.getIndices(lod);
}

getAnimatedMapInputIndices()

template<class TReaderBase >

ConstArrayView< std::uint16_t > dna::ReaderImpl< TReaderBase >::getAnimatedMapInputIndices

inlineoverride

                                                                                             {
    const auto& inputIndices = dna.behavior.animatedMaps.conditionals.inputIndices;
    return {inputIndices.data(), inputIndices.size()};
}

getAnimatedMapLODs()

template<class TReaderBase >

ConstArrayView< std::uint16_t > dna::ReaderImpl< TReaderBase >::getAnimatedMapLODs

inlineoverride

                                                                                     {
    const auto& lods = dna.behavior.animatedMaps.lods;
    return {lods.data(), lods.size()};
}

getAnimatedMapName()

template<class TReaderBase >

StringView dna::ReaderImpl< TReaderBase >::getAnimatedMapName ( std::uint16_t  index ) const

inlineoverride

                                                                                     {
    if (index < dna.definition.animatedMapNames.size()) {
        const auto& animatedMapName = dna.definition.animatedMapNames[index];
        return {animatedMapName.data(), animatedMapName.size()};
    }
    return {};
}

getAnimatedMapOutputIndices()

template<class TReaderBase >

ConstArrayView< std::uint16_t > dna::ReaderImpl< TReaderBase >::getAnimatedMapOutputIndices

inlineoverride

                                                                                              {
    const auto& outputIndices = dna.behavior.animatedMaps.conditionals.outputIndices;
    return {outputIndices.data(), outputIndices.size()};
}

getAnimatedMapSlopeValues()

template<class TReaderBase >

ConstArrayView< float > dna::ReaderImpl< TReaderBase >::getAnimatedMapSlopeValues

inlineoverride

                                                                                      {
    const auto& slopeValues = dna.behavior.animatedMaps.conditionals.slopeValues;
    return {slopeValues.data(), slopeValues.size()};
}

getAnimatedMapToValues()

template<class TReaderBase >

ConstArrayView< float > dna::ReaderImpl< TReaderBase >::getAnimatedMapToValues

inlineoverride

                                                                                   {
    const auto& toValues = dna.behavior.animatedMaps.conditionals.toValues;
    return {toValues.data(), toValues.size()};
}

getArchetype()

template<class TReaderBase >

Archetype dna::ReaderImpl< TReaderBase >::getArchetype

inlineoverride

                                                             {
    return static_cast<Archetype>(dna.descriptor.archetype);
}

getBlendShapeChannelCount()

template<class TReaderBase >

std::uint16_t dna::ReaderImpl< TReaderBase >::getBlendShapeChannelCount

inlineoverride

                                                                            {
    return static_cast<std::uint16_t>(dna.definition.blendShapeChannelNames.size());
}

getBlendShapeChannelIndex()

template<class TReaderBase >

std::uint16_t dna::ReaderImpl< TReaderBase >::getBlendShapeChannelIndex ( std::uint16_t  meshIndex, std::uint16_t  blendShapeTargetIndex  ) const

inlineoverride

                                                                                                                 {
    const auto& meshes = dna.geometry.meshes;
    if ((meshIndex < meshes.size()) && (blendShapeTargetIndex < meshes[meshIndex].blendShapeTargets.size())) {
        return meshes[meshIndex].blendShapeTargets[blendShapeTargetIndex].blendShapeChannelIndex;
    }
    return {};
}

getBlendShapeChannelIndexListCount()

template<class TReaderBase >

std::uint16_t dna::ReaderImpl< TReaderBase >::getBlendShapeChannelIndexListCount

inlineoverride

                                                                                     {
    return dna.definition.lodBlendShapeMapping.getIndexListCount();
}

getBlendShapeChannelIndicesForLOD()

template<class TReaderBase >

ConstArrayView< std::uint16_t > dna::ReaderImpl< TReaderBase >::getBlendShapeChannelIndicesForLOD ( std::uint16_t  lod ) const

inlineoverride

                                                                                                                   {
    return dna.definition.lodBlendShapeMapping.getIndices(lod);
}

getBlendShapeChannelInputIndices()

template<class TReaderBase >

ConstArrayView< std::uint16_t > dna::ReaderImpl< TReaderBase >::getBlendShapeChannelInputIndices

inlineoverride

                                                                                                   {
    const auto& inputIndices = dna.behavior.blendShapeChannels.inputIndices;
    return {inputIndices.data(), inputIndices.size()};
}

getBlendShapeChannelLODs()

template<class TReaderBase >

ConstArrayView< std::uint16_t > dna::ReaderImpl< TReaderBase >::getBlendShapeChannelLODs

inlineoverride

                                                                                           {
    const auto& lods = dna.behavior.blendShapeChannels.lods;
    return {lods.data(), lods.size()};
}

getBlendShapeChannelName()

template<class TReaderBase >

StringView dna::ReaderImpl< TReaderBase >::getBlendShapeChannelName ( std::uint16_t  index ) const

inlineoverride

                                                                                           {
    if (index < dna.definition.blendShapeChannelNames.size()) {
        const auto& blendShapeName = dna.definition.blendShapeChannelNames[index];
        return {blendShapeName.data(), blendShapeName.size()};
    }
    return {};
}

getBlendShapeChannelOutputIndices()

template<class TReaderBase >

ConstArrayView< std::uint16_t > dna::ReaderImpl< TReaderBase >::getBlendShapeChannelOutputIndices

inlineoverride

                                                                                                    {
    const auto& outputIndices = dna.behavior.blendShapeChannels.outputIndices;
    return {outputIndices.data(), outputIndices.size()};
}

getBlendShapeTargetCount()

template<class TReaderBase >

std::uint16_t dna::ReaderImpl< TReaderBase >::getBlendShapeTargetCount ( std::uint16_t  meshIndex ) const

inlineoverride

                                                                                                {
    if (meshIndex < dna.geometry.meshes.size()) {
        return static_cast<std::uint16_t>(dna.geometry.meshes[meshIndex].blendShapeTargets.size());
    }
    return {};
}

getBlendShapeTargetDelta()

template<class TReaderBase >

Delta dna::ReaderImpl< TReaderBase >::getBlendShapeTargetDelta ( std::uint16_t  meshIndex, std::uint16_t  blendShapeTargetIndex, std::uint32_t  deltaIndex  ) const

inlineoverride

                                                                                             {
    const auto& meshes = dna.geometry.meshes;
    if ((meshIndex < meshes.size()) && (blendShapeTargetIndex < meshes[meshIndex].blendShapeTargets.size()) &&
        (deltaIndex < meshes[meshIndex].blendShapeTargets[blendShapeTargetIndex].deltas.size())) {
        const auto& deltas = meshes[meshIndex].blendShapeTargets[blendShapeTargetIndex].deltas;
        return {deltas.xs[deltaIndex], deltas.ys[deltaIndex], deltas.zs[deltaIndex]};
    }
    return {};
}

getBlendShapeTargetDeltaCount()

template<class TReaderBase >

std::uint32_t dna::ReaderImpl< TReaderBase >::getBlendShapeTargetDeltaCount ( std::uint16_t  meshIndex, std::uint16_t  blendShapeTargetIndex  ) const

inlineoverride

                                                                                                                     {
    const auto& meshes = dna.geometry.meshes;
    if ((meshIndex < meshes.size()) && (blendShapeTargetIndex < meshes[meshIndex].blendShapeTargets.size())) {
        return static_cast<std::uint32_t>(meshes[meshIndex].blendShapeTargets[blendShapeTargetIndex].deltas.xs.size());
    }
    return {};
}

getBlendShapeTargetDeltaXs()

template<class TReaderBase >

ConstArrayView< float > dna::ReaderImpl< TReaderBase >::getBlendShapeTargetDeltaXs ( std::uint16_t  meshIndex, std::uint16_t  blendShapeTargetIndex  ) const

inlineoverride

                                                                                                                          {
    const auto& meshes = dna.geometry.meshes;
    if ((meshIndex < meshes.size()) && (blendShapeTargetIndex < meshes[meshIndex].blendShapeTargets.size())) {
        const auto& xDeltas = meshes[meshIndex].blendShapeTargets[blendShapeTargetIndex].deltas.xs;
        return {xDeltas.data(), xDeltas.size()};
    }
    return {};
}

getBlendShapeTargetDeltaYs()

template<class TReaderBase >

ConstArrayView< float > dna::ReaderImpl< TReaderBase >::getBlendShapeTargetDeltaYs ( std::uint16_t  meshIndex, std::uint16_t  blendShapeTargetIndex  ) const

inlineoverride

                                                                                                                          {
    const auto& meshes = dna.geometry.meshes;
    if ((meshIndex < meshes.size()) && (blendShapeTargetIndex < meshes[meshIndex].blendShapeTargets.size())) {
        const auto& yDeltas = meshes[meshIndex].blendShapeTargets[blendShapeTargetIndex].deltas.ys;
        return {yDeltas.data(), yDeltas.size()};
    }
    return {};
}

getBlendShapeTargetDeltaZs()

template<class TReaderBase >

ConstArrayView< float > dna::ReaderImpl< TReaderBase >::getBlendShapeTargetDeltaZs ( std::uint16_t  meshIndex, std::uint16_t  blendShapeTargetIndex  ) const

inlineoverride

                                                                                                                          {
    const auto& meshes = dna.geometry.meshes;
    if ((meshIndex < meshes.size()) && (blendShapeTargetIndex < meshes[meshIndex].blendShapeTargets.size())) {
        const auto& zDeltas = meshes[meshIndex].blendShapeTargets[blendShapeTargetIndex].deltas.zs;
        return {zDeltas.data(), zDeltas.size()};
    }
    return {};
}

getBlendShapeTargetVertexIndices()

template<class TReaderBase >

ConstArrayView< std::uint32_t > dna::ReaderImpl< TReaderBase >::getBlendShapeTargetVertexIndices ( std::uint16_t  meshIndex, std::uint16_t  blendShapeTargetIndex  ) const

inlineoverride

      {
    const auto& meshes = dna.geometry.meshes;
    if ((meshIndex < meshes.size()) && (blendShapeTargetIndex < meshes[meshIndex].blendShapeTargets.size())) {
        const auto& vertexIndices = meshes[meshIndex].blendShapeTargets[blendShapeTargetIndex].vertexIndices;
        return {vertexIndices.data(), vertexIndices.size()};
    }
    return {};
}

getCoordinateSystem()

template<class TReaderBase >

CoordinateSystem dna::ReaderImpl< TReaderBase >::getCoordinateSystem

inlineoverride

                                                                           {
    return {
        static_cast<Direction>(dna.descriptor.coordinateSystem.xAxis),
        static_cast<Direction>(dna.descriptor.coordinateSystem.yAxis),
        static_cast<Direction>(dna.descriptor.coordinateSystem.zAxis)
    };
}

getDBComplexity()

template<class TReaderBase >

StringView dna::ReaderImpl< TReaderBase >::getDBComplexity

inlineoverride

                                                                 {
    return {dna.descriptor.complexity.data(), dna.descriptor.complexity.size()};
}

getDBMaxLOD()

template<class TReaderBase >

std::uint16_t dna::ReaderImpl< TReaderBase >::getDBMaxLOD

inlineoverride

                                                              {
    return dna.descriptor.maxLOD;
}

getDBName()

template<class TReaderBase >

StringView dna::ReaderImpl< TReaderBase >::getDBName

inlineoverride

                                                           {
    return {dna.descriptor.dbName.data(), dna.descriptor.dbName.size()};
}

getFaceCount()

template<class TReaderBase >

std::uint32_t dna::ReaderImpl< TReaderBase >::getFaceCount ( std::uint16_t  meshIndex ) const

inlineoverride

                                                                                    {
    if (meshIndex < dna.geometry.meshes.size()) {
        return static_cast<std::uint32_t>(dna.geometry.meshes[meshIndex].faces.size());
    }
    return 0u;
}

getFaceVertexLayoutIndices()

template<class TReaderBase >

ConstArrayView< std::uint32_t > dna::ReaderImpl< TReaderBase >::getFaceVertexLayoutIndices ( std::uint16_t  meshIndex, std::uint32_t  faceIndex  ) const

inlineoverride

                                                                                                                      {
    const auto& meshes = dna.geometry.meshes;
    if ((meshIndex < meshes.size()) && (faceIndex < meshes[meshIndex].faces.size())) {
        const auto& layoutIndices = meshes[meshIndex].faces[faceIndex].layoutIndices;
        return {layoutIndices.data(), layoutIndices.size()};
    }
    return {};
}

getGender()

template<class TReaderBase >

Gender dna::ReaderImpl< TReaderBase >::getGender

inlineoverride

                                                       {
    return static_cast<Gender>(dna.descriptor.gender);
}

getGUIControlCount()

template<class TReaderBase >

std::uint16_t dna::ReaderImpl< TReaderBase >::getGUIControlCount

inlineoverride

                                                                     {
    return static_cast<std::uint16_t>(dna.definition.guiControlNames.size());
}

getGUIControlName()

template<class TReaderBase >

StringView dna::ReaderImpl< TReaderBase >::getGUIControlName ( std::uint16_t  index ) const

inlineoverride

                                                                                    {
    if (index < dna.definition.guiControlNames.size()) {
        const auto& guiControlName = dna.definition.guiControlNames[index];
        return {guiControlName.data(), guiControlName.size()};
    }
    return {};
}

getGUIToRawCutValues()

template<class TReaderBase >

ConstArrayView< float > dna::ReaderImpl< TReaderBase >::getGUIToRawCutValues

inlineoverride

                                                                                 {
    const auto& cutValues = dna.behavior.controls.conditionals.cutValues;
    return {cutValues.data(), cutValues.size()};
}

getGUIToRawFromValues()

template<class TReaderBase >

ConstArrayView< float > dna::ReaderImpl< TReaderBase >::getGUIToRawFromValues

inlineoverride

                                                                                  {
    const auto& fromValues = dna.behavior.controls.conditionals.fromValues;
    return {fromValues.data(), fromValues.size()};
}

getGUIToRawInputIndices()

template<class TReaderBase >

ConstArrayView< std::uint16_t > dna::ReaderImpl< TReaderBase >::getGUIToRawInputIndices

inlineoverride

                                                                                          {
    const auto& inputIndices = dna.behavior.controls.conditionals.inputIndices;
    return {inputIndices.data(), inputIndices.size()};
}

getGUIToRawOutputIndices()

template<class TReaderBase >

ConstArrayView< std::uint16_t > dna::ReaderImpl< TReaderBase >::getGUIToRawOutputIndices

inlineoverride

                                                                                           {
    const auto& outputIndices = dna.behavior.controls.conditionals.outputIndices;
    return {outputIndices.data(), outputIndices.size()};
}

getGUIToRawSlopeValues()

template<class TReaderBase >

ConstArrayView< float > dna::ReaderImpl< TReaderBase >::getGUIToRawSlopeValues

inlineoverride

                                                                                   {
    const auto& slopeValues = dna.behavior.controls.conditionals.slopeValues;
    return {slopeValues.data(), slopeValues.size()};
}

getGUIToRawToValues()

template<class TReaderBase >

ConstArrayView< float > dna::ReaderImpl< TReaderBase >::getGUIToRawToValues

inlineoverride

                                                                                {
    const auto& toValues = dna.behavior.controls.conditionals.toValues;
    return {toValues.data(), toValues.size()};
}

getJointColumnCount()

template<class TReaderBase >

std::uint16_t dna::ReaderImpl< TReaderBase >::getJointColumnCount

inlineoverride

                                                                      {
    return dna.behavior.joints.colCount;
}

getJointCount()

template<class TReaderBase >

std::uint16_t dna::ReaderImpl< TReaderBase >::getJointCount

inlineoverride

                                                                {
    return static_cast<std::uint16_t>(dna.definition.jointNames.size());
}

getJointGroupCount()

template<class TReaderBase >

std::uint16_t dna::ReaderImpl< TReaderBase >::getJointGroupCount

inlineoverride

                                                                     {
    return static_cast<std::uint16_t>(dna.behavior.joints.jointGroups.size());
}

getJointGroupInputIndices()

template<class TReaderBase >

ConstArrayView< std::uint16_t > dna::ReaderImpl< TReaderBase >::getJointGroupInputIndices ( std::uint16_t  jointGroupIndex ) const

inlineoverride

                                                                                                                       {
    if (jointGroupIndex < dna.behavior.joints.jointGroups.size()) {
        const auto& inputIndices = dna.behavior.joints.jointGroups[jointGroupIndex].inputIndices;
        return {inputIndices.data(), inputIndices.size()};
    }
    return {};
}

getJointGroupJointIndices()

template<class TReaderBase >

ConstArrayView< std::uint16_t > dna::ReaderImpl< TReaderBase >::getJointGroupJointIndices ( std::uint16_t  jointGroupIndex ) const

inlineoverride

                                                                                                                       {
    if (jointGroupIndex < dna.behavior.joints.jointGroups.size()) {
        const auto& jointIndices = dna.behavior.joints.jointGroups[jointGroupIndex].jointIndices;
        return {jointIndices.data(), jointIndices.size()};
    }
    return {};
}

getJointGroupLODs()

template<class TReaderBase >

ConstArrayView< std::uint16_t > dna::ReaderImpl< TReaderBase >::getJointGroupLODs ( std::uint16_t  jointGroupIndex ) const

inlineoverride

                                                                                                               {
    if (jointGroupIndex < dna.behavior.joints.jointGroups.size()) {
        const auto& lods = dna.behavior.joints.jointGroups[jointGroupIndex].lods;
        return {lods.data(), lods.size()};
    }
    return {};
}

getJointGroupOutputIndices()

template<class TReaderBase >

ConstArrayView< std::uint16_t > dna::ReaderImpl< TReaderBase >::getJointGroupOutputIndices ( std::uint16_t  jointGroupIndex ) const

inlineoverride

                                                                                                                        {
    if (jointGroupIndex < dna.behavior.joints.jointGroups.size()) {
        const auto& outputIndices = dna.behavior.joints.jointGroups[jointGroupIndex].outputIndices;
        return {outputIndices.data(), outputIndices.size()};
    }
    return {};
}

getJointGroupValues()

template<class TReaderBase >

ConstArrayView< float > dna::ReaderImpl< TReaderBase >::getJointGroupValues ( std::uint16_t  jointGroupIndex ) const

inlineoverride

                                                                                                           {
    if (jointGroupIndex < dna.behavior.joints.jointGroups.size()) {
        const auto& values = dna.behavior.joints.jointGroups[jointGroupIndex].values;
        return {values.data(), values.size()};
    }
    return {};
}

getJointIndexListCount()

template<class TReaderBase >

std::uint16_t dna::ReaderImpl< TReaderBase >::getJointIndexListCount

inlineoverride

                                                                         {
    return dna.definition.lodJointMapping.getIndexListCount();
}

getJointIndicesForLOD()

template<class TReaderBase >

ConstArrayView< std::uint16_t > dna::ReaderImpl< TReaderBase >::getJointIndicesForLOD ( std::uint16_t  lod ) const

inlineoverride

                                                                                                       {
    return dna.definition.lodJointMapping.getIndices(lod);
}

getJointName()

template<class TReaderBase >

StringView dna::ReaderImpl< TReaderBase >::getJointName ( std::uint16_t  index ) const

inlineoverride

                                                                               {
    if (index < dna.definition.jointNames.size()) {
        const auto& jointName = dna.definition.jointNames[index];
        return {jointName.data(), jointName.size()};
    }
    return {};
}

getJointParentIndex()

template<class TReaderBase >

std::uint16_t dna::ReaderImpl< TReaderBase >::getJointParentIndex ( std::uint16_t  index ) const

inlineoverride

                                                                                       {
    if (index < dna.definition.jointHierarchy.size()) {
        return dna.definition.jointHierarchy[index];
    }
    return std::numeric_limits<std::uint16_t>::max();
}

getJointRowCount()

template<class TReaderBase >

std::uint16_t dna::ReaderImpl< TReaderBase >::getJointRowCount

inlineoverride

                                                                   {
    return dna.behavior.joints.rowCount;
}

getJointVariableAttributeIndices()

template<class TReaderBase >

ConstArrayView< std::uint16_t > dna::ReaderImpl< TReaderBase >::getJointVariableAttributeIndices ( std::uint16_t  lod ) const

inlineoverride

                                                                                                                  {
    if (cache.jointVariableAttributeIndices.getLODCount() == static_cast<std::uint16_t>(0)) {
        cache.populate(this);
    }
    return cache.jointVariableAttributeIndices.getIndices(lod);
}

getLODCount()

template<class TReaderBase >

std::uint16_t dna::ReaderImpl< TReaderBase >::getLODCount

inlineoverride

                                                              {
    return dna.descriptor.lodCount;
}

getMaximumInfluencePerVertex()

template<class TReaderBase >

std::uint16_t dna::ReaderImpl< TReaderBase >::getMaximumInfluencePerVertex ( std::uint16_t  meshIndex ) const

inlineoverride

                                                                                                    {
    if (meshIndex < dna.geometry.meshes.size()) {
        return dna.geometry.meshes[meshIndex].maximumInfluencePerVertex;
    }
    return {};
}

getMeshBlendShapeChannelMapping()

template<class TReaderBase >

MeshBlendShapeChannelMapping dna::ReaderImpl< TReaderBase >::getMeshBlendShapeChannelMapping ( std::uint16_t  index ) const

inlineoverride

                                                                                                                    {
    const auto mapping = dna.definition.meshBlendShapeChannelMapping.get(index);
    return {mapping.from, mapping.to};
}

getMeshBlendShapeChannelMappingCount()

template<class TReaderBase >

std::uint16_t dna::ReaderImpl< TReaderBase >::getMeshBlendShapeChannelMappingCount

inlineoverride

                                                                                       {
    return static_cast<std::uint16_t>(dna.definition.meshBlendShapeChannelMapping.size());
}

getMeshBlendShapeChannelMappingIndicesForLOD()

template<class TReaderBase >

ConstArrayView< std::uint16_t > dna::ReaderImpl< TReaderBase >::getMeshBlendShapeChannelMappingIndicesForLOD ( std::uint16_t  lod ) const

inlineoverride

      {
    if (cache.meshBlendShapeMappingIndices.getLODCount() == static_cast<std::uint16_t>(0)) {
        cache.populate(this);
    }
    return cache.meshBlendShapeMappingIndices.getIndices(lod);
}

getMeshCount()

template<class TReaderBase >

std::uint16_t dna::ReaderImpl< TReaderBase >::getMeshCount

inlineoverride

                                                               {
    return static_cast<std::uint16_t>(dna.definition.meshNames.size());
}

getMeshIndexListCount()

template<class TReaderBase >

std::uint16_t dna::ReaderImpl< TReaderBase >::getMeshIndexListCount

inlineoverride

                                                                        {
    return dna.definition.lodMeshMapping.getIndexListCount();
}

getMeshIndicesForLOD()

template<class TReaderBase >

ConstArrayView< std::uint16_t > dna::ReaderImpl< TReaderBase >::getMeshIndicesForLOD ( std::uint16_t  lod ) const

inlineoverride

                                                                                                      {
    return dna.definition.lodMeshMapping.getIndices(lod);
}

getMeshName()

template<class TReaderBase >

StringView dna::ReaderImpl< TReaderBase >::getMeshName ( std::uint16_t  index ) const

inlineoverride

                                                                              {
    if (index < dna.definition.meshNames.size()) {
        const auto& meshName = dna.definition.meshNames[index];
        return {meshName.data(), meshName.size()};
    }
    return {};
}

getMetaDataCount()

template<class TReaderBase >

std::uint32_t dna::ReaderImpl< TReaderBase >::getMetaDataCount

inlineoverride

                                                                   {
    return static_cast<std::uint32_t>(dna.descriptor.metadata.size());
}

getMetaDataKey()

template<class TReaderBase >

StringView dna::ReaderImpl< TReaderBase >::getMetaDataKey ( std::uint32_t  index ) const

inlineoverride

                                                                                 {
    if (index < dna.descriptor.metadata.size()) {
        const auto& key = std::get<0>(dna.descriptor.metadata[index]);
        return {key.data(), key.size()};
    }
    return {};
}

getMetaDataValue()

template<class TReaderBase >

StringView dna::ReaderImpl< TReaderBase >::getMetaDataValue ( const char *  key ) const

inlineoverride

                                                                                 {
    for (const auto& data: dna.descriptor.metadata) {
        if (std::get<0>(data) == key) {
            const auto& value = std::get<1>(data);
            return {value.data(), value.size()};
        }
    }
    return {};
}

getName()

template<class TReaderBase >

StringView dna::ReaderImpl< TReaderBase >::getName

inlineoverride

                                                         {
    return {dna.descriptor.name.data(), dna.descriptor.name.size()};
}

getNeutralJointRotation()

template<class TReaderBase >

Vector3 dna::ReaderImpl< TReaderBase >::getNeutralJointRotation ( std::uint16_t  index ) const

inlineoverride

                                                                                       {
    const auto& rotations = dna.definition.neutralJointRotations;
    if (index < rotations.size()) {
        return {rotations.xs[index], rotations.ys[index], rotations.zs[index]};
    }
    return {};
}

getNeutralJointRotationXs()

template<class TReaderBase >

ConstArrayView< float > dna::ReaderImpl< TReaderBase >::getNeutralJointRotationXs

inlineoverride

                                                                                      {
    const auto& xs = dna.definition.neutralJointRotations.xs;
    return {xs.data(), xs.size()};
}

getNeutralJointRotationYs()

template<class TReaderBase >

ConstArrayView< float > dna::ReaderImpl< TReaderBase >::getNeutralJointRotationYs

inlineoverride

                                                                                      {
    const auto& ys = dna.definition.neutralJointRotations.ys;
    return {ys.data(), ys.size()};
}

getNeutralJointRotationZs()

template<class TReaderBase >

ConstArrayView< float > dna::ReaderImpl< TReaderBase >::getNeutralJointRotationZs

inlineoverride

                                                                                      {
    const auto& zs = dna.definition.neutralJointRotations.zs;
    return {zs.data(), zs.size()};
}

getNeutralJointTranslation()

template<class TReaderBase >

Vector3 dna::ReaderImpl< TReaderBase >::getNeutralJointTranslation ( std::uint16_t  index ) const

inlineoverride

                                                                                          {
    const auto& translations = dna.definition.neutralJointTranslations;
    if (index < translations.xs.size()) {
        return {translations.xs[index], translations.ys[index], translations.zs[index]};
    }
    return {};
}

getNeutralJointTranslationXs()

template<class TReaderBase >

ConstArrayView< float > dna::ReaderImpl< TReaderBase >::getNeutralJointTranslationXs

inlineoverride

                                                                                         {
    const auto& xs = dna.definition.neutralJointTranslations.xs;
    return {xs.data(), xs.size()};
}

getNeutralJointTranslationYs()

template<class TReaderBase >

ConstArrayView< float > dna::ReaderImpl< TReaderBase >::getNeutralJointTranslationYs

inlineoverride

                                                                                         {
    const auto& ys = dna.definition.neutralJointTranslations.ys;
    return {ys.data(), ys.size()};
}

getNeutralJointTranslationZs()

template<class TReaderBase >

ConstArrayView< float > dna::ReaderImpl< TReaderBase >::getNeutralJointTranslationZs

inlineoverride

                                                                                         {
    const auto& zs = dna.definition.neutralJointTranslations.zs;
    return {zs.data(), zs.size()};
}

getPSDColumnIndices()

template<class TReaderBase >

ConstArrayView< std::uint16_t > dna::ReaderImpl< TReaderBase >::getPSDColumnIndices

inlineoverride

                                                                                      {
    const auto& columns = dna.behavior.controls.psds.columns;
    return {columns.data(), columns.size()};
}

getPSDCount()

template<class TReaderBase >

std::uint16_t dna::ReaderImpl< TReaderBase >::getPSDCount

inlineoverride

                                                              {
    return dna.behavior.controls.psdCount;
}

getPSDRowIndices()

template<class TReaderBase >

ConstArrayView< std::uint16_t > dna::ReaderImpl< TReaderBase >::getPSDRowIndices

inlineoverride

                                                                                   {
    const auto& rows = dna.behavior.controls.psds.rows;
    return {rows.data(), rows.size()};
}

getPSDValues()

template<class TReaderBase >

ConstArrayView< float > dna::ReaderImpl< TReaderBase >::getPSDValues

inlineoverride

                                                                         {
    const auto& values = dna.behavior.controls.psds.values;
    return {values.data(), values.size()};
}

getRawControlCount()

template<class TReaderBase >

std::uint16_t dna::ReaderImpl< TReaderBase >::getRawControlCount

inlineoverride

                                                                     {
    return static_cast<std::uint16_t>(dna.definition.rawControlNames.size());
}

getRawControlName()

template<class TReaderBase >

StringView dna::ReaderImpl< TReaderBase >::getRawControlName ( std::uint16_t  index ) const

inlineoverride

                                                                                    {
    if (index < dna.definition.rawControlNames.size()) {
        const auto& rawControlName = dna.definition.rawControlNames[index];
        return {rawControlName.data(), rawControlName.size()};
    }
    return {};
}

getRotationUnit()

template<class TReaderBase >

RotationUnit dna::ReaderImpl< TReaderBase >::getRotationUnit

inlineoverride

                                                                   {
    return static_cast<RotationUnit>(dna.descriptor.rotationUnit);
}

getSkinWeightsCount()

template<class TReaderBase >

std::uint32_t dna::ReaderImpl< TReaderBase >::getSkinWeightsCount ( std::uint16_t  meshIndex ) const

inlineoverride

                                                                                           {
    const auto& meshes = dna.geometry.meshes;
    if (meshIndex < meshes.size()) {
        return static_cast<std::uint32_t>(meshes[meshIndex].skinWeights.size());
    }
    return {};
}

getSkinWeightsJointIndices()

template<class TReaderBase >

ConstArrayView< std::uint16_t > dna::ReaderImpl< TReaderBase >::getSkinWeightsJointIndices ( std::uint16_t  meshIndex, std::uint32_t  vertexIndex  ) const

inlineoverride

                                                                                                                        {
    const auto& meshes = dna.geometry.meshes;
    if ((meshIndex < meshes.size()) && (vertexIndex < meshes[meshIndex].skinWeights.size())) {
        const auto& jointIndices = meshes[meshIndex].skinWeights[vertexIndex].jointIndices;
        return {jointIndices.data(), jointIndices.size()};
    }
    return {};
}

getSkinWeightsValues()

template<class TReaderBase >

ConstArrayView< float > dna::ReaderImpl< TReaderBase >::getSkinWeightsValues ( std::uint16_t  meshIndex, std::uint32_t  vertexIndex  ) const

inlineoverride

                                                                                                          {
    const auto& meshes = dna.geometry.meshes;
    if ((meshIndex < meshes.size()) && (vertexIndex < meshes[meshIndex].skinWeights.size())) {
        const auto& weights = meshes[meshIndex].skinWeights[vertexIndex].weights;
        return {weights.data(), weights.size()};
    }
    return {};
}

getTranslationUnit()

template<class TReaderBase >

TranslationUnit dna::ReaderImpl< TReaderBase >::getTranslationUnit

inlineoverride

                                                                         {
    return static_cast<TranslationUnit>(dna.descriptor.translationUnit);
}

getVertexLayout()

template<class TReaderBase >

VertexLayout dna::ReaderImpl< TReaderBase >::getVertexLayout ( std::uint16_t  meshIndex, std::uint32_t  layoutIndex  ) const

inlineoverride

                                                                                                                 {
    if (meshIndex < dna.geometry.meshes.size()) {
        const auto& layouts = dna.geometry.meshes[meshIndex].layouts;
        if (layoutIndex < layouts.size()) {
            return {layouts.positions[layoutIndex], layouts.textureCoordinates[layoutIndex], layouts.normals[layoutIndex]};
        }
    }
    return {};
}

getVertexLayoutCount()

template<class TReaderBase >

std::uint32_t dna::ReaderImpl< TReaderBase >::getVertexLayoutCount ( std::uint16_t  meshIndex ) const

inlineoverride

                                                                                            {
    if (meshIndex < dna.geometry.meshes.size()) {
        return static_cast<std::uint32_t>(dna.geometry.meshes[meshIndex].layouts.positions.size());
    }
    return 0u;
}

getVertexLayoutNormalIndices()

template<class TReaderBase >

ConstArrayView< std::uint32_t > dna::ReaderImpl< TReaderBase >::getVertexLayoutNormalIndices ( std::uint16_t  meshIndex ) const

inlineoverride

                                                                                                                    {
    if (meshIndex < dna.geometry.meshes.size()) {
        const auto& normals = dna.geometry.meshes[meshIndex].layouts.normals;
        return {normals.data(), normals.size()};
    }
    return {};
}

getVertexLayoutPositionIndices()

template<class TReaderBase >

ConstArrayView< std::uint32_t > dna::ReaderImpl< TReaderBase >::getVertexLayoutPositionIndices ( std::uint16_t  meshIndex ) const

inlineoverride

                                                                                                                      {
    if (meshIndex < dna.geometry.meshes.size()) {
        const auto& positions = dna.geometry.meshes[meshIndex].layouts.positions;
        return {positions.data(), positions.size()};
    }
    return {};
}

getVertexLayoutTextureCoordinateIndices()

template<class TReaderBase >

ConstArrayView< std::uint32_t > dna::ReaderImpl< TReaderBase >::getVertexLayoutTextureCoordinateIndices ( std::uint16_t  meshIndex ) const

inlineoverride

      {
    if (meshIndex < dna.geometry.meshes.size()) {
        const auto& textureCoordinated = dna.geometry.meshes[meshIndex].layouts.textureCoordinates;
        return {textureCoordinated.data(), textureCoordinated.size()};
    }
    return {};
}

getVertexNormal()

template<class TReaderBase >

Normal dna::ReaderImpl< TReaderBase >::getVertexNormal ( std::uint16_t  meshIndex, std::uint32_t  normalIndex  ) const

inlineoverride

                                                                                                           {
    if (meshIndex < dna.geometry.meshes.size()) {
        const auto& normals = dna.geometry.meshes[meshIndex].normals;
        if (normalIndex < normals.size()) {
            return {normals.xs[normalIndex], normals.ys[normalIndex], normals.zs[normalIndex]};
        }
    }
    return {};
}

getVertexNormalCount()

template<class TReaderBase >

std::uint32_t dna::ReaderImpl< TReaderBase >::getVertexNormalCount ( std::uint16_t  meshIndex ) const

inlineoverride

                                                                                            {
    if (meshIndex < dna.geometry.meshes.size()) {
        return static_cast<std::uint32_t>(dna.geometry.meshes[meshIndex].normals.xs.size());
    }
    return 0u;
}

getVertexNormalXs()

template<class TReaderBase >

ConstArrayView< float > dna::ReaderImpl< TReaderBase >::getVertexNormalXs ( std::uint16_t  meshIndex ) const

inlineoverride

                                                                                                   {
    if (meshIndex < dna.geometry.meshes.size()) {
        const auto& xNormals = dna.geometry.meshes[meshIndex].normals.xs;
        return {xNormals.data(), xNormals.size()};
    }
    return {};
}

getVertexNormalYs()

template<class TReaderBase >

ConstArrayView< float > dna::ReaderImpl< TReaderBase >::getVertexNormalYs ( std::uint16_t  meshIndex ) const

inlineoverride

                                                                                                   {
    if (meshIndex < dna.geometry.meshes.size()) {
        const auto& yNormals = dna.geometry.meshes[meshIndex].normals.ys;
        return {yNormals.data(), yNormals.size()};
    }
    return {};
}

getVertexNormalZs()

template<class TReaderBase >

ConstArrayView< float > dna::ReaderImpl< TReaderBase >::getVertexNormalZs ( std::uint16_t  meshIndex ) const

inlineoverride

                                                                                                   {
    if (meshIndex < dna.geometry.meshes.size()) {
        const auto& zNormals = dna.geometry.meshes[meshIndex].normals.zs;
        return {zNormals.data(), zNormals.size()};
    }
    return {};
}

getVertexPosition()

template<class TReaderBase >

Position dna::ReaderImpl< TReaderBase >::getVertexPosition ( std::uint16_t  meshIndex, std::uint32_t  vertexIndex  ) const

inlineoverride

                                                                                                               {
    if (meshIndex < dna.geometry.meshes.size()) {
        const auto& positions = dna.geometry.meshes[meshIndex].positions;
        if (vertexIndex < positions.size()) {
            return {positions.xs[vertexIndex], positions.ys[vertexIndex], positions.zs[vertexIndex]};
        }
    }
    return {};
}

getVertexPositionCount()

template<class TReaderBase >

std::uint32_t dna::ReaderImpl< TReaderBase >::getVertexPositionCount ( std::uint16_t  meshIndex ) const

inlineoverride

                                                                                              {
    if (meshIndex < dna.geometry.meshes.size()) {
        return static_cast<std::uint32_t>(dna.geometry.meshes[meshIndex].positions.xs.size());
    }
    return 0u;
}

getVertexPositionXs()

template<class TReaderBase >

ConstArrayView< float > dna::ReaderImpl< TReaderBase >::getVertexPositionXs ( std::uint16_t  meshIndex ) const

inlineoverride

                                                                                                     {
    if (meshIndex < dna.geometry.meshes.size()) {
        const auto& xPositions = dna.geometry.meshes[meshIndex].positions.xs;
        return {xPositions.data(), xPositions.size()};
    }
    return {};
}

getVertexPositionYs()

template<class TReaderBase >

ConstArrayView< float > dna::ReaderImpl< TReaderBase >::getVertexPositionYs ( std::uint16_t  meshIndex ) const

inlineoverride

                                                                                                     {
    if (meshIndex < dna.geometry.meshes.size()) {
        const auto& yPositions = dna.geometry.meshes[meshIndex].positions.ys;
        return {yPositions.data(), yPositions.size()};
    }
    return {};
}

getVertexPositionZs()

template<class TReaderBase >

ConstArrayView< float > dna::ReaderImpl< TReaderBase >::getVertexPositionZs ( std::uint16_t  meshIndex ) const

inlineoverride

                                                                                                     {
    if (meshIndex < dna.geometry.meshes.size()) {
        const auto& zPositions = dna.geometry.meshes[meshIndex].positions.zs;
        return {zPositions.data(), zPositions.size()};
    }
    return {};
}

getVertexTextureCoordinate()

template<class TReaderBase >

TextureCoordinate dna::ReaderImpl< TReaderBase >::getVertexTextureCoordinate ( std::uint16_t  meshIndex, std::uint32_t  textureCoordinateIndex  ) const

inlineoverride

                                                                                                                       {
    if (meshIndex < dna.geometry.meshes.size()) {
        const auto& textureCoordinates = dna.geometry.meshes[meshIndex].textureCoordinates;
        if (textureCoordinateIndex < textureCoordinates.size()) {
            return {textureCoordinates.us[textureCoordinateIndex], textureCoordinates.vs[textureCoordinateIndex]};
        }
    }
    return {};
}

getVertexTextureCoordinateCount()

template<class TReaderBase >

std::uint32_t dna::ReaderImpl< TReaderBase >::getVertexTextureCoordinateCount ( std::uint16_t  meshIndex ) const

inlineoverride

                                                                                                       {
    if (meshIndex < dna.geometry.meshes.size()) {
        return static_cast<std::uint32_t>(dna.geometry.meshes[meshIndex].textureCoordinates.us.size());
    }
    return 0u;
}

getVertexTextureCoordinateUs()

template<class TReaderBase >

ConstArrayView< float > dna::ReaderImpl< TReaderBase >::getVertexTextureCoordinateUs ( std::uint16_t  meshIndex ) const

inlineoverride

                                                                                                              {
    const auto& uTextureCoordinates = dna.geometry.meshes[meshIndex].textureCoordinates.us;
    return {uTextureCoordinates.data(), uTextureCoordinates.size()};
}

getVertexTextureCoordinateVs()

template<class TReaderBase >

ConstArrayView< float > dna::ReaderImpl< TReaderBase >::getVertexTextureCoordinateVs ( std::uint16_t  meshIndex ) const

inlineoverride

                                                                                                              {
    const auto& vTextureCoordinates = dna.geometry.meshes[meshIndex].textureCoordinates.vs;
    return {vTextureCoordinates.data(), vTextureCoordinates.size()};
}

Member Data Documentation

cache

template<class TReaderBase >

DenormalizedData<TReaderBase> dna::ReaderImpl< TReaderBase >::cache

mutableprotected

---

The documentation for this class was generated from the following file:

• dna/ReaderImpl.h