DAG.bt

//------------------------------------------------
//--- 010 Editor v8.0.1 Binary Template
//
//      File: 
//   Authors: 
//   Version: 
//   Purpose: 
//  Category: 
// File Mask: 
//  ID Bytes: 
//   History: 
//------------------------------------------------

local uint n, k, n0, io, childNumber, isObjStarted, sectionType, pos;
local float Size, Sz, cnt;

typedef struct {
  FLOAT X;
  FLOAT Y;
  FLOAT Z;
}  VECTOR_3F;

typedef struct {
  FLOAT X;
  FLOAT Y;
}  VECTOR_2F;

typedef struct {
  UINT16 X;
  UINT16 Y;
  UINT16 Z;
}  VECTOR_3UI;

uint getType()
{
  local uint type;
  FSkip(4);
  type = ReadInt(FTell());
  FSkip(-4);
  return type;
}

uint getSize()
{
  local uint size;
  size = ReadInt(FTell());
  return size;
}

struct {
  UCHAR Magic[4]; // signature
  UINT DataSize;
  UCHAR DAG[4];
} HEADER <name="File Header">;

typedef struct {
  UINT DataSize;
  UINT Type;
  BYTE Length;
  UCHAR MaterialName[Length];
  struct {
    INT Unknown;
    INT Unknown;
    INT Unknown;
    FLOAT Unknown;
    INT Unknown;
    INT16 TextureIndex;
    INT16 Unknown;
    INT Unknown;
    INT Unknown;
    INT Unknown;
    FLOAT Unknown;
    FLOAT Unknown;
    INT Unknown;
    INT Unknown;
    INT Unknown;
    INT Unknown;
    INT Unknown;
    INT Unknown;
    BYTE Length;
    UCHAR LightMapName[Length];
  } PROPERTIES;
  UBYTE UNKNOWN_DATA[DataSize - (Length + PROPERTIES.Length + 74)];
} MATERIAL <name=GetMatName>;
 

typedef enum <uint> {
  END = 0,
  BEGIN = 1,
  HEADER = 2,
  DATA1 = 3,
  MESH_OBJECTS_CONTAINER = 4,
  DATA2 = 5,
  DATA3 = 6,
  OBJECTS_CONTAINER = 7,
  DATA5 = 8,
} OBJECT_SECTION_TYPE;


uint readMeshObject(uint datasize)
{
   local uint dsize = datasize - 4;
   local uint faceNum;
   while (dsize > 0)
   {
      UINT DataSize1; 
      UINT Type; 

      if (Type == 1) {
        struct { 
          UINT16 VertexCount;
          VECTOR_3F VertexCoordinates[VertexCount];
         
          UINT16 FaceCount;
          struct {
             uint i1;
             uint i2;
             uint i3;
          } Facent[FaceCount];  

          UBYTE Count8;
          struct {
            UINT16 Count0;
            UINT16 Count;

            VECTOR_2F TexCoordinates[Count0];     
            VECTOR_3UI Indexes[FaceCount];   
        
          } YU[Count8];
        } S1;
      }
      if (Type == 3) {
        struct {
          FLOAT TY[5];
          UINT16 KK;
          FLOAT TY2[3];
        } S3; 
      }
      if (Type == 4) {
        struct {
          uint16 num0;
          struct {
            uint16 index;
            float x;
            float y;
            float z;
            float x;
            float y;
            float z;
            float x;
            float y;
            float z;
            float x;
            float y;
            float z;
          } Un[num0];
          uint num;
          struct {
            float fg[num0];           
          } un[num];     
        } S4;
      }
      if (Type == 6) {
       struct {
         if (exists(S1))
             byte data1[S1.FaceCount];
         else
             byte data1[DataSize1 - 4]; 
       } S6;
      }
      if (Type == 2)
      {
       struct {
          UINT16 FaceCount;
          UINT16 Un; 

          struct {
            UINT16 Index1;
            UINT16 Un;
            UINT16 Index2;
            UINT16 Un;
            UINT16 Index3;
            UINT16 Un;

            UINT16 Un;  
            UINT16 Un;
            UINT16 Un;
          } Facent[FaceCount];  

          BYTE Count00;
          struct {
            UINT Count3;
   
            BYTE Count001;
            BYTE Count002;
            struct {
              FLOAT XYZ[Count001];                
            } TY[Count3];
      
            struct {
              UINT Indexes[3];                
            } TY2[FaceCount];  
                     
          } wqr[Count00] <optimize=false>;  

          UINT Count; 
          BYTE R[Count];  
        } S2;
      }       
      dsize -= (DataSize1 + 4);
    };    

  return 0;
}


