AxioDL
/
metaforce
mirror of https://github.com/AxioDL/metaforce.git
2
0
Fork 0
Code Issues Projects Releases Wiki Activity

Initial PATH cooking support

This commit is contained in:
Jack Andersen 2018-02-24 22:23:27 -10:00
parent 13e6ff31c6
commit 619a784434
58 changed files with 459 additions and 340 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

82
DataSpec/DNACommon/AROTBuilder.cpp
View File

@ -1,5 +1,6 @@
#include "AROTBuilder.hpp" #include "AROTBuilder.hpp"
#include "hecl/Blender/Connection.hpp" #include "hecl/Blender/Connection.hpp"
#include "../DNAMP1/PATH.hpp"
namespace DataSpec namespace DataSpec
{ {
@ -287,6 +288,60 @@ void AROTBuilder::Node::writeColNodes(uint8_t*& ptr, const zeus::CAABox& curAABB
} }
} }
void AROTBuilder::Node::pathCountNodesAndLookups(size_t& nodeCount, size_t& lookupCount)
{
++nodeCount;
if (childNodes.empty())
{
lookupCount += childIndices.size();
}
else
{
for (int i=0 ; i<8 ; ++i)
childNodes[i].pathCountNodesAndLookups(nodeCount, lookupCount);
}
}
void AROTBuilder::Node::pathWrite(DNAMP1::PATH& path, const zeus::CAABox& curAABB)
{
if (childNodes.empty())
{
path.octree.emplace_back();
DNAMP1::PATH::OctreeNode& n = path.octree.back();
n.isLeaf = 1;
n.aabb[0] = curAABB.min;
n.aabb[1] = curAABB.max;
n.centroid = curAABB.center();
for (int i=0 ; i<8 ; ++i)
n.children[i] = 0xffffffff;
n.regionCount = childIndices.size();
n.regionStart = path.octreeRegionLookup.size();
for (int r : childIndices)
path.octreeRegionLookup.push_back(r);
}
else
{
atUint32 children[8];
for (int i=0 ; i<8 ; ++i)
{
/* Head recursion (first node will be a leaf) */
children[i] = path.octree.size();
childNodes[i].pathWrite(path, SplitAABB(curAABB, i));
}
path.octree.emplace_back();
DNAMP1::PATH::OctreeNode& n = path.octree.back();
n.isLeaf = 0;
n.aabb[0] = curAABB.min;
n.aabb[1] = curAABB.max;
n.centroid = curAABB.center();
for (int i=0 ; i<8 ; ++i)
n.children[i] = children[i];
n.regionCount = 0;
n.regionStart = 0;
}
}
void AROTBuilder::build(std::vector<std::vector<uint8_t>>& secs, const zeus::CAABox& fullAabb, void AROTBuilder::build(std::vector<std::vector<uint8_t>>& secs, const zeus::CAABox& fullAabb,
const std::vector<zeus::CAABox>& meshAabbs, const std::vector<DNACMDL::Mesh>& meshes) const std::vector<zeus::CAABox>& meshAabbs, const std::vector<DNACMDL::Mesh>& meshes)
{ {
@ -391,4 +446,31 @@ std::pair<std::unique_ptr<uint8_t[]>, uint32_t> AROTBuilder::buildCol(const ColM
return {std::move(ret), totalSize}; return {std::move(ret), totalSize};
} }
void AROTBuilder::buildPath(DNAMP1::PATH& path)
{
/* Accumulate total AABB and gather region boxes */
std::vector<zeus::CAABox> regionBoxes;
regionBoxes.reserve(path.regions.size());
zeus::CAABox fullAABB;
for (const DNAMP1::PATH::Region& r : path.regions)
{
regionBoxes.emplace_back(r.aabb[0], r.aabb[1]);
fullAABB.accumulateBounds(regionBoxes.back());
}
/* Recursively split */
BspNodeType dontCare;
rootNode.addChild(0, 4, regionBoxes, fullAABB, dontCare);
/* Write out */
size_t nodeCount = 0;
size_t lookupCount = 0;
rootNode.pathCountNodesAndLookups(nodeCount, lookupCount);
path.octreeNodeCount = nodeCount;
path.octree.reserve(nodeCount);
path.octreeRegionLookupCount = lookupCount;
path.octreeRegionLookup.reserve(lookupCount);
rootNode.pathWrite(path, fullAABB);
}
} }

8
DataSpec/DNACommon/AROTBuilder.hpp
View File

@ -9,6 +9,10 @@
namespace DataSpec namespace DataSpec
{ {
namespace DNAMP1
{
struct PATH;
}
struct AROTBuilder struct AROTBuilder
{ {
@ -40,11 +44,15 @@ struct AROTBuilder
void colSize(size_t& totalSz); void colSize(size_t& totalSz);
void writeColNodes(uint8_t*& ptr, const zeus::CAABox& curAABB); void writeColNodes(uint8_t*& ptr, const zeus::CAABox& curAABB);
void pathCountNodesAndLookups(size_t& nodeCount, size_t& lookupCount);
void pathWrite(DNAMP1::PATH& path, const zeus::CAABox& curAABB);
} rootNode; } rootNode;
void build(std::vector<std::vector<uint8_t>>& secs, const zeus::CAABox& fullAabb, void build(std::vector<std::vector<uint8_t>>& secs, const zeus::CAABox& fullAabb,
const std::vector<zeus::CAABox>& meshAabbs, const std::vector<DNACMDL::Mesh>& meshes); const std::vector<zeus::CAABox>& meshAabbs, const std::vector<DNACMDL::Mesh>& meshes);
std::pair<std::unique_ptr<uint8_t[]>, uint32_t> buildCol(const ColMesh& mesh, BspNodeType& rootOut); std::pair<std::unique_ptr<uint8_t[]>, uint32_t> buildCol(const ColMesh& mesh, BspNodeType& rootOut);
void buildPath(DNAMP1::PATH& path);
}; };
} }

2
DataSpec/DNACommon/CMDL.hpp
View File

@ -33,7 +33,7 @@ struct Header : BigDNA
Value<atVec3f> aabbMax; Value<atVec3f> aabbMax;
Value<atUint32> secCount; Value<atUint32> secCount;
Value<atUint32> matSetCount; Value<atUint32> matSetCount;
Vector<atUint32, DNA_COUNT(secCount)> secSizes; Vector<atUint32, AT_DNA_COUNT(secCount)> secSizes;
Align<32> align; Align<32> align;
}; };

2
DataSpec/DNACommon/DGRP.hpp
View File

@ -19,7 +19,7 @@ struct AT_SPECIALIZE_PARMS(DataSpec::UniqueID32, DataSpec::UniqueID64) DGRP : Bi
Value<IDType> id; Value<IDType> id;
}; };
Vector<ObjectTag, DNA_COUNT(dependCount)> depends; Vector<ObjectTag, AT_DNA_COUNT(dependCount)> depends;
}; };
template <class IDType> template <class IDType>

2
DataSpec/DNACommon/EGMC.hpp
View File

@ -17,7 +17,7 @@ struct EGMC : public BigDNA
Value<atUint32> instanceId; Value<atUint32> instanceId;
}; };
Vector<Object, DNA_COUNT(count)> objects; Vector<Object, AT_DNA_COUNT(count)> objects;
}; };
} }
#endif // _DNACOMMON_EGMC_HPP_ #endif // _DNACOMMON_EGMC_HPP_

2
DataSpec/DNACommon/FONT.hpp
View File

@ -109,7 +109,7 @@ struct AT_SPECIALIZE_PARMS(DataSpec::UniqueID32, DataSpec::UniqueID64) FONT : Bi
Value<atUint32> glyphCount; Value<atUint32> glyphCount;
std::vector<std::unique_ptr<IGlyph>> glyphs; std::vector<std::unique_ptr<IGlyph>> glyphs;
Value<atUint32> kerningInfoCount; Value<atUint32> kerningInfoCount;
Vector<KerningInfo, DNA_COUNT(kerningInfoCount)> kerningInfo; Vector<KerningInfo, AT_DNA_COUNT(kerningInfoCount)> kerningInfo;
void gatherDependencies(std::vector<hecl::ProjectPath>& pathsOut) const void gatherDependencies(std::vector<hecl::ProjectPath>& pathsOut) const
{ {

32
DataSpec/DNACommon/FSM2.hpp
View File

@ -42,7 +42,7 @@ struct AT_SPECIALIZE_PARMS(DataSpec::UniqueID32, DataSpec::UniqueID64) FSM2 : Bi
AT_DECL_DNA_YAML AT_DECL_DNA_YAML
String<-1> name; String<-1> name;
Value<atUint32> unknownCount; Value<atUint32> unknownCount;
Vector<CommonStruct, DNA_COUNT(unknownCount)> unknown; Vector<CommonStruct, AT_DNA_COUNT(unknownCount)> unknown;
}; };
struct Unknown1 : BigDNA struct Unknown1 : BigDNA
@ -51,7 +51,7 @@ struct AT_SPECIALIZE_PARMS(DataSpec::UniqueID32, DataSpec::UniqueID64) FSM2 : Bi
String<-1> name; String<-1> name;
Value<float> unknown1; Value<float> unknown1;
Value<atUint32> unknown2Count; Value<atUint32> unknown2Count;
Vector<CommonStruct, DNA_COUNT(unknown2Count)> unknown2; Vector<CommonStruct, AT_DNA_COUNT(unknown2Count)> unknown2;
Value<atUint8> unknown3; Value<atUint8> unknown3;
}; };
@ -60,7 +60,7 @@ struct AT_SPECIALIZE_PARMS(DataSpec::UniqueID32, DataSpec::UniqueID64) FSM2 : Bi
AT_DECL_DNA_YAML AT_DECL_DNA_YAML
String<-1> name; String<-1> name;
Value<atUint32> unknownCount; Value<atUint32> unknownCount;
Vector<CommonStruct, DNA_COUNT(unknownCount)> unknown; Vector<CommonStruct, AT_DNA_COUNT(unknownCount)> unknown;
}; };
struct Unknown3 : BigDNA struct Unknown3 : BigDNA
@ -68,14 +68,14 @@ struct AT_SPECIALIZE_PARMS(DataSpec::UniqueID32, DataSpec::UniqueID64) FSM2 : Bi
AT_DECL_DNA_YAML AT_DECL_DNA_YAML
String<-1> name; String<-1> name;
Value<atUint32> unknownCount; Value<atUint32> unknownCount;
Vector<CommonStruct, DNA_COUNT(unknownCount)> unknown; Vector<CommonStruct, AT_DNA_COUNT(unknownCount)> unknown;
Value<IDType> fsmId; Value<IDType> fsmId;
}; };
Vector<State, DNA_COUNT(stateCount)> states; Vector<State, AT_DNA_COUNT(stateCount)> states;
Vector<Unknown1, DNA_COUNT(unknown1Count)> unknown1; Vector<Unknown1, AT_DNA_COUNT(unknown1Count)> unknown1;
Vector<Unknown2, DNA_COUNT(unknown2Count)> unknown2; Vector<Unknown2, AT_DNA_COUNT(unknown2Count)> unknown2;
Vector<Unknown3, DNA_COUNT(unknown3Count)> unknown3; Vector<Unknown3, AT_DNA_COUNT(unknown3Count)> unknown3;
}; };
struct FSMV2 : IFSM struct FSMV2 : IFSM
@ -95,7 +95,7 @@ struct AT_SPECIALIZE_PARMS(DataSpec::UniqueID32, DataSpec::UniqueID64) FSM2 : Bi
Value<atUint32> unknown3; Value<atUint32> unknown3;
Value<atUint32> unknown4; Value<atUint32> unknown4;
Value<atUint32> unknown5Count; Value<atUint32> unknown5Count;
Vector<CommonStruct, DNA_COUNT(unknown5Count)> unknown5; Vector<CommonStruct, AT_DNA_COUNT(unknown5Count)> unknown5;
}; };
struct Unknown1 : BigDNA struct Unknown1 : BigDNA
@ -108,7 +108,7 @@ struct AT_SPECIALIZE_PARMS(DataSpec::UniqueID32, DataSpec::UniqueID64) FSM2 : Bi
Value<atUint32> unknown4; Value<atUint32> unknown4;
Value<float> unknown5; Value<float> unknown5;
Value<atUint32> unknown6Count; Value<atUint32> unknown6Count;
Vector<CommonStruct, DNA_COUNT(unknown6Count)> unknown6; Vector<CommonStruct, AT_DNA_COUNT(unknown6Count)> unknown6;
Value<atUint8> unknown7; Value<atUint8> unknown7;
}; };
@ -121,7 +121,7 @@ struct AT_SPECIALIZE_PARMS(DataSpec::UniqueID32, DataSpec::UniqueID64) FSM2 : Bi
Value<atUint32> unknown3; Value<atUint32> unknown3;
Value<atUint32> unknown4; Value<atUint32> unknown4;
Value<atUint32> unknown5Count; Value<atUint32> unknown5Count;
Vector<CommonStruct, DNA_COUNT(unknown5Count)> unknown5; Vector<CommonStruct, AT_DNA_COUNT(unknown5Count)> unknown5;
}; };
struct Unknown3 : BigDNA struct Unknown3 : BigDNA
@ -133,14 +133,14 @@ struct AT_SPECIALIZE_PARMS(DataSpec::UniqueID32, DataSpec::UniqueID64) FSM2 : Bi
Value<atUint32> unknown3; Value<atUint32> unknown3;
Value<atUint32> unknown4; Value<atUint32> unknown4;
Value<atUint32> unknown5Count; Value<atUint32> unknown5Count;
Vector<CommonStruct, DNA_COUNT(unknown5Count)> unknown5; Vector<CommonStruct, AT_DNA_COUNT(unknown5Count)> unknown5;
Value<IDType> fsmId; Value<IDType> fsmId;
}; };
Vector<State, DNA_COUNT(stateCount)> states; Vector<State, AT_DNA_COUNT(stateCount)> states;
Vector<Unknown1, DNA_COUNT(unknown1Count)> unknown1; Vector<Unknown1, AT_DNA_COUNT(unknown1Count)> unknown1;
Vector<Unknown2, DNA_COUNT(unknown2Count)> unknown2; Vector<Unknown2, AT_DNA_COUNT(unknown2Count)> unknown2;
Vector<Unknown3, DNA_COUNT(unknown3Count)> unknown3; Vector<Unknown3, AT_DNA_COUNT(unknown3Count)> unknown3;
}; };
std::unique_ptr<IFSM> detail; std::unique_ptr<IFSM> detail;

18
DataSpec/DNACommon/MAPA.hpp
View File

