DNA Calib 1.1
Project brief
Public Member Functions | List of all members
dnac::WriterImpl< TWriterBase > Class Template Reference

#include <WriterImpl.h>

Inheritance diagram for dnac::WriterImpl< TWriterBase >:
Inheritance graph
Collaboration diagram for dnac::WriterImpl< TWriterBase >:
Collaboration graph

Public Member Functions

 WriterImpl (MemoryResource *memRes_)
 
void setName (const char *name) override
 
void setArchetype (Archetype archetype) override
 
void setGender (Gender gender) override
 
void setAge (std::uint16_t age) override
 
void clearMetaData () override
 
void setMetaData (const char *key, const char *value) override
 
void setTranslationUnit (TranslationUnit unit) override
 
void setRotationUnit (RotationUnit unit) override
 
void setCoordinateSystem (CoordinateSystem system) override
 
void setLODCount (std::uint16_t lodCount) override
 
void setDBMaxLOD (std::uint16_t lod) override
 
void setDBComplexity (const char *name) override
 
void setDBName (const char *name) override
 
void clearGUIControlNames () override
 
void setGUIControlName (std::uint16_t index, const char *name) override
 
void clearRawControlNames () override
 
void setRawControlName (std::uint16_t index, const char *name) override
 
void clearJointNames () override
 
void setJointName (std::uint16_t index, const char *name) override
 
void clearJointIndices () override
 
void setJointIndices (std::uint16_t index, const std::uint16_t *jointIndices, std::uint16_t count) override
 
void clearLODJointMappings () override
 
void setLODJointMapping (std::uint16_t lod, std::uint16_t index) override
 
void clearBlendShapeChannelNames () override
 
void setJointHierarchy (const std::uint16_t *jointIndices, std::uint16_t count) override
 
void setBlendShapeChannelName (std::uint16_t index, const char *name) override
 
void clearBlendShapeChannelIndices () override
 
void setBlendShapeChannelIndices (std::uint16_t index, const std::uint16_t *blendShapeChannelIndices, std::uint16_t count) override
 
void clearLODBlendShapeChannelMappings () override
 
void setLODBlendShapeChannelMapping (std::uint16_t lod, std::uint16_t index) override
 
void clearAnimatedMapNames () override
 
void setAnimatedMapName (std::uint16_t index, const char *name) override
 
void clearAnimatedMapIndices () override
 
void setAnimatedMapIndices (std::uint16_t index, const std::uint16_t *animatedMapIndices, std::uint16_t count) override
 
void clearLODAnimatedMapMappings () override
 
void setLODAnimatedMapMapping (std::uint16_t lod, std::uint16_t index) override
 
void clearMeshNames () override
 
void setMeshName (std::uint16_t index, const char *name) override
 
void clearMeshIndices () override
 
void setMeshIndices (std::uint16_t index, const std::uint16_t *meshIndices, std::uint16_t count) override
 
void clearLODMeshMappings () override
 
void setLODMeshMapping (std::uint16_t lod, std::uint16_t index) override
 
void clearMeshBlendShapeChannelMappings () override
 
void setMeshBlendShapeChannelMapping (std::uint32_t index, std::uint16_t meshIndex, std::uint16_t blendShapeChannelIndex) override
 
void setNeutralJointTranslations (const Vector3 *translations, std::uint16_t count) override
 
void setNeutralJointRotations (const Vector3 *rotations, std::uint16_t count) override
 
void setGUIToRawInputIndices (const std::uint16_t *inputIndices, std::uint16_t count) override
 
void setGUIToRawOutputIndices (const std::uint16_t *outputIndices, std::uint16_t count) override
 
void setGUIToRawFromValues (const float *fromValues, std::uint16_t count) override
 
void setGUIToRawToValues (const float *toValues, std::uint16_t count) override
 
void setGUIToRawSlopeValues (const float *slopeValues, std::uint16_t count) override
 
void setGUIToRawCutValues (const float *cutValues, std::uint16_t count) override
 
void setPSDCount (std::uint16_t count) override
 
void setPSDRowIndices (const std::uint16_t *rowIndices, std::uint16_t count) override
 
void setPSDColumnIndices (const std::uint16_t *columnIndices, std::uint16_t count) override
 
void setPSDValues (const float *weights, std::uint16_t count) override
 
void setJointRowCount (std::uint16_t rowCount) override
 
void setJointColumnCount (std::uint16_t columnCount) override
 
void clearJointGroups () override
 
void deleteJointGroup (std::uint16_t jointGroupIndex) override
 
void setJointGroupLODs (std::uint16_t jointGroupIndex, const std::uint16_t *lods, std::uint16_t count) override
 
void setJointGroupInputIndices (std::uint16_t jointGroupIndex, const std::uint16_t *inputIndices, std::uint16_t count) override
 
void setJointGroupOutputIndices (std::uint16_t jointGroupIndex, const std::uint16_t *outputIndices, std::uint16_t count) override
 
void setJointGroupValues (std::uint16_t jointGroupIndex, const float *values, std::uint32_t count) override
 
void setJointGroupJointIndices (std::uint16_t jointGroupIndex, const std::uint16_t *jointIndices, std::uint16_t count) override
 
void setBlendShapeChannelLODs (const std::uint16_t *lods, std::uint16_t count) override
 
void setBlendShapeChannelInputIndices (const std::uint16_t *inputIndices, std::uint16_t count) override
 
void setBlendShapeChannelOutputIndices (const std::uint16_t *outputIndices, std::uint16_t count) override
 
void setAnimatedMapLODs (const std::uint16_t *lods, std::uint16_t count) override
 
