FC1/CryCommon/CryHeaders.h

//////////////////////////////////////////////////////////////////////
//
//  CryEngine Source code
//	
//	File:CryHeaders.h
//  Definition of cgf, caf file chunks
//
//	History:
//	-:Created by Vladimir Kajalin
//
//////////////////////////////////////////////////////////////////////

#ifndef __CS_HEADERS_H__
#define __CS_HEADERS_H__

#include "Cry_Math.h"


enum ChunkTypes
{
	ChunkType_ANY			= 0,
	ChunkType_Mesh			= 0xCCCC0000,
	ChunkType_Helper,
	ChunkType_VertAnim,
	ChunkType_BoneAnim,
	ChunkType_GeomNameList,	//Obsolute
	ChunkType_BoneNameList,
	ChunkType_MtlList,		//obsolute
	ChunkType_MRM,			//obsolute
	ChunkType_SceneProps,
	ChunkType_Light,
	ChunkType_PatchMesh,	//not implemented
	ChunkType_Node,
	ChunkType_Mtl,
	ChunkType_Controller,
	ChunkType_Timing,
	ChunkType_BoneMesh,
	ChunkType_BoneLightBinding, // describes the lights binded to bones
	ChunkType_MeshMorphTarget,  // describes a morph target of a mesh chunk
	ChunkType_BoneInitialPos,		// describes the initial position (4x3 matrix) of each bone; just an array of 4x3 matrices
	ChunkType_SourceInfo // describes the source from which the cgf was exported: source max file, machine and user
};

#ifdef WIN64 // TODO: comment this, to apply the pack pragma to all platforms
#pragma pack(push,4)
#endif

struct CryVertex
{
	Vec3 p;			//position
	Vec3 n;			//normal vector
};

struct CryFace
{
	int v0,v1,v2;			//vertex indices
	int MatID;				//mat ID
	int SmGroup;			//smoothing group


	int& operator [] (int i) {return (&v0)[i];}
	int operator [] (int i)const {return (&v0)[i];}
	bool isDegenerate ()const {return v0 == v1 || v1 == v2 || v2 == v0;}
	bool isCollapsed()const {return v0 == v1 && v1 == v2;}
};

// structure used for sorting the cryFace arrays by material id
struct CryFaceOrderByMatID
{
	bool operator () (const CryFace& faceLeft, const CryFace& faceRight)const
	{
		return faceLeft.MatID < faceRight.MatID;
	}
};

struct CryKey
{
	int			time;		//in ticks
	Vec3	abspos;		//absolute position;

	Vec3	relpos;		//relative position;
	CryQuat		relquat;	//relative quaternion

};

struct CryUV
{
	float u,v;				//texture coordinates
};

struct CryTexFace
{
	int t0,t1,t2;			//texture vertex indices
	CryTexFace(){}
	CryTexFace (int _t0,int _t1, int _t2):t0(_t0),t1(_t1),t2(_t2) {}
	int& operator[] (int i) {return (&t0)[i];}
	int operator[] (int i) const {return (&t0)[i];}
};

// Material & Texture Primitives _____________________________________________________________________________________________________
struct TextureMap
{
	char	name[32];

	//tiling and mirror
	bool	utile;
	bool	umirror;
	bool	vtile;
	bool	vmirror;
	
	//texture position values
	float	uoff_val;
	float	uscl_val;
	float	urot_val;
	float	voff_val;
	float	vscl_val;
	float	vrot_val;
	float	wrot_val;

	//texture position controller chunk id's (if not animated they are -1)
	int	uoff_ctrlID;
	int	uscl_ctrlID;
	int	urot_ctrlID;
	int	voff_ctrlID;
	int	vscl_ctrlID;
	int	vrot_ctrlID;
	int	wrot_ctrlID;
};
/*
//////////////////////////////////////////////////////////////////////////
struct TextureMap
{
	char	path[128];	// Name and path of file.

	unsigned char	type;		// Mapping type.
	unsigned char flags;	// Texture map flags.
	unsigned char	ammount;// Ammopunt of blending (0-100).
	unsigned char	reserved[32];	// Some reserved variables.

	//tiling and mirror
	bool	utile;
	bool	umirror;
	bool	vtile;
	bool	vmirror;

	int		nthFrame;	// Update reflection every Nth frame.
	int		refSize;	// Reflection size.
	float	refBlur;	// Reflection blur.
	
	//texture position values
	float	uoff_val;
	float	uscl_val;
	float	urot_val;
	float	voff_val;
	float	vscl_val;
	float	vrot_val;
	float	wrot_val;

	//texture position controller chunk id's (if not animated they are -1)
	int	uoff_ctrlID;
	int	uscl_ctrlID;
	int	urot_ctrlID;
	int	voff_ctrlID;
	int	vscl_ctrlID;
	int	vrot_ctrlID;
	int	wrot_ctrlID;
};
*/

