KIT.bt

//------------------------------------------------
//--- 010 Editor v7.0 Binary Template
//
//      File: KIT.bt
//   Authors: Alexander Evdokimov
//   Version: 1.0
//   Purpose: Force 21 KIT file
//
//   History: 
// 
//   2018.04 v0.5 initial release
//------------------------------------------------

typedef enum <ubyte> {
    no,
    yes
} BOOL; // bool data type

struct {   
 struct {
    UINT Length;  
    char String[Length];  
  } KT_String <name="KIT FileID">; 
  time_t DateTime;
} KIT_FILE_HEADER <name="KIT Header", fgcolor=cBlack, bgcolor=0xccff66>;


struct {
  UINT Length;
  char String[Length]; 
} BEGINMODEL_STRING <name="BEGINMODEL">;

typedef struct {
  struct {
    UINT SectionSize;
    UINT ID; // 2
    struct {    
       UINT Length; // 
       char Text[Length]; //
    } MATERIAL_NAME_STRING <name="Material Name">; 
    struct {    
       UINT Length; // 
       char Text[Length]; //
    } TEXTURE_NAME_STRING <name="Texture FileName">; 
  } HEADER <name="Material Section Header">;
  struct { 
    FLOAT Opacity;
    FLOAT isFaceted;
    UINT MN;
    UINT MN;
    UINT MN;
    UINT MN;
    UINT MN;
    UINT MN;
    UINT MN;
    UINT MN;   
    UINT MN;
    UINT MN; 
    FLOAT SpecularLevel; //o.o5
    BOOL twoSide;
  } PARAMETRES;
} MATERIAL <name=MaterialName>;

string MaterialName(MATERIAL &material) {
  return "Name: " + material.HEADER.MATERIAL_NAME_STRING.Text + " ";
} 

struct {  
  struct { 
    UINT SectionSize;
    UINT ID; // 8
    //struct {    
    //  UINT Length; // 
    //  char Text[Length]; //
   //   UINT Value;
   // } VERSION; 

    struct {
      UINT Length; // 
      char Text[Length]; // 
    } MATERIALLIST_STRING;
  } HEADER <name="1.0 MaterialList section header">;
    
  struct {
    UINT Count <name="Materials Count">;

    typedef struct (int arraySize) {
      MATERIAL array[arraySize] <optimize=false>;
    } MATERIAL_ARRAY; 

    MATERIAL_ARRAY MaterialArray(Count) <name="Material Array">; 
  } MATERIALS <name="1.1 Materials section">;

} KITMATERIALLIST <name="1. MaterialList section">;

//--------------------
// HierarchyList
// --------------------

struct {  
  struct { 
    UINT SectionSize;
    UINT ID; // 8
    //struct {    
    //  UINT Length; // 
    //  char Text[Length]; //
   //   UINT Value;
   // } VERSION; 

    struct {
      UINT Length; // 
      char Text[Length]; // 
    } MATERIALLIST_STRING;
  } HEADER <name="Section header">;
 
  UINT Count <name="Count">;

  typedef struct {
    struct { 
      UINT Length; // 
      char Text[Length]; // 
    } NAME_STRING; 
      struct { 
        UINT Length; // 
        char Text[Length]; // 
      } NAME_STRING;
    //BYTE A[2]; 
  } HL <name=HName>;

  typedef struct (int arraySize) {
    HL array[arraySize] <optimize=false>;
  } H_ARRAY; 

  H_ARRAY HArray(Count) <name="Array">; 
   

} KITHierarchyLIST <name="1. HierarchyList section">;

string HName(HL &hl) {
  return "Name: " + hl.NAME_STRING.Text;
}

//--------------------
// KITGEOMETRYLIST
// --------------------

