dnac Namespace Reference

Namespaces
namespace	anonymous_namespace{VersionInfo.cpp}

Classes
class	AnimatedMapFilter
class	BaseImpl
class	BlendShapeFilter
class	BoundingBox
class	CalculateMeshLowerLODsCommand
	CalculateMeshLowerLODsCommand is used to recalculate vertex positions for lower LOD meshes of the specified mesh. More...
class	ClearBlendShapesCommand
	ClearBlendShapesCommand is used to clear all blend shapes data from a DNA. More...
class	Command
	Command is an abstract class whose implementations are expected to modify the DNA provided in the run() method in some way. More...
class	CommandImplBase
class	CommandSequence
	CommandSequence is used to run a sequence of commands on the same DNA. More...
class	ConditionalCommand
	ConditionalCommand is used to run a command if the specified condition is met. More...
struct	DenormalizedData
struct	DNA
class	DNACalibDNAReader
class	DNACalibDNAReaderImpl
struct	ExpectedValue
class	JointFilter
class	LODConstraint
class	LODMapping
class	MeshFilter
struct	OperationFactory
class	PruneBlendShapeTargetsCommand
	PruneBlendShapeTargetsCommand is used to prune blend shape target deltas whose absolute magnitude is less than or equal to the specified threshold. More...
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	ReaderImpl
class	RemoveAnimatedMapCommand
	RemoveAnimatedMapCommand is used to remove animated maps. More...
class	RemoveBlendShapeCommand
	RemoveBlendShapeCommand is used to remove blend shapes. More...
class	RemoveJointAnimationCommand
	RemoveJointAnimationCommand is used to remove joint animation data. More...
class	RemoveJointCommand
	RemoveJointCommand is used to remove joints. More...
class	RemoveMeshCommand
	RemoveMeshCommand is used to remove meshes. More...
class	RenameAnimatedMapCommand
	RenameAnimatedMapCommand is used to rename an animated map. More...
class	RenameBlendShapeCommand
	RenameBlendShapeCommand is used to rename a blend shape channel. More...
class	RenameJointCommand
	RenameJointCommand is used to rename a joint. More...
class	RenameMeshCommand
	RenameMeshCommand is used to rename a mesh. More...
class	RenameResourceCommand
class	RotateCommand
	RotateCommand is used to rotate neutral joints and vertex positions around given origin. More...
class	ScaleCommand
	ScaleCommand is used to scale neutral joints, vertex positions and joint and blendshape deltas by a factor. More...
struct	SectionLookupTable
class	SetBlendShapeTargetDeltasCommand
	SetBlendShapeTargetDeltasCommand is used to change blend shape target deltas. More...
class	SetLODsCommand
	SetLODsCommand is used to specify LODs to use. Joints, blend shapes, animated maps and meshes that are not in specified LODs are removed from the DNA. More...
class	SetNeutralJointRotationsCommand
	SetNeutralJointRotationsCommand is used to set new rotation values to neutral joints. More...
class	SetNeutralJointTranslationsCommand
	SetNeutralJointTranslationsCommand is used to set new translation values to neutral joints. More...
class	SetSkinWeightsCommand
	SetSkinWeightsCommand is used to set new skin weights for a vertex in a mesh. More...
class	SetVertexPositionsCommand
	SetVertexPositionsCommand is used to change vertex positions values. More...
struct	Signature
struct	SurjectiveMapping
class	TranslateCommand
	TranslateCommand is used to translate neutral joints and vertex positions. More...
class	Triangle
class	UVBarycentricMapping
struct	Version
struct	VersionInfo
struct	WeightGetterFactory
class	WriterImpl

Typedefs
template<typename T >
using	ArrayView = dna::ArrayView< T >
template<typename T >
using	ConstArrayView = dna::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 > >

Enumerations
enum class	VectorOperation { Interpolate , Add , Subtract , Multiply }

Functions
template<class TCommand , class TCondition >
ConditionalCommand< TCommand, TCondition >	makeConditional (TCommand *command, TCondition condition)
template<typename T >
void	remap (T originalCount, const UnorderedSet< T > &keptIndices, UnorderedMap< T, T > &mapping)
template<class TContainer , typename ... Args>
void	ensureHasSize (TContainer &target, std::size_t size, Args &&... args)
fmat4	getTransformationMatrix (const fvec3 &translation, const fvec3 &rotation, const fvec3 &scale={1.0f, 1.0f, 1.0f})
fmat4	extractTranslationMatrix (const fmat4 &transformationMatrix)
fvec3	extractScaleVector (const fmat4 &transformationMatrix)
fmat4	extractRotationMatrix (const fmat4 &transformationMatrix)
fvec3	extractTranslationVector (const fmat4 &transformationMatrix)
fvec3	extractRotationVector (const fmat4 &transformationMatrix)
template<typename ... Args>
String< char >	formatString (MemoryResource *memRes, const char *format, Args &&... args)
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)

