dna Namespace Reference

Namespaces
namespace	anonymous_namespace{Writer.cpp}

Classes
class	AnimatedMapFilter
class	BaseImpl
class	BehaviorReader
	Read-only accessors for DNA attributes that define the rig's evaluation. More...
class	BehaviorWriter
	Write-only accessors for DNA attributes that define the rig's evaluation. More...
class	BinaryStreamReader
class	BinaryStreamReaderImpl
class	BinaryStreamWriter
class	BinaryStreamWriterImpl
class	BlendShapeFilter
struct	CoordinateSystem
class	DefinitionReader
	Read-only accessors for DNA attributes that represent the rig's static data. More...
class	DefinitionWriter
	Write-only accessors for DNA attributes that represent the rig's static data. More...
struct	DenormalizedData
class	DescriptorReader
	Read-only accessors for various metadata about the character and the rig. More...
class	DescriptorWriter
	Write-only accessors to various metadata about the character and the rig. More...
struct	DNA
struct	ExpectedValue
class	FilteredInputArchive
class	GeometryReader
	Read-only accessors to the geometry data associated with a rig. More...
class	GeometryWriter
	Write-only accessors for the geometry data associated with a rig. More...
class	JointFilter
class	JSONStreamReader
class	JSONStreamReaderImpl
class	JSONStreamWriter
class	JSONStreamWriterImpl
class	LODConstraint
struct	LODLimits
class	LODMapping
struct	MeshBlendShapeChannelMapping
	Mapping that associates a blend shape channel to it's mesh. More...
class	MeshFilter
struct	RawAnimatedMaps
struct	RawBehavior
struct	RawBlendShapeChannels
struct	RawBlendShapeTarget
struct	RawConditionalTable
struct	RawControls
struct	RawCoordinateSystem
struct	RawDefinition
struct	RawDescriptor
struct	RawFace
struct	RawGeometry
struct	RawJointGroup
struct	RawJoints
struct	RawLODMapping
struct	RawMesh
struct	RawPSDMatrix
struct	RawSurjectiveMapping
struct	RawTextureCoordinateVector
struct	RawVector3Vector
struct	RawVertexLayoutVector
struct	RawVertexSkinWeights
class	Reader
	The abstract Reader which its implementations are expected to inherit. More...
class	ReaderImpl
struct	SectionLookupTable
struct	Signature
class	StreamReader
class	StreamWriter
class	StringView
struct	SurjectiveMapping
struct	TextureCoordinate
struct	Vector3
struct	Version
struct	VertexLayout
class	Writer
	The abstract Writer which its implementations are expected to inherit. More...
class	WriterImpl

Typedefs
using	Position = Vector3
using	Normal = Vector3
using	Delta = Vector3
template<typename T >
using	ArrayView = trust::ArrayView< T >
template<typename T >
using	ConstArrayView = trust::ConstArrayView< T >
template<typename T >
using	AlignedAllocator = PolyAllocator< T, 64ul, AlignedMemoryResource >
template<typename T >
using	DynArray = terse::DynArray< T, PolyAllocator< T > >
template<typename T >
using	AlignedDynArray = terse::DynArray< T, AlignedAllocator< T > >
using	IndicesGetter = std::function< ConstArrayView< std::uint16_t >(std::uint16_t)>
using	IndicesSetter = std::function< void(std::uint16_t, const std::uint16_t *, std::uint16_t)>
using	LODMappingSetter = std::function< void(std::uint16_t, std::uint16_t)>

Enumerations
enum class	DataLayer {   Descriptor , Definition , Behavior , Geometry ,   GeometryWithoutBlendShapes , AllWithoutBlendShapes , All }
enum class	Archetype {   asian , black , caucasian , hispanic ,   alien , other }
enum class	Gender { male , female , other }
enum class	TranslationUnit { cm , m }
enum class	RotationUnit { degrees , radians }
enum class	Direction {   left , right , up , down ,   front , back }
enum class	DataLayerBitmask {   Descriptor = 1 , Definition = 2 , Behavior = 4 , GeometryBlendShapesOnly = 8 ,   GeometryRest = 16 }

Functions
bool	operator== (const StringView &lhs, const StringView &rhs)
bool	operator!= (const StringView &lhs, const StringView &rhs)
Vector3	operator+ (Vector3 lhs, const Vector3 &rhs)
Vector3	operator- (Vector3 lhs, const Vector3 &rhs)
Vector3	operator* (Vector3 lhs, const Vector3 &rhs)
Vector3	operator/ (Vector3 lhs, const Vector3 &rhs)
Vector3	operator+ (Vector3 lhs, float rhs)
Vector3	operator- (Vector3 lhs, float rhs)
Vector3	operator* (Vector3 lhs, float rhs)
Vector3	operator/ (Vector3 lhs, float rhs)
bool	operator== (const Vector3 &lhs, const Vector3 &rhs)
bool	operator!= (const Vector3 &lhs, const Vector3 &rhs)
DataLayerBitmask	computeDataLayerBitmask (DataLayer layer)
template<typename T >
void	remap (T originalCount, const UnorderedSet< T > &keptIndices, UnorderedMap< T, T > &mapping)
template<typename T , typename U >
static UnorderedMap< U, U >	remappedPositions (const Vector< T > &target, const UnorderedSet< U > &indices, MemoryResource *memRes)
template<typename TEnum >
std::enable_if< std::is_enum< TEnum >::value, TEnum >::type	operator& (TEnum lhs, TEnum rhs)
template<typename TEnum >
std::enable_if< std::is_enum< TEnum >::value, TEnum >::type	operator| (TEnum lhs, TEnum rhs)
template<typename TEnum >
std::enable_if< std::is_enum< TEnum >::value, TEnum >::type	operator^ (TEnum lhs, TEnum rhs)
template<typename TEnum >
std::enable_if< std::is_enum< TEnum >::value, TEnum >::type	operator~ (TEnum value)
template<typename TEnum >
std::enable_if< std::is_enum< TEnum >::value, TEnum >::type	operator&= (TEnum &lhs, TEnum rhs)
template<typename TEnum >
std::enable_if< std::is_enum< TEnum >::value, TEnum >::type	operator|= (TEnum &lhs, TEnum rhs)
template<typename TEnum >
std::enable_if< std::is_enum< TEnum >::value, TEnum >::type	operator^= (TEnum &lhs, TEnum rhs)
template<typename TEnum >
std::enable_if< std::is_enum< TEnum >::value, bool >::type	contains (TEnum lhs, TEnum rhs)
template<typename TVector , typename TGetter >
static TVector	collect_n (std::size_t count, TGetter getter, MemoryResource *memRes)
static void	copyDescriptor (const DescriptorReader *source, DescriptorWriter *destination, MemoryResource *)
static std::pair< bool, std::uint16_t >	findIndices (const Matrix< std::uint16_t > &source, ConstArrayView< std::uint16_t > indices)
static void	copyNameIndices (IndicesGetter getIndices, IndicesSetter setIndices, LODMappingSetter setLODMapping, std::uint16_t lodCount, MemoryResource *memRes)
static void	copyDefinition (const DefinitionReader *source, DefinitionWriter *destination, MemoryResource *memRes)
static void	copyBehavior (const BehaviorReader *source, BehaviorWriter *destination, MemoryResource *)
static bool	hasGeometry (const GeometryReader *source)
static void	copyGeometry (const GeometryReader *source, GeometryWriter *destination, MemoryResource *memRes)
static bool	hasBlendShapeTargets (const GeometryReader *source)
static void	copyBlendShapeTargets (const GeometryReader *source, GeometryWriter *destination, MemoryResource *memRes)
template<class TContainer , typename ... Args>
void	ensureHasSize (TContainer &target, std::size_t size, Args &&... args)

