MAP(gr).bt

//------------------------------------------------
//--- 010 Editor v7.0 Binary Template ------------
//
//      File: MAP(gr).bt
//   Authors: Alexander Evdokimov
//   Version: 0.8
//   Purpose: Ghost Recon MAP file 
// File Mask: *.map
// 
//   History: 
//
//   2016.12 v0.1 initial release
//   
//   Notes:
//   1. When exporting from 3ds Max with developers export plugin:
//   If 4 byte var stored in map file (int or float) is FFFFFFFF (hex) or 4294967295 (dec) 
//      then it wasn't set in 3ds max, so it's empty.
//------------------------------------------------

struct {
  local byte check_enable = 0; // 1 - enable value checking | 0 - disable
} VARS <hidden=true>;

void Check(int value, int number, string str) {
  if (VARS.check_enable) {
    local string s1, s2;
    SPrintf( s1, "%d", (int)value );
    SPrintf( s2, "%d", (int)number );
     if (value != number) {
      MessageBox( idYes, "Warning", str + ": " + s1 + " not " + s2);
      break;
     }; 
  }; 
};

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

//typedef struct {
//  UINT SectionSize;
//  UINT MN;
//  struct {    
//    UINT Length; // 8
//    char Text[Length]; // "version"
//    UINT Value;
//  } VERSION_STRING; 
//  struct {    
//     UINT Length; 
//     char Text[Length];
//  } NAME_STRING <name="Name">; 
//} SECTION_HEADER <name=HeaderName>;

struct {
 struct {
    UINT Length; // 
    char Text[Length]; // BeginMapv4.0
  } BEGINMAP_STRING <name="File ID (Signature)">;
 struct {
    time_t CreateDate <name="File Creation Date">;
  } DATETIME <name="File DATETIME">;
} MAPHEADER <name="MAP Header", fgcolor=cBlack, bgcolor=0xccff66>;

//------------------------------------------------
// Section - MaterialList 
//------------------------------------------------

typedef struct {
  struct {
    UINT SectionSize;
    UINT MN; // 2
    Check(MN, 2, "Material Section Header MN");
    struct {    
      UINT Length; // 8
      char Text[Length]; // "version"
      UINT Value; // 2
    } VERSION; 
    Check(VERSION.Value, 2, "Material Section Header Version value");
    struct {    
       UINT Length; 
       char Text[Length]; //
    } MATERIAL_NAME_STRING <name="Material Name">; 
  } HEADER <name="Material Section Header">;
  struct { 
    FLOAT Opacity; // 0..1, 1 - default
    UINT Faceted; // 0 - on, 3 - unset
    //Check(Faceted, 0, "isFaceted");
    struct {
      struct {              
        FLOAT Red;
        FLOAT Green;
        FLOAT Blue;
        FLOAT mn; // 1
        Check(mn, 1, "AMBIENT MN");
      } AMBIENT; 
      struct {           
        FLOAT Red;
        FLOAT Green;
        FLOAT Blue; 
        FLOAT mn; // 1
        Check(mn, 1, "DIFFUSE MN");
      } DIFFUSE;   
      struct { 
        FLOAT Red;
        FLOAT Green;
        FLOAT Blue;
        FLOAT mn; // 1
        Check(mn, 1, "SPECULAR MN");
      } SPECULAR;
    } COLORS <name="Colors">; // you can change theme if there is no material (texture) assigned to the object otherwise it's ignored by GRE
    FLOAT SpecularLevel; // 
    BOOL twoSided <name="2-Sided">;
  } PARAMETRES;
} MATERIAL <name=MaterialName>;

typedef struct {
  struct {
    UINT SectionSize;
    UINT MN; // 38
    Check(MN, 38, "Textures section header MN");
    struct {    
      UINT Length; 
      char Text[Length]; 
      UINT Value;  // 2
    } VERSION; 
    Check(VERSION.Value, 2, "Textures section header Value");
    struct {    
       UINT Length;  
       char Text[Length]; 
    } TEXTURENAME_STRING <name="Texture Name">; 
  } HEADER <name="Textures section header">;
  BOOL mn <comment="always 0">; // 0
  struct {    
     UINT Length;  
     char Text[Length]; 
  } TEXTURE_FILENAME_STRING <name="Texture .rsb file name">;   
  struct { 
    UINT AdvTransparencyType;  // 0 - subtractive, 2 - additive, 3 - filter
    UINT Tiled; // 1 - u tiled only, 2 - v tiled only, 3 - untiled
    FLOAT SelfIllumination; // 0..1, 0 - default
  } PARAMETERS; 
} TEXTURE <name=TextureName>;

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

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