@ -72,7 +72,7 @@ struct MAPA : BigDNA
Value<atUint32> surfCount = 0; Value<atUint32> surfCount = 0;
Value<atUint32> internalNameLength = 0; Value<atUint32> internalNameLength = 0;
Value<atUint32> unknown7 = 0; Value<atUint32> unknown7 = 0;
String<DNA_COUNT(internalNameLength)> internalName; String<AT_DNA_COUNT(internalNameLength)> internalName;
atUint32 visMode() const { return mapVisMode; } atUint32 visMode() const { return mapVisMode; }
atUint32 mappableObjectCount() const { return moCount;} atUint32 mappableObjectCount() const { return moCount;}
atUint32 vertexCount() const { return vtxCount; } atUint32 vertexCount() const { return vtxCount; }
@ -131,14 +131,14 @@ struct MAPA : BigDNA
Value<Type> type; Value<Type> type;
Value<atUint32> visMode; Value<atUint32> visMode;
Value<atUint32> sclyId; Value<atUint32> sclyId;
Buffer<DNA_COUNT(0x10)> unknownHash; Buffer<AT_DNA_COUNT(0x10)> unknownHash;
Value<atInt32> seek1 = -1; Value<atInt32> seek1 = -1;
Value<atVec4f> transformMtx[3]; Value<atVec4f> transformMtx[3];
Value<atInt32> seek2[4] = {-1, -1, -1, -1}; Value<atInt32> seek2[4] = {-1, -1, -1, -1};
}; };
std::vector<std::unique_ptr<IMappableObject>> mappableObjects; std::vector<std::unique_ptr<IMappableObject>> mappableObjects;
Vector<atVec3f, DNA_COUNT(header->vertexCount())> vertices; Vector<atVec3f, AT_DNA_COUNT(header->vertexCount())> vertices;
struct SurfaceHeader : BigDNA struct SurfaceHeader : BigDNA
{ {
@ -149,7 +149,7 @@ struct MAPA : BigDNA
Value<atUint32> edgeOff; Value<atUint32> edgeOff;
}; };
Vector<SurfaceHeader, DNA_COUNT(header->surfaceCount())> surfaceHeaders; Vector<SurfaceHeader, AT_DNA_COUNT(header->surfaceCount())> surfaceHeaders;
struct Surface : BigDNA struct Surface : BigDNA
{ {
@ -160,22 +160,22 @@ struct MAPA : BigDNA
AT_DECL_DNA AT_DECL_DNA
Value<atUint32> type; Value<atUint32> type;
Value<atUint32> indexCount; Value<atUint32> indexCount;
Vector<atUint8, DNA_COUNT(indexCount)> indices; Vector<atUint8, AT_DNA_COUNT(indexCount)> indices;
Align<4> align; Align<4> align;
}; };
Vector<Primitive, DNA_COUNT(primitiveCount)> primitives; Vector<Primitive, AT_DNA_COUNT(primitiveCount)> primitives;
Value<atUint32> borderCount; Value<atUint32> borderCount;
struct Border : BigDNA struct Border : BigDNA
{ {
AT_DECL_DNA AT_DECL_DNA
Value<atUint32> indexCount; Value<atUint32> indexCount;
Vector<atUint8, DNA_COUNT(indexCount)> indices; Vector<atUint8, AT_DNA_COUNT(indexCount)> indices;
Align<4> align; Align<4> align;
}; };
Vector<Border, DNA_COUNT(borderCount)> borders; Vector<Border, AT_DNA_COUNT(borderCount)> borders;
}; };
Vector<Surface, DNA_COUNT(header->surfaceCount())> surfaces; Vector<Surface, AT_DNA_COUNT(header->surfaceCount())> surfaces;
}; };
template <typename PAKRouter> template <typename PAKRouter>

4
DataSpec/DNACommon/MAPU.hpp
View File

@ -24,10 +24,10 @@ struct MAPU : BigDNA
UniqueID32 mlvl; UniqueID32 mlvl;
Transform transform; Transform transform;
Value<uint32_t> hexCount; Value<uint32_t> hexCount;
Vector<Transform, DNA_COUNT(hexCount)> hexTransforms; Vector<Transform, AT_DNA_COUNT(hexCount)> hexTransforms;
DNAColor hexColor; DNAColor hexColor;
}; };
Vector<World, DNA_COUNT(worldCount)> worlds; Vector<World, AT_DNA_COUNT(worldCount)> worlds;
static bool Cook(const hecl::blender::MapUniverse& mapu, const hecl::ProjectPath& out); static bool Cook(const hecl::blender::MapUniverse& mapu, const hecl::ProjectPath& out);
}; };

8
DataSpec/DNACommon/ParticleCommon.hpp
View File

@ -129,7 +129,7 @@ struct REKeyframeEmitter : IRealElement
Value<atUint32> loopEnd; Value<atUint32> loopEnd;
Value<atUint32> loopStart; Value<atUint32> loopStart;
Value<atUint32> count; Value<atUint32> count;
Vector<float, DNA_COUNT(count)> keys; Vector<float, AT_DNA_COUNT(count)> keys;
const char* ClassID() const {return percentageTween ? "KEYP" : "KEYE";} const char* ClassID() const {return percentageTween ? "KEYP" : "KEYE";}
}; };
@ -339,7 +339,7 @@ struct IEKeyframeEmitter : IIntElement
Value<atUint32> loopEnd; Value<atUint32> loopEnd;
Value<atUint32> loopStart; Value<atUint32> loopStart;
Value<atUint32> count; Value<atUint32> count;
Vector<atUint32, DNA_COUNT(count)> keys; Vector<atUint32, AT_DNA_COUNT(count)> keys;
const char* ClassID() const {return percentageTween ? "KEYP" : "KEYE";} const char* ClassID() const {return percentageTween ? "KEYP" : "KEYE";}
}; };
@ -544,7 +544,7 @@ struct VEKeyframeEmitter : IVectorElement
Value<atUint32> loopEnd; Value<atUint32> loopEnd;
Value<atUint32> loopStart; Value<atUint32> loopStart;
Value<atUint32> count; Value<atUint32> count;
Vector<atVec3f, DNA_COUNT(count)> keys; Vector<atVec3f, AT_DNA_COUNT(count)> keys;
const char* ClassID() const {return percentageTween ? "KEYP" : "KEYE";} const char* ClassID() const {return percentageTween ? "KEYP" : "KEYE";}
}; };
@ -620,7 +620,7 @@ struct CEKeyframeEmitter : IColorElement
Value<atUint32> loopEnd; Value<atUint32> loopEnd;
Value<atUint32> loopStart; Value<atUint32> loopStart;
Value<atUint32> count; Value<atUint32> count;
Vector<atVec4f, DNA_COUNT(count)> keys; Vector<atVec4f, AT_DNA_COUNT(count)> keys;
const char* ClassID() const {return percentageTween ? "KEYP" : "KEYE";} const char* ClassID() const {return percentageTween ? "KEYP" : "KEYE";}
}; };

8
DataSpec/DNAMP1/AFSM.hpp
View File

@ -11,7 +11,7 @@ struct AFSM : public BigDNA
{ {
AT_DECL_DNA_YAML AT_DECL_DNA_YAML
Value<atUint32> stateCount; Value<atUint32> stateCount;
Vector<String<-1>, DNA_COUNT(stateCount)> stateNames; Vector<String<-1>, AT_DNA_COUNT(stateCount)> stateNames;
Value<atUint32> triggerCount; Value<atUint32> triggerCount;
struct State : public BigDNA struct State : public BigDNA
@ -31,11 +31,11 @@ struct AFSM : public BigDNA
Value<float> parameter; Value<float> parameter;
Value<atUint32> targetState; Value<atUint32> targetState;
}; };
Vector<Trigger, DNA_COUNT(triggerCount)> triggers; Vector<Trigger, AT_DNA_COUNT(triggerCount)> triggers;
}; };
Vector<Transition, DNA_COUNT(transitionCount)> transitions; Vector<Transition, AT_DNA_COUNT(transitionCount)> transitions;
}; };
Vector<State, DNA_COUNT(stateCount)> states; Vector<State, AT_DNA_COUNT(stateCount)> states;
static bool Extract(PAKEntryReadStream& rs, const hecl::ProjectPath& outPath) static bool Extract(PAKEntryReadStream& rs, const hecl::ProjectPath& outPath)
{ {

10
DataSpec/DNAMP1/ANCS.hpp
View File

@ -99,7 +99,7 @@ struct ANCS : BigDNA
}; };
std::vector<AnimInfo> animInfos; std::vector<AnimInfo> animInfos;
}; };
Vector<AnimState, DNA_COUNT(animStateCount)> animStates; Vector<AnimState, AT_DNA_COUNT(animStateCount)> animStates;
} pasDatabase; } pasDatabase;
struct ParticleResData struct ParticleResData
@ -136,7 +136,7 @@ struct ANCS : BigDNA
Value<atUint32> parentMode; Value<atUint32> parentMode;
Value<atUint32> flags; Value<atUint32> flags;
}; };
Vector<EffectComponent, DNA_COUNT(compCount)> comps; Vector<EffectComponent, AT_DNA_COUNT(compCount)> comps;
}; };
std::vector<Effect> effects; std::vector<Effect> effects;
@ -145,7 +145,7 @@ struct ANCS : BigDNA
std::vector<atUint32> animIdxs; std::vector<atUint32> animIdxs;
}; };
Vector<CharacterInfo, DNA_COUNT(characterCount)> characters; Vector<CharacterInfo, AT_DNA_COUNT(characterCount)> characters;
} characterSet; } characterSet;
struct AnimationSet : BigDNA struct AnimationSet : BigDNA
@ -262,7 +262,7 @@ struct ANCS : BigDNA
MetaAnimFactory anim; MetaAnimFactory anim;
Value<atUint32> probability; Value<atUint32> probability;
}; };
Vector<Child, DNA_COUNT(animCount)> children; Vector<Child, AT_DNA_COUNT(animCount)> children;
void gatherPrimitives(std::map<atUint32, DNAANCS::AnimationResInfo<UniqueID32>>& out) void gatherPrimitives(std::map<atUint32, DNAANCS::AnimationResInfo<UniqueID32>>& out)
{ {
@ -284,7 +284,7 @@ struct ANCS : BigDNA
AT_DECL_DNA_YAML AT_DECL_DNA_YAML
AT_DECL_DNAV AT_DECL_DNAV
Value<atUint32> animCount; Value<atUint32> animCount;
Vector<MetaAnimFactory, DNA_COUNT(animCount)> children; Vector<MetaAnimFactory, AT_DNA_COUNT(animCount)> children;
void gatherPrimitives(std::map<atUint32, DNAANCS::AnimationResInfo<UniqueID32>>& out) void gatherPrimitives(std::map<atUint32, DNAANCS::AnimationResInfo<UniqueID32>>& out)
{ {

8
DataSpec/DNAMP1/CINF.hpp
View File

@ -18,12 +18,12 @@ struct CINF : BigDNA
Value<atUint32> parentId; Value<atUint32> parentId;
Value<atVec3f> origin; Value<atVec3f> origin;
Value<atUint32> linkedCount; Value<atUint32> linkedCount;
Vector<atUint32, DNA_COUNT(linkedCount)> linked; Vector<atUint32, AT_DNA_COUNT(linkedCount)> linked;
}; };
Vector<Bone, DNA_COUNT(boneCount)> bones; Vector<Bone, AT_DNA_COUNT(boneCount)> bones;
Value<atUint32> boneIdCount; Value<atUint32> boneIdCount;
Vector<atUint32, DNA_COUNT(boneIdCount)> boneIds; Vector<atUint32, AT_DNA_COUNT(boneIdCount)> boneIds;
Value<atUint32> nameCount; Value<atUint32> nameCount;
struct Name : BigDNA struct Name : BigDNA
@ -32,7 +32,7 @@ struct CINF : BigDNA
String<-1> name; String<-1> name;
Value<atUint32> boneId; Value<atUint32> boneId;
}; };
Vector<Name, DNA_COUNT(nameCount)> names; Vector<Name, AT_DNA_COUNT(nameCount)> names;
atUint32 getInternalBoneIdxFromId(atUint32 id) const; atUint32 getInternalBoneIdxFromId(atUint32 id) const;
atUint32 getBoneIdxFromId(atUint32 id) const; atUint32 getBoneIdxFromId(atUint32 id) const;

32
DataSpec/DNAMP1/CMDLMaterials.hpp
View File