Variables
static constexpr std::uint16_t	jointAttributeCount = 9u

Typedef Documentation

AlignedAllocator

template<typename T >

using dna::AlignedAllocator = typedef PolyAllocator<T, 64ul, AlignedMemoryResource>

AlignedDynArray

template<typename T >

using dna::AlignedDynArray = typedef terse::DynArray<T, AlignedAllocator<T> >

ArrayView

template<typename T >

using dna::ArrayView = typedef trust::ArrayView<T>

ConstArrayView

template<typename T >

using dna::ConstArrayView = typedef trust::ConstArrayView<T>

Delta

using dna::Delta = typedef Vector3

DynArray

template<typename T >

using dna::DynArray = typedef terse::DynArray<T, PolyAllocator<T> >

IndicesGetter

using dna::IndicesGetter = typedef std::function<ConstArrayView<std::uint16_t>(std::uint16_t)>

IndicesSetter

using dna::IndicesSetter = typedef std::function<void (std::uint16_t, const std::uint16_t*, std::uint16_t)>

LODMappingSetter

using dna::LODMappingSetter = typedef std::function<void (std::uint16_t, std::uint16_t)>

Normal

using dna::Normal = typedef Vector3

Position

using dna::Position = typedef Vector3

Enumeration Type Documentation

Archetype

enum class dna::Archetype

strong

Enumerator
asian
black
caucasian
hispanic
alien
other

                     {
    asian,
    black,
    caucasian,
    hispanic,
    alien,
    other
};

DataLayer

enum class dna::DataLayer

strong

Enumerator
Descriptor
Definition
Behavior
Geometry
GeometryWithoutBlendShapes
AllWithoutBlendShapes
All

                     {
    Descriptor,
    Definition,  // Includes Descriptor
    Behavior,  // Includes Descriptor and Definition
    Geometry,  // Includes Descriptor and Definition
    GeometryWithoutBlendShapes,  // Includes Descriptor and Definition
    AllWithoutBlendShapes,  // Includes everything except blend shapes from Geometry
    All
};

DataLayerBitmask

enum class dna::DataLayerBitmask

strong

Enumerator
Descriptor
Definition
Behavior
GeometryBlendShapesOnly
GeometryRest

                            {
    Descriptor = 1,
    Definition = 2,
    Behavior = 4,
    GeometryBlendShapesOnly = 8,
    GeometryRest = 16,
};

Direction

enum class dna::Direction

strong

Enumerator
left
right
up
down
front
back

                     {
    left,
    right,
    up,
    down,
    front,
    back
};

Gender

enum class dna::Gender

strong

Enumerator
male
female
other

                  {
    male,
    female,
    other
};

RotationUnit

enum class dna::RotationUnit

strong

Enumerator
degrees
radians

                        {
    degrees,
    radians
};

TranslationUnit

enum class dna::TranslationUnit

strong

Enumerator
cm
m

                           {
    cm,
    m
};

Function Documentation

collect_n()

template<typename TVector , typename TGetter >

static TVector dna::collect_n ( std::size_t  count, TGetter  getter, MemoryResource *  memRes  )

static

                                                                                  {
    TVector retval{memRes};
    retval.reserve(count);
    for (std::size_t i = 0ul; i < count; ++i) {
        retval.push_back(getter(i));
    }
    return retval;
}

computeDataLayerBitmask()

DataLayerBitmask dna::computeDataLayerBitmask ( DataLayer  layer )

inline

                                                                 {
    DataLayerBitmask result = DataLayerBitmask::Descriptor;
    if (layer == DataLayer::Definition) {
        result |= DataLayerBitmask::Definition;
    } else if (layer == DataLayer::Behavior) {
        result |= DataLayerBitmask::Definition;
        result |= DataLayerBitmask::Behavior;
    } else if (layer == DataLayer::Geometry) {
        result |= DataLayerBitmask::Definition;
        result |= DataLayerBitmask::GeometryBlendShapesOnly;
        result |= DataLayerBitmask::GeometryRest;
    } else if (layer == DataLayer::GeometryWithoutBlendShapes) {
        result |= DataLayerBitmask::Definition;
        result |= DataLayerBitmask::GeometryRest;
    } else if (layer == DataLayer::AllWithoutBlendShapes) {
        result |= DataLayerBitmask::Definition;
        result |= DataLayerBitmask::Behavior;
        result |= DataLayerBitmask::GeometryRest;
    } else if (layer == DataLayer::All) {
        result |= DataLayerBitmask::Definition;
        result |= DataLayerBitmask::Behavior;
        result |= DataLayerBitmask::GeometryBlendShapesOnly;
        result |= DataLayerBitmask::GeometryRest;
    }
    return result;
}

References All, AllWithoutBlendShapes, Behavior, Definition, Descriptor, Geometry, GeometryBlendShapesOnly, GeometryRest, and GeometryWithoutBlendShapes.

Referenced by dna::Writer::setFrom().

contains()

template<typename TEnum >

std::enable_if< std::is_enum< TEnum >::value, bool >::type dna::contains	(	TEnum	lhs,
		TEnum	rhs
	)

                               {
    return (lhs & rhs) == rhs;
}

Referenced by dna::FilteredInputArchive::process(), and dna::Writer::setFrom().

copyBehavior()

static void dna::copyBehavior ( const BehaviorReader *  source, BehaviorWriter *  destination, MemoryResource *    )