struct {  
  struct { 
    UINT SectionSize;
    UINT MN; // 8
    Check(MN, 8, "MaterialList Section Header MN");
    struct {    
      UINT Length;  
      char Text[Length]; 
      UINT Value; // 3
    } VERSION; 
    Check(VERSION.Value, 3, "MaterialList Section Header Version value");
    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">;
  struct {
    UINT Count <name="Textures Count">;
     if (Count > 0) {
        typedef struct (int arraySize) {
          TEXTURE array[arraySize] <optimize=false>;
        } TEXTURE_ARRAY;     
        TEXTURE_ARRAY TextureArray(Count) <name="Textures Array">; 
    };
  } TEXTURES <name="1.2 Textures section">;
} MAPMATERIALLIST <name="1. MaterialList section">;

//------------------------------------------------
// Section - GeometryList 
//------------------------------------------------

typedef enum <uint> {
  Carpet,
  Concrete,
  Wood,
  Metal,
  Asphalt,
  Sand,
  LowGrass,
  HighGrass,
  Puddle,
  Water,
  Drywall,
  ThinMetal,
  ThickMetal,
  MetalGasTank,
  SteamPipe,
  ElectricalPanel,
  Snow,
  SafetyGlass,
  BulletResistantGlass,
  Ice,
  Mud,
  Glass,
  Foliage,
  Gravel,
  GlassShards,
  CreakyWood,
  DeepSand,
  BakedClay,
  unset = 4294967295
} SURFACE_PROPERTY;

typedef struct {
  UINT Length;
  char Name[Length]; //
  BYTE FloorPolygon; // 2 - non colidable 2d, 10 - non colidable 3d, 26 - 3
  BYTE CarvingBoundary; // 1 - Carving Boundary  2 - cannot carve
  BYTE MN; // 0
  Check(MN, 0, "POLYGON_PARAMETERS 1");
  BYTE MN; // 0 
  Check(MN, 0, "POLYGON_PARAMETERS 2");
  SURFACE_PROPERTY SurfaceProperty <name="Surface Property">; // 0 - 12
} POLYGON_PROPERTIES <name=PPName>; 

string PPName(POLYGON_PROPERTIES &polygonproperties) {  
  return "Name: " + polygonproperties.Name;
} 

typedef struct {
    UINT Length;
    char PointName[Length];
    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;   
} POINT <name=Point_Name>;

string Point_Name (POINT &point) {
  return "Name: " + point.PointName;
};

typedef struct {  
  struct { 
    UINT SectionSize;
    UINT MN; // 4 - rooms, 35 - others
    //Check(MN, 4, "Section Header MN");
    struct {    
      UINT Length; // 
      char Text[Length]; //
      UINT Value; // 8
    } VERSION;
    Check(VERSION.Value, 8, "Section Header Version value");
    struct {
      UINT Length; // 
      char Text[Length]; // 
    } NAME_STRING;
  } HEADER <name="Section header">; 

  struct { 
    UINT SectionSize;
    UINT MN; // 4 - rooms, 3 - others
    //Check(MN, 4, "Object section header MN");
    struct {    
      UINT Length; // 
      char Text[Length]; //
      UINT Value; // 8
    } VERSION;
    Check(VERSION.Value, 8, "Object section header VERSION.Value"); 
    struct {
      UINT Length; // 
      char Text[Length]; // 
     } NAMESTRING; 
    BOOL DarkMapped <name="DarkMapped">; // 1 - rooms, 0 - other
    //Check(DarkMapped, 1, "DarkMapped");  
    BOOL CastShadows  <name="CastShadows">;
  } SUBSECTION_HEADER <name="Object section header">; 

struct {
  UINT VertexCount;  
  typedef struct {     
    FLOAT X;
    FLOAT Y;
    FLOAT Z;
   } VERTEX <name="VERTEX">;
  typedef struct (int arraySize) {
    VERTEX array[arraySize] <optimize=false>;
  } VERTEX_ARRAY; 
  VERTEX_ARRAY VertexArray(VertexCount) <name="Object vertices array">; 
} VERTICES <name="Object vertices section">;

struct {
  UINT Count;
  typedef struct {
  struct {
      BOOL mn; // 1
      Check(mn, 1, "Texture PARAMETERS");
      BOOL UseDetailedDarkmap;
      BOOL DetailTexture;
      UINT MaterialIndex;
      UINT isTextured;
      if (isTextured > 0) {
        UINT TextureIndex;
        if (DetailTexture == yes || isTextured > 1)  {
           UINT DetailTextureIndex;
        };
      };
      struct {
        UINT MN; // 1 
        Check(mn, 1, "Map MN");  
        UINT SelfIlluminationMap;
        UINT SpecularMap;
        UINT BumpMap;
        UINT ReflectionMap;
        UINT MapCount;
      } MAP;
   } PARAMETERS;

  struct {
    UINT FaceCount; 
    typedef struct {     
      FLOAT X;
      FLOAT Y;
      FLOAT Z;
      FLOAT DistanceOriginFace; // Distance from object origin to face, sign defines direction of normal vector
     } FACE_NORMAL <name="Normal">;
    typedef struct (int arraySize) {
      FACE_NORMAL array[arraySize] <optimize=false>;
    } FACE_NORMAL_ARRAY;  
    FACE_NORMAL_ARRAY FaceNormalArray(FaceCount) <name="Normals">;

    typedef struct  {
      UINT16 P1;
      UINT16 P2;
      UINT16 P3;
    } FACE_INDICIES;
    typedef struct (int arraySize) {
      FACE_INDICIES array[arraySize] <optimize=false>;
    } FACE_INDICIES_ARRAY;  
    FACE_INDICIES_ARRAY FaceIndiciesArray(FaceCount) <name="Faces index array">;

    typedef struct  {
      UINT16 P1;
      UINT16 P2;
      UINT16 P3;
    } TEXTURE_INDICIES <name="Texture indicies">;
    typedef struct (int arraySize) {
      TEXTURE_INDICIES array[arraySize] <optimize=false>;
    } TEXTURE_INDICIES_ARRAY;  
    TEXTURE_INDICIES_ARRAY TextureIndiciesArray(FaceCount) <name="Texture index array">;
  } FACES <name="Faces">;

struct {  
  UINT VerticiesCount; // ?
  UINT TextureCount;
  
  typedef struct   {
    FLOAT X;
    FLOAT Y;
    FLOAT Z;
  } NORMAL_COORDINATES <name="Normal">; 
  typedef struct (int arraySize) {
    NORMAL_COORDINATES array[arraySize] <optimize=false>;
  } NORMAL_COORDINATES_ARRAY;
  NORMAL_COORDINATES_ARRAY NormalCoordinatesArray(VerticiesCount) <name="Normal Coordinates">;

  if (TextureCount > 0) { 
    typedef struct   {
      FLOAT U;
      FLOAT V;
    } TEXTURE_UVCOORDINATES <name="UV coordinates">;
    typedef struct (int arraySize) {
      TEXTURE_UVCOORDINATES array[arraySize] <optimize=false>;
    } TEXTURE_UVCOORDINATES_ARRAY; 
    TEXTURE_UVCOORDINATES_ARRAY TextureCoordinatesArray(VerticiesCount*TextureCount) <name="Texture Coordinates">; 
  }; 

  typedef struct   {
    FLOAT Red;  // 0..1 (0..255 in RGB)
    FLOAT Green;  
    FLOAT Blue;  
    FLOAT MN;  
    Check(MN, 1, " value");
  } FACE_COLOR <name="Face RGB color">; 
  typedef struct (int arraySize) {
   FACE_COLOR array[arraySize] <optimize=false>;
  } FACE_COLOR_ARRAY; 
  FACE_COLOR_ARRAY CoordinatesArray(VerticiesCount) <name="Faces color array">; 

} TEXTURE_VERTICIES <name="Texture data">;
} OBJECT_DATA;

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

OBJECT_DATA_ARRAY MAPObjectsDataArray(Count) <name="Objects data array">; 
} OBJECTS_DATA <name="Objects data section">;
  
  // List of used taged HPs (3ds Max Helper Points) like special effects (e.g. water splashes), 
  // dynamic grass (foliage setup)
  struct {
    UINT Count;  
    //Check(MN, 0, "Points Count"); 
    if (Count) {    
       typedef struct(int arraySize) {
       POINT array[arraySize] <optimize=false>;
       } POINT_ARRAY;  
       POINT_ARRAY MAPPointArray(Count) <name="Point array">;
    }
  } Points <name="Points section">;

  struct {
      UINT VerticiesCount;
      if (VerticiesCount > 0) {
        typedef struct {     
          FLOAT X;
          FLOAT Y;
          FLOAT Z;
        } COVERTICE <name="Vertex">;
        typedef struct (int arraySize) {
          COVERTICE array[arraySize];
        } COVERTICE_ARRAY; 
        COVERTICE_ARRAY COArray(VerticiesCount) <name="Vertex Array">; 
      };

      UINT FaceCount;
      if (FaceCount > 0) {
        typedef struct {     
          FLOAT X;
          FLOAT Y;
          FLOAT Z;
          FLOAT DistanceOriginFace;
         } COLLISION_FACE_NORMALS <name="Face Normals">;
        typedef struct (int arraySize) {
          COLLISION_FACE_NORMALS array[arraySize];
        } COLLISION_FACE_NORMALS_ARRAY;
        COLLISION_FACE_NORMALS_ARRAY MAPCollisionFaceNormalsArray(FaceCount) <name="Face Normals Array">;
      };
  } CollisionObjects <name="2D-Collision (non-rendered) objects section">;

  // Objects tagging properties 
  struct {
    UINT ObjectsCount;

    struct {   
      UINT Count; // Rendered objects count (visible in game)
      if (Count > 0) {     
        typedef struct (int arraySize) {
          POLYGON_PROPERTIES array[arraySize] <optimize=false>;
        } POLYGON_PROPERTIES_ARRAY;       
        POLYGON_PROPERTIES_ARRAY PolygonsPropArray(Count) <name="Object Array">;
      };
    } POLYGONS <name="Poligons tagging">; 

    struct {
      UINT Count; // // non-Rendered objects count (invisible in game)
      if (Count > 0) {  
          typedef struct {
            POLYGON_PROPERTIES pproperties;
            UINT FCount;
            typedef struct  {
              UINT16 p1;
              UINT16 p2;
              UINT16 p3;
              UINT16 FIndex;
            } NRO_FACE_INDICIES <name="Face Indicies">;
            typedef struct (int arraySize) {
              NRO_FACE_INDICIES array[arraySize] <optimize=false>;
            } NRO_FACE_INDICIES_ARRAY;  
            NRO_FACE_INDICIES_ARRAY NROFaceIndiciesArray(FCount) <name="Face Indicies Array">;       
          } NON_REND_OBJECT <name="Object">;
          
          typedef struct (int arraySize) {
            NON_REND_OBJECT NonRendArray[arraySize] <optimize=false>;
          } NONREND_OBJECT_ARRAY;  
          NONREND_OBJECT_ARRAY MAPNonRendObjectArray(Count) <name="Objects Array">;
      };
    } NONROBJECTS <name="Non-rendered objects section">; 
  } OBJECTSTAGGING <name="Tagging section">;

} GEOMETRY <name=ObjectName>;

string ObjectName(GEOMETRY &geometry) {
  return "Name: " + geometry.HEADER.NAME_STRING.Text + " ";
} 

struct {   //
  struct { 
    UINT SectionSize;
    UINT MN;  // 7 
    Check(MN, 7, "GeometryList Header MN"); 
    struct {    
      UINT Length; 
      char Text[Length];
      UINT Value; // 1
    } VERSION; 
   Check(VERSION.Value, 1, "GeometryList Header MN"); 
    struct {
      UINT Length; // 
      char Text[Length]; // 
    } GEOMETRYLIST_STRING;
  } HEADER <name="GeometryList Header">;  
  struct {   
    UINT Count <name="Object Count">;
    typedef struct (int arraySize) {
      GEOMETRY array[arraySize] <optimize=false>;
    } GEOMETRY_ARRAY; 
    GEOMETRY_ARRAY GeometryArray(Count) <name="Object geometry data array">; 
  } GEOMETRYDATA <name="Geometry data section">;
} MAPGEOMETRYLIST <name="2. GeometryList Section">;

//------------------------------------------------------
//  PortalList Section
//------------------------------------------------------