typedef struct {
     struct { 
       UINT SectionSize;
       UINT ID; // 7   
       UINT Length; // 
       if (Length == 8) {
          char Text[Length]; //
          if (Text == "Version") {
            UINT version; 
            struct {
              UINT Length;  
              char Text[Length]; 
            } OBJECT_NAME;
            UINT MN; // 0
            UINT MN; // 0
          };
       } else {
         struct {
           char Text[Length]; 
         } OBJECT_NAME;
       }
     } HEADER <name="Object Header">;  

    switch (HEADER.ID) {
    case 3:
    struct {
      UINT VertexCount;  
      typedef struct {     
        FLOAT X;
        FLOAT Y;
        FLOAT Z;
       } Vertex <name="Vertex">;    
      typedef struct (int arraySize) {
        Vertex array[arraySize];
      } VERTEX_ARRAY;     
      VERTEX_ARRAY VertexArray(VertexCount) <name="Vertex array">; 
    } VERTICES <name="Vertices">;

    struct {
       UINT Count; 
       typedef struct {
         struct {
           FLOAT X;
           FLOAT Y;
           FLOAT Z;
           FLOAT W;
         } NORMALS;
         struct {
           FLOAT U;
           FLOAT V;
         } UV;
         struct {
           UINT Red;
           UINT Green;
           UINT Blue;
         } Color;
        } AA <name="Vertex">;
       typedef struct (int arraySize) {
         AA array[arraySize] <optimize=false>;
       } AA_ARRAY ;
       AA_ARRAY AAArray(Count) <name="data array">; 
     } NORMALS_ARRAY <name="Vertex Normals | UV coordinates">;

     struct {
       UINT Count <name = "Face Count">; 
       typedef struct {     
         struct {
           UINT P1;
           UINT P2;
           UINT P3;
         } Face_Index;
         struct {
           UINT P1;
           UINT P2;
           UINT P3;
         } Texture_Index;
         struct {
           struct {
             FLOAT X;
             FLOAT Y;
             FLOAT Z;
             FLOAT W;
           } FACE_NORMAL;
           UINT MaterialIndex;
         } Properties;
       } Face <name = "Face">;
       typedef struct (int arraySize) {
          Face array[arraySize] <optimize=false>;
       } Face_ARRAY;
       Face_ARRAY FaceArray(Count) <name="Face array">; 
     } TEXTURE_DATA <name="Indexes">;

    struct {
    UINT Count; 
    typedef struct  { 
       UINT Count; 
       struct {
         UINT Length; // 
         char Text[Length]; // 
       } String <name="String">; 

       UINT Count; 
       typedef struct {  
         UINT Index; 
       } CC;
       typedef struct (int arraySize) {
          CC array[arraySize] <optimize=false>;
       } CC_ARRAY;
       CC_ARRAY CCArray(Count) <name="Face indexes">; 

       UINT Count; 
       typedef struct {  
         UINT Index; 
       } DD;
       typedef struct (int arraySize) {
          DD array[arraySize] <optimize=false>;
       } DD_ARRAY;
       DD_ARRAY DDArray(Count) <name="Texture indexes">; 

       UINT Count; 
       struct {
         UINT Length; // 
         char Text[Length]; // 
       } String <name="String">;      
       UINT Count;       
    } MM;

    typedef struct (int arraySize) {
      MM array[arraySize] <optimize=false>;
    } MM_ARRAY;
    MM_ARRAY MMArray(Count) <name="Indexes array">; 
    }  IND <name="Params">; 
    break;
    case 26:
      FLOAT Y;
      FLOAT X;
      struct { 
       struct { 
          FLOAT x;        
          FLOAT y;
          FLOAT z;
       } XAxis;
       struct { 
          FLOAT x;
          FLOAT y;
          FLOAT z;
       } YAxis;
       struct {
          FLOAT x;
          FLOAT y;
          FLOAT z;
       } ZAxis;
       struct {
          FLOAT Y;
          FLOAT X;
          FLOAT Z;
       } Position;
      } TRANSFORMATION_MATRIX;    
    break;
    };
} DATA <name=ObjectName>;  

string ObjectName(DATA &data) {
  return "Name: " + data.HEADER.OBJECT_NAME.Text + " ";
} 

struct {   

  struct { 
    UINT SectionSize;
    UINT ID; // 7
    struct {
      UINT Length;  
      char Text[Length];  
    } GEOMETRYLIST_STRING;
  } HEADER <name="GeometryList Header">;  

 UINT Count <name="Object Count">;

 struct {
  

    typedef struct (int arraySize) {
      DATA array[arraySize] <optimize=false>;
    } GEOMETRY_DATA_ARRAY; 

    GEOMETRY_DATA_ARRAY GeometryDataArray(Count) <name="Object geometry data array">; 

   } SOB_GEOMETRY_DATA <name="Geometry data">; 
}  GEOMETRYLIST  <name="GeometryList Section">;

UINT MN;

struct {
  UINT Length; // 
  char Text[Length]; // 
} EndModelString <name="ENDMODEL">;