static

                                                                                                        {
    destination->clearJointGroups();
 
    auto guiToRawInputIndices = source->getGUIToRawInputIndices();
    destination->setGUIToRawInputIndices(guiToRawInputIndices.data(), static_cast<std::uint16_t>(guiToRawInputIndices.size()));
 
    auto guiToRawOutputIndices = source->getGUIToRawOutputIndices();
    destination->setGUIToRawOutputIndices(guiToRawOutputIndices.data(), static_cast<std::uint16_t>(guiToRawOutputIndices.size()));
 
    auto guiToRawFromValues = source->getGUIToRawFromValues();
    destination->setGUIToRawFromValues(guiToRawFromValues.data(), static_cast<std::uint16_t>(guiToRawFromValues.size()));
 
    auto guiToRawToValues = source->getGUIToRawToValues();
    destination->setGUIToRawToValues(guiToRawToValues.data(), static_cast<std::uint16_t>(guiToRawToValues.size()));
 
    auto guiToRawSlopeValues = source->getGUIToRawSlopeValues();
    destination->setGUIToRawSlopeValues(guiToRawSlopeValues.data(), static_cast<std::uint16_t>(guiToRawSlopeValues.size()));
 
    auto guiToRawCutValues = source->getGUIToRawCutValues();
    destination->setGUIToRawCutValues(guiToRawCutValues.data(), static_cast<std::uint16_t>(guiToRawCutValues.size()));
 
    destination->setPSDCount(source->getPSDCount());
 
    auto psdRowIndices = source->getPSDRowIndices();
    destination->setPSDRowIndices(psdRowIndices.data(), static_cast<std::uint16_t>(psdRowIndices.size()));
 
    auto psdColumnIndices = source->getPSDColumnIndices();
    destination->setPSDColumnIndices(psdColumnIndices.data(), static_cast<std::uint16_t>(psdColumnIndices.size()));
 
    auto psdValues = source->getPSDValues();
    destination->setPSDValues(psdValues.data(), static_cast<std::uint16_t>(psdValues.size()));
 
    destination->setJointRowCount(source->getJointRowCount());
    destination->setJointColumnCount(source->getJointColumnCount());
 
    for (std::uint16_t jointGroupIndexPlusOne = source->getJointGroupCount();
         jointGroupIndexPlusOne > 0u;
         --jointGroupIndexPlusOne) {
        const auto jointGroupIndex = static_cast<std::uint16_t>(jointGroupIndexPlusOne - 1u);
 
        auto jointGroupLODs = source->getJointGroupLODs(jointGroupIndex);
        destination->setJointGroupLODs(jointGroupIndex, jointGroupLODs.data(), static_cast<std::uint16_t>(jointGroupLODs.size()));
 
        auto jointGroupInputIndices = source->getJointGroupInputIndices(jointGroupIndex);
        destination->setJointGroupInputIndices(jointGroupIndex, jointGroupInputIndices.data(),
                                               static_cast<std::uint16_t>(jointGroupInputIndices.size()));
 
        auto jointGroupOutputIndices = source->getJointGroupOutputIndices(jointGroupIndex);
        destination->setJointGroupOutputIndices(jointGroupIndex, jointGroupOutputIndices.data(),
                                                static_cast<std::uint16_t>(jointGroupOutputIndices.size()));
 
        auto jointGroupValues = source->getJointGroupValues(jointGroupIndex);
        destination->setJointGroupValues(jointGroupIndex, jointGroupValues.data(),
                                         static_cast<std::uint32_t>(jointGroupValues.size()));
 
        auto jointGroupJointIndices = source->getJointGroupJointIndices(jointGroupIndex);
        destination->setJointGroupJointIndices(jointGroupIndex, jointGroupJointIndices.data(),
                                               static_cast<std::uint16_t>(jointGroupJointIndices.size()));
    }
 
    auto blendShapeLODs = source->getBlendShapeChannelLODs();
    destination->setBlendShapeChannelLODs(blendShapeLODs.data(), static_cast<std::uint16_t>(blendShapeLODs.size()));
 
    auto blendShapeInputIndices = source->getBlendShapeChannelInputIndices();
    destination->setBlendShapeChannelInputIndices(blendShapeInputIndices.data(),
                                                  static_cast<std::uint16_t>(blendShapeInputIndices.size()));
 
    auto blendShapeOutputIndices = source->getBlendShapeChannelOutputIndices();
    destination->setBlendShapeChannelOutputIndices(blendShapeOutputIndices.data(),
                                                   static_cast<std::uint16_t>(blendShapeOutputIndices.size()));
 
    auto animatedMapLODs = source->getAnimatedMapLODs();
    destination->setAnimatedMapLODs(animatedMapLODs.data(), static_cast<std::uint16_t>(animatedMapLODs.size()));
 
    auto animatedMapInputIndices = source->getAnimatedMapInputIndices();
    destination->setAnimatedMapInputIndices(animatedMapInputIndices.data(),
                                            static_cast<std::uint16_t>(animatedMapInputIndices.size()));
 
    auto animatedMapOutputIndices = source->getAnimatedMapOutputIndices();
    destination->setAnimatedMapOutputIndices(animatedMapOutputIndices.data(),
                                             static_cast<std::uint16_t>(animatedMapOutputIndices.size()));
 
    auto animatedMapFromValues = source->getAnimatedMapFromValues();
    destination->setAnimatedMapFromValues(animatedMapFromValues.data(), static_cast<std::uint16_t>(animatedMapFromValues.size()));
 
    auto animatedMapToValues = source->getAnimatedMapToValues();
    destination->setAnimatedMapToValues(animatedMapToValues.data(), static_cast<std::uint16_t>(animatedMapToValues.size()));
 
    auto animatedMapSlopeValues = source->getAnimatedMapSlopeValues();
    destination->setAnimatedMapSlopeValues(animatedMapSlopeValues.data(),
                                           static_cast<std::uint16_t>(animatedMapSlopeValues.size()));
 
    auto animatedMapCutValues = source->getAnimatedMapCutValues();
    destination->setAnimatedMapCutValues(animatedMapCutValues.data(), static_cast<std::uint16_t>(animatedMapCutValues.size()));
}