 typedef struct {
    struct { 
      UINT SectionSize;
      UINT mn; // 0
      Check(mn, 0, "PortalList section header mn");
      struct {
         UINT Length;
        char Text[Length]; 
        UINT Value; // 2
      } VERSION_STRING;
      Check(VERSION_STRING.Value, 2, "PortalList section header VersionString");
      struct {
        UINT Length;
        char Text[Length];   
      } PORTAL_NAME_STRING;
    } HEADER <name="Portal header">;    
    struct {
      UINT VertexCount;
      typedef struct {
        FLOAT x;
        FLOAT y;
        FLOAT z;  
      } COORDINATES <name="Vertex Coordinates">;
      COORDINATES CoordinatesArray[VertexCount];      
      UINT RoomNumber;
      UINT OpositeRoomNumber; 
      BYTE mn; // 0
      Check(mn, 0, "PortalList section header mn");
    } PORTAL_PARAMS; 
  } PORTAL <name=PortalName>;

string PortalName(PORTAL &portal) {
  return "Name: " + portal.HEADER.PORTAL_NAME_STRING.Text;
};

struct {
  struct { 
    UINT SectionSize;
    UINT mn; //9
    Check(mn, 9, "PortalList section header mn");
    struct {
      UINT Length;
      char Text[Length]; 
      UINT Value;  // 1
    } VERSION_STRING;
    Check(VERSION_STRING.Value, 1, "PortalList section header VersionString");
    struct {
      UINT Length;
      char Text[Length];   
    } PORTALLIST_STRING;
  } PORTALLIST_HEADER <name="PortalList section header">; 
  UINT Count;
  typedef struct(int arraySize) {
    PORTAL array[arraySize] <optimize=false>;
  } PORTAL_ARRAY;
  PORTAL_ARRAY MAPPORTAL_ARRAY(Count) <name="Portal Array">;   
} PORTALLIST <name="3. PortalList section">;

//------------------------------------------------------------
//  OccluderList Section
//------------------------------------------------------------

typedef struct {
     struct { 
        UINT SectionSize;
        UINT mn;        
        struct {
          UINT Length;
          char Text[Length]; 
          UINT Value;
        } VERSION_STRING;        
        struct {
          UINT Length;
          char Text[Length];   
        } OCCLUDER_NAME_STRING;
     } HEADER <name="Occluder header">;        
     BYTE mnm[2];
     UINT mn;        
     BYTE mnk[3];         
     UINT VertexCount;
     typedef struct {
       FLOAT X;
       FLOAT Y;
       FLOAT Z;
     } OCCLUDER_VERTEX;
     OCCLUDER_VERTEX VertexArray[VertexCount];     
 } OCCLUDER <name=OccluderName>; 

string OccluderName(OCCLUDER &occluder) {
  return "Name: " + occluder.HEADER.OCCLUDER_NAME_STRING.Text;
};

struct {
   struct {
    UINT SectionSize;
    UINT mn;
    struct {
      UINT Length;
      char Text[Length];
      UINT Value;
    } VERSION_STRING;
    struct  { 
      UINT Length;
      char Text[Length];
    } OCCLUDERLIST_STRING;
  } OCCLUDERLIST_HEADER <name="OccluderList section header">;
  UINT Count;
  if (Count > 0) {     
      typedef struct(int arraySize) {
        OCCLUDER array[arraySize] <optimize=false>;
      } OCCLUDER_ARRAY;    
      OCCLUDER_ARRAY OccluderArray(Count) <name="Occluder Array">;
  };  
} OccluderList <name="4. OccluderList section">;

//----------------------------------------------------------------
// LightList Section
//---------------------------------------------------------------

struct {
   struct {
    UINT SectionSize;
    UINT mn;