// objects tree
uint readObject() {
  struct {
    UINT DataSize;
    UINT Type;

    local uint faceCount, datasize, childNum;
    datasize = DataSize - 4;

    while (datasize > 0)
    {
      UINT DataSize1; 
      UINT Type;
      
      if (Type == 1) {
        struct {
          if (DataSize1 == 52)
            struct {
                FLOAT X;
                FLOAT Y;
                FLOAT Z;
     
                FLOAT X;
                FLOAT Y;
                FLOAT Z;
    
                FLOAT X;
                FLOAT Y;
                FLOAT Z;
    
                FLOAT PosX;
                FLOAT PosY;
                FLOAT PosZ; 
              } MATRIX;
        } MATRIX;
      }
      if (Type == 2) {
        struct {
            INT16 Index <name="Object index">;
            INT16 ChildCount <name="Number of child objects">;
            childNum = ChildCount;
            UINT type;
             
            if (DataSize1 > 12)
              UCHAR ObjectName[DataSize1 - 12]; 
        } HEADER;
     }
     if (Type == 3) {
        struct {
              CHAR Str[DataSize1 - 4]; 
        } NAME; 
      }
     if (Type == 4) {
         struct {
           readMeshObject(DataSize1); 
         } MESH; 
     };
     if (Type == 5) {
            struct {
              BYTE DAta[DataSize1 - 4];
            } U_5;
     };
     if (Type == 6) {
        struct {   
          if (faceCount == 0)
          { 
            INT16 A;
              INT16 num;

              if (num > 1)
                struct { 
                  uint unk;    
                  FLOAT tt0;              
                  FLOAT tt1;
                  FLOAT tt2;
                  FLOAT tt0;              
                  FLOAT tt1;
                  FLOAT tt2;
                  FLOAT tt0;              
                  FLOAT tt1;
                  FLOAT tt2;
                } tqi[num];

              else uint tiuyo[3];
              INT16 num;

                struct { 
                  FLOAT tt0;              
                  FLOAT tt1;  
                  FLOAT tt0;              
                  FLOAT tt1;
                  FLOAT tt2;
                  FLOAT tt0;              
                  FLOAT tt1;
                  FLOAT tt2;
                  FLOAT tt0;              
                  FLOAT tt1;
                  FLOAT tt2;
                  FLOAT tt1;
                  FLOAT tt2;
                } tqi2[num];

              INT16 num;
              if (num > 1) 
                struct { 
                  uint unk;    
                  FLOAT tt0;              
                  FLOAT tt1;
                  FLOAT tt2;
                  FLOAT tt0;              
                  FLOAT tt1;
                  FLOAT tt2;
                  FLOAT tt0;              
                  FLOAT tt1;
                  FLOAT tt2;
                } tqi3[num];
               else struct {
                  uint unk;    
                  FLOAT tt0;              
                  FLOAT tt1;
               } e;
          }       
          else {
              UBYTE Indexes1[faceCount]; 
          }
        } U_6;
      };
      if (Type == 7) {
          if (HEADER.ChildCount > 0) 
          {
            struct {
              local uint i; 
              for (i = 0; i < childNum; i++)
              {
                struct {
                  readObject();
                } ONE_HELL_OF_AN_OBJECT; 
              }
            } CHILD_OBJECTS;
          }
      };
      if (Type == 8) {
        byte data034[DataSize1 - 4];
      }
      datasize -= (DataSize1 + 4); 
    };
  } OBJECT;
  
  return 0;
};

local uint frameNum;

while (!FEof())
{ 
  FSkip(4);
  n = ReadInt(FTell());
  FSkip(-4);
  
  if (n == 5) {
    struct {
      UINT DataSize;
      UINT Type;
      struct {  
        UINT16 AnimationIndex;
        UINT frameIndex;
      } A[frameNum];
     } ANIMATION_FRAME <name="Frames data">;
  }

  if (n == 4) 
    struct {
      UINT DataSize;
      UINT Type;
      UINT16 Count;
      frameNum = Count; 
      typedef struct {
          BYTE Length;
          UCHAR Name[Length];
      } STATE_NAME <name=GetStateName>;
      typedef struct (uint arraysize) {
        STATE_NAME Array[arraysize] <optimize=false>;
      } STATE_NAMES;
      STATE_NAMES FileNames(Count) <name="State Names">;     
    } ANIMATIONS <name="Animations">;

  if (n == 3) 
    struct {
      UINT DataSize;
      UINT Type;
      UINT16 TextureCount;
      typedef struct {
          BYTE Length;
          UCHAR FileName[Length];
      } FILE_NAME <optimize=false, name=GetTexName>;
      typedef struct (uint arraysize) {
        FILE_NAME Array[arraysize];
      } FILE_NAME_ARRAY <optimize=false>;
      FILE_NAME_ARRAY FileNames(TextureCount) <name="Texture List">;     
    } TEXTURE <name="Textures">;

  if (n == 2) 
    MATERIAL Material;

  if (n == 1) {
    struct {
      readObject();
    } GEOMETRY;

  };

  if (n == 0)
   struct {
      UINT DataSize;
      UINT Type;
  } end;

}

//string GetObjName(OBJECT &obj)
//{
//  return "Object: " + obj.ObjectName;
//}

string GetStateName(STATE_NAME &st)
{
  return "State: " + st.Name;
}


string GetTexName(FILE_NAME &fn)
{
  return "Texture: " + fn.FileName;
}

string GetMatName(MATERIAL &mt)
{
  if (exists(mt.MaterialName))
    return "Material: " + mt.MaterialName;
  else
    return "Material";    
}