CCollisionTree.bt

#ifndef _CAABOXCOLLISIONTREE
#define _CAABOXCOLLISIONTREE

#include "CAABox.bt"
#include "COBBox.bt"
#include "CTransform4f.bt"

typedef enum {
  kCOL_AABox = 0,
  kCOL_OBBox = 1,
} CollisionPrimitiveType;

struct CAABoxTreeNode {
  CAABox bounds;
  uint start;
  uint end;
  uchar unk3;
  uchar unk4;
  uchar unk5;
  uchar unk6;
};

struct COBBoxTreeNode {
  COBBox bounds;
  uint start;
  uint end;
  uchar unk3;
  uchar unk4;
  uchar unk5;
  uchar unk6;
};

struct CCollisionMaterial {
  uint orientation;
  uint materialType;
  uint worldType;
  uint behaviorList;
  uint filterList;
};

struct CIndexedTriangle {
  uint idx1;
  uint idx2;
  uint idx3;
  if (form.readerVersion > 2 && form.writerVersion > 2) //Fix reading test collisions from DKCTF
  {
    ushort material;
    ushort unk2;
  }
};

struct CollisionMaterialVector {
  uint count;
  CCollisionMaterial collisionMaterials[count];
};

struct VertexVector {
  uint count;
  CVector3f vertices[count];
};

struct IndexedTriangleVector {
  uint count;
  CIndexedTriangle tris[count]<optimize=false>;
};

struct TreeNodeVector(CollisionPrimitiveType type) {
  uint count;
  switch (type) {
  case kCOL_AABox:
    CAABoxTreeNode nodes[count];
    break;
  case kCOL_OBBox:
    COBBoxTreeNode nodes[count];
    break;
  }
};

struct ModConData {
  char id[16];
  CTransform4f xf;
  ushort unk;
};

local int idx <hidden=true> =0;
typedef struct CCollisionTree(uint64 size, CollisionPrimitiveType type) {
  local CollisionPrimitiveType tmpType <hidden = true> = type;
  local uint64 start<format = hex, hidden = true> = FTell();
  while (FTell() != start + size) {
    struct Chunk {
      ChunkDescriptor desc;
      union {
        switch (desc.id) {
        case "INFO":
          CAABox bounds;
          break;
        case "MTRL":
          CollisionMaterialVector materials;
          break;
        case "TRIS":
          IndexedTriangleVector triangles;
          break;
        case "VERT":
          VertexVector vertices;
          break;
        case "TREE":
          TreeNodeVector treeNodes(tmpType);
          break;
        }
        char raw[desc.size];
      } data;
    } chunks;
  }
  if (idx == 0) {
    local int i = 0;
    //Hack, do this so DCLN doesn't break the printouts, seems to work on MP1R DCLN but haven't tested CLSN
    local int vertChunk = 0;
    local int triangleChunk = 2;
    local int materialChunk = 1;
    if (form.id == "DCLN") 
    {
        vertChunk = 1;
        if (form.readerVersion > 2 && form.writerVersion > 2) //Read legacy CLSNs
        {
            materialChunk = 2;
            triangleChunk = 3;
        }
        else
        {
            triangleChunk = 2;
            materialChunk = 0;
        }
    }
    else if (form.id == "CLSN" && (form.readerVersion == 2 && form.writerVersion == 2))
    {
        materialChunk = 0;
        triangleChunk = 1;
    }   
    for (i = 0; i < chunks[vertChunk].data.vertices.count; ++i) {
      Printf("v %f  %f %f\n", chunks[vertChunk].data.vertices.vertices[i].x,
             chunks[vertChunk].data.vertices.vertices[i].y,
             chunks[vertChunk].data.vertices.vertices[i].z);
    }
    local int t;
    local int y;
    local int prevMat = -1;
    for (i = 0; i < chunks[triangleChunk].data.triangles.count; ++i) {
    if (materialChunk != 0)
    {
        if (chunks[triangleChunk].data.triangles.tris[i].material != prevMat && (form.readerVersion > 2 && form.writerVersion > 2)) {
            Printf("o mat_%i_%08X\n", chunks[triangleChunk].data.triangles.tris[i].material,
                   chunks[materialChunk]
                       .data.materials
                       .collisionMaterials[chunks[triangleChunk].data.triangles.tris[i].material]
                       .filterList);
            prevMat = chunks[triangleChunk].data.triangles.tris[i].material;
          }
      }
      Printf("f %i %i %i\n", chunks[triangleChunk].data.triangles.tris[i].idx1 + 1,
             chunks[triangleChunk].data.triangles.tris[i].idx2 + 1,
             chunks[triangleChunk].data.triangles.tris[i].idx3 + 1);
    }
  }
  /*
    for (i = 0; i < chunks[2].data.triangles.count; ++i) {
      Printf("%i->%i: orientation=%08X, materialType=%08X, worldType=%08X, "
             "behaviorList=%08X, filterList=%08X\n",
             i, chunks[2].data.triangles.tris[i].material,
             chunks[1]
                 .data.materials
                 .collisionMaterials[chunks[2].data.triangles.tris[i].material]
                 .orientation,
             chunks[1]
                 .data.materials
                 .collisionMaterials[chunks[2].data.triangles.tris[i].material]
                 .materialType,
             chunks[1]
                 .data.materials
                 .collisionMaterials[chunks[2].data.triangles.tris[i].material]
                 .worldType,
             chunks[1]
                 .data.materials
                 .collisionMaterials[chunks[2].data.triangles.tris[i].material]
                 .behaviorList,
             chunks[1]
                 .data.materials
                 .collisionMaterials[chunks[2].data.triangles.tris[i].material]
                 .filterList);
    }
    */
    ++idx;
} CCollisionTree;

#endif // _CAABOXCOLLISIONTREE