void setAnimatedMapInputIndices (const std::uint16_t *inputIndices, std::uint16_t count) override
 
void setAnimatedMapOutputIndices (const std::uint16_t *outputIndices, std::uint16_t count) override
 
void setAnimatedMapFromValues (const float *fromValues, std::uint16_t count) override
 
void setAnimatedMapToValues (const float *toValues, std::uint16_t count) override
 
void setAnimatedMapSlopeValues (const float *slopeValues, std::uint16_t count) override
 
void setAnimatedMapCutValues (const float *cutValues, std::uint16_t count) override
 
void clearMeshes () override
 
void deleteMesh (std::uint16_t meshIndex) override
 
void setVertexPositions (std::uint16_t meshIndex, const Position *positions, std::uint32_t count) override
 
void setVertexTextureCoordinates (std::uint16_t meshIndex, const TextureCoordinate *textureCoordinates, std::uint32_t count) override
 
void setVertexNormals (std::uint16_t meshIndex, const Normal *normals, std::uint32_t count) override
 
void setVertexLayouts (std::uint16_t meshIndex, const VertexLayout *layouts, std::uint32_t count) override
 
void clearFaceVertexLayoutIndices (std::uint16_t meshIndex) override
 
void setFaceVertexLayoutIndices (std::uint16_t meshIndex, std::uint32_t faceIndex, const std::uint32_t *layoutIndices, std::uint32_t count) override
 
void setMaximumInfluencePerVertex (std::uint16_t meshIndex, std::uint16_t maxInfluenceCount) override
 
void clearSkinWeights (std::uint16_t meshIndex) override
 
void setSkinWeightsValues (std::uint16_t meshIndex, std::uint32_t vertexIndex, const float *weights, std::uint16_t count) override
 
void setSkinWeightsJointIndices (std::uint16_t meshIndex, std::uint32_t vertexIndex, const std::uint16_t *jointIndices, std::uint16_t count) override
 
void clearBlendShapeTargets (std::uint16_t meshIndex) override
 
void setBlendShapeChannelIndex (std::uint16_t meshIndex, std::uint16_t blendShapeTargetIndex, std::uint16_t blendShapeChannelIndex) override
 
void setBlendShapeTargetDeltas (std::uint16_t meshIndex, std::uint16_t blendShapeTargetIndex, const Delta *deltas, std::uint32_t count) override
 
void setBlendShapeTargetVertexIndices (std::uint16_t meshIndex, std::uint16_t blendShapeTargetIndex, const std::uint32_t *vertexIndices, std::uint32_t count) override
 
- Public Member Functions inherited from dnac::BaseImpl
MemoryResource * getMemoryResource ()
 

Additional Inherited Members

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

Constructor & Destructor Documentation

◆ WriterImpl()

template<class TWriterBase >
dnac::WriterImpl< TWriterBase >::WriterImpl ( MemoryResource *  memRes_)
explicit
166 : BaseImpl{memRes_} {
167}
dnac::BaseImpl::BaseImpl
BaseImpl(MemoryResource *memRes_)
Definition: dnacalib/dna/BaseImpl.h:12

Member Function Documentation

◆ clearAnimatedMapIndices()

template<class TWriterBase >
void dnac::WriterImpl< TWriterBase >::clearAnimatedMapIndices
inlineoverride
365 {
366 dna.definition.lodAnimatedMapMapping.resetIndices();
367}
dna
Definition: BinaryStreamReader.h:10

◆ clearAnimatedMapNames()

template<class TWriterBase >
void dnac::WriterImpl< TWriterBase >::clearAnimatedMapNames
inlineoverride
354 {
355 dna.definition.animatedMapNames.clear();
356}

◆ clearBlendShapeChannelIndices()

template<class TWriterBase >
void dnac::WriterImpl< TWriterBase >::clearBlendShapeChannelIndices
inlineoverride
331 {
332 dna.definition.lodBlendShapeMapping.resetIndices();
333}

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

◆ clearBlendShapeChannelNames()

template<class TWriterBase >
void dnac::WriterImpl< TWriterBase >::clearBlendShapeChannelNames
inlineoverride
320 {
321 dna.definition.blendShapeChannelNames.clear();
322}

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

◆ clearBlendShapeTargets()

template<class TWriterBase >
void dnac::WriterImpl< TWriterBase >::clearBlendShapeTargets ( std::uint16_t  meshIndex)
inlineoverride
717 {
718 if (meshIndex < dna.geometry.meshes.size()) {
719 dna.geometry.meshes[meshIndex].blendShapeTargets.clear();
720 }
721}

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

◆ clearFaceVertexLayoutIndices()

template<class TWriterBase >
void dnac::WriterImpl< TWriterBase >::clearFaceVertexLayoutIndices ( std::uint16_t  meshIndex)
inlineoverride
664 {
665 if (meshIndex < dna.geometry.meshes.size()) {
666 dna.geometry.meshes[meshIndex].faces.clear();
667 }
668}

◆ clearGUIControlNames()

template<class TWriterBase >
void dnac::WriterImpl< TWriterBase >::clearGUIControlNames
inlineoverride
260 {
261 dna.definition.guiControlNames.clear();
262}

◆ clearJointGroups()

template<class TWriterBase >
void dnac::WriterImpl< TWriterBase >::clearJointGroups
inlineoverride
502 {
503 dna.behavior.joints.jointGroups.clear();
504}

◆ clearJointIndices()

template<class TWriterBase >
void dnac::WriterImpl< TWriterBase >::clearJointIndices
inlineoverride
293 {
294 dna.definition.lodJointMapping.resetIndices();
295}