References dna::BehaviorWriter::clearJointGroups(), dna::BehaviorReader::getAnimatedMapCutValues(), dna::BehaviorReader::getAnimatedMapFromValues(), dna::BehaviorReader::getAnimatedMapInputIndices(), dna::BehaviorReader::getAnimatedMapLODs(), dna::BehaviorReader::getAnimatedMapOutputIndices(), dna::BehaviorReader::getAnimatedMapSlopeValues(), dna::BehaviorReader::getAnimatedMapToValues(), dna::BehaviorReader::getBlendShapeChannelInputIndices(), dna::BehaviorReader::getBlendShapeChannelLODs(), dna::BehaviorReader::getBlendShapeChannelOutputIndices(), dna::BehaviorReader::getGUIToRawCutValues(), dna::BehaviorReader::getGUIToRawFromValues(), dna::BehaviorReader::getGUIToRawInputIndices(), dna::BehaviorReader::getGUIToRawOutputIndices(), dna::BehaviorReader::getGUIToRawSlopeValues(), dna::BehaviorReader::getGUIToRawToValues(), dna::BehaviorReader::getJointColumnCount(), dna::BehaviorReader::getJointGroupCount(), dna::BehaviorReader::getJointGroupInputIndices(), dna::BehaviorReader::getJointGroupJointIndices(), dna::BehaviorReader::getJointGroupLODs(), dna::BehaviorReader::getJointGroupOutputIndices(), dna::BehaviorReader::getJointGroupValues(), dna::BehaviorReader::getJointRowCount(), dna::BehaviorReader::getPSDColumnIndices(), dna::BehaviorReader::getPSDCount(), dna::BehaviorReader::getPSDRowIndices(), dna::BehaviorReader::getPSDValues(), dna::BehaviorWriter::setAnimatedMapCutValues(), dna::BehaviorWriter::setAnimatedMapFromValues(), dna::BehaviorWriter::setAnimatedMapInputIndices(), dna::BehaviorWriter::setAnimatedMapLODs(), dna::BehaviorWriter::setAnimatedMapOutputIndices(), dna::BehaviorWriter::setAnimatedMapSlopeValues(), dna::BehaviorWriter::setAnimatedMapToValues(), dna::BehaviorWriter::setBlendShapeChannelInputIndices(), dna::BehaviorWriter::setBlendShapeChannelLODs(), dna::BehaviorWriter::setBlendShapeChannelOutputIndices(), dna::BehaviorWriter::setGUIToRawCutValues(), dna::BehaviorWriter::setGUIToRawFromValues(), dna::BehaviorWriter::setGUIToRawInputIndices(), dna::BehaviorWriter::setGUIToRawOutputIndices(), dna::BehaviorWriter::setGUIToRawSlopeValues(), dna::BehaviorWriter::setGUIToRawToValues(), dna::BehaviorWriter::setJointColumnCount(), dna::BehaviorWriter::setJointGroupInputIndices(), dna::BehaviorWriter::setJointGroupJointIndices(), dna::BehaviorWriter::setJointGroupLODs(), dna::BehaviorWriter::setJointGroupOutputIndices(), dna::BehaviorWriter::setJointGroupValues(), dna::BehaviorWriter::setJointRowCount(), dna::BehaviorWriter::setPSDColumnIndices(), dna::BehaviorWriter::setPSDCount(), dna::BehaviorWriter::setPSDRowIndices(), and dna::BehaviorWriter::setPSDValues().

Referenced by dna::Writer::setFrom().

copyBlendShapeTargets()

static void dna::copyBlendShapeTargets ( const GeometryReader *  source, GeometryWriter *  destination, MemoryResource *  memRes  )

static

                                                                                                                     {
    if (!hasBlendShapeTargets(source)) {
        // Source DNA was loaded without blend shape targets
        return;
    }
 
    for (std::uint16_t meshIndexPlusOne = source->getMeshCount(); meshIndexPlusOne > 0u; --meshIndexPlusOne) {
        const auto meshIndex = static_cast<std::uint16_t>(meshIndexPlusOne - 1u);
        for (std::uint16_t blendShapeTargetIndexPlusOne = source->getBlendShapeTargetCount(meshIndex);
             blendShapeTargetIndexPlusOne > 0u;
             --blendShapeTargetIndexPlusOne) {
            const auto blendShapeTargetIndex = static_cast<std::uint16_t>(blendShapeTargetIndexPlusOne - 1u);
            auto channelIndex = source->getBlendShapeChannelIndex(meshIndex, blendShapeTargetIndex);
            destination->setBlendShapeChannelIndex(meshIndex, blendShapeTargetIndex, channelIndex);
            auto deltaCount = source->getBlendShapeTargetDeltaCount(meshIndex, blendShapeTargetIndex);
            auto deltas = collect_n<Vector3Vector>(deltaCount, [source, meshIndex, blendShapeTargetIndex](std::size_t index) {
                    return source->getBlendShapeTargetDelta(meshIndex, blendShapeTargetIndex,
                                                            static_cast<std::uint32_t>(index));
                }, memRes);
            destination->setBlendShapeTargetDeltas(meshIndex, blendShapeTargetIndex, deltas.data(),
                                                   static_cast<std::uint32_t>(deltas.size()));
 
            auto deltasVertices = source->getBlendShapeTargetVertexIndices(meshIndex, blendShapeTargetIndex);
            destination->setBlendShapeTargetVertexIndices(meshIndex, blendShapeTargetIndex, deltasVertices.data(),
                                                          static_cast<std::uint32_t>(deltasVertices.size()));
        }
    }
}

References dna::GeometryReader::getBlendShapeChannelIndex(), dna::GeometryReader::getBlendShapeTargetCount(), dna::GeometryReader::getBlendShapeTargetDelta(), dna::GeometryReader::getBlendShapeTargetDeltaCount(), dna::GeometryReader::getBlendShapeTargetVertexIndices(), dna::DefinitionReader::getMeshCount(), hasBlendShapeTargets(), dna::GeometryWriter::setBlendShapeChannelIndex(), dna::GeometryWriter::setBlendShapeTargetDeltas(), and dna::GeometryWriter::setBlendShapeTargetVertexIndices().

Referenced by dna::Writer::setFrom().

copyDefinition()

static void dna::copyDefinition ( const DefinitionReader *  source, DefinitionWriter *  destination, MemoryResource *  memRes  )