    struct {
      UINT StringLength;
      char String[StringLength];
      UINT number;
    } VersionString;

    struct  { 
      UINT StringLength;
      char OccluderList[StringLength];
    } LightListString;
  } LightListHeader <name="OccluderList section header">;
  

  UINT Count;

  struct {
    typedef struct {
      struct { 
        UINT SectionSize;
        UINT mn;
    
        struct {
          UINT StringLength;
          char String[StringLength]; 
          UINT number;
        } VersionString;
    
        struct {
          UINT StringLength;
          char String[StringLength];   
        } GeometryListString;
      } Header <name="Light header">;

      UINT Count;
      UINT LightType; // 0 - ambient, 6 - sun
      FLOAT Angle;
      FLOAT MN; // 0.3926991
      FLOAT MN; // 0
      FLOAT MN; // 0.5
      FLOAT MN; // 0.5
      FLOAT Atennuation;
      FLOAT MN;

      struct {  
        FLOAT MN;
        FLOAT MN;
        FLOAT MN;
        FLOAT MN;
        FLOAT MN;
        FLOAT MN;
        FLOAT MN;
      } direction;

      struct { 
        FLOAT x;
        FLOAT y;
        FLOAT z;
      } position;

      FLOAT MN;  // 0
      FLOAT MN; // 0    
      FLOAT MN; // 0
      FLOAT MN; // 0
      FLOAT MN; // 0
      FLOAT MN; // 0
      BYTE AlwaysOn;
      struct {
        FLOAT Red;
        FLOAT Green;
        FLOAT Blue;
      } Color;
      FLOAT MN;
      BYTE mn;  // 1
      BYTE CastShadows;
      BYTE mn;  // 0
      BYTE Negative;
      struct {
        UINT StringLength;
        char String[StringLength];
      } NameString1;
      struct {
        UINT StringLength;
        char String[StringLength];
      } ProjectedTextureString;
      UINT LinearAttenuation;
      BYTE mn;  // 0
      BYTE DecayOn;
      FLOAT DecayStart;
      BYTE DynLightActors;
} Light;  
    typedef struct(int arraySize) {
      Light array[arraySize] <optimize=false>;
    } LightsArray;
    LightsArray MAPLightsArray(Count);  
  } Lights;
} LightList <name="5. LightList section">;

//----------------------------------------------------------------
// VFogList Section
//---------------------------------------------------------------

struct {
   struct {
    UINT SectionSize;
    UINT mn;
    struct {
      UINT Length;
      char Text[Length];
      UINT value;
    } VERSION_STRING;
    struct  { 
      UINT Length;
      char OccluderList[Length];
    } FOGLIST_NAME_STRING;
  } FOGLIST_HEADER <name="FogList section header">; 
  UINT Count;
} VFogList <name="6. VFogList section">;

//----------------------------------------------------------------
// ObjectList section
//---------------------------------------------------------------

typedef struct {

  typedef struct { 
    UINT SectionSize;
    UINT MN;
    struct {    
        UINT Length; // 1
        char Text[Length]; //
        UINT Value;
    } VERSION;  

    struct {    
        UINT Length; // 
        char Text[Length]; //
    } NAME_STRING;         
  } FOHEADER;


  typedef 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_MATRIX2;
  typedef struct {
      UINT DynamicsType; // 2 - Pbomb (Parray)
      FLOAT Duration;
      FLOAT Strength;
      FLOAT Range;
      UINT ExplosionType; // 2 - Eponential

      struct {
        FLOAT X; // 0
        FLOAT Y; // 0  
        FLOAT Z; // 1 
      } Position; 

      FLOAT MN;
      FLOAT MN;
      FLOAT MN;

      UINT BlastSymmetry; // 1 - cylindrical
      FLOAT StartTime;   
      FLOAT Chaos;  
  } SPACE_WARPS;   
        
    struct {
      BYTE A; 
      UINT Y;
      UINT SpawnOnDeath; // 1
      FLOAT Z;
      FLOAT Y;
      FLOAT X;
      FLOAT Z;
      FLOAT Y;
      BYTE X;
      BYTE X;
      UINT AA; 
      BYTE MN; 
    } HEADER;

    UINT ParticleSystemType; // 0 - blizzard, 1 - snow, 2 - Spray, 3 - SuperSpray, 4 - PArray, 5 - PCloud
    if (ParticleSystemType != 3) {
      struct { 
        UINT Length; // 
        char Text[Length]; //
      } Properties;
    }   
 
    struct { 
      FLOAT Width; // IconSize
      FLOAT Length; // 
      FLOAT Height; // 3D
    } EMITTER_SIZE;
    
    struct { 
      FLOAT ParticleSpeed; // Parray (units in sec) (Particle Motion Speed (units per frame) * 30)
      FLOAT ParticleSpeedVariation; // %ParticleSpeed 
    } PARTICLE_MOTION;
    
    struct {
      FLOAT GrowFor; // Parray (Particle size Grow For / 30)     
      FLOAT FadeFor; // Parray (Particle size Fade For / 30)
    } PARTICLE_Size;
    
    struct {
      FLOAT MN;
      FLOAT MN;
    } SOME;
    
    struct {
      FLOAT Life;
      FLOAT LifeVariation; 
    } PARTICLE_TIMING;
    
    struct{
      FLOAT ParticleSize;
      FLOAT ParticleSizeVariation;
    } PARTICLE_SIZE;
    
    struct {
      FLOAT UseRate; // * 3
      UINT UseTotal;
    } PARTICLE_QUANTITY;
    
    struct {
      UINT SpinAxisControlType; // 0 - Random, 2- user defined
      FLOAT XAxis;
      FLOAT YAxis;
      FLOAT ZAxis;
      FLOAT Variation;
    } SpinAxisControl ;
    
    FLOAT MN; // 1  
    FLOAT MN; // 0
    // 
    struct {
      FLOAT OffAxis;
      FLOAT Spread;
      FLOAT OffPlane;
      FLOAT Spread;
    } PARTICLE_FORMATION;
    //
    struct {        
      FLOAT GrowFor;
      FLOAT FadeFor;
    } ParticleSize2;
    
    FLOAT MN;
    FLOAT MN;    
    UINT MN;     
    FLOAT MN;
    FLOAT MN;
    FLOAT MN;
    FLOAT MN;
        
    struct {
      FLOAT SpinTime;
      FLOAT SpinTimeVariation;
      FLOAT Phase;
      FLOAT PhaseVariation;
    } SpinSpeedControls;
    
    UINT particleType; // 2 - object fragments
    
    UINT SpawnType; // 2 instanced geometry
    struct {
      UINT Spawns;
      UINT Spawns;
      FLOAT Spawn_Affects;
    } SPAWN_EFFECTS; 
    
    FLOAT MN; // time
    
    struct {
      FLOAT EmiStart; // time    
      FLOAT EmiStop; // time
    } PARTICLE_TIMING;
    
    UINT MN;
    struct {
        UINT UseTotal; // * PercentageOfParticles
    } PARTICLE_QUANTITY;
    BYTE isTextured; 
    if (isTextured) {
          UINT Length;   
          char TextureName[Length];
    } 
    if (particleType == 2) {
         
      typedef struct {
        struct {
            FLOAT MN;  
            FLOAT MN; 
            FLOAT MN;  
            FLOAT MN; 
            FLOAT MN;  
            FLOAT MN; 
            FLOAT MN;  
            FLOAT MN; 
            FLOAT MN;  
            FLOAT MN; 
            FLOAT MN; 
            FLOAT MN;  
            FLOAT MN; 
         } Some;
             UINT Count;
         FOHEADER F1;
         struct {
              UINT Length;  
              char Text[Length];  
         } ObjectProperties;   
         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;
         UINT Count; 
         FOHEADER F2;
         BYTE A;
      } FRAGMENT <name="Fragment object">;
      struct { 
        FRAGMENT frg[PARTICLE_QUANTITY.UseTotal] <optimize=false>;
      } Array <name="Fragment object Array">;
    }
    else {
      UINT A;
      if (A > 0) {
        SPACE_WARPS SpaceWarps;
      }
    }
} PARTICLE_NODE_PROPERTIES;

typedef struct {         
   UINT Length;
   char Name[Length];
   FLOAT SwitchDist;
} TREE_MODEL_NAME <name=TreeName>; 

string TreeName(TREE_MODEL_NAME &tree ) {
  return "(LOD)Model Name: " + tree.Name;
};

typedef struct {
  struct { 
      struct {  
        FLOAT X;
        FLOAT Y;
        FLOAT Z;
      } point1;
      struct { 
        FLOAT X;
        FLOAT Y;
        FLOAT Z;
      } point2;
  } FOREST_SQUARE;
  UINT GroupsCount; 

  typedef struct {
   struct {
      struct {  
        FLOAT X;
        FLOAT Y;
        FLOAT Z;
      } point1;
      struct { 
        FLOAT X;
        FLOAT Y;
        FLOAT Z;
      } point2;
    } FOREST_SQUARE;

    UINT TreesCount;
    typedef struct { 
        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;
        } TransformationMatrix;
    
        // -------------------------
    
        UINT LODModelNameCount;
        if (LODModelNameCount > 2) { 
           BYTE V[56];
        };
        //
        TREE_MODEL_NAME Treename[LODModelNameCount] <optimize=false>;
    } Tree ;
    typedef struct(int arraySize) {
      Tree array[arraySize] <optimize=false>;
    } TREE_ARRAY <name="Tree array">;
    TREE_ARRAY TreeArray(TreesCount) <optimize=false>;
  } FOREST_ARRAY <name="Foliage">;
  FOREST_ARRAY ForestArray[GroupsCount] <optimize=false>;
} FOREST_NODE_PROPERTIES;