@ -18,9 +18,9 @@ struct MaterialSet : BigDNA
{ {
AT_DECL_DNA AT_DECL_DNA
Value<atUint32> textureCount = 0; Value<atUint32> textureCount = 0;
Vector<UniqueID32, DNA_COUNT(textureCount)> textureIDs; Vector<UniqueID32, AT_DNA_COUNT(textureCount)> textureIDs;
Value<atUint32> materialCount = 0; Value<atUint32> materialCount = 0;
Vector<atUint32, DNA_COUNT(materialCount)> materialEndOffs; Vector<atUint32, AT_DNA_COUNT(materialCount)> materialEndOffs;
void addTexture(const UniqueID32& id) {textureIDs.push_back(id); ++textureCount;} void addTexture(const UniqueID32& id) {textureIDs.push_back(id); ++textureCount;}
void addMaterialEndOff(atUint32 off) {materialEndOffs.push_back(off); ++materialCount;} void addMaterialEndOff(atUint32 off) {materialEndOffs.push_back(off); ++materialCount;}
@ -59,7 +59,7 @@ struct MaterialSet : BigDNA
const Flags& getFlags() const {return flags;} const Flags& getFlags() const {return flags;}
Value<atUint32> textureCount = 0; Value<atUint32> textureCount = 0;
Vector<atUint32, DNA_COUNT(textureCount)> textureIdxs; Vector<atUint32, AT_DNA_COUNT(textureCount)> textureIdxs;
struct VAFlags : BigDNA struct VAFlags : BigDNA
{ {
AT_DECL_DNA AT_DECL_DNA
@ -132,13 +132,13 @@ struct MaterialSet : BigDNA
const VAFlags& getVAFlags() const {return vaFlags;} const VAFlags& getVAFlags() const {return vaFlags;}
Value<atUint32> groupIdx; Value<atUint32> groupIdx;
Vector<atUint32, DNA_COUNT(flags.konstValuesEnabled())> konstCount; Vector<atUint32, AT_DNA_COUNT(flags.konstValuesEnabled())> konstCount;
Vector<GX::Color, DNA_COUNT(flags.konstValuesEnabled() ? konstCount[0] : 0)> konstColors; Vector<GX::Color, AT_DNA_COUNT(flags.konstValuesEnabled() ? konstCount[0] : 0)> konstColors;
using BlendFactor = GX::BlendFactor; using BlendFactor = GX::BlendFactor;
Value<BlendFactor> blendDstFac; Value<BlendFactor> blendDstFac;
Value<BlendFactor> blendSrcFac; Value<BlendFactor> blendSrcFac;
Vector<atUint32, DNA_COUNT(flags.samusReflectionIndirectTexture())> indTexSlot; Vector<atUint32, AT_DNA_COUNT(flags.samusReflectionIndirectTexture())> indTexSlot;
Value<atUint32> colorChannelCount = 0; Value<atUint32> colorChannelCount = 0;
struct ColorChannel : BigDNA struct ColorChannel : BigDNA
@ -158,7 +158,7 @@ struct MaterialSet : BigDNA
GX::AttnFn attenuationFn() const {return GX::AttnFn(flags >> 13 & 0x3);} GX::AttnFn attenuationFn() const {return GX::AttnFn(flags >> 13 & 0x3);}
void setAttenuationFn(GX::AttnFn fn) {flags &= ~0x6000; flags |= atUint32(fn) << 13;} void setAttenuationFn(GX::AttnFn fn) {flags &= ~0x6000; flags |= atUint32(fn) << 13;}
}; };
Vector<ColorChannel, DNA_COUNT(colorChannelCount)> colorChannels; Vector<ColorChannel, AT_DNA_COUNT(colorChannelCount)> colorChannels;
Value<atUint32> tevStageCount = 0; Value<atUint32> tevStageCount = 0;
struct TEVStage : BigDNA struct TEVStage : BigDNA
@ -218,7 +218,7 @@ struct MaterialSet : BigDNA
GX::TevKAlphaSel kAlphaIn() const {return GX::TevKAlphaSel(kaInput);} GX::TevKAlphaSel kAlphaIn() const {return GX::TevKAlphaSel(kaInput);}
void setKAlphaIn(GX::TevKAlphaSel val) {kaInput = val;} void setKAlphaIn(GX::TevKAlphaSel val) {kaInput = val;}
}; };
Vector<TEVStage, DNA_COUNT(tevStageCount)> tevStages; Vector<TEVStage, AT_DNA_COUNT(tevStageCount)> tevStages;
struct TEVStageTexInfo : BigDNA struct TEVStageTexInfo : BigDNA
{ {
AT_DECL_DNA AT_DECL_DNA
@ -226,7 +226,7 @@ struct MaterialSet : BigDNA
Value<atUint8> texSlot = 0xff; Value<atUint8> texSlot = 0xff;
Value<atUint8> tcgSlot = 0xff; Value<atUint8> tcgSlot = 0xff;
}; };
Vector<TEVStageTexInfo, DNA_COUNT(tevStageCount)> tevStageTexInfo; Vector<TEVStageTexInfo, AT_DNA_COUNT(tevStageCount)> tevStageTexInfo;
Value<atUint32> tcgCount = 0; Value<atUint32> tcgCount = 0;
struct TexCoordGen : BigDNA struct TexCoordGen : BigDNA
@ -245,7 +245,7 @@ struct MaterialSet : BigDNA
GX::PTTexMtx postMtx() const {return GX::PTTexMtx((flags >> 15 & 0x3f) + 64);} GX::PTTexMtx postMtx() const {return GX::PTTexMtx((flags >> 15 & 0x3f) + 64);}
void setPostMtx(GX::PTTexMtx val) {flags &= ~0x1f8000; flags |= (atUint32(val)-64) << 15;} void setPostMtx(GX::PTTexMtx val) {flags &= ~0x1f8000; flags |= (atUint32(val)-64) << 15;}
}; };
Vector<TexCoordGen, DNA_COUNT(tcgCount)> tcgs; Vector<TexCoordGen, AT_DNA_COUNT(tcgCount)> tcgs;
Value<atUint32> uvAnimsSize = 4; Value<atUint32> uvAnimsSize = 4;
Value<atUint32> uvAnimsCount = 0; Value<atUint32> uvAnimsCount = 0;
@ -270,7 +270,7 @@ struct MaterialSet : BigDNA
UVAnimation(const std::string& gameFunction, UVAnimation(const std::string& gameFunction,
const std::vector<atVec4f>& gameArgs); const std::vector<atVec4f>& gameArgs);
}; };
Vector<UVAnimation, DNA_COUNT(uvAnimsCount)> uvAnims; Vector<UVAnimation, AT_DNA_COUNT(uvAnimsCount)> uvAnims;
static void AddTexture(hecl::blender::PyOutStream& out, static void AddTexture(hecl::blender::PyOutStream& out,
GX::TexGenSrc type, int mtxIdx, uint32_t texIdx); GX::TexGenSrc type, int mtxIdx, uint32_t texIdx);
@ -293,7 +293,7 @@ struct MaterialSet : BigDNA
bool matrixSkinning, bool matrixSkinning,
atUint32 grpIdx); atUint32 grpIdx);
}; };
Vector<Material, DNA_COUNT(head.materialCount)> materials; Vector<Material, AT_DNA_COUNT(head.materialCount)> materials;
static void RegisterMaterialProps(hecl::blender::PyOutStream& out); static void RegisterMaterialProps(hecl::blender::PyOutStream& out);
static void ConstructMaterial(hecl::blender::PyOutStream& out, static void ConstructMaterial(hecl::blender::PyOutStream& out,
@ -366,13 +366,13 @@ struct HMDLMaterialSet : BigDNA
MaterialSet::Material::Flags flags; MaterialSet::Material::Flags flags;
Value<atUint32> textureCount = 0; Value<atUint32> textureCount = 0;
Vector<atUint32, DNA_COUNT(textureCount)> textureIdxs; Vector<atUint32, AT_DNA_COUNT(textureCount)> textureIdxs;
Vector<atUint32, DNA_COUNT(flags.samusReflectionIndirectTexture())> indTexSlot; Vector<atUint32, AT_DNA_COUNT(flags.samusReflectionIndirectTexture())> indTexSlot;
Value<atUint32> uvAnimsSize = 4; Value<atUint32> uvAnimsSize = 4;
Value<atUint32> uvAnimsCount = 0; Value<atUint32> uvAnimsCount = 0;
Vector<MaterialSet::Material::UVAnimation, DNA_COUNT(uvAnimsCount)> uvAnims; Vector<MaterialSet::Material::UVAnimation, AT_DNA_COUNT(uvAnimsCount)> uvAnims;
String<-1> heclSource; String<-1> heclSource;
hecl::Frontend::IR heclIr; hecl::Frontend::IR heclIr;
@ -384,7 +384,7 @@ struct HMDLMaterialSet : BigDNA
const std::unordered_map<std::string, int32_t>& iprops, const std::unordered_map<std::string, int32_t>& iprops,
const std::vector<hecl::ProjectPath>& texPaths); const std::vector<hecl::ProjectPath>& texPaths);
}; };
Vector<Material, DNA_COUNT(head.materialCount)> materials; Vector<Material, AT_DNA_COUNT(head.materialCount)> materials;
}; };
} }

4
DataSpec/DNAMP1/CSKR.hpp
View File

@ -21,10 +21,10 @@ struct CSKR : BigDNA
Value<atUint32> boneId; Value<atUint32> boneId;
Value<float> weight; Value<float> weight;
}; };
Vector<Weight, DNA_COUNT(weightCount)> weights; Vector<Weight, AT_DNA_COUNT(weightCount)> weights;
Value<atUint32> vertCount; Value<atUint32> vertCount;
}; };
Vector<SkinningRule, DNA_COUNT(skinningRuleCount)> skinningRules; Vector<SkinningRule, AT_DNA_COUNT(skinningRuleCount)> skinningRules;
const atInt16* getMatrixBank(size_t) const const atInt16* getMatrixBank(size_t) const
{ {

18
DataSpec/DNAMP1/DCLN.hpp
View File

@ -30,19 +30,19 @@ struct DCLN : BigDNA
Value<atUint32> version; Value<atUint32> version;
Value<atUint32> memSize; Value<atUint32> memSize;
Value<atUint32> materialCount; Value<atUint32> materialCount;
Vector<Material, DNA_COUNT(materialCount)> materials; Vector<Material, AT_DNA_COUNT(materialCount)> materials;
Value<atUint32> vertMatsCount; Value<atUint32> vertMatsCount;
Vector<atUint8, DNA_COUNT(vertMatsCount)> vertMats; Vector<atUint8, AT_DNA_COUNT(vertMatsCount)> vertMats;
Value<atUint32> edgeMatsCount; Value<atUint32> edgeMatsCount;
Vector<atUint8, DNA_COUNT(edgeMatsCount)> edgeMats; Vector<atUint8, AT_DNA_COUNT(edgeMatsCount)> edgeMats;
Value<atUint32> triMatsCount; Value<atUint32> triMatsCount;
Vector<atUint8, DNA_COUNT(triMatsCount)> triMats; Vector<atUint8, AT_DNA_COUNT(triMatsCount)> triMats;
Value<atUint32> edgeVertsCount; Value<atUint32> edgeVertsCount;
Vector<Edge, DNA_COUNT(edgeVertsCount)> edgeVertConnections; Vector<Edge, AT_DNA_COUNT(edgeVertsCount)> edgeVertConnections;
Value<atUint32> triangleEdgesCount; Value<atUint32> triangleEdgesCount;
Vector<Triangle, DNA_COUNT(triangleEdgesCount / 3)> triangleEdgeConnections; Vector<Triangle, AT_DNA_COUNT(triangleEdgesCount / 3)> triangleEdgeConnections;
Value<atUint32> vertCount; Value<atUint32> vertCount;
Vector<atVec3f, DNA_COUNT(vertCount)> verts; Vector<atVec3f, AT_DNA_COUNT(vertCount)> verts;
struct Node : BigDNA struct Node : BigDNA
{ {
@ -52,7 +52,7 @@ struct DCLN : BigDNA
{ {
AT_DECL_DNA AT_DECL_DNA
Value<atUint32> triangleIndexCount; Value<atUint32> triangleIndexCount;
Vector<atUint16, DNA_COUNT(triangleIndexCount)> triangleIndices; Vector<atUint16, AT_DNA_COUNT(triangleIndexCount)> triangleIndices;
size_t getMemoryUsage() const { return (((triangleIndices.size() * 2) + 16) + 3) & ~3; } size_t getMemoryUsage() const { return (((triangleIndices.size() * 2) + 16) + 3) & ~3; }
}; };
@ -92,7 +92,7 @@ struct DCLN : BigDNA
}; };
Vector<Collision, DNA_COUNT(colCount)> collision; Vector<Collision, AT_DNA_COUNT(colCount)> collision;
void sendToBlender(hecl::blender::Connection& conn, std::string_view entryName); void sendToBlender(hecl::blender::Connection& conn, std::string_view entryName);

16
DataSpec/DNAMP1/DeafBabe.hpp
View File

@ -124,21 +124,21 @@ struct DeafBabe : BigDNA
Value<atVec3f> aabb[2]; Value<atVec3f> aabb[2];
Value<BspNodeType> rootNodeType; Value<BspNodeType> rootNodeType;
Value<atUint32> bspSize; Value<atUint32> bspSize;
Buffer<DNA_COUNT(bspSize)> bspTree; Buffer<AT_DNA_COUNT(bspSize)> bspTree;
Value<atUint32> materialCount; Value<atUint32> materialCount;
Vector<Material, DNA_COUNT(materialCount)> materials; Vector<Material, AT_DNA_COUNT(materialCount)> materials;
Value<atUint32> vertMatsCount; Value<atUint32> vertMatsCount;
Vector<atUint8, DNA_COUNT(vertMatsCount)> vertMats; Vector<atUint8, AT_DNA_COUNT(vertMatsCount)> vertMats;
Value<atUint32> edgeMatsCount; Value<atUint32> edgeMatsCount;
Vector<atUint8, DNA_COUNT(edgeMatsCount)> edgeMats; Vector<atUint8, AT_DNA_COUNT(edgeMatsCount)> edgeMats;
Value<atUint32> triMatsCount; Value<atUint32> triMatsCount;
Vector<atUint8, DNA_COUNT(triMatsCount)> triMats; Vector<atUint8, AT_DNA_COUNT(triMatsCount)> triMats;
Value<atUint32> edgeVertsCount; Value<atUint32> edgeVertsCount;
Vector<Edge, DNA_COUNT(edgeVertsCount)> edgeVertConnections; Vector<Edge, AT_DNA_COUNT(edgeVertsCount)> edgeVertConnections;
Value<atUint32> triangleEdgesCount; Value<atUint32> triangleEdgesCount;
Vector<Triangle, DNA_COUNT(triangleEdgesCount / 3)> triangleEdgeConnections; Vector<Triangle, AT_DNA_COUNT(triangleEdgesCount / 3)> triangleEdgeConnections;
Value<atUint32> vertCount; Value<atUint32> vertCount;
Vector<atVec3f, DNA_COUNT(vertCount)> verts; Vector<atVec3f, AT_DNA_COUNT(vertCount)> verts;
/* Dummy MP2 member */ /* Dummy MP2 member */
void insertNoClimb(hecl::blender::PyOutStream&) const {} void insertNoClimb(hecl::blender::PyOutStream&) const {}

8
DataSpec/DNAMP1/EVNT.hpp
View File

@ -48,7 +48,7 @@ struct EVNT : BigDNA
Value<atUint8> value; Value<atUint8> value;
}; };
Value<atUint32> boolPOICount; Value<atUint32> boolPOICount;
Vector<BoolPOINode, DNA_COUNT(boolPOICount)> boolPOINodes; Vector<BoolPOINode, AT_DNA_COUNT(boolPOICount)> boolPOINodes;
struct Int32POINode : POINode struct Int32POINode : POINode
{ {
@ -57,7 +57,7 @@ struct EVNT : BigDNA
String<-1> locator; String<-1> locator;
}; };
Value<atUint32> int32POICount; Value<atUint32> int32POICount;
Vector<Int32POINode, DNA_COUNT(int32POICount)> int32POINodes; Vector<Int32POINode, AT_DNA_COUNT(int32POICount)> int32POINodes;
struct ParticlePOINode : POINode struct ParticlePOINode : POINode
{ {
@ -70,7 +70,7 @@ struct EVNT : BigDNA
Value<atUint32> parentMode; Value<atUint32> parentMode;
}; };
Value<atUint32> particlePOICount; Value<atUint32> particlePOICount;
Vector<ParticlePOINode, DNA_COUNT(particlePOICount)> particlePOINodes; Vector<ParticlePOINode, AT_DNA_COUNT(particlePOICount)> particlePOINodes;
struct SoundPOINode : POINode struct SoundPOINode : POINode
{ {
@ -80,7 +80,7 @@ struct EVNT : BigDNA
Value<float> maxDist; Value<float> maxDist;
}; };
Value<atUint32> soundPOICount; Value<atUint32> soundPOICount;
Vector<SoundPOINode, DNA_COUNT(soundPOICount)> soundPOINodes; Vector<SoundPOINode, AT_DNA_COUNT(soundPOICount)> soundPOINodes;
static bool Extract(PAKEntryReadStream& rs, const hecl::ProjectPath& outPath) static bool Extract(PAKEntryReadStream& rs, const hecl::ProjectPath& outPath)
{ {

6
DataSpec/DNAMP1/FRME.hpp
View File

@ -296,15 +296,15 @@ struct FRME : BigDNA
Value<atUint32> unk1; Value<atUint32> unk1;
Value<atUint32> unk2; Value<atUint32> unk2;
Value<atUint32> quadCoordCount; Value<atUint32> quadCoordCount;
Vector<atVec3f, DNA_COUNT(quadCoordCount)> quadCoords; Vector<atVec3f, AT_DNA_COUNT(quadCoordCount)> quadCoords;
Value<atUint32> uvCoordCount; Value<atUint32> uvCoordCount;
Vector<atVec2f, DNA_COUNT(uvCoordCount)> uvCoords; Vector<atVec2f, AT_DNA_COUNT(uvCoordCount)> uvCoords;
FourCC fourcc() const { return FOURCC('IMGP'); } FourCC fourcc() const { return FOURCC('IMGP'); }
}; };
}; };
Vector<Widget, DNA_COUNT(widgetCount)> widgets; Vector<Widget, AT_DNA_COUNT(widgetCount)> widgets;
static bool Extract(const SpecBase& dataSpec, static bool Extract(const SpecBase& dataSpec,
PAKEntryReadStream& rs, PAKEntryReadStream& rs,
const hecl::ProjectPath& outPath, const hecl::ProjectPath& outPath,

4
DataSpec/DNAMP1/HINT.hpp
View File

@ -30,10 +30,10 @@ struct HINT : BigDNA
}; };
Value<atUint32> locationCount; Value<atUint32> locationCount;
Vector<Location, DNA_COUNT(locationCount)> locations; Vector<Location, AT_DNA_COUNT(locationCount)> locations;
}; };
Value<atUint32> hintCount; Value<atUint32> hintCount;
Vector<Hint, DNA_COUNT(hintCount)> hints; Vector<Hint, AT_DNA_COUNT(hintCount)> hints;
static bool Extract(PAKEntryReadStream& rs, const hecl::ProjectPath& outPath) static bool Extract(PAKEntryReadStream& rs, const hecl::ProjectPath& outPath)

3
DataSpec/DNAMP1/MLVL.cpp
View File