◆ clearJointNames()

template<class TWriterBase >
void dnac::WriterImpl< TWriterBase >::clearJointNames
inlineoverride
282 {
283 dna.definition.jointNames.clear();
284}

◆ clearLODAnimatedMapMappings()

template<class TWriterBase >
void dnac::WriterImpl< TWriterBase >::clearLODAnimatedMapMappings
inlineoverride
378 {
379 dna.definition.lodAnimatedMapMapping.resetLODs();
380}

◆ clearLODBlendShapeChannelMappings()

template<class TWriterBase >
void dnac::WriterImpl< TWriterBase >::clearLODBlendShapeChannelMappings
inlineoverride
344 {
345 dna.definition.lodBlendShapeMapping.resetLODs();
346}

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

◆ clearLODJointMappings()

template<class TWriterBase >
void dnac::WriterImpl< TWriterBase >::clearLODJointMappings
inlineoverride
305 {
306 dna.definition.lodJointMapping.resetLODs();
307}

◆ clearLODMeshMappings()

template<class TWriterBase >
void dnac::WriterImpl< TWriterBase >::clearLODMeshMappings
inlineoverride
410 {
411 dna.definition.lodMeshMapping.resetLODs();
412}

◆ clearMeshBlendShapeChannelMappings()

template<class TWriterBase >
void dnac::WriterImpl< TWriterBase >::clearMeshBlendShapeChannelMappings
inlineoverride
420 {
421 dna.definition.meshBlendShapeChannelMapping.clear();
422}

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

◆ clearMeshes()

template<class TWriterBase >
void dnac::WriterImpl< TWriterBase >::clearMeshes
inlineoverride
609 {
610 dna.geometry.meshes.clear();
611}

◆ clearMeshIndices()

template<class TWriterBase >
void dnac::WriterImpl< TWriterBase >::clearMeshIndices
inlineoverride
399 {
400 dna.definition.lodMeshMapping.resetIndices();
401}

◆ clearMeshNames()

template<class TWriterBase >
void dnac::WriterImpl< TWriterBase >::clearMeshNames
inlineoverride
388 {
389 dna.definition.meshNames.clear();
390}

◆ clearMetaData()

template<class TWriterBase >
void dnac::WriterImpl< TWriterBase >::clearMetaData
inlineoverride
198 {
199 dna.descriptor.metadata.clear();
200}

◆ clearRawControlNames()

template<class TWriterBase >
void dnac::WriterImpl< TWriterBase >::clearRawControlNames
inlineoverride
271 {
272 dna.definition.rawControlNames.clear();
273}

◆ clearSkinWeights()

template<class TWriterBase >
void dnac::WriterImpl< TWriterBase >::clearSkinWeights ( std::uint16_t  meshIndex)
inlineoverride
688 {
689 if (meshIndex < dna.geometry.meshes.size()) {
690 dna.geometry.meshes[meshIndex].skinWeights.clear();
691 }
692}

◆ deleteJointGroup()

template<class TWriterBase >
void dnac::WriterImpl< TWriterBase >::deleteJointGroup ( std::uint16_t  jointGroupIndex)
inlineoverride
507 {
508 if (jointGroupIndex < dna.behavior.joints.jointGroups.size()) {
509 auto it = extd::advanced(dna.behavior.joints.jointGroups.begin(), jointGroupIndex);
510 dna.behavior.joints.jointGroups.erase(it);
511 }
512}
extd::advanced
TIterator advanced(TIterator source, TDistance distance)
Definition: utils/Extd.h:128

References extd::advanced().

◆ deleteMesh()

template<class TWriterBase >
void dnac::WriterImpl< TWriterBase >::deleteMesh ( std::uint16_t  meshIndex)
inlineoverride
614 {
615 if (meshIndex < dna.geometry.meshes.size()) {
616 auto it = extd::advanced(dna.geometry.meshes.begin(), meshIndex);
617 dna.geometry.meshes.erase(it);
618 }
619}

References extd::advanced().

◆ setAge()

template<class TWriterBase >
void dnac::WriterImpl< TWriterBase >::setAge ( std::uint16_t  age)
inlineoverride
193 {
194 dna.descriptor.age = age;
195}

◆ setAnimatedMapCutValues()

template<class TWriterBase >
void dnac::WriterImpl< TWriterBase >::setAnimatedMapCutValues ( const float *  cutValues,
std::uint16_t  count 
)
inlineoverride
604 {
605 dna.behavior.animatedMaps.conditionals.cutValues.assign(cutValues, cutValues + count);
606}

◆ setAnimatedMapFromValues()

template<class TWriterBase >
void dnac::WriterImpl< TWriterBase >::setAnimatedMapFromValues ( const float *  fromValues,
std::uint16_t  count 
)
inlineoverride
589 {
590 dna.behavior.animatedMaps.conditionals.fromValues.assign(fromValues, fromValues + count);
591}

◆ setAnimatedMapIndices()

template<class TWriterBase >
void dnac::WriterImpl< TWriterBase >::setAnimatedMapIndices ( std::uint16_t  index,
const std::uint16_t *  animatedMapIndices,
std::uint16_t  count 
)
inlineoverride
372 {
373 dna.definition.lodAnimatedMapMapping.clearIndices(index);
374 dna.definition.lodAnimatedMapMapping.addIndices(index, animatedMapIndices, count);
375}

◆ setAnimatedMapInputIndices()

template<class TWriterBase >
void dnac::WriterImpl< TWriterBase >::setAnimatedMapInputIndices ( const std::uint16_t *  inputIndices,
std::uint16_t  count 
)
inlineoverride
579 {
580 dna.behavior.animatedMaps.conditionals.inputIndices.assign(inputIndices, inputIndices + count);
581}