//////////////////////////////////////////////////////////////////////////
enum TextureMappingType
{
	TEXMAP_NORMAL = 0,
	TEXMAP_ENVIRONMENT,
	TEXMAP_SCREENENVIRONMENT,
	TEXMAP_CUBIC,
	TEXMAP_AUTOCUBIC
};

enum TextureMappingFlags
{
	TEXMAP_NOMIPMAP = 1,
};


struct TextureMap2
{
	char	name[32];	// Name of file.

	unsigned char	type;	  // Mapping type.
	unsigned char	flags;	// Mapping type.
  unsigned char Amount;
	unsigned char Reserved[1];

	//tiling and mirror
	bool	utile;
	bool	umirror;
	bool	vtile;
	bool	vmirror;

	int		nthFrame;	// Update reflection every Nth frame.
	int		refSize;	// Reflection size.
	float	refBlur;	// Reflection blur.
	
	//texture position values
	float	uoff_val;
	float	uscl_val;
	float	urot_val;
	float	voff_val;
	float	vscl_val;
	float	vrot_val;
	float	wrot_val;

	//texture position controller chunk id's (if not animated they are -1)
	int	uoff_ctrlID;
	int	uscl_ctrlID;
	int	urot_ctrlID;
	int	voff_ctrlID;
	int	vscl_ctrlID;
	int	vrot_ctrlID;
	int	wrot_ctrlID;
};

struct TextureMap3
{
	char	name[128];	// Name of file.

	unsigned char	type;	  // Mapping type.
	unsigned char	flags;	// Mapping type.
  unsigned char Amount;
	unsigned char Reserved[32];

	//tiling and mirror
	bool	utile;
	bool	umirror;
	bool	vtile;
	bool	vmirror;

	int		nthFrame;	// Update reflection every Nth frame.
	int		refSize;	// Reflection size.
	float	refBlur;	// Reflection blur.
	
	//texture position values
	float	uoff_val;
	float	uscl_val;
	float	urot_val;
	float	voff_val;
	float	vscl_val;
	float	vrot_val;
	float	wrot_val;

	//texture position controller chunk id's (if not animated they are -1)
	int	uoff_ctrlID;
	int	uscl_ctrlID;
	int	urot_ctrlID;
	int	voff_ctrlID;
	int	vscl_ctrlID;
	int	vrot_ctrlID;
	int	wrot_ctrlID;

  TextureMap3& operator = (const TextureMap2& tm)
  {
    strcpy(name, tm.name);
    type = tm.type;
    umirror = tm.umirror;
    vtile = tm.vtile;
    vmirror = tm.vmirror;
    
    nthFrame = tm.nthFrame;
    refSize = tm.refSize;
    refBlur = tm.refBlur;
    
    uoff_val = tm.uoff_val;
    uscl_val = tm.uscl_val;
    urot_val = tm.urot_val;
    voff_val = tm.voff_val;
    vscl_val = tm.vscl_val;
    vrot_val = tm.vrot_val;
    wrot_val = tm.wrot_val;
    
    uoff_ctrlID = tm.uoff_ctrlID;
    uscl_ctrlID = tm.uscl_ctrlID;
    urot_ctrlID = tm.urot_ctrlID;
    voff_ctrlID = tm.voff_ctrlID;
    vscl_ctrlID = tm.vscl_ctrlID;
    vrot_ctrlID = tm.vrot_ctrlID;
    wrot_ctrlID = tm.wrot_ctrlID;
    
    return *this;
  }  
};

struct CryLink
{
	int			BoneID;
	Vec3	offset;
	float		Blending;
};

// structure used to sort the crylink array by the blending factor, descending
struct CryLinkOrderByBlending
{
	bool operator () (const CryLink& left, const CryLink& right)
	{
		return left.Blending > right.Blending;
	}
};

struct CryIRGB
{
	unsigned char r,g,b;
};

struct CryFRGB
{
	float r,g,b;
};

struct NAME_ENTITY
{
	char	name[64];
};

struct SCENEPROP_ENTITY
{
	char	name[32];
	char	value[64];
};
  /*
struct BONE_ENTITY
{
	int		BoneID;
	int		ParentID;
	int		nChildren;
	int		nKeys;
	char	prop[32];	// do not forget to update strncpy len
};
*/

struct phys_geometry;
struct BONE_PHYSICS
{
	phys_geometry *pPhysGeom; // id of a separate mesh for this bone
	// additional joint parameters
	int		flags;
	float min[3],max[3];
	float spring_angle[3];
	float spring_tension[3];
	float damping[3];
	float framemtx[3][3];
};

// the compatible between 32- and 64-bits structure 
struct BONE_PHYSICS_COMP
{
	int nPhysGeom; // id of a separate mesh for this bone
	// additional joint parameters
	int		flags;
	float min[3],max[3];
	float spring_angle[3];
	float spring_tension[3];
	float damping[3];
	float framemtx[3][3];
};