typedef struct {
    struct {

      UINT Position_OutOfRangeType; // 1 - cycle, 3 - ping-pong
      UINT Rotation_OutOfRangeType; // 1 - cycle, 3 - ping-pong
      UINT n3;
      FLOAT n4; 
      UINT16 n5;
      UINT n6; 
      UINT16 n7; 
      UINT n8;  
      BYTE n9;
      BYTE n10; 
      UBYTE A;     
    } Prop;

    UINT PKeysCount;
    
    typedef struct {
        UINT ControllerType; // 3 - Linear Position, 5 - TCB Position
        if (ControllerType == 3) {
            FLOAT n2; // 0
            FLOAT Time;
            FLOAT X;          
            FLOAT Y;
            FLOAT Z;  
        }
        else {
            FLOAT n2; // 0
            FLOAT Time;
            FLOAT X;          
            FLOAT Y;
            FLOAT Z; 

            FLOAT Tension;  
            FLOAT Contunioty;
            FLOAT Bias;         
        }  
    } PositionKey;   

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

     PositionKeysArray POBPositionKeysArray(PKeysCount);

    UINT RKeysCount;
    typedef struct {
        UINT ControllerType; // 4 - Linear Rotation
        if (ControllerType == 4) {
            UINT n2; // 0
            FLOAT Time;
            UINT MN;        
            UINT MN;
            UINT MN; 
            FLOAT X;          
            FLOAT Y;
            FLOAT Z; 
            FLOAT Angel;
        }
    } RotationKey;

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

     RotationKeysArray POBRotationKeysArray(RKeysCount);
 } ANIMATION_NODE_PROPERTIES;  