◆ setAnimatedMapLODs()

template<class TWriterBase >
void dnac::WriterImpl< TWriterBase >::setAnimatedMapLODs ( const std::uint16_t *  lods,
std::uint16_t  count 
)
inlineoverride
574 {
575 dna.behavior.animatedMaps.lods.assign(lods, lods + count);
576}

◆ setAnimatedMapName()

template<class TWriterBase >
void dnac::WriterImpl< TWriterBase >::setAnimatedMapName ( std::uint16_t  index,
const char *  name 
)
inlineoverride
359 {
360 ensureHasSize(dna.definition.animatedMapNames, index + 1ul, memRes);
361 dna.definition.animatedMapNames[index] = name;
362}
dnac::BaseImpl::memRes
MemoryResource * memRes
Definition: dnacalib/dna/BaseImpl.h:31
dnac::ensureHasSize
void ensureHasSize(TContainer &target, std::size_t size, Args &&... args)
Definition: dnacalib/dna/WriterImpl.h:24

References dnac::ensureHasSize().

◆ setAnimatedMapOutputIndices()

template<class TWriterBase >
void dnac::WriterImpl< TWriterBase >::setAnimatedMapOutputIndices ( const std::uint16_t *  outputIndices,
std::uint16_t  count 
)
inlineoverride
584 {
585 dna.behavior.animatedMaps.conditionals.outputIndices.assign(outputIndices, outputIndices + count);
586}

◆ setAnimatedMapSlopeValues()

template<class TWriterBase >
void dnac::WriterImpl< TWriterBase >::setAnimatedMapSlopeValues ( const float *  slopeValues,
std::uint16_t  count 
)
inlineoverride
599 {
600 dna.behavior.animatedMaps.conditionals.slopeValues.assign(slopeValues, slopeValues + count);
601}

◆ setAnimatedMapToValues()

template<class TWriterBase >
void dnac::WriterImpl< TWriterBase >::setAnimatedMapToValues ( const float *  toValues,
std::uint16_t  count 
)
inlineoverride
594 {
595 dna.behavior.animatedMaps.conditionals.toValues.assign(toValues, toValues + count);
596}

◆ setArchetype()

template<class TWriterBase >
void dnac::WriterImpl< TWriterBase >::setArchetype ( Archetype  archetype)
inlineoverride
183 {
184 dna.descriptor.archetype = static_cast<std::uint16_t>(archetype);
185}

◆ setBlendShapeChannelIndex()

template<class TWriterBase >
void dnac::WriterImpl< TWriterBase >::setBlendShapeChannelIndex ( std::uint16_t  meshIndex,
std::uint16_t  blendShapeTargetIndex,
std::uint16_t  blendShapeChannelIndex 
)
inlineoverride
726 {
727 ensureHasSize(dna.geometry.meshes, meshIndex + 1ul, memRes);
728 ensureHasSize(dna.geometry.meshes[meshIndex].blendShapeTargets, blendShapeTargetIndex + 1ul, memRes);
729 dna.geometry.meshes[meshIndex].blendShapeTargets[blendShapeTargetIndex].blendShapeChannelIndex = blendShapeChannelIndex;
730}

References dnac::ensureHasSize().

◆ setBlendShapeChannelIndices()

template<class TWriterBase >
void dnac::WriterImpl< TWriterBase >::setBlendShapeChannelIndices ( std::uint16_t  index,
const std::uint16_t *  blendShapeChannelIndices,
std::uint16_t  count 
)
inlineoverride
338 {
339 dna.definition.lodBlendShapeMapping.clearIndices(index);
340 dna.definition.lodBlendShapeMapping.addIndices(index, blendShapeChannelIndices, count);
341}

◆ setBlendShapeChannelInputIndices()

template<class TWriterBase >
void dnac::WriterImpl< TWriterBase >::setBlendShapeChannelInputIndices ( const std::uint16_t *  inputIndices,
std::uint16_t  count 
)
inlineoverride
564 {
565 dna.behavior.blendShapeChannels.inputIndices.assign(inputIndices, inputIndices + count);
566}

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

◆ setBlendShapeChannelLODs()

template<class TWriterBase >
void dnac::WriterImpl< TWriterBase >::setBlendShapeChannelLODs ( const std::uint16_t *  lods,
std::uint16_t  count 
)
inlineoverride
559 {
560 dna.behavior.blendShapeChannels.lods.assign(lods, lods + count);
561}

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

◆ setBlendShapeChannelName()

template<class TWriterBase >
void dnac::WriterImpl< TWriterBase >::setBlendShapeChannelName ( std::uint16_t  index,
const char *  name 
)
inlineoverride
325 {
326 ensureHasSize(dna.definition.blendShapeChannelNames, index + 1ul, memRes);
327 dna.definition.blendShapeChannelNames[index] = name;
328}

References dnac::ensureHasSize().

◆ setBlendShapeChannelOutputIndices()

template<class TWriterBase >
void dnac::WriterImpl< TWriterBase >::setBlendShapeChannelOutputIndices ( const std::uint16_t *  outputIndices,
std::uint16_t  count 
)
inlineoverride
569 {
570 dna.behavior.blendShapeChannels.outputIndices.assign(outputIndices, outputIndices + count);
571}

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

◆ setBlendShapeTargetDeltas()