#ifdef WIN64
#pragma warning( push )								//AMD Port
#pragma warning( disable : 4311 4312 )
#endif

#define __copy3(MEMBER) left.MEMBER[0] = right.MEMBER[0]; left.MEMBER[1] = right.MEMBER[1]; left.MEMBER[2] = right.MEMBER[2];
inline void CopyPhysInfo (BONE_PHYSICS& left, const BONE_PHYSICS_COMP& right)
{
	left.pPhysGeom = (phys_geometry*)(INT_PTR)right.nPhysGeom;
	left.flags     = right.flags;
	__copy3(min);
	__copy3(max);
	__copy3(spring_angle);
	__copy3(spring_tension);
	__copy3(damping);
	__copy3(framemtx[0]);
	__copy3(framemtx[1]);
	__copy3(framemtx[2]);
}
inline void CopyPhysInfo (BONE_PHYSICS_COMP& left, const BONE_PHYSICS& right)
{
	left.nPhysGeom = (int)right.pPhysGeom;
	left.flags     = right.flags;
	__copy3(min);
	__copy3(max);
	__copy3(spring_angle);
	__copy3(spring_tension);
	__copy3(damping);
	__copy3(framemtx[0]);
	__copy3(framemtx[1]);
	__copy3(framemtx[2]);
}

#undef __copy3

struct BONE_ENTITY
{
	int		BoneID;
	int		ParentID;
	int		nChildren;

	// Id of controller (CRC32 From name of bone).
	unsigned int	ControllerID;

	char	prop[32];	// do not forget to update strncpy len // [Sergiy] why not use sizeof??? :)
	BONE_PHYSICS_COMP phys;
};

  /*
struct MAT_ENTITY
{
	char	name[64];	//material name
	bool	IsStdMat;	//if false the below values are meaningless

	CryIRGB	col_d;		//diffuse color
	CryIRGB	col_s;		//specular color
	CryIRGB	col_a;		//ambiant color
	
	char	map_d[32];	//diffuse map file name
	char	map_o[32];	//opacity map file name
	char	map_b[32];	//bump map file name

	float	Dyn_Bounce;
	float	Dyn_StaticFriction;
	float	Dyn_SlidingFriction;
};
*/

enum MTL_CHUNK_FLAGS
{
	MTLFLAG_WIRE =		0x001,
	MTLFLAG_2SIDED =	0x002,
	MTLFLAG_FACEMAP = 0x004,
	MTLFLAG_FACETED = 0x008,
	MTLFLAG_ADDITIVE= 0x010,
	MTLFLAG_SUBTRACTIVE= 0x020,
	MTLFLAG_CRYSHADER= 0x040,
	MTLFLAG_PHYSICALIZE= 0x080,
	MTLFLAG_ADDITIVEDECAL = 0x0100,
  MTLFLAG_USEGLOSSINESS = 0x0200,
};

struct MAT_ENTITY_DATA
{
	char	name[64];	  //material/shader name
	bool	IsStdMat;	  //if false the below values are meaningless
  int  m_New;

	CryIRGB	col_d;		//diffuse color
	CryIRGB	col_s;		//specular color
	CryIRGB	col_a;		//ambient color

	float specLevel; // Specular level.
  float	specShininess;
	float	selfIllum;	// self illumination.
	float opacity;		// Opacity 0-1.
	float alpharef;		// Alpha-test 0-1.
  float m_Temp[8]; // For future modifications

	int flags;
	
	TextureMap3 map_a;	//Ambient map file name
	TextureMap3 map_d;	//Diffuse map file name
	TextureMap3 map_o;	//Opacity map file name
	TextureMap3 map_b;	//Bump map file name
  TextureMap3 map_s;	//Specular Texture settings
  TextureMap3 map_g;	//Gloss Texture settings
  TextureMap3 map_detail;	//Detail Texture settings
  TextureMap3 map_e;	//Environment Texture settings
	TextureMap3 map_subsurf; //Subsurface scattering Texture settings
  TextureMap3	map_displ;//Displacement Texture settings

	float	Dyn_Bounce;
	float	Dyn_StaticFriction;
	float	Dyn_SlidingFriction;

	int iGameID;

	int   nChildren;
};

struct MAT_ENTITY: public MAT_ENTITY_DATA
{
	int		*m_pMaterialChildren;
};

struct MAT_ENTITY_COMP: public MAT_ENTITY_DATA
{
	int m_iMaterialChildren;
};

inline void CopyMatEntity(MAT_ENTITY& left, const MAT_ENTITY_COMP& right)
{
	(MAT_ENTITY_DATA&)left = (MAT_ENTITY_DATA&)right;
	left.m_pMaterialChildren = (int*)right.m_iMaterialChildren;
}
inline void CopyMatEntity(MAT_ENTITY_COMP& left, const MAT_ENTITY& right)
{
	(MAT_ENTITY_DATA&)left = (MAT_ENTITY_DATA&)right;
	left.m_iMaterialChildren = (int)right.m_pMaterialChildren;
}