@ -314,7 +314,8 @@ bool MLVL::Cook(const hecl::ProjectPath& outPath, const hecl::ProjectPath& inPat
} }
} }
urde::SObjectTag pathTag = g_curSpec->buildTagFromPath(areaPath.ensureAuxInfo(_S("PATH")), btok); hecl::ProjectPath pathPath(areaPath.getParentPath(), _S("!path.blend"));
urde::SObjectTag pathTag = g_curSpec->buildTagFromPath(pathPath, btok);
if (pathTag.id.IsValid()) if (pathTag.id.IsValid())
areaOut.deps.emplace_back(pathTag.id.Value(), pathTag.type); areaOut.deps.emplace_back(pathTag.id.Value(), pathTag.type);

24
DataSpec/DNAMP1/MLVL.hpp
View File

@ -26,7 +26,7 @@ struct MLVL : BigDNA
Value<atUint16> msg; Value<atUint16> msg;
Value<bool> active; Value<bool> active;
}; };
Vector<MemRelayLink, DNA_COUNT(memRelayLinkCount)> memRelayLinks; Vector<MemRelayLink, AT_DNA_COUNT(memRelayLinkCount)> memRelayLinks;
Value<atUint32> areaCount; Value<atUint32> areaCount;
Value<atUint32> unknown1; Value<atUint32> unknown1;
@ -40,7 +40,7 @@ struct MLVL : BigDNA
Value<atUint32> areaId; Value<atUint32> areaId;
Value<atUint32> attachedAreaCount; Value<atUint32> attachedAreaCount;
Vector<atUint16, DNA_COUNT(attachedAreaCount)> attachedAreas; Vector<atUint16, AT_DNA_COUNT(attachedAreaCount)> attachedAreas;
Value<atUint32> padding; Value<atUint32> padding;
Value<atUint32> depCount; Value<atUint32> depCount;
@ -54,10 +54,10 @@ struct MLVL : BigDNA
Dependency(const UniqueID32& idin, const hecl::FourCC& fcc) Dependency(const UniqueID32& idin, const hecl::FourCC& fcc)
: id(idin), type(fcc) {} : id(idin), type(fcc) {}
}; };
Vector<Dependency, DNA_COUNT(depCount)> deps; Vector<Dependency, AT_DNA_COUNT(depCount)> deps;
Value<atUint32> depLayerCount; Value<atUint32> depLayerCount;
Vector<atUint32, DNA_COUNT(depLayerCount)> depLayers; Vector<atUint32, AT_DNA_COUNT(depLayerCount)> depLayers;
Value<atUint32> dockCount; Value<atUint32> dockCount;
struct Dock : BigDNA struct Dock : BigDNA
@ -70,14 +70,14 @@ struct MLVL : BigDNA
Value<atUint32> areaIdx; Value<atUint32> areaIdx;
Value<atUint32> dockIdx; Value<atUint32> dockIdx;
}; };
Vector<Endpoint, DNA_COUNT(endpointCount)> endpoints; Vector<Endpoint, AT_DNA_COUNT(endpointCount)> endpoints;
Value<atUint32> planeVertCount; Value<atUint32> planeVertCount;
Vector<atVec3f, DNA_COUNT(planeVertCount)> planeVerts; Vector<atVec3f, AT_DNA_COUNT(planeVertCount)> planeVerts;
}; };
Vector<Dock, DNA_COUNT(dockCount)> docks; Vector<Dock, AT_DNA_COUNT(dockCount)> docks;
}; };
Vector<Area, DNA_COUNT(areaCount)> areas; Vector<Area, AT_DNA_COUNT(areaCount)> areas;
void finishLastArea() void finishLastArea()
{ {
@ -102,7 +102,7 @@ struct MLVL : BigDNA
Value<atUint32> groupId; Value<atUint32> groupId;
UniqueID32 agscId; UniqueID32 agscId;
}; };
Vector<AudioGroup, DNA_COUNT(audioGroupCount)> audioGroups; Vector<AudioGroup, AT_DNA_COUNT(audioGroupCount)> audioGroups;
String<-1> unkString; String<-1> unkString;
Value<atUint32> layerFlagCount; Value<atUint32> layerFlagCount;
@ -112,13 +112,13 @@ struct MLVL : BigDNA
Value<atUint32> layerCount; Value<atUint32> layerCount;
Value<atUint64> flags; Value<atUint64> flags;
}; };
Vector<LayerFlags, DNA_COUNT(layerFlagCount)> layerFlags; Vector<LayerFlags, AT_DNA_COUNT(layerFlagCount)> layerFlags;
Value<atUint32> layerNameCount; Value<atUint32> layerNameCount;
Vector<String<-1>, DNA_COUNT(layerNameCount)> layerNames; Vector<String<-1>, AT_DNA_COUNT(layerNameCount)> layerNames;
Value<atUint32> layerNameOffsetCount; Value<atUint32> layerNameOffsetCount;
Vector<atUint32, DNA_COUNT(layerNameOffsetCount)> layerNameOffsets; Vector<atUint32, AT_DNA_COUNT(layerNameOffsetCount)> layerNameOffsets;
void readMeta(athena::io::YAMLDocReader& __dna_docin) void readMeta(athena::io::YAMLDocReader& __dna_docin)
{ {

30
DataSpec/DNAMP1/MREA.cpp
View File

@ -798,7 +798,8 @@ bool MREA::PCCook(const hecl::ProjectPath& outPath,
/* PATH */ /* PATH */
{ {
UniqueID32 pathId = inPath.ensureAuxInfo(_S("PATH")); hecl::ProjectPath pathPath(inPath.getParentPath(), _S("!path.blend"));
UniqueID32 pathId = pathPath;
secs.emplace_back(4, 0); secs.emplace_back(4, 0);
athena::io::MemoryWriter w(secs.back().data(), secs.back().size()); athena::io::MemoryWriter w(secs.back().data(), secs.back().size());
pathId.write(w); pathId.write(w);
@ -826,31 +827,4 @@ bool MREA::PCCook(const hecl::ProjectPath& outPath,
return true; return true;
} }
bool MREA::CookPath(const hecl::ProjectPath& outPath,
const hecl::ProjectPath& inPath)
{
PATH path = {};
path.version = 4;
path.octreeNodeCount = 1;
path.octree.emplace_back();
PATH::OctreeNode& s = path.octree.back();
s.isLeaf = 1;
s.points[0] = atVec3f{FLT_MAX, FLT_MAX, FLT_MAX};
s.points[1] = atVec3f{-FLT_MAX, -FLT_MAX, -FLT_MAX};
s.points[2] = atVec3f{0.f, 0.f, 0.f};
for (int i=0 ; i<8 ; ++i)
s.children[i] = 0xffffffff;
s.regionCount = 0;
s.regionStart = 0;
athena::io::FileWriter w(outPath.getAbsolutePath());
path.write(w);
int64_t rem = w.position() % 32;
if (rem)
for (int64_t i=0 ; i<32-rem ; ++i)
w.writeUByte(0xff);
return true;
}
} }

5
DataSpec/DNAMP1/MREA.hpp
View File

@ -26,7 +26,7 @@ struct MREA
Value<atUint32> visiSecIdx; Value<atUint32> visiSecIdx;
Value<atUint32> pathSecIdx; Value<atUint32> pathSecIdx;
Value<atUint32> arotSecIdx; Value<atUint32> arotSecIdx;
Vector<atUint32, DNA_COUNT(secCount)> secSizes; Vector<atUint32, AT_DNA_COUNT(secCount)> secSizes;
}; };
struct MeshHeader : BigDNA struct MeshHeader : BigDNA
@ -137,9 +137,6 @@ struct MREA
const ColMesh& cMesh, const ColMesh& cMesh,
const std::vector<Light>& lights, const std::vector<Light>& lights,
hecl::blender::Token& btok); hecl::blender::Token& btok);
static bool CookPath(const hecl::ProjectPath& outPath,
const hecl::ProjectPath& inPath);
}; };
} }

2
DataSpec/DNAMP1/PAK.hpp
View File

@ -22,7 +22,7 @@ struct PAK : BigDNA
DNAFourCC type; DNAFourCC type;
UniqueID32 id; UniqueID32 id;
Value<atUint32> nameLen; Value<atUint32> nameLen;
String<DNA_COUNT(nameLen)> name; String<AT_DNA_COUNT(nameLen)> name;
}; };
struct Entry : BigDNA struct Entry : BigDNA

84
DataSpec/DNAMP1/PATH.cpp
View File

@ -1,6 +1,7 @@
#include "PATH.hpp" #include "PATH.hpp"
#include "hecl/Blender/Connection.hpp" #include "hecl/Blender/Connection.hpp"
#include <unordered_set> #include "zeus/CAABox.hpp"
#include "../DNACommon/AROTBuilder.hpp"
namespace DataSpec::DNAMP1 namespace DataSpec::DNAMP1
{ {
@ -14,18 +15,41 @@ void PATH::sendToBlender(hecl::blender::Connection& conn, std::string_view entry
"import bmesh\n" "import bmesh\n"
"from mathutils import Vector, Matrix\n" "from mathutils import Vector, Matrix\n"
"\n" "\n"
"bpy.types.Material.retro_path_idx_mask = bpy.props.IntProperty(name='Retro: Path Index Mask')\n"
"bpy.types.Material.retro_path_type_mask = bpy.props.IntProperty(name='Retro: Path Type Mask')\n"
"\n"
"material_dict = {}\n" "material_dict = {}\n"
"material_index = []\n" "material_index = []\n"
"def select_material(data):\n" "def make_ground_material(idxMask):\n"
" if data in material_index:\n" " mat = bpy.data.materials.new('Ground %%X' %% idxMask)\n"
" return material_index.index(data)\n" " mat.diffuse_color = (0.8, 0.460, 0.194)\n"
" elif data in material_dict:\n" " return mat\n"
" material_index.append(data)\n" "def make_flyer_material(idxMask):\n"
" mat = bpy.data.materials.new('Flyer %%X' %% idxMask)\n"
" mat.diffuse_color = (0.016, 0.8, 0.8)\n"
" return mat\n"
"def make_swimmer_material(idxMask):\n"
" mat = bpy.data.materials.new('Swimmer %%X' %% idxMask)\n"
" mat.diffuse_color = (0.074, 0.293, 0.8)\n"
" return mat\n"
"def select_material(meshIdxMask, meshTypeMask):\n"
" key = (meshIdxMask, meshTypeMask)\n"
" if key in material_index:\n"
" return material_index.index(key)\n"
" elif key in material_dict:\n"
" material_index.append(key)\n"
" return len(material_index)-1\n" " return len(material_index)-1\n"
" else:\n" " else:\n"
" mat = bpy.data.materials.new(data)\n" " if meshTypeMask == 0x2:\n"
" material_dict[data] = mat\n" " mat = make_flyer_material(meshIdxMask)\n"
" material_index.append(data)\n" " elif meshTypeMask == 0x4:\n"
" mat = make_swimmer_material(meshIdxMask)\n"
" else:\n"
" mat = make_ground_material(meshIdxMask)\n"
" mat.retro_path_idx_mask = meshIdxMask\n"
" mat.retro_path_type_mask = meshTypeMask\n"
" material_dict[key] = mat\n"
" material_index.append(key)\n"
" return len(material_index)-1\n" " return len(material_index)-1\n"
"\n" "\n"
"bpy.context.scene.name = '%s'\n" "bpy.context.scene.name = '%s'\n"
@ -35,7 +59,8 @@ void PATH::sendToBlender(hecl::blender::Connection& conn, std::string_view entry
" bpy.context.scene.objects.unlink(ob)\n" " bpy.context.scene.objects.unlink(ob)\n"
" bpy.data.objects.remove(ob)\n" " bpy.data.objects.remove(ob)\n"
"\n" "\n"
"bm = bmesh.new()\n", "bm = bmesh.new()\n"
"height_lay = bm.faces.layers.float.new('Height')\n",
entryName.data()); entryName.data());
for (const Node& n : nodes) for (const Node& n : nodes)
@ -50,23 +75,38 @@ void PATH::sendToBlender(hecl::blender::Connection& conn, std::string_view entry
for (int i=0 ; i<r.nodeCount ; ++i) for (int i=0 ; i<r.nodeCount ; ++i)
os.format("tri_verts.append(bm.verts[%u])\n", r.nodeStart + i); os.format("tri_verts.append(bm.verts[%u])\n", r.nodeStart + i);
zeus::CVector3f centroid = r.centroid;
if (xf)
centroid = xf->multiplyOneOverW(centroid);
os.format("face = bm.faces.get(tri_verts)\n" os.format("face = bm.faces.get(tri_verts)\n"
"if face is None:\n" "if face is None:\n"
" face = bm.faces.new(tri_verts)\n" " face = bm.faces.new(tri_verts)\n"
" face.normal_flip()\n" " face.normal_flip()\n"
"face.material_index = select_material('0x%08X')\n" "face.material_index = select_material(0x%04X, 0x%04X)\n"
"face.smooth = False\n" "face.smooth = False\n"
"hobj = bpy.data.objects.new('Height', None)\n" "face[height_lay] = %f\n"
"hobj.location = (%f,%f,%f)\n" "\n", r.meshIndexMask, r.meshTypeMask, r.height);
"hobj.layers[1] = True\n"
"bpy.context.scene.objects.link(hobj)\n" #if 0
"\n", r.flags, centroid.v[0], centroid.v[1], centroid.v[2] + r.height); zeus::CVector3f center = xf->multiplyOneOverW(r.centroid);
zeus::CAABox aabb(xf->multiplyOneOverW(r.aabb[0]), xf->multiplyOneOverW(r.aabb[1]));
os.format("aabb = bpy.data.objects.new('AABB', None)\n"
"aabb.location = (%f,%f,%f)\n"
"aabb.scale = (%f,%f,%f)\n"
"aabb.empty_draw_type = 'CUBE'\n"
"bpy.context.scene.objects.link(aabb)\n"
"centr = bpy.data.objects.new('Center', None)\n"
"centr.location = (%f,%f,%f)\n"
"bpy.context.scene.objects.link(centr)\n",
aabb.min.v[0] + (aabb.max.v[0] - aabb.min.v[0]) / 2.f,
aabb.min.v[1] + (aabb.max.v[1] - aabb.min.v[1]) / 2.f,
aabb.min.v[2] + (aabb.max.v[2] - aabb.min.v[2]) / 2.f,
(aabb.max.v[0] - aabb.min.v[0]) / 2.f,
(aabb.max.v[1] - aabb.min.v[1]) / 2.f,
(aabb.max.v[2] - aabb.min.v[2]) / 2.f,
center.x, center.y, center.z);
#endif
} }
os << "path_mesh = bpy.data.meshes.new('PATH')\n" os << "bmesh.ops.remove_doubles(bm, verts=bm.verts, dist=0.001)\n"
"path_mesh = bpy.data.meshes.new('PATH')\n"
"bm.to_mesh(path_mesh)\n" "bm.to_mesh(path_mesh)\n"
"path_mesh_obj = bpy.data.objects.new(path_mesh.name, path_mesh)\n" "path_mesh_obj = bpy.data.objects.new(path_mesh.name, path_mesh)\n"
"\n" "\n"
@ -129,7 +169,11 @@ bool PATH::Cook(const hecl::ProjectPath& outPath,
const PathMesh& mesh, const PathMesh& mesh,
hecl::blender::Connection* conn) hecl::blender::Connection* conn)
{ {
athena::io::MemoryReader r(mesh.data.data(), mesh.data.size());
PATH path; PATH path;
path.read(r);
AROTBuilder octreeBuilder;
octreeBuilder.buildPath(path);
athena::io::FileWriter w(outPath.getAbsolutePath()); athena::io::FileWriter w(outPath.getAbsolutePath());
path.write(w); path.write(w);

22
DataSpec/DNAMP1/PATH.hpp
View File

@ -21,7 +21,7 @@ struct PATH : BigDNA
Value<atVec3f> normal; Value<atVec3f> normal;
}; };
Value<atUint32> nodeCount; Value<atUint32> nodeCount;
Vector<Node, DNA_COUNT(nodeCount)> nodes; Vector<Node, AT_DNA_COUNT(nodeCount)> nodes;
struct Link : BigDNA struct Link : BigDNA
{ {
@ -32,7 +32,7 @@ struct PATH : BigDNA
Value<float> oneOverWidth2d; Value<float> oneOverWidth2d;
}; };
Value<atUint32> linkCount; Value<atUint32> linkCount;
Vector<Link, DNA_COUNT(linkCount)> links; Vector<Link, AT_DNA_COUNT(linkCount)> links;
struct Region : BigDNA struct Region : BigDNA
{ {
@ -41,7 +41,8 @@ struct PATH : BigDNA
Value<atUint32> nodeStart; Value<atUint32> nodeStart;
Value<atUint32> linkCount; Value<atUint32> linkCount;
Value<atUint32> linkStart; Value<atUint32> linkStart;
Value<atUint32> flags; Value<atUint16> meshIndexMask;
Value<atUint16> meshTypeMask;
Value<float> height; Value<float> height;
Value<atVec3f> normal; Value<atVec3f> normal;
Value<atUint32> regionIdx; Value<atUint32> regionIdx;
@ -50,26 +51,27 @@ struct PATH : BigDNA
Value<atUint32> regionIdxPtr; Value<atUint32> regionIdxPtr;
}; };
Value<atUint32> regionCount; Value<atUint32> regionCount;
Vector<Region, DNA_COUNT(regionCount)> regions; Vector<Region, AT_DNA_COUNT(regionCount)> regions;
Vector<atUint32, DNA_COUNT((((regionCount * (regionCount - 1)) / 2) + 31) / 32)> bitmap1; Vector<atUint32, AT_DNA_COUNT((((regionCount * (regionCount - 1)) / 2) + 31) / 32)> bitmap1;
Vector<atUint32, DNA_COUNT(bitmap1.size())> bitmap2; Vector<atUint32, AT_DNA_COUNT(bitmap1.size())> bitmap2;
Vector<atUint32, DNA_COUNT(((((regionCount * regionCount) + 31) / 32) - bitmap1.size()) * 2)> bitmap3; Vector<atUint32, AT_DNA_COUNT(((((regionCount * regionCount) + 31) / 32) - bitmap1.size()) * 2)> bitmap3;
Value<atUint32> octreeRegionLookupCount; Value<atUint32> octreeRegionLookupCount;
Vector<atUint32, DNA_COUNT(octreeRegionLookupCount)> octreeRegionLookup; Vector<atUint32, AT_DNA_COUNT(octreeRegionLookupCount)> octreeRegionLookup;
struct OctreeNode : BigDNA struct OctreeNode : BigDNA
{ {
AT_DECL_DNA AT_DECL_DNA
Value<atUint32> isLeaf; Value<atUint32> isLeaf;
Value<atVec3f> points[3]; Value<atVec3f> aabb[2];
Value<atVec3f> centroid;
Value<atUint32> children[8]; Value<atUint32> children[8];
Value<atUint32> regionCount; Value<atUint32> regionCount;
Value<atUint32> regionStart; Value<atUint32> regionStart;
}; };
Value<atUint32> octreeNodeCount; Value<atUint32> octreeNodeCount;
Vector<OctreeNode, DNA_COUNT(octreeNodeCount)> octree; Vector<OctreeNode, AT_DNA_COUNT(octreeNodeCount)> octree;
void sendToBlender(hecl::blender::Connection& conn, std::string_view entryName, void sendToBlender(hecl::blender::Connection& conn, std::string_view entryName,
const zeus::CMatrix4f* xf); const zeus::CMatrix4f* xf);