template<class TWriterBase >
void dnac::WriterImpl< TWriterBase >::setBlendShapeTargetDeltas ( std::uint16_t  meshIndex,
std::uint16_t  blendShapeTargetIndex,
const Delta *  deltas,
std::uint32_t  count 
)
inlineoverride
736 {
737 ensureHasSize(dna.geometry.meshes, meshIndex + 1ul, memRes);
738 ensureHasSize(dna.geometry.meshes[meshIndex].blendShapeTargets, blendShapeTargetIndex + 1ul, memRes);
739 dna.geometry.meshes[meshIndex].blendShapeTargets[blendShapeTargetIndex].deltas.assign(deltas, deltas + count);
740}

References dnac::ensureHasSize().

◆ setBlendShapeTargetVertexIndices()

template<class TWriterBase >
void dnac::WriterImpl< TWriterBase >::setBlendShapeTargetVertexIndices ( std::uint16_t  meshIndex,
std::uint16_t  blendShapeTargetIndex,
const std::uint32_t *  vertexIndices,
std::uint32_t  count 
)
inlineoverride
746 {
747 ensureHasSize(dna.geometry.meshes, meshIndex + 1ul, memRes);
748 auto& blendShapeTargets = dna.geometry.meshes[meshIndex].blendShapeTargets;
749 ensureHasSize(blendShapeTargets, blendShapeTargetIndex + 1ul, memRes);
750 blendShapeTargets[blendShapeTargetIndex].vertexIndices.assign(vertexIndices, vertexIndices + count);
751}

References dnac::ensureHasSize().

◆ setCoordinateSystem()

template<class TWriterBase >
void dnac::WriterImpl< TWriterBase >::setCoordinateSystem ( CoordinateSystem  system)
inlineoverride
233 {
234 dna.descriptor.coordinateSystem.xAxis = static_cast<std::uint16_t>(system.xAxis);
235 dna.descriptor.coordinateSystem.yAxis = static_cast<std::uint16_t>(system.yAxis);
236 dna.descriptor.coordinateSystem.zAxis = static_cast<std::uint16_t>(system.zAxis);
237}

References dna::CoordinateSystem::xAxis, dna::CoordinateSystem::yAxis, and dna::CoordinateSystem::zAxis.

◆ setDBComplexity()

template<class TWriterBase >
void dnac::WriterImpl< TWriterBase >::setDBComplexity ( const char *  name)
inlineoverride
250 {
251 dna.descriptor.complexity = name;
252}

◆ setDBMaxLOD()

template<class TWriterBase >
void dnac::WriterImpl< TWriterBase >::setDBMaxLOD ( std::uint16_t  lod)
inlineoverride
245 {
246 dna.descriptor.maxLOD = lod;
247}

◆ setDBName()

template<class TWriterBase >
void dnac::WriterImpl< TWriterBase >::setDBName ( const char *  name)
inlineoverride
255 {
256 dna.descriptor.dbName = name;
257}

◆ setFaceVertexLayoutIndices()

template<class TWriterBase >
void dnac::WriterImpl< TWriterBase >::setFaceVertexLayoutIndices ( std::uint16_t  meshIndex,
std::uint32_t  faceIndex,
const std::uint32_t *  layoutIndices,
std::uint32_t  count 
)
inlineoverride
674 {
675 ensureHasSize(dna.geometry.meshes, meshIndex + 1ul, memRes);
676 auto& faces = dna.geometry.meshes[meshIndex].faces;
677 ensureHasSize(faces, faceIndex + 1ul, memRes);
678 faces[faceIndex].layoutIndices.assign(layoutIndices, layoutIndices + count);
679}

References dnac::ensureHasSize().

◆ setGender()

template<class TWriterBase >
void dnac::WriterImpl< TWriterBase >::setGender ( Gender  gender)
inlineoverride
188 {
189 dna.descriptor.gender = static_cast<std::uint16_t>(gender);
190}

◆ setGUIControlName()

template<class TWriterBase >
void dnac::WriterImpl< TWriterBase >::setGUIControlName ( std::uint16_t  index,
const char *  name 
)
inlineoverride
265 {
266 ensureHasSize(dna.definition.guiControlNames, index + 1ul, memRes);
267 dna.definition.guiControlNames[index] = name;
268}

References dnac::ensureHasSize().

◆ setGUIToRawCutValues()

template<class TWriterBase >
void dnac::WriterImpl< TWriterBase >::setGUIToRawCutValues ( const float *  cutValues,
std::uint16_t  count 
)
inlineoverride
467 {
468 dna.behavior.controls.conditionals.cutValues.assign(cutValues, cutValues + count);
469}

◆ setGUIToRawFromValues()

template<class TWriterBase >
void dnac::WriterImpl< TWriterBase >::setGUIToRawFromValues ( const float *  fromValues,
std::uint16_t  count 
)
inlineoverride
452 {
453 dna.behavior.controls.conditionals.fromValues.assign(fromValues, fromValues + count);
454}

◆ setGUIToRawInputIndices()

template<class TWriterBase >
void dnac::WriterImpl< TWriterBase >::setGUIToRawInputIndices ( const std::uint16_t *  inputIndices,
std::uint16_t  count 
)
inlineoverride
442 {
443 dna.behavior.controls.conditionals.inputIndices.assign(inputIndices, inputIndices + count);
444}

◆ setGUIToRawOutputIndices()

template<class TWriterBase >
void dnac::WriterImpl< TWriterBase >::setGUIToRawOutputIndices ( const std::uint16_t *  outputIndices,
std::uint16_t  count 
)
inlineoverride
447 {
448 dna.behavior.controls.conditionals.outputIndices.assign(outputIndices, outputIndices + count);
449}

◆ setGUIToRawSlopeValues()