Typedef Documentation

AlignedAllocator

template<typename T >

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

AlignedDynArray

template<typename T >

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

ArrayView

template<typename T >

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

ConstArrayView

template<typename T >

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

DynArray

template<typename T >

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

Enumeration Type Documentation

VectorOperation

enum class dnac::VectorOperation

strong

Enumerator
Interpolate
Add
Subtract
Multiply

                           {
    Interpolate,
    Add,
    Subtract,
    Multiply
};

Function Documentation

contains()

template<typename TEnum >

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

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

Referenced by dnac::UVBarycentricMapping::getBarycentric().

ensureHasSize()

template<class TContainer , typename ... Args>

void dnac::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 dnac::WriterImpl< TWriterBase >::setAnimatedMapName(), dnac::WriterImpl< TWriterBase >::setBlendShapeChannelIndex(), dnac::WriterImpl< TWriterBase >::setBlendShapeChannelName(), dnac::WriterImpl< TWriterBase >::setBlendShapeTargetDeltas(), dnac::DNACalibDNAReaderImpl::setBlendShapeTargetDeltas(), dnac::WriterImpl< TWriterBase >::setBlendShapeTargetVertexIndices(), dnac::DNACalibDNAReaderImpl::setBlendShapeTargetVertexIndices(), dnac::WriterImpl< TWriterBase >::setFaceVertexLayoutIndices(), dnac::WriterImpl< TWriterBase >::setGUIControlName(), dnac::WriterImpl< TWriterBase >::setJointGroupInputIndices(), dnac::WriterImpl< TWriterBase >::setJointGroupJointIndices(), dnac::WriterImpl< TWriterBase >::setJointGroupLODs(), dnac::WriterImpl< TWriterBase >::setJointGroupOutputIndices(), dnac::DNACalibDNAReaderImpl::setJointGroupValues(), dnac::WriterImpl< TWriterBase >::setJointGroupValues(), dnac::WriterImpl< TWriterBase >::setJointName(), dnac::WriterImpl< TWriterBase >::setMaximumInfluencePerVertex(), dnac::WriterImpl< TWriterBase >::setMeshName(), dnac::WriterImpl< TWriterBase >::setRawControlName(), dnac::WriterImpl< TWriterBase >::setSkinWeightsJointIndices(), dnac::WriterImpl< TWriterBase >::setSkinWeightsValues(), dnac::WriterImpl< TWriterBase >::setVertexLayouts(), dnac::WriterImpl< TWriterBase >::setVertexNormals(), dnac::WriterImpl< TWriterBase >::setVertexPositions(), dnac::DNACalibDNAReaderImpl::setVertexPositions(), and dnac::WriterImpl< TWriterBase >::setVertexTextureCoordinates().

extractRotationMatrix()

fmat4 dnac::extractRotationMatrix ( const fmat4 &  transformationMatrix )

inline

                                                                      {
    auto r = transformationMatrix;
    r(3, 0) = 0.0f;
    r(3, 1) = 0.0f;
    r(3, 2) = 0.0f;
    const auto scale = tdm::scale(extractScaleVector(transformationMatrix));
    const auto inverseScale = tdm::inverse(scale);
    return inverseScale * r;
}

References extractScaleVector(), tdm::inverse(), and tdm::affine::scale().

Referenced by extractRotationVector().

extractRotationVector()

fvec3 dnac::extractRotationVector ( const fmat4 &  transformationMatrix )

inline

                                                                      {
    fvec3 angle{};
    const auto r = extractRotationMatrix(transformationMatrix);
    const auto r02 = r(0, 2);
    if (r02 < 1.0f) {
        if (r02 > -1.0f) {
            angle[0] = std::atan2(r(1, 2), r(2, 2));
            angle[1] = std::asin(-r02);
            angle[2] = std::atan2(r(0, 1), r(0, 0));
        } else {
            angle[0] = std::atan2(-r(2, 1), r(1, 1));
            angle[1] = static_cast<float>(tdm::pi() / 2.0f);
            angle[2] = 0;
        }
    } else {
        angle[0] = -std::atan2(-r(2, 1), r(1, 1));
        angle[1] = static_cast<float>(-tdm::pi() / 2.0f);
        angle[2] = 0;
    }
    return angle;
}