#ifdef WIN64
#pragma warning( pop )									//AMD Port
#endif

struct KEY_HEADER
{
	int		KeyTime;	//in ticks
};

//========================================
//File Headers
//========================================
#define FILE_SIGNATURE	"CryTek"

struct FILE_HEADER
{
	char	Signature[7];
	int		FileType;
	int		Version;
	int		ChunkTableOffset;
};

enum FileTypes
{
	FileType_Geom			= 0xFFFF0000,
	FileType_Anim,
};
/*
#define GeomFileVersion		0x0623
#define AnimFileVersion		0x0290
  */
#define GeomFileVersion		0x0744
#define AnimFileVersion		0x0744

//========================================
//Chunk Table Entity
//========================================


struct CHUNK_HEADER_0623
{
	enum {VERSION = 0x0623};
	ChunkTypes	ChunkType;
	int			ChunkVersion;
	int			FileOffset;
};

struct CHUNK_HEADER_0744
{
	enum {VERSION = 0x0744};
	ChunkTypes	ChunkType;
	int			ChunkVersion;
	int			FileOffset;
	int			ChunkID;		//new in version 0x0744

	CHUNK_HEADER_0744()
	{
		FileOffset = -1;
	}
};

typedef CHUNK_HEADER_0744 CHUNK_HEADER;

struct RANGE_ENTITY
{
	char name[32];
	int start;
	int end;
};

//========================================
//Timing Chunk Header
//========================================
struct TIMING_CHUNK_DESC_0918
{
	enum {VERSION = 0x0918};
	CHUNK_HEADER	chdr;

	float			SecsPerTick;		// seconds/ticks
	int				TicksPerFrame;		// ticks/Frame

	RANGE_ENTITY	global_range;		// covers all of the time ranges
	int				nSubRanges;
};

typedef TIMING_CHUNK_DESC_0918 TIMING_CHUNK_DESC;
#define TIMING_CHUNK_DESC_VERSION TIMING_CHUNK_DESC::VERSION

//========================================
//Material Chunk Header
//========================================
enum MtlTypes { MTL_UNKNOWN, MTL_STANDARD, MTL_MULTI, MTL_2SIDED };
struct MTL_CHUNK_DESC_0744
{
	enum {VERSION = 0x0744};
	CHUNK_HEADER	chdr;
	char			name[64];	//material name 
	MtlTypes		MtlType;	//one of the MtlTypes enum values

	union
	{
		struct
		{
			CryIRGB		col_d;		//diffuse color
			CryIRGB		col_s;		//specular color
			CryIRGB		col_a;		//ambiant color
			
			TextureMap	tex_d;		//Diffuse Texture settings
			TextureMap	tex_o;		//opacity Texture settings
			TextureMap	tex_b;		//Bump Texture settings

			float		Dyn_Bounce;
			float		Dyn_StaticFriction;
			float		Dyn_SlidingFriction;
		};

		struct
		{
			int		nChildren;
		};
	};
};

//////////////////////////////////////////////////////////////////////////
struct MTL_CHUNK_DESC_0745
{
	enum {VERSION=0x0745};
	CHUNK_HEADER	chdr;
	char			name[64];	  //material/shader name 
	MtlTypes		MtlType;	//one of the MtlTypes enum values

	union
	{
		struct
		{
			CryIRGB		col_d;		//diffuse color
			CryIRGB		col_s;		//specular color
			CryIRGB		col_a;		//ambient color
			float     specLevel; // Specular level.
      float     specShininess;
			float			selfIllum;	// self illumination.
			float			opacity;		// Opacity 0-1.
			
			TextureMap2	tex_a;		//Ambient Texture settings
			TextureMap2	tex_d;		//Diffuse Texture settings
			TextureMap2	tex_s;		//Specular Texture settings
			TextureMap2	tex_o;		//Opacity Texture settings
			TextureMap2	tex_b;		//Bump Texture settings
      TextureMap2	tex_g;		//Gloss Texture settings
      TextureMap2	tex_c;		//Cubemap Texture settings
      TextureMap2	tex_rl;		//Reflection Texture settings
			TextureMap2	tex_subsurf;		//Subsurface scattering Texture settings
      TextureMap2	tex_det;  //Detail Texture settings

			int			flags;
			
			float		Dyn_Bounce;
			float		Dyn_StaticFriction;
			float		Dyn_SlidingFriction;
		};

		struct
		{
			int		nChildren;
		};
	};
};

struct MTL_CHUNK_DESC_0746
{
	enum {VERSION = 0x0746};
	CHUNK_HEADER	chdr;
	char			name[64];	  //material/shader name 
  char      Reserved[60];
  float			alphaTest;
	MtlTypes		MtlType;	//one of the MtlTypes enum values

