dna/DNA.h dna/LODMapping.h dna/SurjectiveMapping.h dna/TypeDefs.h terse/types/ArchiveOffset.h algorithm array cassert cstddef cstdint iterator memory tuple dna/types/Aliases.h dna/types/ArrayView.h dna/types/StringView.h pma/Defs.h pma/MemoryResource.h pma/PolyAllocator.h pma/ScopedPtr.h pma/TypeDefs.h pma/resources/AlignedMemoryResource.h pma/resources/ArenaMemoryResource.h pma/resources/DefaultMemoryResource.h status/Defs.h status/Status.h status/StatusCode.h trio/Concepts.h trio/Defs.h trio/Stream.h trio/streams/FileStream.h trio/streams/MemoryMappedFileStream.h trio/streams/MemoryStream.h trio/types/Aliases.h trio/types/Parameters.h DNA.h dna/TypeDefs.h terse/types/ArchiveOffset.h terse/types/DynArray.h algorithm array cassert cstddef cstdint cstring dna/LODMapping.h dna/SurjectiveMapping.h functional iterator list map memory scoped_allocator set string tuple type_traits unordered_map unordered_set utility vector dna::RawSurjectiveMapping dna::ExpectedValue dna::Signature dna::Version dna::SectionLookupTable dna::RawCoordinateSystem dna::RawLODMapping dna::RawDescriptor dna::RawVector3Vector dna::RawDefinition dna::RawConditionalTable dna::RawPSDMatrix dna::RawControls dna::RawJointGroup dna::RawJoints dna::RawBlendShapeChannels dna::RawAnimatedMaps dna::RawBehavior dna::RawTextureCoordinateVector dna::RawVertexLayoutVector dna::RawFace dna::RawVertexSkinWeights dna::RawBlendShapeTarget dna::RawMesh dna::RawGeometry dna::DNA dna //CopyrightEpicGames,Inc.AllRightsReserved. #pragmaonce #include"dna/LODMapping.h" #include"dna/SurjectiveMapping.h" #include"dna/TypeDefs.h" #include<terse/types/ArchiveOffset.h> #ifdef_MSC_VER #pragmawarning(push) #pragmawarning(disable:43654987) #endif #include<algorithm> #include<array> #include<cassert> #include<cstddef> #include<cstdint> #include<iterator> #include<memory> #include<tuple> #ifdef_MSC_VER #pragmawarning(pop) #endif namespacedna{ template<typenameTFrom,typenameTTo=TFrom> structRawSurjectiveMapping:publicSurjectiveMapping<TFrom,TTo>{ usingSurjectiveMapping<TFrom,TTo>::SurjectiveMapping; template<classArchive> voidserialize(Archive&archive){ archive.label("from"); archive(this->from); archive.label("to"); archive(this->to); } }; template<typenameT> structExpectedValue{ Texpected; Tgot; explicitExpectedValue(constT&value):expected{value},got{}{ } template<classArchive> voidload(Archive&archive){ archive.label("value"); archive(got); } template<classArchive> voidsave(Archive&archive){ archive.label("value"); archive(expected); } boolmatches()const{ return(expected==got); } }; template<std::size_tSize> structSignature{ usingSignatureValueType=std::array<char,Size>; ExpectedValue<SignatureValueType>value; explicitSignature(SignatureValueTypebytes):value{bytes}{ } template<classArchive> voidserialize(Archive&archive){ archive.label("data"); archive(value); } boolmatches()const{ returnvalue.matches(); } }; structVersion{ ExpectedValue<std::uint16_t>generation; ExpectedValue<std::uint16_t>version; Version(std::uint16_tgeneration_,std::uint16_tversion_): generation{generation_}, version{version_}{ } template<classArchive> voidserialize(Archive&archive){ archive.label("generation"); archive(generation); archive.label("version"); archive(version); } boolmatches()const{ return(generation.matches()&&version.matches()); } }; structSectionLookupTable{ terse::ArchiveOffset<std::uint32_t>descriptor; terse::ArchiveOffset<std::uint32_t>definition; terse::ArchiveOffset<std::uint32_t>behavior; terse::ArchiveOffset<std::uint32_t>controls; terse::ArchiveOffset<std::uint32_t>joints; terse::ArchiveOffset<std::uint32_t>blendShapeChannels; terse::ArchiveOffset<std::uint32_t>animatedMaps; terse::ArchiveOffset<std::uint32_t>geometry; template<classArchive> voidserialize(Archive&archive){ archive.label("descriptor"); archive(descriptor); archive.label("definition"); archive(definition); archive.label("behavior"); archive(behavior); archive.label("controls"); archive(controls); archive.label("joints"); archive(joints); archive.label("blendShapeChannels"); archive(blendShapeChannels); archive.label("animatedMaps"); archive(animatedMaps); archive.label("geometry"); archive(geometry); } }; structRawCoordinateSystem{ std::uint16_txAxis; std::uint16_tyAxis; std::uint16_tzAxis; template<classArchive> voidserialize(Archive&archive){ archive.label("xAxis"); archive(xAxis); archive.label("yAxis"); archive(yAxis); archive.label("zAxis"); archive(zAxis); } }; structRawLODMapping:publicLODMapping{ usingLODMapping::LODMapping; template<classArchive> voidserialize(Archive&archive){ archive.label("lods"); archive(lods); archive.label("indices"); archive(indices); } }; structRawDescriptor{ usingStringPair=std::tuple<String<char>,String<char>>; terse::ArchiveOffset<std::uint32_t>::Proxymarker; String<char>name; std::uint16_tarchetype; std::uint16_tgender; std::uint16_tage; Vector<StringPair>metadata; std::uint16_ttranslationUnit; std::uint16_trotationUnit; RawCoordinateSystemcoordinateSystem; std::uint16_tlodCount; std::uint16_tmaxLOD; String<char>complexity; String<char>dbName; RawDescriptor(terse::ArchiveOffset<std::uint32_t>&markerTarget,MemoryResource*memRes): marker{markerTarget}, name{memRes}, archetype{}, gender{}, age{}, metadata{memRes}, translationUnit{}, rotationUnit{}, coordinateSystem{}, lodCount{}, maxLOD{}, complexity{memRes}, dbName{memRes}{ } template<classArchive> voidserialize(Archive&archive){ archive(marker); archive.label("name"); archive(name); archive.label("archetype"); archive(archetype); archive.label("gender"); archive(gender); archive.label("age"); archive(age); archive.label("metadata"); archive(metadata); archive.label("translationUnit"); archive(translationUnit); archive.label("rotationUnit"); archive(rotationUnit); archive.label("coordinateSystem"); archive(coordinateSystem); archive.label("lodCount"); archive(lodCount); archive.label("maxLOD"); archive(maxLOD); archive.label("complexity"); archive(complexity); archive.label("dbName"); archive(dbName); } }; structRawVector3Vector{ AlignedDynArray<float>xs; AlignedDynArray<float>ys; AlignedDynArray<float>zs; explicitRawVector3Vector(MemoryResource*memRes): xs{memRes}, ys{memRes}, zs{memRes}{ } RawVector3Vector(std::size_tsize_,floatinitial,MemoryResource*memRes): xs{size_,initial,memRes}, ys{size_,initial,memRes}, zs{size_,initial,memRes}{ } RawVector3Vector(ConstArrayView<float>xs_,ConstArrayView<float>ys_,ConstArrayView<float>zs_,MemoryResource*memRes): xs{xs_.begin(),xs_.end(),memRes}, ys{ys_.begin(),ys_.end(),memRes}, zs{zs_.begin(),zs_.end(),memRes}{ } template<classArchive> voidserialize(Archive&archive){ archive.label("xs"); archive(xs); archive.label("ys"); archive(ys); archive.label("zs"); archive(zs); } std::size_tsize()const{ assert(xs.size()==ys.size()&&ys.size()==zs.size()); returnxs.size(); } voidreserve(std::size_tcount){ xs.resize_uninitialized(count); ys.resize_uninitialized(count); zs.resize_uninitialized(count); } voidresize(std::size_tcount){ xs.resize(count); ys.resize(count); zs.resize(count); } voidresize(std::size_tcount,floatvalue){ xs.resize(count,value); ys.resize(count,value); zs.resize(count,value); } voidclear(){ xs.clear(); ys.clear(); zs.clear(); } template<typenameIterator> voidassign(Iteratorstart,Iteratorend){ reserve(static_cast<std::size_t>(std::distance(start,end))); std::size_ti{}; for(autoit=start;it!=end;++it,++i){ xs[i]=it->x; ys[i]=it->y; zs[i]=it->z; } } }; structRawDefinition{ terse::ArchiveOffset<std::uint32_t>::Proxymarker; RawLODMappinglodJointMapping; RawLODMappinglodBlendShapeMapping; RawLODMappinglodAnimatedMapMapping; RawLODMappinglodMeshMapping; Vector<String<char>>guiControlNames; Vector<String<char>>rawControlNames; Vector<String<char>>jointNames; Vector<String<char>>blendShapeChannelNames; Vector<String<char>>animatedMapNames; Vector<String<char>>meshNames; RawSurjectiveMapping<std::uint16_t>meshBlendShapeChannelMapping; DynArray<std::uint16_t>jointHierarchy; RawVector3VectorneutralJointTranslations; RawVector3VectorneutralJointRotations; RawDefinition(terse::ArchiveOffset<std::uint32_t>&markerTarget,MemoryResource*memRes): marker{markerTarget}, lodJointMapping{memRes}, lodBlendShapeMapping{memRes}, lodAnimatedMapMapping{memRes}, lodMeshMapping{memRes}, guiControlNames{memRes}, rawControlNames{memRes}, jointNames{memRes}, blendShapeChannelNames{memRes}, animatedMapNames{memRes}, meshNames{memRes}, meshBlendShapeChannelMapping{memRes}, jointHierarchy{memRes}, neutralJointTranslations{memRes}, neutralJointRotations{memRes}{ } template<classArchive> voidserialize(Archive&archive){ archive(marker); archive.label("lodJointMapping"); archive(lodJointMapping); archive.label("lodBlendShapeMapping"); archive(lodBlendShapeMapping); archive.label("lodAnimatedMapMapping"); archive(lodAnimatedMapMapping); archive.label("lodMeshMapping"); archive(lodMeshMapping); archive.label("guiControlNames"); archive(guiControlNames); archive.label("rawControlNames"); archive(rawControlNames); archive.label("jointNames"); archive(jointNames); archive.label("blendShapeChannelNames"); archive(blendShapeChannelNames); archive.label("animatedMapNames"); archive(animatedMapNames); archive.label("meshNames"); archive(meshNames); archive.label("meshBlendShapeChannelMapping"); archive(meshBlendShapeChannelMapping); archive.label("jointHierarchy"); archive(jointHierarchy); archive.label("neutralJointTranslations"); archive(neutralJointTranslations); archive.label("neutralJointRotations"); archive(neutralJointRotations); } }; structRawConditionalTable{ DynArray<std::uint16_t>inputIndices; DynArray<std::uint16_t>outputIndices; DynArray<float>fromValues; DynArray<float>toValues; DynArray<float>slopeValues; DynArray<float>cutValues; explicitRawConditionalTable(MemoryResource*memRes): inputIndices{memRes}, outputIndices{memRes}, fromValues{memRes}, toValues{memRes}, slopeValues{memRes}, cutValues{memRes}{ } template<classArchive> voidserialize(Archive&archive){ archive.label("inputIndices"); archive(inputIndices); archive.label("outputIndices"); archive(outputIndices); archive.label("fromValues"); archive(fromValues); archive.label("toValues"); archive(toValues); archive.label("slopeValues"); archive(slopeValues); archive.label("cutValues"); archive(cutValues); } }; structRawPSDMatrix{ DynArray<std::uint16_t>rows; DynArray<std::uint16_t>columns; DynArray<float>values; explicitRawPSDMatrix(MemoryResource*memRes): rows{memRes}, columns{memRes}, values{memRes}{ } template<classArchive> voidserialize(Archive&archive){ archive.label("rows"); archive(rows); archive.label("columns"); archive(columns); archive.label("values"); archive(values); } }; structRawControls{ std::uint16_tpsdCount; RawConditionalTableconditionals; RawPSDMatrixpsds; explicitRawControls(MemoryResource*memRes): psdCount{}, conditionals{memRes}, psds{memRes}{ } template<classArchive> voidserialize(Archive&archive){ archive.label("psdCount"); archive(psdCount); archive.label("conditionals"); archive(conditionals); archive.label("psds"); archive(psds); } }; structRawJointGroup{ //RowcountofeachLOD //12,9,3, //||+LOD-2containsfirst3rows //|+LOD-1containsfirst9rows //+LOD-0containsfirst12rows DynArray<std::uint16_t>lods; //Sub-matrixcol->inputvector DynArray<std::uint16_t>inputIndices; //Sub-matrixrow->outputvector DynArray<std::uint16_t>outputIndices; //Non-zerovaluesofallsub-matrices AlignedDynArray<float>values; DynArray<std::uint16_t>jointIndices; explicitRawJointGroup(MemoryResource*memRes): lods{memRes}, inputIndices{memRes}, outputIndices{memRes}, values{memRes}, jointIndices{memRes}{ } template<classArchive> voidserialize(Archive&archive){ archive.label("lods"); archive(lods); archive.label("inputIndices"); archive(inputIndices); archive.label("outputIndices"); archive(outputIndices); archive.label("values"); archive(values); archive.label("jointIndices"); archive(jointIndices); } }; structRawJoints{ std::uint16_trowCount; std::uint16_tcolCount; Vector<RawJointGroup>jointGroups; explicitRawJoints(MemoryResource*memRes): rowCount{}, colCount{}, jointGroups{memRes}{ } template<classArchive> voidserialize(Archive&archive){ archive.label("rowCount"); archive(rowCount); archive.label("colCount"); archive(colCount); archive.label("jointGroups"); archive(jointGroups); } }; structRawBlendShapeChannels{ DynArray<std::uint16_t>lods; DynArray<std::uint16_t>inputIndices; DynArray<std::uint16_t>outputIndices; explicitRawBlendShapeChannels(MemoryResource*memRes): lods{memRes}, inputIndices{memRes}, outputIndices{memRes}{ } template<classArchive> voidserialize(Archive&archive){ archive.label("lods"); archive(lods); archive.label("inputIndices"); archive(inputIndices); archive.label("outputIndices"); archive(outputIndices); } }; structRawAnimatedMaps{ DynArray<std::uint16_t>lods; RawConditionalTableconditionals; explicitRawAnimatedMaps(MemoryResource*memRes): lods{memRes}, conditionals{memRes}{ } template<classArchive> voidserialize(Archive&archive){ archive.label("lods"); archive(lods); archive.label("conditionals"); archive(conditionals); } }; structRawBehavior{ terse::ArchiveOffset<std::uint32_t>::Proxymarker; terse::ArchiveOffset<std::uint32_t>::ProxycontrolsMarker; RawControlscontrols; terse::ArchiveOffset<std::uint32_t>::ProxyjointsMarker; RawJointsjoints; terse::ArchiveOffset<std::uint32_t>::ProxyblendShapeChannelsMarker; RawBlendShapeChannelsblendShapeChannels; terse::ArchiveOffset<std::uint32_t>::ProxyanimatedMapsMarker; RawAnimatedMapsanimatedMaps; RawBehavior(terse::ArchiveOffset<std::uint32_t>&markerTarget, terse::ArchiveOffset<std::uint32_t>&controlsMarkerTarget, terse::ArchiveOffset<std::uint32_t>&jointsMarkerTarget, terse::ArchiveOffset<std::uint32_t>&blendShapeChannelsMarkerTarget, terse::ArchiveOffset<std::uint32_t>&animatedMapsMarkerTarget, MemoryResource*memRes): marker{markerTarget}, controlsMarker{controlsMarkerTarget}, controls{memRes}, jointsMarker{jointsMarkerTarget}, joints{memRes}, blendShapeChannelsMarker{blendShapeChannelsMarkerTarget}, blendShapeChannels{memRes}, animatedMapsMarker{animatedMapsMarkerTarget}, animatedMaps{memRes}{ } template<classArchive> voidserialize(Archive&archive){ archive(marker,controlsMarker); archive.label("controls"); archive(controls); archive(jointsMarker); archive.label("joints"); archive(joints); archive(blendShapeChannelsMarker); archive.label("blendShapeChannels"); archive(blendShapeChannels); archive(animatedMapsMarker); archive.label("animatedMaps"); archive(animatedMaps); } }; structRawTextureCoordinateVector{ DynArray<float>us; DynArray<float>vs; explicitRawTextureCoordinateVector(MemoryResource*memRes): us{memRes}, vs{memRes}{ } template<classArchive> voidserialize(Archive&archive){ archive.label("us"); archive(us); archive.label("vs"); archive(vs); } std::size_tsize()const{ assert(us.size()==vs.size()); returnus.size(); } voidclear(){ us.clear(); vs.clear(); } }; structRawVertexLayoutVector{ DynArray<std::uint32_t>positions; DynArray<std::uint32_t>textureCoordinates; DynArray<std::uint32_t>normals; explicitRawVertexLayoutVector(MemoryResource*memRes): positions{memRes}, textureCoordinates{memRes}, normals{memRes}{ } template<classArchive> voidserialize(Archive&archive){ archive.label("positions"); archive(positions); archive.label("textureCoordinates"); archive(textureCoordinates); archive.label("normals"); archive(normals); } std::size_tsize()const{ assert(positions.size()==textureCoordinates.size()&&textureCoordinates.size()==normals.size()); returnpositions.size(); } voidclear(){ positions.clear(); textureCoordinates.clear(); normals.clear(); } }; structRawFace{ DynArray<std::uint32_t>layoutIndices; explicitRawFace(MemoryResource*memRes): layoutIndices{memRes}{ } template<classArchive> voidserialize(Archive&archive){ archive.label("layoutIndices"); archive(layoutIndices); } }; structRawVertexSkinWeights{ AlignedDynArray<float>weights; DynArray<std::uint16_t>jointIndices; explicitRawVertexSkinWeights(MemoryResource*memRes): weights{memRes}, jointIndices{memRes}{ } template<classArchive> voidserialize(Archive&archive){ archive.label("weights"); archive(weights); archive.label("jointIndices"); archive(jointIndices); } }; structRawBlendShapeTarget{ RawVector3Vectordeltas; DynArray<std::uint32_t>vertexIndices; std::uint16_tblendShapeChannelIndex; explicitRawBlendShapeTarget(MemoryResource*memRes): deltas{memRes}, vertexIndices{memRes}, blendShapeChannelIndex{}{ } template<classArchive> voidserialize(Archive&archive){ archive.label("deltas"); archive(deltas); archive.label("vertexIndices"); archive(vertexIndices); archive.label("blendShapeChannelIndex"); archive(blendShapeChannelIndex); } }; structRawMesh{ terse::ArchiveOffset<std::uint32_t>offset; RawVector3Vectorpositions; RawTextureCoordinateVectortextureCoordinates; RawVector3Vectornormals; RawVertexLayoutVectorlayouts; Vector<RawFace>faces; std::uint16_tmaximumInfluencePerVertex; Vector<RawVertexSkinWeights>skinWeights; Vector<RawBlendShapeTarget>blendShapeTargets; terse::ArchiveOffset<std::uint32_t>::Proxymarker; explicitRawMesh(MemoryResource*memRes): offset{}, positions{memRes}, textureCoordinates{memRes}, normals{memRes}, layouts{memRes}, faces{memRes}, maximumInfluencePerVertex{}, skinWeights{memRes}, blendShapeTargets{memRes}, marker{offset}{ } template<classArchive> voidserialize(Archive&archive){ archive.label("offset"); archive(offset); archive.label("positions"); archive(positions); archive.label("textureCoordinates"); archive(textureCoordinates); archive.label("normals"); archive(normals); archive.label("layouts"); archive(layouts); archive.label("faces"); archive(faces); archive.label("maximumInfluencePerVertex"); archive(maximumInfluencePerVertex); archive.label("skinWeights"); archive(skinWeights); archive.label("blendShapeTargets"); archive(blendShapeTargets); archive(marker); } }; structRawGeometry{ terse::ArchiveOffset<std::uint32_t>::Proxymarker; Vector<RawMesh>meshes; RawGeometry(terse::ArchiveOffset<std::uint32_t>&markerTarget,MemoryResource*memRes): marker{markerTarget}, meshes{memRes}{ } template<classArchive> voidserialize(Archive&archive){ archive(marker); archive.label("meshes"); archive(meshes); } }; structDNA{ MemoryResource*memRes; Signature<3>signature{{'D','N','A'}}; Versionversion{2,1}; SectionLookupTablesections; RawDescriptordescriptor; RawDefinitiondefinition; RawBehaviorbehavior; RawGeometrygeometry; Signature<3>eof{{'A','N','D'}}; explicitDNA(MemoryResource*memRes_): memRes{memRes_}, sections{}, descriptor{sections.descriptor,memRes}, definition{sections.definition,memRes}, behavior{sections.behavior, sections.controls, sections.joints, sections.blendShapeChannels, sections.animatedMaps, memRes}, geometry{sections.geometry,memRes}{ } template<classArchive> voidload(Archive&archive){ archive.label("signature"); archive(signature); archive.label("version"); archive(version); if(signature.matches()&&version.matches()){ archive.label("sections"); archive(sections); archive.label("descriptor"); archive(descriptor); archive.label("definition"); archive(definition); archive.label("behavior"); archive(behavior); archive.label("geometry"); archive(geometry); archive.label("eof"); archive(eof); assert(eof.matches()); } } template<classArchive> voidsave(Archive&archive){ archive.label("signature"); archive(signature); archive.label("version"); archive(version); archive.label("sections"); archive(sections); archive.label("descriptor"); archive(descriptor); archive.label("definition"); archive(definition); archive.label("behavior"); archive(behavior); archive.label("geometry"); archive(geometry); archive.label("eof"); archive(eof); } voidunloadDefinition(){ definition=RawDefinition{sections.definition,memRes}; } voidunloadBehavior(){ behavior= RawBehavior{sections.behavior,sections.controls,sections.joints,sections.blendShapeChannels,sections.animatedMaps, memRes}; } voidunloadGeometry(){ geometry=RawGeometry{sections.geometry,memRes}; } }; }//namespacedna