10
DataSpec/DNAMP1/SAVW.hpp
View File

@ -21,15 +21,15 @@ struct SAVW : BigDNA
AT_DECL_DNA_YAML AT_DECL_DNA_YAML
SAVWCommon::Header header; SAVWCommon::Header header;
Value<atUint32> skippableCutsceneCount; Value<atUint32> skippableCutsceneCount;
Vector<atUint32, DNA_COUNT(skippableCutsceneCount)> skippableCutscenes; Vector<atUint32, AT_DNA_COUNT(skippableCutsceneCount)> skippableCutscenes;
Value<atUint32> relayCount; Value<atUint32> relayCount;
Vector<atUint32, DNA_COUNT(relayCount)> relays; Vector<atUint32, AT_DNA_COUNT(relayCount)> relays;
Value<atUint32> layerCount; Value<atUint32> layerCount;
Vector<SAVWCommon::Layer, DNA_COUNT(layerCount)> layers; Vector<SAVWCommon::Layer, AT_DNA_COUNT(layerCount)> layers;
Value<atUint32> doorCount; Value<atUint32> doorCount;
Vector<atUint32, DNA_COUNT(doorCount)> doors; Vector<atUint32, AT_DNA_COUNT(doorCount)> doors;
Value<atUint32> scanCount; Value<atUint32> scanCount;
Vector<Scan, DNA_COUNT(scanCount)> scans; Vector<Scan, AT_DNA_COUNT(scanCount)> scans;
}; };
} }

6
DataSpec/DNAMP1/SCLY.hpp
View File

@ -14,19 +14,19 @@ struct SCLY : BigDNA
Value<atUint32> version; Value<atUint32> version;
Value<atUint32> layerCount; Value<atUint32> layerCount;
Vector<atUint32, DNA_COUNT(layerCount)> layerSizes; Vector<atUint32, AT_DNA_COUNT(layerCount)> layerSizes;
struct ScriptLayer : BigDNA struct ScriptLayer : BigDNA
{ {
AT_DECL_EXPLICIT_DNA_YAML AT_DECL_EXPLICIT_DNA_YAML
Value<atUint8> unknown; Value<atUint8> unknown;
Value<atUint32> objectCount; Value<atUint32> objectCount;
Vector<std::unique_ptr<IScriptObject>, DNA_COUNT(objectCount)> objects; Vector<std::unique_ptr<IScriptObject>, AT_DNA_COUNT(objectCount)> objects;
void addCMDLRigPairs(PAKRouter<PAKBridge>& pakRouter, void addCMDLRigPairs(PAKRouter<PAKBridge>& pakRouter,
std::unordered_map<UniqueID32, std::pair<UniqueID32, UniqueID32>>& addTo) const; std::unordered_map<UniqueID32, std::pair<UniqueID32, UniqueID32>>& addTo) const;
void nameIDs(PAKRouter<PAKBridge>& pakRouter) const; void nameIDs(PAKRouter<PAKBridge>& pakRouter) const;
}; };
Vector<ScriptLayer, DNA_COUNT(layerCount)> layers; Vector<ScriptLayer, AT_DNA_COUNT(layerCount)> layers;
void exportToLayerDirectories(const PAK::Entry &, PAKRouter<PAKBridge>&, bool) const; void exportToLayerDirectories(const PAK::Entry &, PAKRouter<PAKBridge>&, bool) const;
void addCMDLRigPairs(PAKRouter<PAKBridge>& pakRouter, void addCMDLRigPairs(PAKRouter<PAKBridge>& pakRouter,

2
DataSpec/DNAMP1/ScriptObjects/IScriptObject.hpp
View File

@ -37,7 +37,7 @@ struct IScriptObject : BigDNAVYaml
}; };
Value<atUint32> connectionCount; Value<atUint32> connectionCount;
Vector<Connection, DNA_COUNT(connectionCount)> connections; Vector<Connection, AT_DNA_COUNT(connectionCount)> connections;
Value<atUint32> propertyCount; Value<atUint32> propertyCount;
virtual ~IScriptObject() = default; virtual ~IScriptObject() = default;

2
DataSpec/DNAMP1/ScriptObjects/Parameters.hpp
View File

@ -383,7 +383,7 @@ struct PlayerParameters : BigDNA
{ {
AT_DECL_DNA_YAML AT_DECL_DNA_YAML
Value<atUint32> propertyCount; Value<atUint32> propertyCount;
Vector<bool, DNA_COUNT(propertyCount)> bools; Vector<bool, AT_DNA_COUNT(propertyCount)> bools;
}; };
struct ActorParameters : BigDNA struct ActorParameters : BigDNA

2
DataSpec/DNAMP1/Tweaks/CTweakAutoMapper.hpp
View File

@ -74,7 +74,7 @@ struct CTweakAutoMapper final : public ITweakAutoMapper
DNAColor xf8_; DNAColor xf8_;
DNAColor xfc_; DNAColor xfc_;
Value<atUint32> x100_doorColorCount; Value<atUint32> x100_doorColorCount;
Vector<DNAColor, DNA_COUNT(x100_doorColorCount)> x104_doorColors; Vector<DNAColor, AT_DNA_COUNT(x100_doorColorCount)> x104_doorColors;
DNAColor x118_doorBorderColor; DNAColor x118_doorBorderColor;
DNAColor x11c_openDoorColor; DNAColor x11c_openDoorColor;

2
DataSpec/DNAMP1/Tweaks/CTweakGui.hpp
View File

@ -162,7 +162,7 @@ struct CTweakGui final : ITweakGui
Value<float> x2bc_hudLightAttMulLinear; Value<float> x2bc_hudLightAttMulLinear;
Value<float> x2c0_hudLightAttMulQuadratic; Value<float> x2c0_hudLightAttMulQuadratic;
Value<atUint32> m_scanSpeedsCount; Value<atUint32> m_scanSpeedsCount;
Vector<float, DNA_COUNT(m_scanSpeedsCount)> x2c4_scanSpeeds; Vector<float, AT_DNA_COUNT(m_scanSpeedsCount)> x2c4_scanSpeeds;
String<-1> x2d0_; String<-1> x2d0_;
String<-1> x2e0_; String<-1> x2e0_;
String<-1> x2f0_; String<-1> x2f0_;

2
DataSpec/DNAMP1/Tweaks/CTweakGuiColors.hpp
View File

@ -133,7 +133,7 @@ struct CTweakGuiColors final : public ITweakGuiColors
}; };
Value<atUint32> x1c4_perVisorCount; Value<atUint32> x1c4_perVisorCount;
/* Combat, Scan, XRay, Thermal, Ball */ /* Combat, Scan, XRay, Thermal, Ball */
Vector<PerVisorColors, DNA_COUNT(x1c4_perVisorCount)> x1c4_perVisorColors; Vector<PerVisorColors, AT_DNA_COUNT(x1c4_perVisorCount)> x1c4_perVisorColors;
CTweakGuiColors() = default; CTweakGuiColors() = default;
CTweakGuiColors(athena::io::IStreamReader& r) { this->read(r); } CTweakGuiColors(athena::io::IStreamReader& r) { this->read(r); }

2
DataSpec/DNAMP1/Tweaks/CTweakPlayerControl.hpp
View File

@ -9,7 +9,7 @@ namespace DataSpec::DNAMP1
struct CTweakPlayerControl final : ITweakPlayerControl struct CTweakPlayerControl final : ITweakPlayerControl
{ {
AT_DECL_DNA_YAML AT_DECL_DNA_YAML
Vector<atUint32, DNA_COUNT(67)> m_mappings; Vector<atUint32, AT_DNA_COUNT(67)> m_mappings;
atUint32 GetMapping(atUint32 command) const {return m_mappings[command];} atUint32 GetMapping(atUint32 command) const {return m_mappings[command];}
CTweakPlayerControl() = default; CTweakPlayerControl() = default;
CTweakPlayerControl(athena::io::IStreamReader& reader) {this->read(reader);} CTweakPlayerControl(athena::io::IStreamReader& reader) {this->read(reader);}

6
DataSpec/DNAMP1/Tweaks/CTweakTargeting.hpp
View File

@ -62,11 +62,11 @@ struct CTweakTargeting final : public ITweakTargeting
{ {
AT_DECL_DNA AT_DECL_DNA
Value<atUint32> count; Value<atUint32> count;
Vector<float, DNA_COUNT(count)> floats; Vector<float, AT_DNA_COUNT(count)> floats;
}; };
Vector<UnkVec, DNA_COUNT(xf8_outerBeamSquareAngleCount)> xf8_outerBeamSquareAngles; Vector<UnkVec, AT_DNA_COUNT(xf8_outerBeamSquareAngleCount)> xf8_outerBeamSquareAngles;
Value<atUint32> x108_chargeGaugeAngleCount; Value<atUint32> x108_chargeGaugeAngleCount;
Vector<float, DNA_COUNT(x108_chargeGaugeAngleCount)> x108_chargeGaugeAngles; Vector<float, AT_DNA_COUNT(x108_chargeGaugeAngleCount)> x108_chargeGaugeAngles;
Value<float> x118_chargeGaugeScale; Value<float> x118_chargeGaugeScale;
DNAColor x11c_chargeGaugeNonFullColor; DNAColor x11c_chargeGaugeNonFullColor;
Value<atUint32> x120_chargeTickCount; Value<atUint32> x120_chargeTickCount;

12
DataSpec/DNAMP2/ANCS.hpp
View File

@ -77,7 +77,7 @@ struct ANCS : BigDNA
Value<atUint32> unk2; Value<atUint32> unk2;
Value<atUint32> unk3; Value<atUint32> unk3;
}; };
Vector<EffectComponent, DNA_COUNT(compCount)> comps; Vector<EffectComponent, AT_DNA_COUNT(compCount)> comps;
}; };
std::vector<Effect> effects; std::vector<Effect> effects;
@ -97,7 +97,7 @@ struct ANCS : BigDNA
}; };
std::vector<Extents> extents; std::vector<Extents> extents;
}; };
Vector<CharacterInfo, DNA_COUNT(characterCount)> characters; Vector<CharacterInfo, AT_DNA_COUNT(characterCount)> characters;
} characterSet; } characterSet;
struct AnimationSet : BigDNA struct AnimationSet : BigDNA
@ -145,7 +145,7 @@ struct ANCS : BigDNA
Value<atUint8> flag; Value<atUint8> flag;
}; };
Value<atUint32> loopEventCount; Value<atUint32> loopEventCount;
Vector<LoopEvent, DNA_COUNT(loopEventCount)> loopEvents; Vector<LoopEvent, AT_DNA_COUNT(loopEventCount)> loopEvents;
struct UEVTEvent : EventBase struct UEVTEvent : EventBase
{ {
@ -154,7 +154,7 @@ struct ANCS : BigDNA
String<-1> boneName; String<-1> boneName;
}; };
Value<atUint32> uevtEventCount; Value<atUint32> uevtEventCount;
Vector<UEVTEvent, DNA_COUNT(uevtEventCount)> uevtEvents; Vector<UEVTEvent, AT_DNA_COUNT(uevtEventCount)> uevtEvents;
struct EffectEvent : EventBase struct EffectEvent : EventBase
{ {
@ -167,7 +167,7 @@ struct ANCS : BigDNA
Value<atUint32> parentMode; Value<atUint32> parentMode;
}; };
Value<atUint32> effectEventCount; Value<atUint32> effectEventCount;
Vector<EffectEvent, DNA_COUNT(effectEventCount)> effectEvents; Vector<EffectEvent, AT_DNA_COUNT(effectEventCount)> effectEvents;
struct SFXEvent : EventBase struct SFXEvent : EventBase
{ {
@ -181,7 +181,7 @@ struct ANCS : BigDNA
Value<float> sfxUnk4; Value<float> sfxUnk4;
}; };
Value<atUint32> sfxEventCount; Value<atUint32> sfxEventCount;
Vector<SFXEvent, DNA_COUNT(sfxEventCount)> sfxEvents; Vector<SFXEvent, AT_DNA_COUNT(sfxEventCount)> sfxEvents;
}; };
std::vector<EVNT> evnts; std::vector<EVNT> evnts;
} animationSet; } animationSet;