void NodesTree(UINT NodeCount, int rootnode)
{   
  typedef struct (int rootnode) {

      if (rootnode) {
        struct {
          UINT SectionSize;
          UINT MN;
          struct {    
             UINT Length; // 
            char Text[Length]; //
            UINT Value;
          } VERSION;  
          struct {
            UINT Length; // 
            char Text[Length]; // 
          } NAME_STRING;
         } HEADER <name="Root node header">; 
      }; 

      struct { 
        UINT SectionSize;
        UINT MN;
        struct {    
            UINT Length; // 
            char Text[Length]; //
            UINT Value;
        } VERSION;  
    
        struct {    
            UINT Length; // 
            char Text[Length]; //
        } NAME_STRING;         
      } HEADER <name="Header">;
    
      if (HEADER.SectionSize == 1) { 
        BYTE MM; //0
      }      
      else {
        if (HEADER.MN != 51) {   
            struct {
              UINT Length; // 
              char Text[Length]; // 
            } ObjectProperties;   
        };
        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;
        } TransformationMatrix;

      if (HEADER.MN == 51) {
        PARTICLE_NODE_PROPERTIES particlenode <name="Particle node properties">;
      }
      else   
      if (HEADER.MN == 50) { 
        ANIMATION_NODE_PROPERTIES animation  <name="Animation node properties">;
      }
      else   
      if (HEADER.MN == 52) { 
        FOREST_NODE_PROPERTIES forest <name="Forest node properties">;
      };  
     
      UINT SubeNodeCount;
      if (SubeNodeCount > 0) {
        NodesTree(SubeNodeCount, 0);
      }
     };

  } NODE <name=NodeName>;
  typedef struct (int arraySize, int rootnode) {
    NODE array(rootnode)[arraySize] <optimize=false>;
  } NODE_ARRAY;         
  NODE_ARRAY MAPNodesArray(NodeCount, rootnode) <name="Child nodes">;
};