References extractRotationMatrix(), and tdm::pi().

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

extractScaleVector()

fvec3 dnac::extractScaleVector ( const fmat4 &  transformationMatrix )

inline

                                                                   {
    const auto& m = transformationMatrix;
    const float sx = fvec3{m(0, 0), m(0, 1), m(0, 2)}.length();
    const float sy = fvec3{m(1, 0), m(1, 1), m(1, 2)}.length();
    const float sz = fvec3{m(2, 0), m(2, 1), m(2, 2)}.length();
    return {sx, sy, sz};
}

Referenced by extractRotationMatrix().

extractTranslationMatrix()

fmat4 dnac::extractTranslationMatrix ( const fmat4 &  transformationMatrix )

inline

                                                                         {
    auto t = fmat4::identity();
    t(3, 0) = transformationMatrix(3, 0);
    t(3, 1) = transformationMatrix(3, 1);
    t(3, 2) = transformationMatrix(3, 2);
    return t;
}

References tdm::mat< R, C, T >::identity().

extractTranslationVector()

fvec3 dnac::extractTranslationVector ( const fmat4 &  transformationMatrix )

inline

                                                                         {
    return {transformationMatrix(3, 0), transformationMatrix(3, 1), transformationMatrix(3, 2)};
}

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

formatString()

template<typename ... Args>

String< char > dnac::formatString	(	MemoryResource *	memRes,
		const char *	format,
		Args &&...	args
	)

                                                                                       {
    String<char> result{memRes};
    result.resize(1024);
    #if !defined(__clang__) && defined(__GNUC__)
        #pragma GCC diagnostic push
        #pragma GCC diagnostic ignored "-Wformat-security"
    #endif
    // The returned number of bytes to be written does not include the null terminator
    const auto neededSize = snprintf(nullptr, 0ul, format, args ...) + 1;
    const auto size = std::min(result.size(), static_cast<std::size_t>(neededSize));
    snprintf(&result[0], size, format, args ...);
    #if !defined(__clang__) && defined(__GNUC__)
        #pragma GCC diagnostic pop
    #endif
    result.resize(size);
    return result;
}

Referenced by dnac::SetBlendShapeTargetDeltasCommand::Impl::computeBlendShapeTargetDeltas(), and dnac::SetVertexPositionsCommand::Impl::computeVertexPositions().

getTransformationMatrix()

fmat4 dnac::getTransformationMatrix ( const fvec3 &  translation, const fvec3 &  rotation, const fvec3 &  scale = {1.0f, 1.0f, 1.0f}  )

inline

                                                                                                           {1.0f, 1.0f, 1.0f}) {
    return tdm::scale(scale) * tdm::rotate(rotation) * tdm::translate(translation);
}

makeConditional()

template<class TCommand , class TCondition >

ConditionalCommand< TCommand, TCondition > dnac::makeConditional	(	TCommand *	command,
		TCondition	condition
	)

                                                                                                  {
    return ConditionalCommand<TCommand, TCondition>{command, condition};
}

Referenced by main().

operator&()

template<typename TEnum >

std::enable_if< std::is_enum< TEnum >::value, TEnum >::type dnac::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 dnac::operator&=	(	TEnum &	lhs,
		TEnum	rhs
	)

                                  {
    return lhs = (lhs & rhs);
}

operator^()

template<typename TEnum >

std::enable_if< std::is_enum< TEnum >::value, TEnum >::type dnac::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 dnac::operator^=	(	TEnum &	lhs,
		TEnum	rhs
	)

                                  {
    return lhs = (lhs ^ rhs);
}

operator|()

template<typename TEnum >

std::enable_if< std::is_enum< TEnum >::value, TEnum >::type dnac::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 dnac::operator|=	(	TEnum &	lhs,
		TEnum	rhs
	)

                                  {
    return lhs = (lhs | rhs);
}

operator~()

template<typename TEnum >

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

(

TEnum

value

)

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

remap()

template<typename T >

void dnac::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 dnac::AnimatedMapFilter::configure(), dnac::BlendShapeFilter::configure(), dnac::JointFilter::configure(), and dnac::MeshFilter::configure().