8
DataSpec/DNAMP2/CINF.hpp
View File

@ -20,12 +20,12 @@ struct CINF : BigDNA
Value<atVec4f> q1; Value<atVec4f> q1;
Value<atVec4f> q2; Value<atVec4f> q2;
Value<atUint32> linkedCount; Value<atUint32> linkedCount;
Vector<atUint32, DNA_COUNT(linkedCount)> linked; Vector<atUint32, AT_DNA_COUNT(linkedCount)> linked;
}; };
Vector<Bone, DNA_COUNT(boneCount)> bones; Vector<Bone, AT_DNA_COUNT(boneCount)> bones;
Value<atUint32> boneIdCount; Value<atUint32> boneIdCount;
Vector<atUint32, DNA_COUNT(boneIdCount)> boneIds; Vector<atUint32, AT_DNA_COUNT(boneIdCount)> boneIds;
Value<atUint32> nameCount; Value<atUint32> nameCount;
struct Name : BigDNA struct Name : BigDNA
@ -34,7 +34,7 @@ struct CINF : BigDNA
String<-1> name; String<-1> name;
Value<atUint32> boneId; Value<atUint32> boneId;
}; };
Vector<Name, DNA_COUNT(nameCount)> names; Vector<Name, AT_DNA_COUNT(nameCount)> names;
atUint32 getInternalBoneIdxFromId(atUint32 id) const; atUint32 getInternalBoneIdxFromId(atUint32 id) const;
atUint32 getBoneIdxFromId(atUint32 id) const; atUint32 getBoneIdxFromId(atUint32 id) const;

20
DataSpec/DNAMP2/CMDLMaterials.hpp
View File

@ -25,7 +25,7 @@ struct MaterialSet : BigDNA
const Flags& getFlags() const {return flags;} const Flags& getFlags() const {return flags;}
Value<atUint32> textureCount; Value<atUint32> textureCount;
Vector<atUint32, DNA_COUNT(textureCount)> textureIdxs; Vector<atUint32, AT_DNA_COUNT(textureCount)> textureIdxs;
using VAFlags = DNAMP1::MaterialSet::Material::VAFlags; using VAFlags = DNAMP1::MaterialSet::Material::VAFlags;
DNAMP1::MaterialSet::Material::VAFlags vaFlags; DNAMP1::MaterialSet::Material::VAFlags vaFlags;
const VAFlags& getVAFlags() const {return vaFlags;} const VAFlags& getVAFlags() const {return vaFlags;}
@ -33,29 +33,29 @@ struct MaterialSet : BigDNA
Value<atUint32> unk1; /* MP2 only */ Value<atUint32> unk1; /* MP2 only */
Value<atUint32> groupIdx; Value<atUint32> groupIdx;
Vector<atUint32, DNA_COUNT(flags.konstValuesEnabled())> konstCount; Vector<atUint32, AT_DNA_COUNT(flags.konstValuesEnabled())> konstCount;
Vector<GX::Color, DNA_COUNT(flags.konstValuesEnabled() ? konstCount[0] : 0)> konstColors; Vector<GX::Color, AT_DNA_COUNT(flags.konstValuesEnabled() ? konstCount[0] : 0)> konstColors;
using BlendFactor = GX::BlendFactor; using BlendFactor = GX::BlendFactor;
Value<BlendFactor> blendDstFac; Value<BlendFactor> blendDstFac;
Value<BlendFactor> blendSrcFac; Value<BlendFactor> blendSrcFac;
Vector<atUint32, DNA_COUNT(flags.samusReflectionIndirectTexture())> indTexSlot; Vector<atUint32, AT_DNA_COUNT(flags.samusReflectionIndirectTexture())> indTexSlot;
Value<atUint32> colorChannelCount; Value<atUint32> colorChannelCount;
Vector<DNAMP1::MaterialSet::Material::ColorChannel, DNA_COUNT(colorChannelCount)> colorChannels; Vector<DNAMP1::MaterialSet::Material::ColorChannel, AT_DNA_COUNT(colorChannelCount)> colorChannels;
Value<atUint32> tevStageCount; Value<atUint32> tevStageCount;
Vector<DNAMP1::MaterialSet::Material::TEVStage, DNA_COUNT(tevStageCount)> tevStages; Vector<DNAMP1::MaterialSet::Material::TEVStage, AT_DNA_COUNT(tevStageCount)> tevStages;
Vector<DNAMP1::MaterialSet::Material::TEVStageTexInfo, DNA_COUNT(tevStageCount)> tevStageTexInfo; Vector<DNAMP1::MaterialSet::Material::TEVStageTexInfo, AT_DNA_COUNT(tevStageCount)> tevStageTexInfo;
Value<atUint32> tcgCount; Value<atUint32> tcgCount;
Vector<DNAMP1::MaterialSet::Material::TexCoordGen, DNA_COUNT(tcgCount)> tcgs; Vector<DNAMP1::MaterialSet::Material::TexCoordGen, AT_DNA_COUNT(tcgCount)> tcgs;
Value<atUint32> uvAnimsSize; Value<atUint32> uvAnimsSize;
Value<atUint32> uvAnimsCount; Value<atUint32> uvAnimsCount;
Vector<DNAMP1::MaterialSet::Material::UVAnimation, DNA_COUNT(uvAnimsCount)> uvAnims; Vector<DNAMP1::MaterialSet::Material::UVAnimation, AT_DNA_COUNT(uvAnimsCount)> uvAnims;
}; };
Vector<Material, DNA_COUNT(head.materialCount)> materials; Vector<Material, AT_DNA_COUNT(head.materialCount)> materials;
static void RegisterMaterialProps(hecl::blender::PyOutStream& out) static void RegisterMaterialProps(hecl::blender::PyOutStream& out)
{ {

18
DataSpec/DNAMP2/DeafBabe.hpp
View File

@ -115,23 +115,23 @@ struct DeafBabe : BigDNA
Value<atVec3f> aabb[2]; Value<atVec3f> aabb[2];
Value<BspNodeType> rootNodeType; Value<BspNodeType> rootNodeType;
Value<atUint32> bspSize; Value<atUint32> bspSize;
Buffer<DNA_COUNT(bspSize)> bspTree; Buffer<AT_DNA_COUNT(bspSize)> bspTree;
Value<atUint32> materialCount; Value<atUint32> materialCount;
Vector<Material, DNA_COUNT(materialCount)> materials; Vector<Material, AT_DNA_COUNT(materialCount)> materials;
Value<atUint32> vertMatsCount; Value<atUint32> vertMatsCount;
Vector<atUint8, DNA_COUNT(vertMatsCount)> vertMats; Vector<atUint8, AT_DNA_COUNT(vertMatsCount)> vertMats;
Value<atUint32> edgeMatsCount; Value<atUint32> edgeMatsCount;
Vector<atUint8, DNA_COUNT(edgeMatsCount)> edgeMats; Vector<atUint8, AT_DNA_COUNT(edgeMatsCount)> edgeMats;
Value<atUint32> triMatsCount; Value<atUint32> triMatsCount;
Vector<atUint8, DNA_COUNT(triMatsCount)> triMats; Vector<atUint8, AT_DNA_COUNT(triMatsCount)> triMats;
Value<atUint32> edgeVertsCount; Value<atUint32> edgeVertsCount;
Vector<Edge, DNA_COUNT(edgeVertsCount)> edgeVertConnections; Vector<Edge, AT_DNA_COUNT(edgeVertsCount)> edgeVertConnections;
Value<atUint32> triangleEdgesCount; Value<atUint32> triangleEdgesCount;
Vector<Triangle, DNA_COUNT(triangleEdgesCount / 3)> triangleEdgeConnections; Vector<Triangle, AT_DNA_COUNT(triangleEdgesCount / 3)> triangleEdgeConnections;
Value<atUint32> noClimbEdgeCount; Value<atUint32> noClimbEdgeCount;
Vector<atInt16, DNA_COUNT(noClimbEdgeCount)> noClimbEdges; Vector<atInt16, AT_DNA_COUNT(noClimbEdgeCount)> noClimbEdges;
Value<atUint32> vertCount; Value<atUint32> vertCount;
Vector<atVec3f, DNA_COUNT(vertCount)> verts; Vector<atVec3f, AT_DNA_COUNT(vertCount)> verts;
static void BlenderInit(hecl::blender::PyOutStream& os); static void BlenderInit(hecl::blender::PyOutStream& os);
void insertNoClimb(hecl::blender::PyOutStream& os) const; void insertNoClimb(hecl::blender::PyOutStream& os) const;

24
DataSpec/DNAMP2/MLVL.hpp
View File

@ -30,7 +30,7 @@ struct MLVL : BigDNA
Value<atUint32> areaId; Value<atUint32> areaId;
Value<atUint32> attachedAreaCount; Value<atUint32> attachedAreaCount;
Vector<atUint16, DNA_COUNT(attachedAreaCount)> attachedAreas; Vector<atUint16, AT_DNA_COUNT(attachedAreaCount)> attachedAreas;
Value<atUint32> padding; Value<atUint32> padding;
Value<atUint32> depCount; Value<atUint32> depCount;
@ -40,10 +40,10 @@ struct MLVL : BigDNA
UniqueID32 id; UniqueID32 id;
DNAFourCC type; DNAFourCC type;
}; };
Vector<Dependency, DNA_COUNT(depCount)> deps; Vector<Dependency, AT_DNA_COUNT(depCount)> deps;
Value<atUint32> depLayerCount; Value<atUint32> depLayerCount;
Vector<atUint32, DNA_COUNT(depLayerCount)> depLayers; Vector<atUint32, AT_DNA_COUNT(depLayerCount)> depLayers;
Value<atUint32> dockCount; Value<atUint32> dockCount;
struct Dock : BigDNA struct Dock : BigDNA
@ -56,21 +56,21 @@ struct MLVL : BigDNA
Value<atUint32> areaIdx; Value<atUint32> areaIdx;
Value<atUint32> dockIdx; Value<atUint32> dockIdx;
}; };
Vector<Endpoint, DNA_COUNT(endpointCount)> endpoints; Vector<Endpoint, AT_DNA_COUNT(endpointCount)> endpoints;
Value<atUint32> planeVertCount; Value<atUint32> planeVertCount;
Vector<atVec3f, DNA_COUNT(planeVertCount)> planeVerts; Vector<atVec3f, AT_DNA_COUNT(planeVertCount)> planeVerts;
}; };
Vector<Dock, DNA_COUNT(dockCount)> docks; Vector<Dock, AT_DNA_COUNT(dockCount)> docks;
Value<atUint32> relCount; Value<atUint32> relCount;
Vector<String<-1>, DNA_COUNT(relCount)> relFilenames; Vector<String<-1>, AT_DNA_COUNT(relCount)> relFilenames;
Value<atUint32> relOffsetCount; Value<atUint32> relOffsetCount;
Vector<atUint32, DNA_COUNT(relOffsetCount)> relOffsets; Vector<atUint32, AT_DNA_COUNT(relOffsetCount)> relOffsets;
String<-1> internalAreaName; String<-1> internalAreaName;
}; };
Vector<Area, DNA_COUNT(areaCount)> areas; Vector<Area, AT_DNA_COUNT(areaCount)> areas;
UniqueID32 worldMap; UniqueID32 worldMap;
Value<atUint8> unknown2; Value<atUint8> unknown2;
@ -83,13 +83,13 @@ struct MLVL : BigDNA
Value<atUint32> layerCount; Value<atUint32> layerCount;
Value<atUint64> flags; Value<atUint64> flags;
}; };
Vector<LayerFlags, DNA_COUNT(layerFlagCount)> layerFlags; Vector<LayerFlags, AT_DNA_COUNT(layerFlagCount)> layerFlags;
Value<atUint32> layerNameCount; Value<atUint32> layerNameCount;
Vector<String<-1>, DNA_COUNT(layerNameCount)> layerNames; Vector<String<-1>, AT_DNA_COUNT(layerNameCount)> layerNames;
Value<atUint32> layerNameOffsetCount; Value<atUint32> layerNameOffsetCount;
Vector<atUint32, DNA_COUNT(layerNameOffsetCount)> layerNameOffsets; Vector<atUint32, AT_DNA_COUNT(layerNameOffsetCount)> layerNameOffsets;
static bool Extract(const SpecBase& dataSpec, static bool Extract(const SpecBase& dataSpec,

2
DataSpec/DNAMP2/MREA.hpp
View File

@ -74,7 +74,7 @@ struct MREA
Value<atUint32> egmcSecIdx; Value<atUint32> egmcSecIdx;
Value<atUint32> compressedBlockCount; Value<atUint32> compressedBlockCount;
Seek<12, athena::Current> align1; Seek<12, athena::Current> align1;
Vector<atUint32, DNA_COUNT(secCount)> secSizes; Vector<atUint32, AT_DNA_COUNT(secCount)> secSizes;
}; };
struct MeshHeader : BigDNA struct MeshHeader : BigDNA

14
DataSpec/DNAMP2/PTLA.hpp
View File

@ -23,12 +23,12 @@ struct PTLA : BigDNA
Value<atUint16> unknown5; Value<atUint16> unknown5;
Value<atUint16> unknown6; Value<atUint16> unknown6;
}; };
Vector<Entry, DNA_COUNT(count)> entries; Vector<Entry, AT_DNA_COUNT(count)> entries;
Value<atUint16> unknown1; Value<atUint16> unknown1;
Value<atVec3f> unknown2[2]; Value<atVec3f> unknown2[2];
}; };
Value<atUint32> count1; Value<atUint32> count1;
Vector<UnknownStruct1, DNA_COUNT(count1)> entries1; Vector<UnknownStruct1, AT_DNA_COUNT(count1)> entries1;
struct UnknownStruct2 : BigDNA struct UnknownStruct2 : BigDNA
{ {
@ -42,17 +42,17 @@ struct PTLA : BigDNA
Value<float> unknown3; Value<float> unknown3;
Value<float> unknown4; Value<float> unknown4;
}; };
Vector<Entry, DNA_COUNT(count)> entries; Vector<Entry, AT_DNA_COUNT(count)> entries;
Value<atUint16> unknown; Value<atUint16> unknown;
}; };
Value<atUint32> count2; Value<atUint32> count2;
Vector<UnknownStruct2, DNA_COUNT(count2)> entries2; Vector<UnknownStruct2, AT_DNA_COUNT(count2)> entries2;
Value<atUint32> shortCount1; Value<atUint32> shortCount1;
Vector<atUint16, DNA_COUNT(shortCount1)> shorts1; Vector<atUint16, AT_DNA_COUNT(shortCount1)> shorts1;
Value<atUint32> shortCount2; Value<atUint32> shortCount2;
Vector<atUint16, DNA_COUNT(shortCount2)> shorts2; Vector<atUint16, AT_DNA_COUNT(shortCount2)> shorts2;
struct UnknownStruct3 : BigDNA struct UnknownStruct3 : BigDNA
{ {
@ -63,7 +63,7 @@ struct PTLA : BigDNA
Value<atUint16> unknown4; Value<atUint16> unknown4;
}; };
Value<atUint32> count3; Value<atUint32> count3;
Vector<UnknownStruct3, DNA_COUNT(count3)> entries3; Vector<UnknownStruct3, AT_DNA_COUNT(count3)> entries3;
}; };
} }
#endif // __DNAMP2_PTLA_HPP__ #endif // __DNAMP2_PTLA_HPP__

