CHR.bt

//------------------------------------------------
//--- 010 Editor v7.0 Binary Template
//
//      File: CHR.bt
//   Authors: AlexKimov
//   Version: 1.1
//   Purpose: Ghost Recon CHR file
//
//   History: 
//
//   2019.01 v1.1  
//   2018.04 v1.0  
//   2017.01 v0.9 
//   2016.12 v0.4 initial release
//------------------------------------------------

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

typedef struct { 
  UINT Length;  
  char Text[Length];
} CSTRING; 

typedef struct {
  UINT SectionSize;
  UINT ID;
  struct {    
    CSTRING Name <name="Version">; 
    UINT Value;
  } VERSION;    
  CSTRING Name <name="Name">; 
} SECTION_HEADER <name="Header">;

typedef struct { 
  FLOAT x;
  FLOAT y;  
} POINT2;

typedef struct {     
  UINT16 x;
  UINT16 y;
  UINT16 z;
} VECTOR_SHORT; 

typedef struct {     
  FLOAT x;
  FLOAT y;
  FLOAT z;
} VECTOR3; 

typedef struct {     
  FLOAT x;
  FLOAT y;
  FLOAT z;
  FLOAT w;  
} VECTOR4; 

//--------------------
// File header
// --------------------

FLOAT Version <name="Version">;
CSTRING Name <name="BeginModel">;   

//--------------------
// MATERIALLIST
// --------------------

typedef struct {
  FLOAT Red; 
  FLOAT Green; 
  FLOAT Blue; 
  FLOAT Alpha;        
} COLOR;

typedef struct {
  SECTION_HEADER Header;
  struct { 
    FLOAT Opacity;
    UINT Unknown;
    COLOR Ambient; 
    COLOR Diffuse;   
    COLOR Specular;
    FLOAT SpecularLevel; //o.o5
    BOOL twoSide;
  } PARAMETERS;
} MATERIAL <name=MaterialName>;

typedef struct {
  SECTION_HEADER Header;
  BOOL Unknown;
  CSTRING Name <name="Texture .rsb file name">;   
  struct { 
    UINT TransparencyType;  // 0 2 3
    UINT IsTiled; // 1 - u-tile, 2 - v-tile, 3 - both none
    FLOAT SelfIllumination; // 0
  } PARAMETERS; 
} TEXTURE <name=TextureName>;

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

string TextureName(TEXTURE &texture) {
  return "FileName: " + texture.Name.Text;
} 

struct {  
  SECTION_HEADER Header;  
  UINT Count <name="Number of materials">;
  typedef struct (int arraySize) {
    MATERIAL array[arraySize] <optimize=false>;
  } MATERIALS; 
  MATERIALS Materials(Count) <name="Materials">; 
  UINT Count <name="Number of textures">;
  if (Count > 0) 
  {
    typedef struct (int arraySize) {
      TEXTURE array[arraySize] <optimize=false>;
    } TEXTURES;    
    TEXTURES TextureArray(Count) <name="Textures">; 
  };
} MATERIAL_LIST <name="Material List">;

//--------------------
// GEOMETRYLIST
// --------------------

