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

#include <WriterImpl.h>

Inheritance diagram for dna::WriterImpl< TWriterBase >:
Inheritance graph
Collaboration diagram for dna::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 dna::BaseImpl
MemoryResource * getMemoryResource ()
 

Additional Inherited Members

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

Constructor & Destructor Documentation

◆ WriterImpl()

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

Member Function Documentation

◆ clearAnimatedMapIndices()

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

◆ clearAnimatedMapNames()

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

◆ clearBlendShapeChannelIndices()

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

◆ clearBlendShapeChannelNames()

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

◆ clearBlendShapeTargets()

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

◆ clearFaceVertexLayoutIndices()

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

◆ clearGUIControlNames()

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

◆ clearJointGroups()

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

◆ clearJointIndices()

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

◆ clearJointNames()

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

◆ clearLODAnimatedMapMappings()

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

◆ clearLODBlendShapeChannelMappings()

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

◆ clearLODJointMappings()

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

◆ clearLODMeshMappings()

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

◆ clearMeshBlendShapeChannelMappings()

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

◆ clearMeshes()

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

◆ clearMeshIndices()

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

◆ clearMeshNames()

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

◆ clearMetaData()

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

◆ clearRawControlNames()

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

◆ clearSkinWeights()

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

◆ deleteJointGroup()

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

References extd::advanced().

◆ deleteMesh()

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

References extd::advanced().

◆ setAge()

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

◆ setAnimatedMapCutValues()

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

◆ setAnimatedMapFromValues()

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

◆ setAnimatedMapIndices()

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

◆ setAnimatedMapInputIndices()

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

◆ setAnimatedMapLODs()

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

◆ setAnimatedMapName()

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

References dna::ensureHasSize().

◆ setAnimatedMapOutputIndices()

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

◆ setAnimatedMapSlopeValues()

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

◆ setAnimatedMapToValues()

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

◆ setArchetype()

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

◆ setBlendShapeChannelIndex()

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

References dna::ensureHasSize().

◆ setBlendShapeChannelIndices()

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

◆ setBlendShapeChannelInputIndices()

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

◆ setBlendShapeChannelLODs()

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

◆ setBlendShapeChannelName()

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

References dna::ensureHasSize().

◆ setBlendShapeChannelOutputIndices()

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

◆ setBlendShapeTargetDeltas()

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

References dna::ensureHasSize().

◆ setBlendShapeTargetVertexIndices()

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

References dna::ensureHasSize().

◆ setCoordinateSystem()

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

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

◆ setDBComplexity()

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

◆ setDBMaxLOD()

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

◆ setDBName()

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

◆ setFaceVertexLayoutIndices()

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

References dna::ensureHasSize().

◆ setGender()

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

◆ setGUIControlName()

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

References dna::ensureHasSize().

◆ setGUIToRawCutValues()

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

◆ setGUIToRawFromValues()

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

◆ setGUIToRawInputIndices()

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

◆ setGUIToRawOutputIndices()

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

◆ setGUIToRawSlopeValues()

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

◆ setGUIToRawToValues()

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

◆ setJointColumnCount()

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

◆ setJointGroupInputIndices()

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

References dna::ensureHasSize().

◆ setJointGroupJointIndices()

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

References dna::ensureHasSize().

◆ setJointGroupLODs()

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

References dna::ensureHasSize().

◆ setJointGroupOutputIndices()

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

References dna::ensureHasSize().

◆ setJointGroupValues()

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

References dna::ensureHasSize().

◆ setJointHierarchy()

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

◆ setJointIndices()

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

◆ setJointName()

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

References dna::ensureHasSize().

◆ setJointRowCount()

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

◆ setLODAnimatedMapMapping()

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

◆ setLODBlendShapeChannelMapping()

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

◆ setLODCount()

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

◆ setLODJointMapping()

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

◆ setLODMeshMapping()

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

◆ setMaximumInfluencePerVertex()

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

References dna::ensureHasSize().

◆ setMeshBlendShapeChannelMapping()

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

◆ setMeshIndices()

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

◆ setMeshName()

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

References dna::ensureHasSize().

◆ setMetaData()

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

◆ setName()

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

◆ setNeutralJointRotations()

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

◆ setNeutralJointTranslations()

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

◆ setPSDColumnIndices()

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

◆ setPSDCount()

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

◆ setPSDRowIndices()

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

◆ setPSDValues()

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

◆ setRawControlName()

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

References dna::ensureHasSize().

◆ setRotationUnit()

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

◆ setSkinWeightsJointIndices()

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

References dna::ensureHasSize().

◆ setSkinWeightsValues()

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

References dna::ensureHasSize().

◆ setTranslationUnit()

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

◆ setVertexLayouts()

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

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

◆ setVertexNormals()

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

References dna::ensureHasSize().

◆ setVertexPositions()

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

References dna::ensureHasSize().

◆ setVertexTextureCoordinates()

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

References dna::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