6
DataSpec/DNAMP2/SAVW.hpp
View File

@ -10,11 +10,11 @@ struct SAVW : DNAMP1::SAVW
{ {
AT_DECL_DNA_YAML AT_DECL_DNA_YAML
Value<atUint32> systemVarCount; Value<atUint32> systemVarCount;
Vector<SAVWCommon::EnvironmentVariable, DNA_COUNT(systemVarCount)> systemVars; Vector<SAVWCommon::EnvironmentVariable, AT_DNA_COUNT(systemVarCount)> systemVars;
Value<atUint32> gameVarCount; Value<atUint32> gameVarCount;
Vector<SAVWCommon::EnvironmentVariable, DNA_COUNT(gameVarCount)> gameVars; Vector<SAVWCommon::EnvironmentVariable, AT_DNA_COUNT(gameVarCount)> gameVars;
Value<atUint32> gameObjectCount; Value<atUint32> gameObjectCount;
Vector<atUint32, DNA_COUNT(gameObjectCount)> gameObjects; Vector<atUint32, AT_DNA_COUNT(gameObjectCount)> gameObjects;
}; };
} }

14
DataSpec/DNAMP3/CAUD.hpp
View File

@ -14,7 +14,7 @@ struct CAUD : BigDNA
Value<atUint32> version; Value<atUint32> version;
String<-1> name; String<-1> name;
Value<atUint32> nameCount; Value<atUint32> nameCount;
Vector<String<-1>, DNA_COUNT(nameCount)> names; Vector<String<-1>, AT_DNA_COUNT(nameCount)> names;
Value<float> unknown1; Value<float> unknown1;
Value<atUint32> unknown2; Value<atUint32> unknown2;
Value<float> unknown3; Value<float> unknown3;
@ -49,12 +49,12 @@ struct CAUD : BigDNA
Value<atUint8> unknown4; Value<atUint8> unknown4;
}; };
Value<atUint32> unknown15; Value<atUint32> unknown15;
Vector<UnknownStruct1, DNA_COUNT(unknown15)> unknown16; Vector<UnknownStruct1, AT_DNA_COUNT(unknown15)> unknown16;
struct UnknownStruct2 : BigDNA struct UnknownStruct2 : BigDNA
{ {
AT_DECL_DNA_YAML AT_DECL_DNA_YAML
Value<atUint8> unknown1; Value<atUint8> unknown1;
Vector<atUint8, DNA_COUNT(unknown1)> unknown2; Vector<atUint8, AT_DNA_COUNT(unknown1)> unknown2;
Value<float> unknown3; Value<float> unknown3;
Value<float> unknown4; Value<float> unknown4;
Value<atUint16> unknown5; Value<atUint16> unknown5;
@ -65,7 +65,7 @@ struct CAUD : BigDNA
Value<atInt32> unknown2; Value<atInt32> unknown2;
}; };
Value<atUint16> unknown6; Value<atUint16> unknown6;
Vector<UnknownPair, DNA_COUNT(unknown6)> unknown7; Vector<UnknownPair, AT_DNA_COUNT(unknown6)> unknown7;
struct UnknownQuad: BigDNA struct UnknownQuad: BigDNA
{ {
AT_DECL_EXPLICIT_DNA_YAML AT_DECL_EXPLICIT_DNA_YAML
@ -77,7 +77,7 @@ struct CAUD : BigDNA
}; };
Value<atUint16> unknown8; Value<atUint16> unknown8;
Vector<UnknownQuad, DNA_COUNT(unknown8)> unknown9; Vector<UnknownQuad, AT_DNA_COUNT(unknown8)> unknown9;
}; };
UnknownStruct2 unknown17[4]; UnknownStruct2 unknown17[4];
Value<atUint16> unknown18; Value<atUint16> unknown18;
@ -99,13 +99,13 @@ struct CAUD : BigDNA
Value<atUint8> unknown3; Value<atUint8> unknown3;
Value<atUint8> unknown4; Value<atUint8> unknown4;
}; };
Vector<UnknownStruct3, DNA_COUNT(unknown27)> unknown29; Vector<UnknownStruct3, AT_DNA_COUNT(unknown27)> unknown29;
Value<float> unknown30; Value<float> unknown30;
Value<float> unknown31; Value<float> unknown31;
}; };
Value<atUint32> infoCount; Value<atUint32> infoCount;
Vector<CSMPInfo, DNA_COUNT(infoCount)> info; Vector<CSMPInfo, AT_DNA_COUNT(infoCount)> info;
static bool Extract(PAKEntryReadStream& rs, const hecl::ProjectPath& outPath) static bool Extract(PAKEntryReadStream& rs, const hecl::ProjectPath& outPath)
{ {

34
DataSpec/DNAMP3/CHAR.hpp
View File

@ -36,7 +36,7 @@ struct CHAR : BigDNA
UniqueID64 cmdl; UniqueID64 cmdl;
UniqueID64 cskr; UniqueID64 cskr;
}; };
Vector<Overlay, DNA_COUNT(overlayCount)> overlays; Vector<Overlay, AT_DNA_COUNT(overlayCount)> overlays;
UniqueID64 cinf; UniqueID64 cinf;
UniqueID64 sand; UniqueID64 sand;
@ -47,17 +47,17 @@ struct CHAR : BigDNA
{ {
AT_DECL_DNA_YAML AT_DECL_DNA_YAML
Value<atUint32> partCount; Value<atUint32> partCount;
Vector<UniqueID64, DNA_COUNT(partCount)> part; Vector<UniqueID64, AT_DNA_COUNT(partCount)> part;
Value<atUint32> swhcCount; Value<atUint32> swhcCount;
Vector<UniqueID64, DNA_COUNT(swhcCount)> swhc; Vector<UniqueID64, AT_DNA_COUNT(swhcCount)> swhc;
Value<atUint32> unkCount; Value<atUint32> unkCount;
Vector<UniqueID64, DNA_COUNT(unkCount)> unk; Vector<UniqueID64, AT_DNA_COUNT(unkCount)> unk;
Value<atUint32> elscCount; Value<atUint32> elscCount;
Vector<UniqueID64, DNA_COUNT(elscCount)> elsc; Vector<UniqueID64, AT_DNA_COUNT(elscCount)> elsc;
Value<atUint32> spscCount; Value<atUint32> spscCount;
Vector<UniqueID64, DNA_COUNT(spscCount)> spsc; Vector<UniqueID64, AT_DNA_COUNT(spscCount)> spsc;
Value<atUint32> unk2Count; Value<atUint32> unk2Count;
Vector<UniqueID64, DNA_COUNT(unk2Count)> unk2; Vector<UniqueID64, AT_DNA_COUNT(unk2Count)> unk2;
} partResData; } partResData;
} characterInfo; } characterInfo;
@ -103,7 +103,7 @@ struct CHAR : BigDNA
Value<atUint32> parentMode; Value<atUint32> parentMode;
}; };
Value<atUint32> effectCount; Value<atUint32> effectCount;
Vector<EffectEvent, DNA_COUNT(effectCount)> effectEvents; Vector<EffectEvent, AT_DNA_COUNT(effectCount)> effectEvents;
struct SFXEvent : EventBase struct SFXEvent : EventBase
{ {
@ -119,10 +119,10 @@ struct CHAR : BigDNA
Value<float> extraFloat; Value<float> extraFloat;
}; };
Value<atUint32> sfxCount; Value<atUint32> sfxCount;
Vector<SFXEvent, DNA_COUNT(sfxCount)> sfxEvents; Vector<SFXEvent, AT_DNA_COUNT(sfxCount)> sfxEvents;
}; };
Value<atUint32> evntCount; Value<atUint32> evntCount;
Vector<EVNT, DNA_COUNT(evntCount)> evnts; Vector<EVNT, AT_DNA_COUNT(evntCount)> evnts;
struct IMetaAnim : BigDNAVYaml struct IMetaAnim : BigDNAVYaml
{ {
@ -206,7 +206,7 @@ struct CHAR : BigDNA
MetaAnimFactory anim; MetaAnimFactory anim;
Value<atUint32> probability; Value<atUint32> probability;
}; };
Vector<Child, DNA_COUNT(animCount)> children; Vector<Child, AT_DNA_COUNT(animCount)> children;
void gatherPrimitives(std::map<atUint32, DNAANCS::AnimationResInfo<UniqueID64>>& out) void gatherPrimitives(std::map<atUint32, DNAANCS::AnimationResInfo<UniqueID64>>& out)
{ {
@ -220,7 +220,7 @@ struct CHAR : BigDNA
AT_DECL_DNA_YAML AT_DECL_DNA_YAML
AT_DECL_DNAV AT_DECL_DNAV
Value<atUint32> animCount; Value<atUint32> animCount;
Vector<MetaAnimFactory, DNA_COUNT(animCount)> children; Vector<MetaAnimFactory, AT_DNA_COUNT(animCount)> children;
void gatherPrimitives(std::map<atUint32, DNAANCS::AnimationResInfo<UniqueID64>>& out) void gatherPrimitives(std::map<atUint32, DNAANCS::AnimationResInfo<UniqueID64>>& out)
{ {
@ -236,7 +236,7 @@ struct CHAR : BigDNA
MetaAnimFactory metaAnim; MetaAnimFactory metaAnim;
}; };
Value<atUint32> animationCount; Value<atUint32> animationCount;
Vector<Animation, DNA_COUNT(animationCount)> animations; Vector<Animation, AT_DNA_COUNT(animationCount)> animations;
struct ActionAABB : BigDNA struct ActionAABB : BigDNA
{ {
@ -245,12 +245,12 @@ struct CHAR : BigDNA
Value<atVec3f> aabb[2]; Value<atVec3f> aabb[2];
}; };
Value<atUint32> animAABBCount; Value<atUint32> animAABBCount;
Vector<ActionAABB, DNA_COUNT(animAABBCount)> animAABBs; Vector<ActionAABB, AT_DNA_COUNT(animAABBCount)> animAABBs;
Value<atUint8> unkByte; Value<atUint8> unkByte;
Value<atUint32> additiveMapCount; Value<atUint32> additiveMapCount;
Vector<bool, DNA_COUNT(additiveMapCount)> additiveMap; Vector<bool, AT_DNA_COUNT(additiveMapCount)> additiveMap;
} animationInfo; } animationInfo;
@ -278,10 +278,10 @@ struct CHAR : BigDNA
String<-1> boneName; String<-1> boneName;
Value<float> unk14; Value<float> unk14;
}; };
Vector<Hitbox, DNA_COUNT(hitboxCount)> hitboxes; Vector<Hitbox, AT_DNA_COUNT(hitboxCount)> hitboxes;
}; };
Value<atUint32> hitboxSetCount; Value<atUint32> hitboxSetCount;
Vector<HitboxSet, DNA_COUNT(hitboxSetCount)> hitboxSets; Vector<HitboxSet, AT_DNA_COUNT(hitboxSetCount)> hitboxSets;
void getCharacterResInfo(std::vector<DNAANCS::CharacterResInfo<UniqueID64>>& out) const void getCharacterResInfo(std::vector<DNAANCS::CharacterResInfo<UniqueID64>>& out) const
{ {

4
DataSpec/DNAMP3/CMDLMaterials.hpp
View File

@ -112,7 +112,7 @@ struct MaterialSet : BigDNA
Value<atUint16> unk2; Value<atUint16> unk2;
DNAMP1::MaterialSet::Material::UVAnimation anim; DNAMP1::MaterialSet::Material::UVAnimation anim;
}; };
Vector<UVAnimation, DNA_COUNT(uvAnimSize != 0)> uvAnim; Vector<UVAnimation, AT_DNA_COUNT(uvAnimSize != 0)> uvAnim;
void constructNode(hecl::blender::PyOutStream& out, void constructNode(hecl::blender::PyOutStream& out,
const PAKRouter<PAKBridge>& pakRouter, const PAKRouter<PAKBridge>& pakRouter,
@ -177,7 +177,7 @@ struct MaterialSet : BigDNA
}; };
std::vector<SectionFactory> sections; std::vector<SectionFactory> sections;
}; };
Vector<Material, DNA_COUNT(materialCount)> materials; Vector<Material, AT_DNA_COUNT(materialCount)> materials;
static void RegisterMaterialProps(hecl::blender::PyOutStream& out); static void RegisterMaterialProps(hecl::blender::PyOutStream& out);
static void ConstructMaterial(hecl::blender::PyOutStream& out, static void ConstructMaterial(hecl::blender::PyOutStream& out,

12
DataSpec/DNAMP3/CSKR.hpp
View File

@ -20,18 +20,18 @@ struct CSKR : BigDNA
AT_DECL_DNA AT_DECL_DNA
Value<atInt16> mtxs[10]; Value<atInt16> mtxs[10];
}; };
Vector<MatrixBindings, DNA_COUNT(matrixCount / 10)> mtxBindings; Vector<MatrixBindings, AT_DNA_COUNT(matrixCount / 10)> mtxBindings;
Value<atUint32> unkCount1; Value<atUint32> unkCount1;
Vector<atUint8, DNA_COUNT(unkCount1)> unk1; Vector<atUint8, AT_DNA_COUNT(unkCount1)> unk1;
Value<atUint32> unkCount2; Value<atUint32> unkCount2;
Vector<atUint8, DNA_COUNT(unkCount2)> unk2; Vector<atUint8, AT_DNA_COUNT(unkCount2)> unk2;
Value<atUint32> unkCount3; Value<atUint32> unkCount3;
Vector<atUint8, DNA_COUNT(unkCount3)> unk3; Vector<atUint8, AT_DNA_COUNT(unkCount3)> unk3;
Value<atUint32> unkCount4; Value<atUint32> unkCount4;
Vector<atUint8, DNA_COUNT(unkCount4)> unk4; Vector<atUint8, AT_DNA_COUNT(unkCount4)> unk4;
Value<atUint32> unkCount5; Value<atUint32> unkCount5;
Vector<atUint8, DNA_COUNT(unkCount5)> unk5; Vector<atUint8, AT_DNA_COUNT(unkCount5)> unk5;
const atInt16* getMatrixBank(size_t idx) const const atInt16* getMatrixBank(size_t idx) const
{ {

4
DataSpec/DNAMP3/HINT.hpp
View File

@ -31,10 +31,10 @@ struct HINT : BigDNA
}; };
Value<atUint32> locationCount; Value<atUint32> locationCount;
Vector<Location, DNA_COUNT(locationCount)> locations; Vector<Location, AT_DNA_COUNT(locationCount)> locations;
}; };
Value<atUint32> hintCount; Value<atUint32> hintCount;
Vector<Hint, DNA_COUNT(hintCount)> hints; Vector<Hint, AT_DNA_COUNT(hintCount)> hints;
static bool Extract(PAKEntryReadStream& rs, const hecl::ProjectPath& outPath) static bool Extract(PAKEntryReadStream& rs, const hecl::ProjectPath& outPath)
{ {

18
DataSpec/DNAMP3/MLVL.hpp
View File

@ -29,7 +29,7 @@ struct MLVL : BigDNA
Value<atUint64> areaId; Value<atUint64> areaId;
Value<atUint32> attachedAreaCount; Value<atUint32> attachedAreaCount;
Vector<atUint16, DNA_COUNT(attachedAreaCount)> attachedAreas; Vector<atUint16, AT_DNA_COUNT(attachedAreaCount)> attachedAreas;
Value<atUint32> dockCount; Value<atUint32> dockCount;
struct Dock : BigDNA struct Dock : BigDNA
@ -42,16 +42,16 @@ struct MLVL : BigDNA
Value<atUint32> areaIdx; Value<atUint32> areaIdx;
Value<atUint32> dockIdx; Value<atUint32> dockIdx;
}; };
Vector<Endpoint, DNA_COUNT(endpointCount)> endpoints; Vector<Endpoint, AT_DNA_COUNT(endpointCount)> endpoints;
Value<atUint32> planeVertCount; Value<atUint32> planeVertCount;
Vector<atVec3f, DNA_COUNT(planeVertCount)> planeVerts; Vector<atVec3f, AT_DNA_COUNT(planeVertCount)> planeVerts;
}; };
Vector<Dock, DNA_COUNT(dockCount)> docks; Vector<Dock, AT_DNA_COUNT(dockCount)> docks;
String<-1> internalAreaName; String<-1> internalAreaName;
}; };
Vector<Area, DNA_COUNT(areaCount)> areas; Vector<Area, AT_DNA_COUNT(areaCount)> areas;
UniqueID64 worldMap; UniqueID64 worldMap;
Value<atUint8> unknown2; Value<atUint8> unknown2;
@ -64,10 +64,10 @@ struct MLVL : BigDNA
Value<atUint32> layerCount; Value<atUint32> layerCount;
Value<atUint64> flags; Value<atUint64> flags;
}; };
Vector<LayerFlags, DNA_COUNT(layerFlagCount)> layerFlags; Vector<LayerFlags, AT_DNA_COUNT(layerFlagCount)> layerFlags;
Value<atUint32> layerNameCount; Value<atUint32> layerNameCount;
Vector<String<-1>, DNA_COUNT(layerNameCount)> layerNames; Vector<String<-1>, AT_DNA_COUNT(layerNameCount)> layerNames;
Value<atUint32> layerIDCount; Value<atUint32> layerIDCount;
struct LayerID : BigDNA struct LayerID : BigDNA
@ -75,10 +75,10 @@ struct MLVL : BigDNA
AT_DECL_DNA_YAML AT_DECL_DNA_YAML
Value<atUint64> id[2]; Value<atUint64> id[2];
}; };
Vector<LayerID, DNA_COUNT(layerIDCount)> layerIDs; Vector<LayerID, AT_DNA_COUNT(layerIDCount)> layerIDs;
Value<atUint32> layerNameOffsetCount; Value<atUint32> layerNameOffsetCount;
Vector<atUint32, DNA_COUNT(layerNameOffsetCount)> layerNameOffsets; Vector<atUint32, AT_DNA_COUNT(layerNameOffsetCount)> layerNameOffsets;
static bool Extract(const SpecBase& dataSpec, static bool Extract(const SpecBase& dataSpec,

6
DataSpec/DNAMP3/MREA.hpp
View File

@ -35,7 +35,7 @@ struct MREA
Value<atUint32> compressedBlockCount; Value<atUint32> compressedBlockCount;
Value<atUint32> secIndexCount; Value<atUint32> secIndexCount;
Seek<20, athena::Current> align1; Seek<20, athena::Current> align1;
Vector<atUint32, DNA_COUNT(secCount)> secSizes; Vector<atUint32, AT_DNA_COUNT(secCount)> secSizes;
atUint32 getSecOffset(atUint32 idx) const atUint32 getSecOffset(atUint32 idx) const
{ {
@ -70,9 +70,9 @@ struct MREA
UniqueID64 id; UniqueID64 id;
DNAFourCC type; DNAFourCC type;
}; };
Vector<Dependency, DNA_COUNT(depCount)> deps; Vector<Dependency, AT_DNA_COUNT(depCount)> deps;
Value<atUint32> depLayerCount; Value<atUint32> depLayerCount;
Vector<atUint32, DNA_COUNT(depLayerCount)> depLayers; Vector<atUint32, AT_DNA_COUNT(depLayerCount)> depLayers;
}; };
struct BabeDeadLight : BigDNA struct BabeDeadLight : BigDNA