	union
	{
		struct
		{
			CryIRGB		col_d;		//diffuse color
			CryIRGB		col_s;		//specular color
			CryIRGB		col_a;		//ambient color
			float     specLevel; // Specular level.
      float     specShininess;
			float			selfIllum;	// self illumination.
			float			opacity;		// Opacity 0-1.
			
			TextureMap3	tex_a;		//Ambient Texture settings
			TextureMap3	tex_d;		//Diffuse Texture settings
			TextureMap3	tex_s;		//Specular Texture settings
			TextureMap3	tex_o;		//Opacity Texture settings
			TextureMap3	tex_b;		//Bump Texture settings
      TextureMap3	tex_g;		//Gloss Texture settings
      TextureMap3	tex_fl;		//Filter texture (Detail Texture settings)
      TextureMap3	tex_rl;		//Reflection Texture settings
			TextureMap3	tex_subsurf;		//Subsurface scattering Texture settings
      TextureMap3	tex_det;  //Detail Texture settings

			int			flags;
			
			float		Dyn_Bounce;
			float		Dyn_StaticFriction;
			float		Dyn_SlidingFriction;
		};

		struct
		{
			int		nChildren;
		};
	};
};

// The default MTL_CHUNK_DESC is different in the engine and in the plugin (exporter)
typedef MTL_CHUNK_DESC_0744 MTL_CHUNK_DESC;
typedef MTL_CHUNK_DESC_0746 MTL_CHUNK_DESC_EXPORTER;

//========================================
//Light Chunk Header
//========================================
enum LightTypes { LT_OMNI, LT_SPOT, LT_DIRECT, LT_AMBIENT };
struct LIGHT_CHUNK_DESC_0351
{
	enum {VERSION = 0x0351};
	int			ChunkType;		//must be ChunkType_Light
	int			ChunkVersion;	

	char		name[64];		// light name
    int			type;			// one of the LightTypes values
    bool 		on;				// light is on
	Vec3	pos;			// world position
	Matrix44	tm;				// transformation matrix
	CryIRGB		color;			// RGB color
	float 		intens;			// multiplier value

	float 		hotsize;		// for spot and direct lights hotspot value
	float 		fallsize;		// for spot and direct lights falloff value
	bool		useNearAtten;	// near atten. on
	float		nearAttenStart;	// near attenuation ranges
	float		nearAttenEnd;
	bool   		useAtten;		// far atteniation
	float 		attenStart;		// far attenuation ranges
	float 		attenEnd;
	bool   		shadow;			// shadow is on
};

struct LIGHT_CHUNK_DESC_0744
{
	enum {VERSION = 0x0744};
	CHUNK_HEADER	chdr;

	LightTypes	type;			// one of the LightTypes values
    bool 		on;				// light is on
	CryIRGB		color;			// RGB color
	float 		intens;			// multiplier value

	float 		hotsize;		// for spot and direct lights hotspot value
	float 		fallsize;		// for spot and direct lights falloff value
	bool		useNearAtten;	// near atten. on
	float		nearAttenStart;	// near attenuation ranges
	float		nearAttenEnd;
	bool   		useAtten;		// far atteniation
	float 		attenStart;		// far attenuation ranges
	float 		attenEnd;
	bool   		shadow;			// shadow is on

	Vec3		vDirection;			//spot light direction
	char		szLightImage[256];	//spot light texture
};

typedef LIGHT_CHUNK_DESC_0744 LIGHT_CHUNK_DESC;
#define LIGHT_CHUNK_DESC_VERSION LIGHT_CHUNK_DESC::VERSION


//========================================
//Mesh Chunk Header
//========================================
struct MESH_CHUNK_DESC_0623
{
	enum {VERSION = 0x0623};
	int		ChunkType;		//must be ChunkType_Mesh
	int		ChunkVersion;
	int		GeomID;
	bool	HasBoneInfo;
	bool	HasVertexCol;
	bool	InWorldSpace;
	int		nVerts;
	int		nTVerts;		// # of texture vertices
	int		nFaces;
	int		MatID;
	int		PropStrLen;		//lenght of the property string
};

struct MESH_CHUNK_DESC_0744
{
	enum {VERSION = 0x0744};
	CHUNK_HEADER	chdr;

	bool	HasBoneInfo;
	bool	HasVertexCol;
	int		nVerts;
	int		nTVerts;		// # of texture vertices
	int		nFaces;
	int		VertAnimID;		// id of the related vertAnim chunk if present. otherwise it is -1
};
typedef MESH_CHUNK_DESC_0744 MESH_CHUNK_DESC;
#define MESH_CHUNK_DESC_VERSION MESH_CHUNK_DESC::VERSION

//========================================
//SceneProps Chunk Header
//========================================
struct SCENEPROPS_CHUNK_DESC_0201
{
	enum {VERSION = 0x0201};
	int		ChunkType;		//must be ChunkType_SceneProps
	int		ChunkVersion;
	int		nProps;
};

struct SCENEPROPS_CHUNK_DESC_0744
{
	enum {VERSION = 0x0744};