static

                                                                                                                  {
    destination->clearGUIControlNames();
    destination->clearRawControlNames();
    destination->clearJointNames();
    destination->clearBlendShapeChannelNames();
    destination->clearAnimatedMapNames();
    destination->clearMeshNames();
    destination->clearJointIndices();
    destination->clearLODJointMappings();
    destination->clearBlendShapeChannelIndices();
    destination->clearLODBlendShapeChannelMappings();
    destination->clearAnimatedMapIndices();
    destination->clearLODAnimatedMapMappings();
    destination->clearMeshIndices();
    destination->clearLODMeshMappings();
    destination->clearMeshBlendShapeChannelMappings();
 
    const auto lodCount = source->getLODCount();
 
    for (std::uint16_t i = source->getGUIControlCount(); i > 0u; --i) {
        const auto idx = static_cast<std::uint16_t>(i - 1u);
        destination->setGUIControlName(idx, source->getGUIControlName(idx).data());
    }
    for (std::uint16_t i = source->getRawControlCount(); i > 0u; --i) {
        const auto idx = static_cast<std::uint16_t>(i - 1u);
        destination->setRawControlName(idx, source->getRawControlName(idx).data());
    }
    for (std::uint16_t i = source->getJointCount(); i > 0u; --i) {
        const auto idx = static_cast<std::uint16_t>(i - 1u);
        destination->setJointName(idx, source->getJointName(idx).data());
    }
    for (std::uint16_t i = source->getBlendShapeChannelCount(); i > 0u; --i) {
        const auto idx = static_cast<std::uint16_t>(i - 1u);
        destination->setBlendShapeChannelName(idx, source->getBlendShapeChannelName(idx).data());
    }
    for (std::uint16_t i = source->getAnimatedMapCount(); i > 0u; --i) {
        const auto idx = static_cast<std::uint16_t>(i - 1u);
        destination->setAnimatedMapName(idx, source->getAnimatedMapName(idx));
    }
    for (std::uint16_t i = source->getMeshCount(); i > 0u; --i) {
        const auto idx = static_cast<std::uint16_t>(i - 1u);
        destination->setMeshName(idx, source->getMeshName(idx).data());
    }
 
    using namespace std::placeholders;
    copyNameIndices(
        std::bind(&DefinitionReader::getJointIndicesForLOD, source, _1),
        std::bind(&DefinitionWriter::setJointIndices, destination, _1, _2, _3),
        std::bind(&DefinitionWriter::setLODJointMapping, destination, _1, _2),
        lodCount,
        memRes);
    copyNameIndices(
        std::bind(&DefinitionReader::getBlendShapeChannelIndicesForLOD, source, _1),
        std::bind(&DefinitionWriter::setBlendShapeChannelIndices, destination, _1, _2, _3),
        std::bind(&DefinitionWriter::setLODBlendShapeChannelMapping, destination, _1, _2),
        lodCount,
        memRes);
    copyNameIndices(
        std::bind(&DefinitionReader::getAnimatedMapIndicesForLOD, source, _1),
        std::bind(&DefinitionWriter::setAnimatedMapIndices, destination, _1, _2, _3),
        std::bind(&DefinitionWriter::setLODAnimatedMapMapping, destination, _1, _2),
        lodCount,
        memRes);
    copyNameIndices(
        std::bind(&DefinitionReader::getMeshIndicesForLOD, source, _1),
        std::bind(&DefinitionWriter::setMeshIndices, destination, _1, _2, _3),
        std::bind(&DefinitionWriter::setLODMeshMapping, destination, _1, _2),
        lodCount,
        memRes);
 
    Vector<std::uint16_t> jointHierarchy{memRes};
    jointHierarchy.reserve(source->getJointCount());
    for (std::uint16_t i = 0u; i < source->getJointCount(); ++i) {
        jointHierarchy.push_back(source->getJointParentIndex(i));
    }
    destination->setJointHierarchy(jointHierarchy.data(), static_cast<std::uint16_t>(jointHierarchy.size()));
 
    for (std::uint16_t i = 0u; i < source->getMeshBlendShapeChannelMappingCount(); ++i) {
        auto mapping = source->getMeshBlendShapeChannelMapping(i);
        destination->setMeshBlendShapeChannelMapping(i, mapping.meshIndex, mapping.blendShapeChannelIndex);
    }
 
    auto jointCount = source->getJointCount();
 
    auto translations = collect_n<Vector3Vector>(jointCount, [source](std::size_t index) {
            return source->getNeutralJointTranslation(static_cast<std::uint16_t>(index));
        }, memRes);
    destination->setNeutralJointTranslations(translations.data(), static_cast<std::uint16_t>(translations.size()));
 
    auto rotations = collect_n<Vector3Vector>(jointCount, [source](std::size_t index) {
            return source->getNeutralJointRotation(static_cast<std::uint16_t>(index));
        }, memRes);
    destination->setNeutralJointRotations(rotations.data(), static_cast<std::uint16_t>(rotations.size()));
}

References dna::DefinitionWriter::clearAnimatedMapIndices(), dna::DefinitionWriter::clearAnimatedMapNames(), dna::DefinitionWriter::clearBlendShapeChannelIndices(), dna::DefinitionWriter::clearBlendShapeChannelNames(), dna::DefinitionWriter::clearGUIControlNames(), dna::DefinitionWriter::clearJointIndices(), dna::DefinitionWriter::clearJointNames(), dna::DefinitionWriter::clearLODAnimatedMapMappings(), dna::DefinitionWriter::clearLODBlendShapeChannelMappings(), dna::DefinitionWriter::clearLODJointMappings(), dna::DefinitionWriter::clearLODMeshMappings(), dna::DefinitionWriter::clearMeshBlendShapeChannelMappings(), dna::DefinitionWriter::clearMeshIndices(), dna::DefinitionWriter::clearMeshNames(), dna::DefinitionWriter::clearRawControlNames(), copyNameIndices(), trust::ArrayView< T >::data(), dna::DefinitionReader::getAnimatedMapCount(), dna::DefinitionReader::getAnimatedMapIndicesForLOD(), dna::DefinitionReader::getAnimatedMapName(), dna::DefinitionReader::getBlendShapeChannelCount(), dna::DefinitionReader::getBlendShapeChannelIndicesForLOD(), dna::DefinitionReader::getBlendShapeChannelName(), dna::DefinitionReader::getGUIControlCount(), dna::DefinitionReader::getGUIControlName(), dna::DefinitionReader::getJointCount(), dna::DefinitionReader::getJointIndicesForLOD(), dna::DefinitionReader::getJointName(), dna::DefinitionReader::getJointParentIndex(), dna::DescriptorReader::getLODCount(), dna::DefinitionReader::getMeshBlendShapeChannelMapping(), dna::DefinitionReader::getMeshBlendShapeChannelMappingCount(), dna::DefinitionReader::getMeshCount(), dna::DefinitionReader::getMeshIndicesForLOD(), dna::DefinitionReader::getMeshName(), dna::DefinitionReader::getNeutralJointRotation(), dna::DefinitionReader::getNeutralJointTranslation(), dna::DefinitionReader::getRawControlCount(), dna::DefinitionReader::getRawControlName(), dna::DefinitionWriter::setAnimatedMapIndices(), dna::DefinitionWriter::setAnimatedMapName(), dna::DefinitionWriter::setBlendShapeChannelIndices(), dna::DefinitionWriter::setBlendShapeChannelName(), dna::DefinitionWriter::setGUIControlName(), dna::DefinitionWriter::setJointHierarchy(), dna::DefinitionWriter::setJointIndices(), dna::DefinitionWriter::setJointName(), dna::DefinitionWriter::setLODAnimatedMapMapping(), dna::DefinitionWriter::setLODBlendShapeChannelMapping(), dna::DefinitionWriter::setLODJointMapping(), dna::DefinitionWriter::setLODMeshMapping(), dna::DefinitionWriter::setMeshBlendShapeChannelMapping(), dna::DefinitionWriter::setMeshIndices(), dna::DefinitionWriter::setMeshName(), dna::DefinitionWriter::setNeutralJointRotations(), dna::DefinitionWriter::setNeutralJointTranslations(), and dna::DefinitionWriter::setRawControlName().