template<class TWriterBase >
void dnac::WriterImpl< TWriterBase >::setGUIToRawSlopeValues ( const float *  slopeValues,
std::uint16_t  count 
)
inlineoverride
462 {
463 dna.behavior.controls.conditionals.slopeValues.assign(slopeValues, slopeValues + count);
464}

◆ setGUIToRawToValues()

template<class TWriterBase >
void dnac::WriterImpl< TWriterBase >::setGUIToRawToValues ( const float *  toValues,
std::uint16_t  count 
)
inlineoverride
457 {
458 dna.behavior.controls.conditionals.toValues.assign(toValues, toValues + count);
459}

◆ setJointColumnCount()

template<class TWriterBase >
void dnac::WriterImpl< TWriterBase >::setJointColumnCount ( std::uint16_t  columnCount)
inlineoverride
497 {
498 dna.behavior.joints.colCount = columnCount;
499}

◆ setJointGroupInputIndices()

template<class TWriterBase >
void dnac::WriterImpl< TWriterBase >::setJointGroupInputIndices ( std::uint16_t  jointGroupIndex,
const std::uint16_t *  inputIndices,
std::uint16_t  count 
)
inlineoverride
526 {
527 auto& jointGroups = dna.behavior.joints.jointGroups;
528 ensureHasSize(jointGroups, jointGroupIndex + 1ul, memRes);
529 jointGroups[jointGroupIndex].inputIndices.assign(inputIndices, inputIndices + count);
530}

References dnac::ensureHasSize().

◆ setJointGroupJointIndices()

template<class TWriterBase >
void dnac::WriterImpl< TWriterBase >::setJointGroupJointIndices ( std::uint16_t  jointGroupIndex,
const std::uint16_t *  jointIndices,
std::uint16_t  count 
)
inlineoverride
552 {
553 auto& jointGroups = dna.behavior.joints.jointGroups;
554 ensureHasSize(jointGroups, jointGroupIndex + 1ul, memRes);
555 jointGroups[jointGroupIndex].jointIndices.assign(jointIndices, jointIndices + count);
556}

References dnac::ensureHasSize().

◆ setJointGroupLODs()

template<class TWriterBase >
void dnac::WriterImpl< TWriterBase >::setJointGroupLODs ( std::uint16_t  jointGroupIndex,
const std::uint16_t *  lods,
std::uint16_t  count 
)
inlineoverride
517 {
518 auto& jointGroups = dna.behavior.joints.jointGroups;
519 ensureHasSize(jointGroups, jointGroupIndex + 1ul, memRes);
520 jointGroups[jointGroupIndex].lods.assign(lods, lods + count);
521}

References dnac::ensureHasSize().

◆ setJointGroupOutputIndices()

template<class TWriterBase >
void dnac::WriterImpl< TWriterBase >::setJointGroupOutputIndices ( std::uint16_t  jointGroupIndex,
const std::uint16_t *  outputIndices,
std::uint16_t  count 
)
inlineoverride
535 {
536 auto& jointGroups = dna.behavior.joints.jointGroups;
537 ensureHasSize(jointGroups, jointGroupIndex + 1ul, memRes);
538 jointGroups[jointGroupIndex].outputIndices.assign(outputIndices, outputIndices + count);
539}

References dnac::ensureHasSize().

◆ setJointGroupValues()

template<class TWriterBase >
void dnac::WriterImpl< TWriterBase >::setJointGroupValues ( std::uint16_t  jointGroupIndex,
const float *  values,
std::uint32_t  count 
)
inlineoverride
543 {
544 auto& jointGroups = dna.behavior.joints.jointGroups;
545 ensureHasSize(jointGroups, jointGroupIndex + 1ul, memRes);
546 jointGroups[jointGroupIndex].values.assign(values, values + count);
547}

References dnac::ensureHasSize().

◆ setJointHierarchy()

template<class TWriterBase >
void dnac::WriterImpl< TWriterBase >::setJointHierarchy ( const std::uint16_t *  jointIndices,
std::uint16_t  count 
)
inlineoverride
315 {
316 dna.definition.jointHierarchy.assign(jointIndices, jointIndices + count);
317}

◆ setJointIndices()

template<class TWriterBase >
void dnac::WriterImpl< TWriterBase >::setJointIndices ( std::uint16_t  index,
const std::uint16_t *  jointIndices,
std::uint16_t  count 
)
inlineoverride
299 {
300 dna.definition.lodJointMapping.clearIndices(index);
301 dna.definition.lodJointMapping.addIndices(index, jointIndices, count);
302}

◆ setJointName()

template<class TWriterBase >
void dnac::WriterImpl< TWriterBase >::setJointName ( std::uint16_t  index,
const char *  name 
)
inlineoverride
287 {
288 ensureHasSize(dna.definition.jointNames, index + 1ul, memRes);
289 dna.definition.jointNames[index] = name;
290}

References dnac::ensureHasSize().

◆ setJointRowCount()

template<class TWriterBase >
void dnac::WriterImpl< TWriterBase >::setJointRowCount ( std::uint16_t  rowCount)
inlineoverride
492 {
493 dna.behavior.joints.rowCount = rowCount;
494}

◆ setLODAnimatedMapMapping()

template<class TWriterBase >
void dnac::WriterImpl< TWriterBase >::setLODAnimatedMapMapping ( std::uint16_t  lod,
std::uint16_t  index 
)
inlineoverride
383 {
384 dna.definition.lodAnimatedMapMapping.associateLODWithIndices(lod, index);
385}

◆ setLODBlendShapeChannelMapping()