	CHUNK_HEADER	chdr;

	int		nProps;
};

typedef SCENEPROPS_CHUNK_DESC_0744 SCENEPROPS_CHUNK_DESC;
#define SCENEPROPS_CHUNK_DESC_VERSION SCENEPROPS_CHUNK_DESC::VERSION

//////////////////////////////////////////////////////////////////////////
// Custom Attribute structure.
//////////////////////////////////////////////////////////////////////////
enum CryCustomAttribFlags
{
	CATYPE_INT,
	CATYPE_FLOAT,
	CATYPE_BOOL,
	CATYPE_STRING
};

struct CryCustomAttribute
{
	// One of CryCustomAttribFlags.
	int type;
	char name[32];
	char value[64];
};

//////////////////////////////////////////////////////////////////////////
// Custom Attributes chunk description.
//////////////////////////////////////////////////////////////////////////
struct CUSTOM_ATTRIBS_CHUNK_DESC_0744
{
	enum {VERSION = 0x0744};

	CHUNK_HEADER	chdr;
	int numAttribs;

	// Here goes array of custom attributes.
	// CryCustomAttribute attributes[];
};

typedef SCENEPROPS_CHUNK_DESC_0744 SCENEPROPS_CHUNK_DESC;
#define SCENEPROPS_CHUNK_DESC_VERSION SCENEPROPS_CHUNK_DESC::VERSION


//========================================
//MRM Chunk Header
//========================================
struct MRM_CHUNK_DESC
{
	int		ChunkType;		//must be ChunkType_MRM
	int		ChunkVersion;
	int		GeomID;
};

#define MRM_CHUNK_DESC_VERSION 0x0201

//========================================
//Dummy Chunk Header
//========================================
struct DUMMY_CHUNK_DESC
{
	int		ChunkType;		//must be ChunkType_Dummy
	int		ChunkVersion;
	char	name[64];
};
#define DUMMY_CHUNK_DESC_VERSION 0x0201

//========================================
//Vertex Anim Chunk Header
//========================================
struct VERTANIM_CHUNK_DESC_0201
{
	int		ChunkType;		// must be ChunkType_VertAnim
	int		ChunkVersion;
	bool	InWorldSpace;
	int		GeomID;			// node ID
	int		nKeys;			// # of keys
	int		nVerts;			// # of vertices this object has
	int		nFaces;			// # of faces this object has (for double check purpose)		
	float	SecsPerTick;	// seconds/ticks
	int		TicksPerFrame;	// ticks/Frame
};

struct VERTANIM_CHUNK_DESC_0744
{
	CHUNK_HEADER	chdr;

	int		GeomID;			// ID of the related mesh chunk
	int		nKeys;			// # of keys
	int		nVerts;			// # of vertices this object has
	int		nFaces;			// # of faces this object has (for double check purpose)		
};

typedef VERTANIM_CHUNK_DESC_0744 VERTANIM_CHUNK_DESC;
#define VERTANIM_CHUNK_DESC_VERSION 0x0744

//========================================
//Bone Anim Chunk Header
//========================================
/*
struct BONEANIM_CHUNK_DESC
{
	int		ChunkType;		// must be ChunkType_BoneAnim
	int		ChunkVersion;
	float	SecsPerTick;	// seconds/ticks
	int		TicksPerFrame;	// ticks/Frame
	int		startframe;		// in frames
	int		endframe;		// in frames
};*/


struct BONEANIM_CHUNK_DESC_0290
{
	enum {VERSION = 0x0290};

	CHUNK_HEADER	chdr;
	int		nBones;
};

typedef BONEANIM_CHUNK_DESC_0290 BONEANIM_CHUNK_DESC;

#define BONEANIM_CHUNK_DESC_VERSION BONEANIM_CHUNK_DESC::VERSION

//========================================
//GeomList Chunk Header #OBSOLETE#
//========================================
struct GEOMNAMELIST_CHUNK_DESC_0201
{
	enum {VERSION=0x0201};
	int		ChunkType;		//must be ChunkType_GeomNameList
	int		ChunkVersion;
	int		nEntities;
};
typedef GEOMNAMELIST_CHUNK_DESC_0201 GEOMNAMELIST_CHUNK_DESC;

#define GEOMNAMELIST_CHUNK_DESC_VERSION GEOMNAMELIST_CHUNK_DESC::VERSION;

//========================================
//Bonelist Chunk Header 
//========================================
struct BONENAMELIST_CHUNK_DESC_0201
{
	enum {VERSION=0x0201};
	int		ChunkType;		//must be ChunkType_BoneNameList
	int		ChunkVersion;
	int		nEntities;
};

struct BONENAMELIST_CHUNK_DESC_0744
{
	enum {VERSION=0x0744};
	CHUNK_HEADER chdr;
	int			 nEntities;
};

// this structure describes the bone names
// it's followed by numEntities packed \0-terminated strings, the list terminated by double-\0
struct BONENAMELIST_CHUNK_DESC_0745
{
	enum {VERSION = 0x0745};
	int numEntities;
};