Referenced by dna::Writer::setFrom().

copyDescriptor()

static void dna::copyDescriptor ( const DescriptorReader *  source, DescriptorWriter *  destination, MemoryResource *    )

static

                                                                                                              {
    destination->setName(source->getName());
    destination->setArchetype(source->getArchetype());
    destination->setGender(source->getGender());
    destination->setAge(source->getAge());
    destination->clearMetaData();
    for (std::uint32_t i = 0u; i < source->getMetaDataCount(); ++i) {
        const auto key = source->getMetaDataKey(i);
        const auto value = source->getMetaDataValue(key);
        destination->setMetaData(key, value);
    }
    destination->setTranslationUnit(source->getTranslationUnit());
    destination->setRotationUnit(source->getRotationUnit());
    destination->setCoordinateSystem(source->getCoordinateSystem());
    destination->setLODCount(source->getLODCount());
    destination->setDBMaxLOD(source->getDBMaxLOD());
    destination->setDBComplexity(source->getDBComplexity());
    destination->setDBName(source->getDBName());
}

References dna::DescriptorWriter::clearMetaData(), dna::DescriptorReader::getAge(), dna::DescriptorReader::getArchetype(), dna::DescriptorReader::getCoordinateSystem(), dna::DescriptorReader::getDBComplexity(), dna::DescriptorReader::getDBMaxLOD(), dna::DescriptorReader::getDBName(), dna::DescriptorReader::getGender(), dna::DescriptorReader::getLODCount(), dna::DescriptorReader::getMetaDataCount(), dna::DescriptorReader::getMetaDataKey(), dna::DescriptorReader::getMetaDataValue(), dna::DescriptorReader::getName(), dna::DescriptorReader::getRotationUnit(), dna::DescriptorReader::getTranslationUnit(), dna::DescriptorWriter::setAge(), dna::DescriptorWriter::setArchetype(), dna::DescriptorWriter::setCoordinateSystem(), dna::DescriptorWriter::setDBComplexity(), dna::DescriptorWriter::setDBMaxLOD(), dna::DescriptorWriter::setDBName(), dna::DescriptorWriter::setGender(), dna::DescriptorWriter::setLODCount(), dna::DescriptorWriter::setMetaData(), dna::DescriptorWriter::setName(), dna::DescriptorWriter::setRotationUnit(), and dna::DescriptorWriter::setTranslationUnit().

Referenced by dna::Writer::setFrom().

copyGeometry()

static void dna::copyGeometry ( const GeometryReader *  source, GeometryWriter *  destination, MemoryResource *  memRes  )

static

                                                                                                            {
    destination->clearMeshes();
 
    if (!hasGeometry(source)) {
        // Source DNA was loaded without geometry layer
        return;
    }
 
    for (std::uint16_t meshIndexPlusOne = source->getMeshCount(); meshIndexPlusOne > 0u; --meshIndexPlusOne) {
        const auto meshIndex = static_cast<std::uint16_t>(meshIndexPlusOne - 1u);
        auto vertexCount = source->getVertexPositionCount(meshIndex);
        auto positions = collect_n<Vector3Vector>(vertexCount, [source, meshIndex](std::size_t index) {
                return source->getVertexPosition(meshIndex, static_cast<std::uint32_t>(index));
            }, memRes);
        destination->setVertexPositions(meshIndex, positions.data(), static_cast<std::uint32_t>(positions.size()));
 
        auto textureCoordinateCount = source->getVertexTextureCoordinateCount(meshIndex);
        auto textureCoordinates = collect_n<TextureCoordinateVector>(textureCoordinateCount,
                                                                     [source, meshIndex](std::size_t index) {
                return source->getVertexTextureCoordinate(meshIndex, static_cast<std::uint32_t>(index));
            }, memRes);
        destination->setVertexTextureCoordinates(meshIndex, textureCoordinates.data(),
                                                 static_cast<std::uint32_t>(textureCoordinates.size()));
 
        auto normalCount = source->getVertexNormalCount(meshIndex);
        auto normals = collect_n<Vector3Vector>(normalCount, [source, meshIndex](std::size_t index) {
                return source->getVertexNormal(meshIndex, static_cast<std::uint32_t>(index));
            }, memRes);
        destination->setVertexNormals(meshIndex, normals.data(), static_cast<std::uint32_t>(normals.size()));
 
        auto layoutCount = source->getVertexLayoutCount(meshIndex);
        auto layouts = collect_n<VertexLayoutVector>(layoutCount, [source, meshIndex](std::size_t index) {
                return source->getVertexLayout(meshIndex, static_cast<std::uint32_t>(index));
            }, memRes);
        destination->setVertexLayouts(meshIndex, layouts.data(), static_cast<std::uint32_t>(layouts.size()));
 
        for (std::uint32_t faceIndexPlusOne = source->getFaceCount(meshIndex); faceIndexPlusOne > 0u; --faceIndexPlusOne) {
            const auto faceIndex = faceIndexPlusOne - 1u;
            auto faceVertices = source->getFaceVertexLayoutIndices(meshIndex, faceIndex);
            destination->setFaceVertexLayoutIndices(meshIndex, faceIndex, faceVertices.data(),
                                                    static_cast<std::uint32_t>(faceVertices.size()));
        }
 
        destination->setMaximumInfluencePerVertex(meshIndex, source->getMaximumInfluencePerVertex(meshIndex));
 
        const auto skinWeightsCount = source->getSkinWeightsCount(meshIndex);
        for (std::uint32_t skinWeightsIndexPlusOne = skinWeightsCount; skinWeightsIndexPlusOne > 0u; --skinWeightsIndexPlusOne) {
            const auto skinWeightsIndex = skinWeightsIndexPlusOne - 1u;
            auto skinWeights = source->getSkinWeightsValues(meshIndex, skinWeightsIndex);
            destination->setSkinWeightsValues(meshIndex, skinWeightsIndex, skinWeights.data(),
                                              static_cast<std::uint16_t>(skinWeights.size()));
 
            auto skinWeightsJoints = source->getSkinWeightsJointIndices(meshIndex, skinWeightsIndex);
            destination->setSkinWeightsJointIndices(meshIndex, skinWeightsIndex, skinWeightsJoints.data(),
                                                    static_cast<std::uint16_t>(skinWeightsJoints.size()));
        }
    }
}