template<class TWriterBase >
void dnac::WriterImpl< TWriterBase >::setLODBlendShapeChannelMapping ( std::uint16_t  lod,
std::uint16_t  index 
)
inlineoverride
349 {
350 dna.definition.lodBlendShapeMapping.associateLODWithIndices(lod, index);
351}

◆ setLODCount()

template<class TWriterBase >
void dnac::WriterImpl< TWriterBase >::setLODCount ( std::uint16_t  lodCount)
inlineoverride
240 {
241 dna.descriptor.lodCount = lodCount;
242}

◆ setLODJointMapping()

template<class TWriterBase >
void dnac::WriterImpl< TWriterBase >::setLODJointMapping ( std::uint16_t  lod,
std::uint16_t  index 
)
inlineoverride
310 {
311 dna.definition.lodJointMapping.associateLODWithIndices(lod, index);
312}

◆ setLODMeshMapping()

template<class TWriterBase >
void dnac::WriterImpl< TWriterBase >::setLODMeshMapping ( std::uint16_t  lod,
std::uint16_t  index 
)
inlineoverride
415 {
416 dna.definition.lodMeshMapping.associateLODWithIndices(lod, index);
417}

◆ setMaximumInfluencePerVertex()

template<class TWriterBase >
void dnac::WriterImpl< TWriterBase >::setMaximumInfluencePerVertex ( std::uint16_t  meshIndex,
std::uint16_t  maxInfluenceCount 
)
inlineoverride
682 {
683 ensureHasSize(dna.geometry.meshes, meshIndex + 1ul, memRes);
684 dna.geometry.meshes[meshIndex].maximumInfluencePerVertex = maxInfluenceCount;
685}

References dnac::ensureHasSize().

◆ setMeshBlendShapeChannelMapping()

template<class TWriterBase >
void dnac::WriterImpl< TWriterBase >::setMeshBlendShapeChannelMapping ( std::uint32_t  index,
std::uint16_t  meshIndex,
std::uint16_t  blendShapeChannelIndex 
)
inlineoverride
427 {
428 dna.definition.meshBlendShapeChannelMapping.set(index, meshIndex, blendShapeChannelIndex);
429}

◆ setMeshIndices()

template<class TWriterBase >
void dnac::WriterImpl< TWriterBase >::setMeshIndices ( std::uint16_t  index,
const std::uint16_t *  meshIndices,
std::uint16_t  count 
)
inlineoverride
404 {
405 dna.definition.lodMeshMapping.clearIndices(index);
406 dna.definition.lodMeshMapping.addIndices(index, meshIndices, count);
407}

◆ setMeshName()

template<class TWriterBase >
void dnac::WriterImpl< TWriterBase >::setMeshName ( std::uint16_t  index,
const char *  name 
)
inlineoverride
393 {
394 ensureHasSize(dna.definition.meshNames, index + 1ul, memRes);
395 dna.definition.meshNames[index] = name;
396}

References dnac::ensureHasSize().

◆ setMetaData()

template<class TWriterBase >
void dnac::WriterImpl< TWriterBase >::setMetaData ( const char *  key,
const char *  value 
)
inlineoverride
203 {
204 using CharStringPair = std::tuple<String<char>, String<char> >;
205 auto it = std::find_if(dna.descriptor.metadata.begin(), dna.descriptor.metadata.end(), [&key](const CharStringPair& kv) {
206 auto& k = std::get<0>(kv);
207 return (std::strlen(key) == k.size() && std::strncmp(k.data(), key, k.size()) == 0);
208 });
209 if (it == dna.descriptor.metadata.end()) {
210 if (value != nullptr) {
211 dna.descriptor.metadata.emplace_back(String<char>{key, memRes}, String<char>{value, memRes});
212 }
213 } else {
214 if (value == nullptr) {
215 dna.descriptor.metadata.erase(it);
216 } else {
217 std::get<1>(*it) = value;
218 }
219 }
220}

◆ setName()

template<class TWriterBase >
void dnac::WriterImpl< TWriterBase >::setName ( const char *  name)
inlineoverride
178 {
179 dna.descriptor.name = name;
180}

◆ setNeutralJointRotations()

template<class TWriterBase >
void dnac::WriterImpl< TWriterBase >::setNeutralJointRotations ( const Vector3 *  rotations,
std::uint16_t  count 
)
inlineoverride
437 {
438 dna.definition.neutralJointRotations.assign(rotations, rotations + count);
439}

◆ setNeutralJointTranslations()

template<class TWriterBase >
void dnac::WriterImpl< TWriterBase >::setNeutralJointTranslations ( const Vector3 *  translations,
std::uint16_t  count 
)
inlineoverride
432 {
433 dna.definition.neutralJointTranslations.assign(translations, translations + count);
434}

◆ setPSDColumnIndices()

template<class TWriterBase >
void dnac::WriterImpl< TWriterBase >::setPSDColumnIndices ( const std::uint16_t *  columnIndices,
std::uint16_t  count 
)
inlineoverride
482 {
483 dna.behavior.controls.psds.columns.assign(columnIndices, columnIndices + count);
484}

◆ setPSDCount()

template<class TWriterBase >
void dnac::WriterImpl< TWriterBase >::setPSDCount ( std::uint16_t  count)
inlineoverride
472 {
473 dna.behavior.controls.psdCount = count;
474}

◆ setPSDRowIndices()

template<class TWriterBase >
void dnac::WriterImpl< TWriterBase >::setPSDRowIndices ( const std::uint16_t *  rowIndices,
std::uint16_t  count 
)
inlineoverride
477 {
478 dna.behavior.controls.psds.rows.assign(rowIndices, rowIndices + count);
479}

◆ setPSDValues()