//========================================
//MtlList Chunk Header  ##OBSOLETE##
//========================================
struct MTLLIST_CHUNK_DESC_0201
{
	enum {VERSION = 0x0201};
	int		ChunkType;		//must be ChunkType_MtlList
	int		ChunkVersion;
	int		nEntities;
};
typedef MTLLIST_CHUNK_DESC_0201 MTLLIST_CHUNK_DESC;
#define MTLLIST_CHUNK_DESC_VERSION MTLLIST_CHUNK_DESC::VERSION


// Keyframe and Timing Primitives __________________________________________________________________________________________________________________
struct BaseKey
{
	int time;
};

struct BaseTCB
{
	float t,c,b;
	float ein, eout;
};

struct BaseKey1 : BaseKey { float		val; };
struct BaseKey3 : BaseKey { Vec3	val; };
struct BaseKeyQ : BaseKey { CryQuat	val; };

struct CryLin1Key : BaseKey1 {};
struct CryLin3Key : BaseKey3 {};
struct CryLinQKey : BaseKeyQ {};
struct CryTCB1Key : BaseKey1 , BaseTCB {};
struct CryTCB3Key : BaseKey3 , BaseTCB {};
struct CryTCBQKey : BaseKeyQ , BaseTCB {};
struct CryBez1Key : BaseKey1 { float		intan, outtan; };
struct CryBez3Key : BaseKey3 { Vec3	intan, outtan; };
struct CryBezQKey : BaseKeyQ {};
struct CryBoneKey : BaseKey
{
	Vec3	abspos;
	Vec3	relpos;
	CryQuat	relquat;
};

struct CryKeyPQLog
{
	int nTime;
	Vec3 vPos;
	Vec3 vRotLog; // logarithm of the rotation

	// resets to initial position/rotation/time
	void reset ()
	{
		nTime = 0;
		vPos.x = vPos.y = vPos.z = 0;
		vRotLog.x = vRotLog.y = vRotLog.z = 0;
	}
};



//========================================
//Controller Chunk Header
//========================================
enum CtrlTypes 
{ 
	CTRL_NONE, 
	CTRL_CRYBONE, 
	CTRL_LINEER1,	CTRL_LINEER3,	CTRL_LINEERQ, 
	CTRL_BEZIER1,	CTRL_BEZIER3,	CTRL_BEZIERQ, 
	CTRL_TCB1,		CTRL_TCB3,		CTRL_TCBQ,
	CTRL_BSPLINE_2O, // 2-byte fixed values, open
	CTRL_BSPLINE_1O, // 1-byte fixed values, open
	CTRL_BSPLINE_2C, // 2-byte fixed values, closed
	CTRL_BSPLINE_1C,  // 1-byte fixed values, closed
	CTRL_CONST       // constant position&rotation
};

enum CtrlFlags
{
	CTRL_ORT_CYCLE = 0x01,
	CTRL_ORT_LOOP = 0x02
};

// descriptor-header of the controller chunk, precedes the controller data
struct CONTROLLER_CHUNK_DESC_0826
{
	enum {VERSION=0x0826};

	CHUNK_HEADER	chdr;

	CtrlTypes		type;		//one ot the CtrlTypes values
	int				nKeys;		// # of keys this controller has; toatl # of knots (positional and orientational) in the case of B-Spline

	//unsigned short nSubCtrl;	// # of sub controllers; not used now/reserved
	unsigned int nFlags;		// Flags of controller.
	//int				nSubCtrl;	// # of sub controllers; not used now/reserved

  unsigned nControllerId; // unique generated in exporter id based on crc32 of bone name
};

// intermediate version between the CONTROLLER_BSPLINE_DATA_0826 and CONTROLLER_CHUNK_DESC_0826
// followed by CryKeyPQLog array
struct CONTROLLER_CHUNK_DESC_0827
{
	enum {VERSION = 0x0827};
	unsigned numKeys;
	unsigned nControllerId;
};


// descriptor of B-Spline controller
struct CONTROLLER_BSPLINE_DATA_0826
{
	enum {VERSION = 0x0826};
	
	// spline degree, normally 3 (cubic)
	// degree 0 is piecewise-constant (CP=K-1), -1 is constant (always 0 knots, 1 control point)
	int nDegree; 
	
	// number of knots; number of Control Points is deduced from
	// the number of knots and the degree: CP = K + D - 1
	int nKnots;
};

typedef CONTROLLER_BSPLINE_DATA_0826 CONTROLLER_BSPLINE_DATA;


#define CRY_RENDERMODE_SHADOW   0
#define CRY_RENDERMODE_TEXTURED 1
#define CRY_RENDERMODE_BUMP     2
#define CRY_RENDERMODE_REFRACT  3

//========================================
//Node Chunk Header
//========================================
struct NODE_CHUNK_DESC_0823
{
	enum {VERSION = 0x0823};
	CHUNK_HEADER	chdr;