References dna::GeometryWriter::clearMeshes(), dna::GeometryReader::getFaceCount(), dna::GeometryReader::getFaceVertexLayoutIndices(), dna::GeometryReader::getMaximumInfluencePerVertex(), dna::DefinitionReader::getMeshCount(), dna::GeometryReader::getSkinWeightsCount(), dna::GeometryReader::getSkinWeightsJointIndices(), dna::GeometryReader::getSkinWeightsValues(), dna::GeometryReader::getVertexLayout(), dna::GeometryReader::getVertexLayoutCount(), dna::GeometryReader::getVertexNormal(), dna::GeometryReader::getVertexNormalCount(), dna::GeometryReader::getVertexPosition(), dna::GeometryReader::getVertexPositionCount(), dna::GeometryReader::getVertexTextureCoordinate(), dna::GeometryReader::getVertexTextureCoordinateCount(), hasGeometry(), dna::GeometryWriter::setFaceVertexLayoutIndices(), dna::GeometryWriter::setMaximumInfluencePerVertex(), dna::GeometryWriter::setSkinWeightsJointIndices(), dna::GeometryWriter::setSkinWeightsValues(), dna::GeometryWriter::setVertexLayouts(), dna::GeometryWriter::setVertexNormals(), dna::GeometryWriter::setVertexPositions(), and dna::GeometryWriter::setVertexTextureCoordinates().

Referenced by dna::Writer::setFrom().

copyNameIndices()

static void dna::copyNameIndices ( IndicesGetter  getIndices, IndicesSetter  setIndices, LODMappingSetter  setLODMapping, std::uint16_t  lodCount, MemoryResource *  memRes  )

static

                                                    {
    Matrix<std::uint16_t> allIndices{memRes};
    std::uint16_t index = 0u;
    for (std::uint16_t lod = 0u; lod < lodCount; ++lod) {
        auto indices = getIndices(lod);
        // Check if these same indices were perhaps already used for previous LODs
        auto found = findIndices(allIndices, indices);
        if (!found.first) {
            setIndices(index, indices.data(), static_cast<std::uint16_t>(indices.size()));
            setLODMapping(lod, index);
            allIndices.emplace_back(indices.begin(), indices.end());
            ++index;
        } else {
            // Already used so do not replicate the same data twice
            setLODMapping(lod, found.second);
        }
    }
}

References findIndices().

Referenced by copyDefinition().

ensureHasSize()

template<class TContainer , typename ... Args>

void dna::ensureHasSize	(	TContainer &	target,
		std::size_t	size,
		Args &&...	args
	)

                                    {
    target.reserve(size);
    while (target.size() < size) {
        target.push_back(typename TContainer::value_type(std::forward<Args>(args)...));
    }
}

Referenced by dna::WriterImpl< TWriterBase >::setAnimatedMapName(), dna::WriterImpl< TWriterBase >::setBlendShapeChannelIndex(), dna::WriterImpl< TWriterBase >::setBlendShapeChannelName(), dna::WriterImpl< TWriterBase >::setBlendShapeTargetDeltas(), dna::WriterImpl< TWriterBase >::setBlendShapeTargetVertexIndices(), dna::WriterImpl< TWriterBase >::setFaceVertexLayoutIndices(), dna::WriterImpl< TWriterBase >::setGUIControlName(), dna::WriterImpl< TWriterBase >::setJointGroupInputIndices(), dna::WriterImpl< TWriterBase >::setJointGroupJointIndices(), dna::WriterImpl< TWriterBase >::setJointGroupLODs(), dna::WriterImpl< TWriterBase >::setJointGroupOutputIndices(), dna::WriterImpl< TWriterBase >::setJointGroupValues(), dna::WriterImpl< TWriterBase >::setJointName(), dna::WriterImpl< TWriterBase >::setMaximumInfluencePerVertex(), dna::WriterImpl< TWriterBase >::setMeshName(), dna::WriterImpl< TWriterBase >::setRawControlName(), dna::WriterImpl< TWriterBase >::setSkinWeightsJointIndices(), dna::WriterImpl< TWriterBase >::setSkinWeightsValues(), dna::WriterImpl< TWriterBase >::setVertexLayouts(), dna::WriterImpl< TWriterBase >::setVertexNormals(), dna::WriterImpl< TWriterBase >::setVertexPositions(), and dna::WriterImpl< TWriterBase >::setVertexTextureCoordinates().

findIndices()

static std::pair< bool, std::uint16_t > dna::findIndices ( const Matrix< std::uint16_t > &  source, ConstArrayView< std::uint16_t >  indices  )

static

                                                                                                                      {
    // In the common scenario each LOD has it's unique set of indices
    for (std::size_t i = 0ul; i < source.size(); ++i) {
        ConstArrayView<std::uint16_t> candidate{source[i].data(), source[i].size()};
        if (indices == candidate) {
            // Unless the indices are the same between multiple LODs, in which case use the
            // already registered index
            return {true, static_cast<std::uint16_t>(i)};
        }
    }
    return {false, static_cast<std::uint16_t>(0)};
}

References trust::ArrayView< T >::data().

Referenced by copyNameIndices().

hasBlendShapeTargets()

static bool dna::hasBlendShapeTargets ( const GeometryReader *  source )

static

                                                               {
    // Heuristic for determining whether source DNA actually has any blend shape target data, or mesh count is non-zero only
    // because of mesh names stored in definition layer
    std::uint32_t totalBlendShapeTargetCount = {};
    for (std::uint16_t meshIndex = {}; meshIndex < source->getMeshCount(); ++meshIndex) {
        totalBlendShapeTargetCount += source->getBlendShapeTargetCount(meshIndex);
    }
    return (totalBlendShapeTargetCount != 0u);
}

References dna::GeometryReader::getBlendShapeTargetCount(), and dna::DefinitionReader::getMeshCount().

Referenced by copyBlendShapeTargets().

hasGeometry()

static bool dna::hasGeometry ( const GeometryReader *  source )

static

                                                      {
    // Heuristic for determining whether source DNA actually has any geometry data, or mesh count is non-zero only
    // because of mesh names stored in definition layer
    std::uint32_t totalVertexCount = {};
    std::uint32_t totalVertexNormalCount = {};
    std::uint32_t totalTextureCoordCount = {};
    std::uint32_t totalVertexLayoutCount = {};
    std::uint32_t totalSkinWeightCount = {};
    for (std::uint16_t meshIndex = {}; meshIndex < source->getMeshCount(); ++meshIndex) {
        totalVertexCount += source->getVertexPositionCount(meshIndex);
        totalVertexNormalCount += source->getVertexNormalCount(meshIndex);
        totalTextureCoordCount += source->getVertexTextureCoordinateCount(meshIndex);
        totalVertexLayoutCount += source->getVertexLayoutCount(meshIndex);
        totalSkinWeightCount += source->getSkinWeightsCount(meshIndex);
    }
    return ((totalVertexCount != 0u) || (totalVertexNormalCount != 0u) || (totalTextureCoordCount != 0u) ||
            (totalVertexLayoutCount != 0u) || (totalSkinWeightCount != 0u));
}