14
DataSpec/DNAMP3/SAVW.hpp
View File

@ -30,19 +30,19 @@ struct SAVW : BigDNA
AT_DECL_DNA_YAML AT_DECL_DNA_YAML
SAVWCommon::Header header; SAVWCommon::Header header;
Value<atUint32> skippableCutsceneCount; Value<atUint32> skippableCutsceneCount;
Vector<SavedState, DNA_COUNT(skippableCutsceneCount)> skippableCutscenes; Vector<SavedState, AT_DNA_COUNT(skippableCutsceneCount)> skippableCutscenes;
Value<atUint32> relayCount; Value<atUint32> relayCount;
Vector<SavedState, DNA_COUNT(relayCount)> relays; Vector<SavedState, AT_DNA_COUNT(relayCount)> relays;
Value<atUint32> doorCount; Value<atUint32> doorCount;
Vector<SavedState, DNA_COUNT(doorCount)> doors; Vector<SavedState, AT_DNA_COUNT(doorCount)> doors;
Value<atUint32> scanCount; Value<atUint32> scanCount;
Vector<Scan, DNA_COUNT(scanCount)> scans; Vector<Scan, AT_DNA_COUNT(scanCount)> scans;
Value<atUint32> systemVarCount; Value<atUint32> systemVarCount;
Vector<SAVWCommon::EnvironmentVariable, DNA_COUNT(systemVarCount)> systemVars; Vector<SAVWCommon::EnvironmentVariable, AT_DNA_COUNT(systemVarCount)> systemVars;
Value<atUint32> gameVarCount; Value<atUint32> gameVarCount;
Vector<SAVWCommon::EnvironmentVariable, DNA_COUNT(gameVarCount)> gameVars; Vector<SAVWCommon::EnvironmentVariable, AT_DNA_COUNT(gameVarCount)> gameVars;
Value<atUint32> gameObjectCount; Value<atUint32> gameObjectCount;
Vector<SavedState, DNA_COUNT(gameObjectCount)> gameObjects; Vector<SavedState, AT_DNA_COUNT(gameObjectCount)> gameObjects;
}; };
} }

17
DataSpec/SpecBase.cpp
View File

@ -272,6 +272,12 @@ void SpecBase::doCook(const hecl::ProjectPath& path, const hecl::ProjectPath& co
cookColMesh(cookedPath, path, ds, fast, btok, progress); cookColMesh(cookedPath, path, ds, fast, btok, progress);
break; break;
} }
case hecl::blender::BlendType::PathMesh:
{
hecl::blender::DataStream ds = conn.beginData();
cookPathMesh(cookedPath, path, ds, fast, btok, progress);
break;
}
case hecl::blender::BlendType::Actor: case hecl::blender::BlendType::Actor:
{ {
hecl::blender::DataStream ds = conn.beginData(); hecl::blender::DataStream ds = conn.beginData();
@ -1106,17 +1112,6 @@ bool SpecBase::addFileToIndex(const hecl::ProjectPath& path,
pathTag = {SBIG('AGSC'), asGlob.hash().val32()}; pathTag = {SBIG('AGSC'), asGlob.hash().val32()};
useGlob = true; useGlob = true;
} }
else if (pathTag.type == SBIG('MREA'))
{
hecl::ProjectPath subPath = path.ensureAuxInfo(_S("PATH"));
urde::SObjectTag pathTag = buildTagFromPath(subPath, m_backgroundBlender);
m_tagToPath[pathTag] = subPath;
m_pathToTag[subPath.hash()] = pathTag;
WriteTag(cacheWriter, pathTag, subPath);
#if DUMP_CACHE_FILL
DumpCacheAdd(pathTag, subPath);
#endif
}
/* Cache in-memory */ /* Cache in-memory */
const hecl::ProjectPath& usePath = useGlob ? asGlob : path; const hecl::ProjectPath& usePath = useGlob ? asGlob : path;

4
DataSpec/SpecBase.hpp
View File

@ -74,6 +74,7 @@ struct SpecBase : hecl::Database::IDataSpec
using BlendStream = hecl::blender::DataStream; using BlendStream = hecl::blender::DataStream;
using Mesh = hecl::blender::Mesh; using Mesh = hecl::blender::Mesh;
using ColMesh = hecl::blender::ColMesh; using ColMesh = hecl::blender::ColMesh;
using PathMesh = hecl::blender::PathMesh;
using Light = hecl::blender::Light; using Light = hecl::blender::Light;
using Actor = hecl::blender::Actor; using Actor = hecl::blender::Actor;
@ -83,6 +84,9 @@ struct SpecBase : hecl::Database::IDataSpec
virtual void cookColMesh(const hecl::ProjectPath& out, const hecl::ProjectPath& in, virtual void cookColMesh(const hecl::ProjectPath& out, const hecl::ProjectPath& in,
BlendStream& ds, bool fast, hecl::blender::Token& btok, BlendStream& ds, bool fast, hecl::blender::Token& btok,
FCookProgress progress)=0; FCookProgress progress)=0;
virtual void cookPathMesh(const hecl::ProjectPath& out, const hecl::ProjectPath& in,
BlendStream& ds, bool fast, hecl::blender::Token& btok,
FCookProgress progress)=0;
virtual void cookActor(const hecl::ProjectPath& out, const hecl::ProjectPath& in, virtual void cookActor(const hecl::ProjectPath& out, const hecl::ProjectPath& in,
BlendStream& ds, bool fast, hecl::blender::Token& btok, BlendStream& ds, bool fast, hecl::blender::Token& btok,
FCookProgress progress)=0; FCookProgress progress)=0;

22
DataSpec/SpecMP1.cpp
View File

@ -16,6 +16,7 @@
#include "DNAMP1/AGSC.hpp" #include "DNAMP1/AGSC.hpp"
#include "DNAMP1/CSNG.hpp" #include "DNAMP1/CSNG.hpp"
#include "DNAMP1/MAPA.hpp" #include "DNAMP1/MAPA.hpp"
#include "DNAMP1/PATH.hpp"
#include "DNACommon/ATBL.hpp" #include "DNACommon/ATBL.hpp"
#include "DNACommon/FONT.hpp" #include "DNACommon/FONT.hpp"
#include "DNACommon/PART.hpp" #include "DNACommon/PART.hpp"
@ -571,6 +572,8 @@ struct SpecMP1 : SpecBase
return {SBIG('CMDL'), path.hash().val32()}; return {SBIG('CMDL'), path.hash().val32()};
case hecl::blender::BlendType::ColMesh: case hecl::blender::BlendType::ColMesh:
return {SBIG('DCLN'), path.hash().val32()}; return {SBIG('DCLN'), path.hash().val32()};
case hecl::blender::BlendType::PathMesh:
return {SBIG('PATH'), path.hash().val32()};
case hecl::blender::BlendType::Actor: case hecl::blender::BlendType::Actor:
if (path.getAuxInfo().size()) if (path.getAuxInfo().size())
{ {
@ -583,11 +586,7 @@ struct SpecMP1 : SpecBase
} }
return {SBIG('ANCS'), path.getWithExtension(_S(".*"), true).hash().val32()}; return {SBIG('ANCS'), path.getWithExtension(_S(".*"), true).hash().val32()};
case hecl::blender::BlendType::Area: case hecl::blender::BlendType::Area:
{
if (hecl::StringUtils::EndsWith(path.getAuxInfo(), _S("PATH")))
return {SBIG('PATH'), path.hash().val32()};
return {SBIG('MREA'), path.hash().val32()}; return {SBIG('MREA'), path.hash().val32()};
}
case hecl::blender::BlendType::World: case hecl::blender::BlendType::World:
{ {
if (path.getAuxInfo().size()) if (path.getAuxInfo().size())
@ -764,6 +763,14 @@ struct SpecMP1 : SpecBase
DNAMP1::DCLN::Cook(out, in, mesh); DNAMP1::DCLN::Cook(out, in, mesh);
} }
void cookPathMesh(const hecl::ProjectPath& out, const hecl::ProjectPath& in, BlendStream& ds, bool fast,
hecl::blender::Token& btok, FCookProgress progress)
{
PathMesh mesh = ds.compilePathMesh();
ds.close();
DNAMP1::PATH::Cook(out, in, mesh);
}
void cookActor(const hecl::ProjectPath& out, const hecl::ProjectPath& in, BlendStream& ds, bool fast, void cookActor(const hecl::ProjectPath& out, const hecl::ProjectPath& in, BlendStream& ds, bool fast,
hecl::blender::Token& btok, FCookProgress progress) hecl::blender::Token& btok, FCookProgress progress)
{ {
@ -800,12 +807,6 @@ struct SpecMP1 : SpecBase
void cookArea(const hecl::ProjectPath& out, const hecl::ProjectPath& in, BlendStream& ds, bool fast, void cookArea(const hecl::ProjectPath& out, const hecl::ProjectPath& in, BlendStream& ds, bool fast,
hecl::blender::Token& btok, FCookProgress progress) hecl::blender::Token& btok, FCookProgress progress)
{
if (hecl::StringUtils::EndsWith(in.getAuxInfo(), _S("PATH")))
{
DNAMP1::MREA::CookPath(out, in);
}
else
{ {
std::vector<std::string> meshes = ds.getMeshList(); std::vector<std::string> meshes = ds.getMeshList();
std::vector<Mesh> meshCompiles; std::vector<Mesh> meshCompiles;
@ -839,7 +840,6 @@ struct SpecMP1 : SpecBase
else else
DNAMP1::MREA::Cook(out, in, meshCompiles, *colMesh, lights); DNAMP1::MREA::Cook(out, in, meshCompiles, *colMesh, lights);
} }
}
void cookWorld(const hecl::ProjectPath& out, const hecl::ProjectPath& in, BlendStream& ds, bool fast, void cookWorld(const hecl::ProjectPath& out, const hecl::ProjectPath& in, BlendStream& ds, bool fast,
hecl::blender::Token& btok, FCookProgress progress) hecl::blender::Token& btok, FCookProgress progress)

6
DataSpec/SpecMP2.cpp
View File

@ -339,6 +339,12 @@ struct SpecMP2 : SpecBase
{ {
} }
void cookPathMesh(const hecl::ProjectPath& out, const hecl::ProjectPath& in,
BlendStream& ds, bool fast, hecl::blender::Token& btok,
FCookProgress progress)
{
}
void cookActor(const hecl::ProjectPath& out, const hecl::ProjectPath& in, void cookActor(const hecl::ProjectPath& out, const hecl::ProjectPath& in,
BlendStream& ds, bool fast, hecl::blender::Token& btok, BlendStream& ds, bool fast, hecl::blender::Token& btok,
FCookProgress progress) FCookProgress progress)

6
DataSpec/SpecMP3.cpp
View File

@ -533,6 +533,12 @@ struct SpecMP3 : SpecBase
{ {
} }
void cookPathMesh(const hecl::ProjectPath& out, const hecl::ProjectPath& in,
BlendStream& ds, bool fast, hecl::blender::Token& btok,
FCookProgress progress)
{
}
void cookActor(const hecl::ProjectPath& out, const hecl::ProjectPath& in, void cookActor(const hecl::ProjectPath& out, const hecl::ProjectPath& in,
BlendStream& ds, bool fast, hecl::blender::Token& btok, BlendStream& ds, bool fast, hecl::blender::Token& btok,
FCookProgress progress) FCookProgress progress)

2
hecl

@ -1 +1 @@
Subproject commit 8e2c8ed29174aa184d23edd24925062920b25e2b Subproject commit b014d6114bcd34d473bcf2573654c43fee6347c0