	char		name[64];

	int			ObjectID;		// ID of this node's object chunk (if present)
	int			ParentID;		// chunk ID of the parent Node's chunk
	int			nChildren;		// # of children Nodes
	int			MatID;			// Material chunk No

	bool		IsGroupHead;	
	bool		IsGroupMember;

	Matrix44	tm;				// transformation matrix
	Vec3	pos;			// pos component of matrix
	CryQuat		rot;			// rotation component of matrix
	Vec3	scl;			// scale component of matrix

	int			pos_cont_id;	// position controller chunk id
	int			rot_cont_id;	// rotation controller chunk id
	int			scl_cont_id;	// scale controller chunk id

	int			PropStrLen;		// lenght of the property string
};
typedef NODE_CHUNK_DESC_0823 NODE_CHUNK_DESC;
#define NODE_CHUNK_DESC_VERSION NODE_CHUNK_DESC::VERSION

//========================================
//Helper Chunk Header
//========================================
enum HelperTypes
{
	HP_POINT=0,
	HP_DUMMY=1,
	HP_XREF=2,
	HP_CAMERA=3
};
struct HELPER_CHUNK_DESC_0362
{
	enum {VERSION = 0x0362};
	int			ChunkType;		//must be ChunkType_Helper
	int			ChunkVersion;	

	char		name[64];		// helper name
    int			type;			// one of the HelperTypes values
	Vec3	pos;			// world position
	Matrix44	tm;				// transformation matrix
};

struct HELPER_CHUNK_DESC_0744
{
	enum {VERSION = 0x0744};
	CHUNK_HEADER	chdr;

    HelperTypes	type;			// one of the HelperTypes values
	Vec3	size;			// size in local x,y,z axises (for dummy only)
};

typedef HELPER_CHUNK_DESC_0744 HELPER_CHUNK_DESC; 
#define HELPER_CHUNK_DESC_VERSION HELPER_CHUNK_DESC::VERSION

// ChunkType_BoneLightBinding
// describes the lights binded to bones
struct BONELIGHTBINDING_CHUNK_DESC_0001
{
	enum {VERSION = 0x0001};
	unsigned numBindings; // the number of bone-light binding substructures following this structure
};

// single bone-light binding structure; numBindings such structures follow the BONELIGHTBINDING_CHUNK_DESC structure
struct SBoneLightBind
{
	unsigned nLightChunkId;     // chunk id of the light that's bound to a bone
	unsigned nBoneId;           // parent bone id
	Vec3 vLightOffset;         // light position in the parent bone coordinate system
	Vec3 vRotLightOrientation; // logarithm of quaternion that describes the light orientation relative to the parent bone
};

// ChunkType_MeshMorphTarget  - morph target of a mesh chunk
// This chunk contains only the information about the vertices that are changed in the mesh
// This chunk is followed by an array of numMorphVertices structures SMeshMorphTargetVertex,
// immediately followed by the name (null-terminated, variable-length string) of the morph target.
// The string is after the array because of future alignment considerations; it may be padded with 0s.
struct MESHMORPHTARGET_CHUNK_DESC_0001
{
	enum {VERSION = 0x0001};
	unsigned nChunkIdMesh;   // the chunk id of the mesh chunk (ChunkType_Mesh) for which this morph target is
	unsigned numMorphVertices;  // number of MORPHED vertices
};

// an array of these structures follows the MESHMORPHTARGET_CHUNK_DESC_0001
// there are numMorphVertices of them
struct SMeshMorphTargetVertex
{
	unsigned nVertexId; // vertex index in the original (mesh) array of vertices
	Vec3 ptVertex;     // the target point of the morph target
};

//
// ChunkType_BoneInitialPos		- describes the initial position (4x3 matrix) of each bone; just an array of 4x3 matrices
// This structure is followed by 
struct BONEINITIALPOS_CHUNK_DESC_0001
{
	enum {VERSION = 0x0001};
	// the chunk id of the mesh chunk (ChunkType_Mesh) with bone info for which these bone initial positions are applicable.
	// there might be some unused bones here as well. There must be the same number of bones as in the other chunks - they're placed
	// in BoneId order.
	unsigned nChunkIdMesh; 
	// this is the number of bone initial pose matrices here
	unsigned numBones;
};

// an array of these matrices follows the  BONEINITIALPOS_CHUNK_DESC_0001 header
// there are numBones of them
// TO BE REPLACED WITH Matrix43
struct SBoneInitPosMatrix
{
	float mx[4][3];
	float* operator [] (int i) {return mx[i];}
	const float* operator [] (int i)const {return mx[i];}

	const Vec3& getOrt (int nOrt)const {return *(const Vec3*)(mx[nOrt]);}
};

#ifdef WIN64 // TODO: comment this, to apply the pack pragma to all platforms
#pragma pack(pop)
#endif

#endif