string NodeName(NODE &node) {
    local string NodeType;
    switch (node.HEADER.MN) {
         case 46: NodeType = "Empty"; break;
         case 47: NodeType = "Group"; break;
         case 50: NodeType = "Animation"; break;
         case 51: NodeType = "Particle"; break;
         case 52: NodeType = "Forest"; break;
         case 53: NodeType = "Light"; break;
    };
    return "Name: " + node.HEADER.NAME_STRING.Text + " [" + NodeType + "]";
}  

struct {
  struct { 
    UINT SectionSize;
    UINT MN;
    struct {    
       UINT Length; // 
       char Text[Length]; //
      UINT Value;
    } VERSION; 
    struct {
      UINT Length; // 
      char Text[Length]; // 
    } OBJECTLIST_STRING;
  } HEADER <name="ObjectList section header">;  

  struct {
    UINT NodeCount; 
    if (NodeCount > 0) {
        NodesTree(NodeCount, 1);
    };
  } NODE_TREE <name="Nodes Tree">;
} OBJECTLIST <name="7. ObjectList section">;

//----------------------------------------------------------------
//  RoomList section
//---------------------------------------------------------------

typedef struct {
    struct {
        UINT MN; // 12
        struct {
          UINT Length;
          char String[Length];
          UINT Value;
        } VERSION_STRING;
        struct {
          UINT Length;
          char Text[Length];
        } ROOMNAME_STRING;
    } HEADER ;
    
    BYTE MM; // 0
    UINT Mn; // 0
    UINT ShermanLevelCount; 

    typedef struct {
        struct {
          UINT StringLength;
          char String[StringLength];
        } LevelNameString;
        UINT ACount;
        typedef struct {
            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;
            } TransformationMatrix;  
            struct {
                FLOAT X;
                FLOAT Y;
                FLOAT Z;
                FLOAT X;
                FLOAT Y;
                FLOAT Z;
            } Size;
        } somr;
        somr ss[ACount]; 

        UINT A;
        FLOAT arr[A]; // 1
        BYTE mn; // 0
    } SHERMAN_LEVEL;

    struct {
      SHERMAN_LEVEL ShermansArray[ShermanLevelCount] <optimize=false>; 
    } ROOMARRAY <name="Shermanlevel array">;

    UINT A; // 1
    FLOAT mn; // 1
    typedef struct { 
      FLOAT mn; // 40
      UINT mn;  //0
    } some;
    some s[A];
    UINT mn; //0
} ROOM <name=RoomName>;