template<class TWriterBase >
void dnac::WriterImpl< TWriterBase >::setPSDValues ( const float *  weights,
std::uint16_t  count 
)
inlineoverride
487 {
488 dna.behavior.controls.psds.values.assign(weights, weights + count);
489}

◆ setRawControlName()

template<class TWriterBase >
void dnac::WriterImpl< TWriterBase >::setRawControlName ( std::uint16_t  index,
const char *  name 
)
inlineoverride
276 {
277 ensureHasSize(dna.definition.rawControlNames, index + 1ul, memRes);
278 dna.definition.rawControlNames[index] = name;
279}

References dnac::ensureHasSize().

◆ setRotationUnit()

template<class TWriterBase >
void dnac::WriterImpl< TWriterBase >::setRotationUnit ( RotationUnit  unit)
inlineoverride
228 {
229 dna.descriptor.rotationUnit = static_cast<std::uint16_t>(unit);
230}

◆ setSkinWeightsJointIndices()

template<class TWriterBase >
void dnac::WriterImpl< TWriterBase >::setSkinWeightsJointIndices ( std::uint16_t  meshIndex,
std::uint32_t  vertexIndex,
const std::uint16_t *  jointIndices,
std::uint16_t  count 
)
inlineoverride
709 {
710 ensureHasSize(dna.geometry.meshes, meshIndex + 1ul, memRes);
711 auto& skinWeights = dna.geometry.meshes[meshIndex].skinWeights;
712 ensureHasSize(skinWeights, vertexIndex + 1ul, memRes);
713 skinWeights[vertexIndex].jointIndices.assign(jointIndices, jointIndices + count);
714}

References dnac::ensureHasSize().

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

◆ setSkinWeightsValues()

template<class TWriterBase >
void dnac::WriterImpl< TWriterBase >::setSkinWeightsValues ( std::uint16_t  meshIndex,
std::uint32_t  vertexIndex,
const float *  weights,
std::uint16_t  count 
)
inlineoverride
698 {
699 ensureHasSize(dna.geometry.meshes, meshIndex + 1ul, memRes);
700 auto& skinWeights = dna.geometry.meshes[meshIndex].skinWeights;
701 ensureHasSize(skinWeights, vertexIndex + 1ul, memRes);
702 skinWeights[vertexIndex].weights.assign(weights, weights + count);
703}

References dnac::ensureHasSize().

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

◆ setTranslationUnit()

template<class TWriterBase >
void dnac::WriterImpl< TWriterBase >::setTranslationUnit ( TranslationUnit  unit)
inlineoverride
223 {
224 dna.descriptor.translationUnit = static_cast<std::uint16_t>(unit);
225}

◆ setVertexLayouts()

template<class TWriterBase >
void dnac::WriterImpl< TWriterBase >::setVertexLayouts ( std::uint16_t  meshIndex,
const VertexLayout *  layouts,
std::uint32_t  count 
)
inlineoverride
649 {
650 ensureHasSize(dna.geometry.meshes, meshIndex + 1ul, memRes);
651 auto& destination = dna.geometry.meshes[meshIndex].layouts;
652 destination.clear();
653 destination.positions.resize_uninitialized(count);
654 destination.textureCoordinates.resize_uninitialized(count);
655 destination.normals.resize_uninitialized(count);
656 for (std::size_t i = 0ul; i < count; ++i) {
657 destination.positions[i] = layouts[i].position;
658 destination.textureCoordinates[i] = layouts[i].textureCoordinate;
659 destination.normals[i] = layouts[i].normal;
660 }
661}

References dnac::ensureHasSize(), dna::VertexLayout::normal, dna::VertexLayout::position, and dna::VertexLayout::textureCoordinate.

◆ setVertexNormals()

template<class TWriterBase >
void dnac::WriterImpl< TWriterBase >::setVertexNormals ( std::uint16_t  meshIndex,
const Normal *  normals,
std::uint32_t  count 
)
inlineoverride
643 {
644 ensureHasSize(dna.geometry.meshes, meshIndex + 1ul, memRes);
645 dna.geometry.meshes[meshIndex].normals.assign(normals, normals + count);
646}

References dnac::ensureHasSize().

◆ setVertexPositions()

template<class TWriterBase >
void dnac::WriterImpl< TWriterBase >::setVertexPositions ( std::uint16_t  meshIndex,
const Position *  positions,
std::uint32_t  count 
)
inlineoverride
622 {
623 ensureHasSize(dna.geometry.meshes, meshIndex + 1ul, memRes);
624 dna.geometry.meshes[meshIndex].positions.assign(positions, positions + count);
625}

References dnac::ensureHasSize().

◆ setVertexTextureCoordinates()

template<class TWriterBase >
void dnac::WriterImpl< TWriterBase >::setVertexTextureCoordinates ( std::uint16_t  meshIndex,
const TextureCoordinate *  textureCoordinates,
std::uint32_t  count 
)
inlineoverride
630 {
631 ensureHasSize(dna.geometry.meshes, meshIndex + 1ul, memRes);
632 auto& destination = dna.geometry.meshes[meshIndex].textureCoordinates;
633 destination.clear();
634 destination.us.resize_uninitialized(count);
635 destination.vs.resize_uninitialized(count);
636 for (std::size_t i = 0ul; i < count; ++i) {
637 destination.us[i] = textureCoordinates[i].u;
638 destination.vs[i] = textureCoordinates[i].v;
639 }
640}

References dnac::ensureHasSize(), dna::TextureCoordinate::u, and dna::TextureCoordinate::v.

The documentation for this class was generated from the following file:
Generated by doxygen 1.9.4