NOZ.bt

//------------------------------------------------
//--- 010 Editor v7.0 Binary Template
//
//      File: QOB(rsp).bt
//   Authors: Alexander Evdokimov
//   Version: 0.7
//   Purpose: Freedom First Resistance NOZ file
// File Mask: *.qob
//
//   History: 
// 
//   2018.15 0.7 initial release  
//------------------------------------------------


string readCString()
{
  local uint Length;
  local string Name;
  Length = ReadInt(FTell());
  FSkip(4);
  Name = ReadString(FTell());
  FSkip(-4);
  return Name;
};

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

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;
  if (readCString() == "Version")
  {
    struct {    
      CSTRING Name <name="Version">; 
      UINT Value;
    } VERSION;
  }  
  CSTRING Name <name="Name">; 
} SECTION_HEADER <name="Header">;

typedef enum <uint> {
  Opaque = 0, 
  unknown = 1,
  LookupCXP = 3
} ALPHA_METHOD;

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; 

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

// BeginModel token

CSTRING BeginModel <name="BeginModel token">;

//--------------------
// MaterialList
// --------------------

typedef struct {
  SECTION_HEADER Header;
  struct { 
    FLOAT Opacity;   
    ALPHA_METHOD alpha; // 0 - Opaque, 1 - unknown, 3 - Lookup CXP or opaque
    COLOR Ambient; 
    COLOR Diffuse;   
    COLOR Specular;
    FLOAT SpecularLevel; //o.o5
    BOOL twoSided;
  } MATERIAL_PROPERTIES;
} MATERIAL <name=MaterialName>;

typedef struct {
  SECTION_HEADER Header;
  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">;
  if (Count > 0)
  {
    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;       
          
    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 {
        INT MaterialIndex;
        if (Header.VERSION.Value > 2)         
        {
          UINT isTextured;
          if (isTextured > 0) 
            UINT TextureIndex;
          struct {
            INT Unknown;   
            if (Header.VERSION.Value > 4) 
            { 
              INT SelfIlluminationMap;
              INT SpecularMap;
              INT BumpMap;
              INT ReflectionMap;
              INT 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="UV Indexes">;    
 
        UINT VertexCount;
        if (Header.VERSION.Value > 2)   
          UINT TextureCount;         
        typedef struct (int arraySize) {
          VECTOR3 array[arraySize];
        } NORMALS2;       
        NORMALS2 Normals(VertexCount) <name="Normals">;        
        typedef struct (int arraySize) {
          POINT2 array[arraySize];
        } UVs; 
        if (Header.VERSION.Value > 2)               
          UVs TextureCoordinates(VertexCount*TextureCount) <name="Texture coordinates">;           
        else
          UVs TextureCoordinates(VertexCount) <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">;   
  if (ReadInt() == 0)
    UINT Unknown;
} GEOMETRY_LIST  <name="Geometry List">;

// EndModel token

CSTRING EndModel <name="EndModel token">;

//--------------------
// SKELETON
// --------------------

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;
  UINT Count; 
  UINT Data[Count];
  UINT Count; 
  if (Count > 0)
    struct {
      Bone(Count);
    } CHILDREN;
} SKELETON_BONE <name=getBoneName>;

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

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

struct {
  Bone(1);
} SKELETON <name="Skeleton">;