string RoomName(ROOM &room) {
  return room.HEADER.ROOMNAME_STRING.Text;

}

struct {
   struct {
    UINT SectionSize;
    UINT mn;
    struct  { 
      UINT StringLength;
      char OccluderList[StringLength];
    } RoomListString;
  } ROOMLIST_HEADER <name="RoomList section header">;

  UINT Count;

  struct {
    ROOM roomsarray[Count] <optimize=false>; 
  } ROOMARRAY <name="Rooms array">;

} ROOMLIST <name="8. RoomList section">;
//
//
//
////----------------------------------------------------------------
//// TransitionList section
////---------------------------------------------------------------

struct {
  struct {
    UINT SectionSize;
    UINT mn;
    struct  { 
      UINT StringLength;
      char OccluderList[StringLength];
    } TransitionListString;
  } TransitionListHeader <name="TransitionList section header">;
  UINT Count;
  typedef struct {   
    struct {
      UINT StringLength;
      char String[StringLength];
    } TRANSITION_NAME_STRING; 
    struct {
      struct {
        FLOAT X;
        FLOAT Y;
        FLOAT Z;
      } P1;
      struct {
        FLOAT X;
        FLOAT Y;
        FLOAT Z;
      } P2;
    } Size;        
  } TRANSITIONLIST;
  typedef struct(int arraySize) {
      TRANSITIONLIST array[arraySize] <optimize=false>;
  } TRANSITIONLIST_ARRAY ;
  TRANSITIONLIST_ARRAY TransitionListArray(Count); 
} TransitionLineList <name="9. TransitionList section">;

////----------------------------------------------------------------
//// PlanningLevelList section
////---------------------------------------------------------------

struct {
  struct {
    UINT SectionSize;
    UINT mn;

    struct  { 
      UINT StringLength;
      char OccluderList[StringLength];
    } PlanningListString;
  } PlanningListHeader <name="PlanningList section header">;

  UINT Count;
  if (Count > 0) {
    typedef struct { 
        FLOAT mn; 
        FLOAT mn; 
        UINT RoomCount;
    
        typedef struct { 
          UINT StringLength;
          char RoomNumberList[StringLength] ;
        } RoomNumberString;    
    
        typedef struct(int arraySize) {
          RoomNumberString array[arraySize] <optimize=false>;
        } RoomsArray ;
    
        RoomsArray RoomsNumbersArray(RoomCount);
    } Arr;
    Arr arv[Count] <optimize=false>; 
  };
} PlanningLevelList <name="10. PlanningLevelList section">;