References dna::DefinitionReader::getMeshCount(), dna::GeometryReader::getSkinWeightsCount(), dna::GeometryReader::getVertexLayoutCount(), dna::GeometryReader::getVertexNormalCount(), dna::GeometryReader::getVertexPositionCount(), and dna::GeometryReader::getVertexTextureCoordinateCount().

Referenced by copyGeometry().

operator!=() [1/2]

bool dna::operator!= ( const StringView &  lhs, const StringView &  rhs  )

inline

                                                                     {
    return !(lhs == rhs);
}

operator!=() [2/2]

bool dna::operator!= ( const Vector3 &  lhs, const Vector3 &  rhs  )

inline

                                                               {
    return !(lhs == rhs);
}

operator&()

template<typename TEnum >

std::enable_if< std::is_enum< TEnum >::value, TEnum >::type dna::operator&	(	TEnum	lhs,
		TEnum	rhs
	)

                                {
    using Underlying = typename std::underlying_type<TEnum>::type;
    return static_cast<TEnum>(static_cast<Underlying>(lhs) & static_cast<Underlying>(rhs));
}

operator&=()

template<typename TEnum >

std::enable_if< std::is_enum< TEnum >::value, TEnum >::type dna::operator&=	(	TEnum &	lhs,
		TEnum	rhs
	)

                                  {
    return lhs = (lhs & rhs);
}

operator*() [1/2]

Vector3 dna::operator* ( Vector3  lhs, const Vector3 &  rhs  )

inline

                                                          {
    return (lhs *= rhs);
}

operator*() [2/2]

Vector3 dna::operator* ( Vector3  lhs, float  rhs  )

inline

                                                 {
    return (lhs *= rhs);
}

operator+() [1/2]

Vector3 dna::operator+ ( Vector3  lhs, const Vector3 &  rhs  )

inline

                                                          {
    return (lhs += rhs);
}

operator+() [2/2]

Vector3 dna::operator+ ( Vector3  lhs, float  rhs  )

inline

                                                 {
    return (lhs += rhs);
}

operator-() [1/2]

Vector3 dna::operator- ( Vector3  lhs, const Vector3 &  rhs  )

inline

                                                          {
    return (lhs -= rhs);
}

operator-() [2/2]

Vector3 dna::operator- ( Vector3  lhs, float  rhs  )

inline

                                                 {
    return (lhs -= rhs);
}

operator/() [1/2]

Vector3 dna::operator/ ( Vector3  lhs, const Vector3 &  rhs  )

inline

                                                          {
    return (lhs /= rhs);
}

operator/() [2/2]

Vector3 dna::operator/ ( Vector3  lhs, float  rhs  )

inline

                                                 {
    return (lhs /= rhs);
}

operator==() [1/2]

bool dna::operator== ( const StringView &  lhs, const StringView &  rhs  )

inline

                                                                     {
    return (static_cast<const StringView::Base&>(lhs) == static_cast<const StringView::Base&>(rhs));
}

operator==() [2/2]

bool dna::operator== ( const Vector3 &  lhs, const Vector3 &  rhs  )

inline

                                                               {
    return (lhs.x == rhs.x && lhs.y == rhs.y && lhs.z == rhs.z);
}

References dna::Vector3::x, dna::Vector3::y, and dna::Vector3::z.

operator^()

template<typename TEnum >

std::enable_if< std::is_enum< TEnum >::value, TEnum >::type dna::operator^	(	TEnum	lhs,
		TEnum	rhs
	)

                                {
    using Underlying = typename std::underlying_type<TEnum>::type;
    return static_cast<TEnum>(static_cast<Underlying>(lhs) ^ static_cast<Underlying>(rhs));
}

operator^=()

template<typename TEnum >

std::enable_if< std::is_enum< TEnum >::value, TEnum >::type dna::operator^=	(	TEnum &	lhs,
		TEnum	rhs
	)

                                  {
    return lhs = (lhs ^ rhs);
}

operator|()

template<typename TEnum >

std::enable_if< std::is_enum< TEnum >::value, TEnum >::type dna::operator|	(	TEnum	lhs,
		TEnum	rhs
	)

                                {
    using Underlying = typename std::underlying_type<TEnum>::type;
    return static_cast<TEnum>(static_cast<Underlying>(lhs) | static_cast<Underlying>(rhs));
}

operator|=()

template<typename TEnum >

std::enable_if< std::is_enum< TEnum >::value, TEnum >::type dna::operator|=	(	TEnum &	lhs,
		TEnum	rhs
	)

                                  {
    return lhs = (lhs | rhs);
}

operator~()

template<typename TEnum >

std::enable_if< std::is_enum< TEnum >::value, TEnum >::type dna::operator~

(

TEnum

value

)

                       {
    using Underlying = typename std::underlying_type<TEnum>::type;
    return static_cast<TEnum>(~static_cast<Underlying>(value));
}

remap()

template<typename T >

void dna::remap ( T  originalCount, const UnorderedSet< T > &  keptIndices, UnorderedMap< T, T > &  mapping  )

inline

                                                                                                    {
    for (T oldIndex{}, newIndex{}; oldIndex < originalCount; ++oldIndex) {
        if (extd::contains(keptIndices, oldIndex)) {
            mapping.insert({oldIndex, newIndex});
            ++newIndex;
        }
    }
}

References extd::contains().

Referenced by dna::AnimatedMapFilter::configure(), dna::BlendShapeFilter::configure(), dna::JointFilter::configure(), and dna::MeshFilter::configure().

remappedPositions()

template<typename T , typename U >

static UnorderedMap< U, U > dna::remappedPositions ( const Vector< T > &  target, const UnorderedSet< U > &  indices, MemoryResource *  memRes  )

static

                                                                                                                             {
    UnorderedMap<U, U> mapping{memRes};
    for (U oldIndex{}, newIndex{}; oldIndex < static_cast<U>(target.size()); ++oldIndex) {
        if (indices.find(oldIndex) != indices.end()) {
            mapping.insert({oldIndex, newIndex});
            ++newIndex;
        }
    }
    return mapping;
}

Variable Documentation

jointAttributeCount

constexpr std::uint16_t dna::jointAttributeCount = 9u

staticconstexpr

Referenced by dna::JointFilter::apply(), and dna::FilteredInputArchive::process().