struct {   
  SECTION_HEADER Header; 
  UINT Count <name="Number of models">;
  typedef struct {
    SECTION_HEADER Header;       
    BOOL DarkMapped <name="DarkMapped">; 
    BOOL CastShadows <name="CastShadows">;      
    struct {
      UINT Count <name="Number of vertexes">;    
      typedef struct (int arraySize) {
        VECTOR3 array[arraySize];
      } VERTEXES;     
      VERTEXES Vertexes(Count) <name="Vertexes">; 
    } VERTEXES_SECTION <name="Vertex section">;

    UINT Count <name="Number of meshes">; 
    typedef struct {
      struct {
        BYTE Unknown; // 1
        BYTE DetailedDarkmap;
        BYTE DetailTexture;
        UINT MaterialIndex;
        UINT isTextured;
        if (isTextured > 0) 
        {
          UINT TextureIndex;
          if (DetailTexture > 0)
            UINT DetailTextureIndex;
        };
        struct {
          UINT Unknown;     
          UINT SelfIlluminationMap;
          UINT SpecularMap;
          UINT BumpMap;
          UINT ReflectionMap;
          UINT MapCount;
        } MAPPING;
      } TEXTURE_PARAMETERS;
    
      struct {
        UINT Count <name="Number of faces">;     
        typedef struct (int arraySize) {
          VECTOR4 array[arraySize];
        } NORMALS1;          
        NORMALS1 Normals(Count) <name="Normals??">;           
        typedef struct (int arraySize) {
          VECTOR_SHORT array[arraySize];
        } FACE_INDEXES;          
        FACE_INDEXES FaceIndexes(Count) <name="Face Indexes">;    
        typedef struct (int arraySize) {
          VECTOR_SHORT array[arraySize];
        } TEXTURE_INDEXES;          
        TEXTURE_INDEXES TextureIndexes(Count) <name="Texture Indexes">;    
 
        UINT VertexCount;
        UINT TextureCount;         
        typedef struct (int arraySize) {
          VECTOR3 array[arraySize];
        } NORMALS2;       
        NORMALS2 Normals(VertexCount) <name="Normals">;        
        typedef struct (int arraySize) {
          POINT2 array[arraySize];
        } UVs;        
        UVs TextureCoordinates(VertexCount*TextureCount) <name="Texture coordinates">;           
        typedef struct (int arraySize) {
          COLOR array[arraySize] <optimize=false>;
        } FACE_COLOR; 
        FACE_COLOR FaceColor(VertexCount) <name="Faces colors">; 
      } FACE_PARAMETERS;   
    } MESH <name="Mesh">;
    typedef struct (int arraySize) {
      MESH array[arraySize] <optimize=false>;
    } MESHES;     
    MESHES Meshes(Count) <name="Meshes">; 
  } OBJECT;
  typedef struct (int arraySize) {
    OBJECT array[arraySize] <optimize=false>;
  } OBJECTS;     
  OBJECTS Objects(Count) <name="Meshes">; 

  UINT Unknown;  
} GEOMETRY_LIST  <name="Geometry List">;

CSTRING Name <name="EndModel">;

//--------------------
// Skeleton, Weights
// --------------------

typedef struct {
  struct {
    UINT ID; // 37
    struct {    
      CSTRING Name <name="Version">; 
      UINT value; // 1
    } VERSION_STRING; 
    CSTRING Name <name="Bone name">;
  } BONE_HEADER;
  VECTOR3 Position;
  VECTOR4 Rotation;
  FLOAT Unknown; // 0
  UINT Count; 
  if (Count > 0)
    struct {
      Bone(Count);
    } CHILDREN;
} SKELETON_BONE <name=getBoneName>;

void Bone(uint count)
{
  local uint i;
  for (i = 0; i < count; ++i)
    SKELETON_BONE bone;
};

// BoneName function 
string getBoneName(SKELETON_BONE &bone) {
  return "Name: " + bone.BONE_HEADER.Name.Text;
} 

struct {
  struct {
    Bone(1);
  } SKELETON <name="Skeleton">;
  struct {
    struct {
    CSTRING Name <name="Skin">; 
    UINT ID; // 1
    CSTRING Name;
  } HEADER <name = "Header">;   
  UINT VertexCount;
  typedef struct {
    UINT VertexIndex;
    UINT BoneCount;
    if (BoneCount > 0) 
    {
      typedef struct {
        CSTRING Name; 
        FLOAT VertexWeight;
      } BONES;           
      BONES Bones[BoneCount] <optimize=false>;
    };     
  } VERTEX_WEIGHT <name = "Vertex Weight">;   
  typedef struct (int arraySize) {
      VERTEX_WEIGHT array[arraySize] <optimize=false>;
  } VERTEX_WEIGHT_ARRAY;
    VERTEX_WEIGHT_ARRAY VertexWeightArray(VertexCount) <name="Weights">;
  } WEIGHT_TABLE <name="Weight Table">;  
} SKELETON <name="Skeleton + Weights">;