avp/src/win95/chunkpal.hpp

#ifndef _included_chunkpal_hpp_
#define _included_chunkpal_hpp_

#include "chunk.hpp"
#include "bmpnames.hpp"
#if cencon
#include "palette.h"
#endif

static const unsigned char * grab_pixel_data(int ssize, unsigned char const * sdata)
{
	if (!ssize) return 0;
	ssize *= 3;

	unsigned char * pixels = new unsigned char[ssize];

	unsigned char * ddata = pixels;

	for (int cnt = ssize; cnt; --cnt, ++ddata, ++sdata) *ddata = *sdata;

	return pixels;
}



class Environment_Palette_Chunk : public Chunk
{

public:

#if cencon
	// constructor from data - defined in genpal
	Environment_Palette_Chunk (Chunk_With_Children * const parent, PPM_Header const * const palette);
#endif
	// constructor from buffer
	Environment_Palette_Chunk (Chunk_With_Children * const parent, const char * sdata, size_t const /*ssize*/)
		: Chunk (parent, "ENVPALET")
		, width (*(int *)sdata)
		, height (1)
		, flags (*(int *)(sdata+4))
		, pixel_data (grab_pixel_data(*(int *)sdata,(unsigned char *)(sdata+8)))
		{}
	~Environment_Palette_Chunk ();
															
	virtual size_t size_chunk ();

	virtual void fill_data_block (char * data_start);
	
	const int width;
	const int height;
	int flags; // was width, but width was always 1
	// do not use as a flag     0x00000001
	#define EnvPalFlag_UpToDate       0x00000002 // make flag
	#define EnvPalFlag_Lit            0x00000004 // uses darken flag when generating palette
	#define EnvPalFlag_V2             0x00000008 // flagged to distinguish between big tlt palette & normal palette
	#define DEFAULT_ENV_PAL_FLAGS EnvPalFlag_Lit

	const unsigned char * const pixel_data;
	
private:

	friend class Environment_Data_Chunk;
	friend class Environment_Game_Mode_Chunk;
	

};



class Preset_Palette_Chunk;

class Preset_Palette
{
public:

#if cencon
	// constructor from data - defined in genpal
	Preset_Palette (PPM_Header const * const palette);

	// update by generating from bmps chunk
	void update(Global_BMP_Name_Chunk * gbnc, Preset_Palette_Chunk * ppc, class Environment * e, Environment_Data_Chunk * envd, BOOL bDoSoftwareTex);

#if 0
	Preset_Palette (const char * iname)
		: size(0)
		, flags(0)
		, reserved1(0)
		, reserved2(0)
		, startpos(0)
		, pixel_data(0)
		, name(0)
		{
			if (iname)
			{
				name = new char[strlen(iname)+1];
				strcpy(name,iname);
			}
		}
#endif
#endif

	Preset_Palette ()
		: size(0)
		, flags(0)
		, reserved1(0)
		, reserved2(0)
		, startpos(0)
		, name(0)
		, pixel_data(0)
		{}
	
	// copy constructor
	Preset_Palette (Preset_Palette const & c);

	~Preset_Palette ();

	Preset_Palette & operator = (Preset_Palette const & c);

	const int size;
	int flags;
	#define PrePalFlag_Reserved 0x00000001 // preset palette defines contant entries in palette for graphics which are not reloaded
	#define PrePalFlag_UpToDate 0x00000002
	#define PrePalFlag_V2       0x00000004 // calculated fixed palette using wide palette, tlt and lit textures

	const int reserved1;
	const int reserved2;
	int startpos;

	char * name;

	const unsigned char * const pixel_data;

	// for the list template
	inline BOOL operator == (Preset_Palette const & c) const { return !_stricmp(name,c.name); }
	inline BOOL operator != (Preset_Palette const & c) const { return _stricmp(name,c.name); }
	inline BOOL operator < (Preset_Palette const & c) const { return startpos < c.startpos; }

private:

	friend class Preset_Palette_Chunk;
	friend class Preset_Palette_Store_Chunk;
	
	size_t size_chunk () const;

	void fill_data_block (char * data_start);

	// constructor from buffer
	Preset_Palette (char const * sdata)
		: size (*(int *)sdata)
		, flags (*(int *)(sdata+4))
		, reserved1 (*(int *)(sdata+8))
		, reserved2 (*(int *)(sdata+12))
		, startpos (*(int *)(sdata+16))
		, pixel_data (grab_pixel_data(*(int *)sdata,(unsigned char *)(sdata+20)))
		{
			sdata += 20+size*3;
			name = new char[strlen(sdata)+1];
			strcpy(name,sdata);
		}
};


class Preset_Palette_Chunk : public Chunk
{
public:

#if cencon
	// empty constructor
	Preset_Palette_Chunk (Chunk_With_Children * const parent)
		: Chunk (parent,"PRSETPAL")
		, flags(0)
		, version_num(0)
		, reserved1(0)
		, reserved2(0)
		, reserved3(0)
		{}

#endif
	// constructor from buffer
	Preset_Palette_Chunk (Chunk_With_Children * const parent, char const * sdata, size_t const ssize);
	~Preset_Palette_Chunk () {};

	virtual size_t size_chunk ();

	virtual void fill_data_block (char * data_start);

	int flags;
	int version_num;

	const int reserved1;
	const int reserved2;
	const int reserved3;

	List<Preset_Palette> pplist;


private:

	friend class Environment_Data_Chunk;
	

};




class Environment_TLT_Chunk : public Chunk
{

public:

#if cencon
	// constructor using palette - defined in genpal
	Environment_TLT_Chunk (Chunk_With_Children * parent, PPM_Header * palette, PPM_Header * tlt_palette, Lighting_Style const * ls);
#endif
	// constructor from buffer
	Environment_TLT_Chunk (Chunk_With_Children * parent, const char * sdata, size_t ssize);

	~Environment_TLT_Chunk ();
															
	virtual size_t size_chunk ();

	virtual void fill_data_block (char * data_start);

	int width; // should be == palette size, though may well have to be 256 due to the way 3dc lookup works
	int num_levels; // usually 256, for 256 "different" shades of each colour

	#define ChunkTLT_NumReserved 5
	int reserved[ ChunkTLT_NumReserved ];

	int flags; // either expect filename or table
	#define ChunkTLTFlag_ExternalFile   0x00000001
	#define ChunkTLTFlag_OptionsChanged 0x00000002
	#define ChunkTLTFlag_V2             0x00000004 // version 2: may have width != 256, flagged so we can distinguish between two tables in chunk
	
	char * filename; // either a filename

	unsigned char * table; // or an actual table in memory

private:

	friend class Environment_Data_Chunk;
	friend class Environment_Game_Mode_Chunk;
	

	
};


class TLTConfigBlock
{
public:
	// constructos;
	TLTConfigBlock()
		{
			spares[0]=0;
			spares[1]=0;
			spares[2]=0;
			spares[3]=0;
		}

		TLTConfigBlock(double const & iistart, double const & oistart, double const & iiend, double const & oiend)
		: input_intensity_start(iistart)
		, output_intensity_start(oistart)
		, input_intensity_end(iiend)
		, output_intensity_end(oiend)
		{
			spares[0]=0;
			spares[1]=0;
			spares[2]=0;
			spares[3]=0;
		}

	// I/O
	TLTConfigBlock(char const * datablock)
		: input_intensity_start(*(double *)datablock)
		, output_intensity_start(*(double *)(datablock+8))
		, input_intensity_end(*(double *)(datablock+16))
		, output_intensity_end(*(double *)(datablock+24))
		{
			memcpy(spares,datablock+32,16);
		}
	inline size_t Size() const { return 48; }
	inline void WriteData(char * datablock) const
		{
			*(double *)datablock = input_intensity_start;
			datablock += 8;
			*(double *)datablock = output_intensity_start;
			datablock += 8;
			*(double *)datablock = input_intensity_end;
			datablock += 8;
			*(double *)datablock = output_intensity_end;
			datablock += 8;
			memcpy(datablock,spares,16);
		}

	// operators
	inline BOOL operator == (TLTConfigBlock const & tcb2) const
		{
			return input_intensity_start == tcb2.input_intensity_start
				&& output_intensity_start == tcb2.output_intensity_start
				&& input_intensity_end == tcb2.input_intensity_end
				&& output_intensity_end == tcb2.output_intensity_end;
		}
	inline BOOL operator != (TLTConfigBlock const & tcb2) const
		{ return ! operator == (tcb2); }
	
	// members
	double input_intensity_start;
	double output_intensity_start;
	double input_intensity_end;
	double output_intensity_end;

private:

	int spares[4];
	
};

struct TLTCC_Flags
{
	TLTCC_Flags(unsigned int data = 0);

	operator unsigned int () const;

	unsigned int allow_v2 : 1; // palette size refers to bigger size table
	unsigned int nodefault : 1; // suppress normal 256 colour tlts
};

class TLT_Config_Chunk : public Chunk
{

public:

#if cencon
	// constructor for default
	TLT_Config_Chunk (Chunk_With_Children * parent, char const * rifname = 0)
		: Chunk (parent, "TLTCONFG")
		, num_shades_white(16)
		, srcrifname(rifname ? new char [strlen(rifname)+1] : 0)
		, blocks(TLTConfigBlock(0,0,1,1))
		, table_size(256)
		, palette_size(0)
		{
			for (int i=0; i<3; ++i) reserved[i]=0;
			if (rifname) strcpy(srcrifname,rifname);
		}
#endif
	// constructor from buffer
	TLT_Config_Chunk (Chunk_With_Children * parent, const char * sdata, size_t ssize);

	~TLT_Config_Chunk()
		{ if (srcrifname) delete[] srcrifname; }

	virtual size_t size_chunk ();

	virtual void fill_data_block (char * data_start);

	char * srcrifname;

	unsigned int num_shades_white;

	unsigned int table_size;

	List<TLTConfigBlock> blocks;

	unsigned int palette_size; // for version 2 palettes and big tlt

	TLTCC_Flags flags;

	inline BOOL operator == (TLT_Config_Chunk const & tcc2) const
		{ return blocks == tcc2.blocks && num_shades_white == tcc2.num_shades_white && table_size == tcc2.table_size && flags == tcc2.flags && (!flags.allow_v2 || palette_size == tcc2.palette_size); }
	inline BOOL operator != (TLT_Config_Chunk const & tcc2) const
		{ return ! operator == (tcc2); }
	inline BOOL NeedFullRemake(TLT_Config_Chunk const & tcc_old) const
		{ return blocks != tcc_old.blocks || num_shades_white != tcc_old.num_shades_white; }
	inline BOOL NeedNewTLTPalette(TLT_Config_Chunk const & tcc_old) const
		{ return flags != tcc_old.flags || flags.allow_v2 && palette_size != tcc_old.palette_size; }
		
private:
	int reserved[3];

	friend class Environment_Data_Chunk;
	friend class Environment_Game_Mode_Chunk;
	

	
};

#if cencon
extern TLT_Config_Chunk Default_TLT_Config_Chunk;
#endif




// Multi-Palettes for one environment

// Coloured polygons will be set on load-up
// If 15 bit is good-enough, we can use a 32K
// lookup table for the coloured polygons,
// otherwise we'll have to do the slower
// distance comparisons

// We need a new chunk which is a child of the REBENVDT environment data chunk

// this will be a GAMEMODE chunk with children, and there may be more than one
//  in the case where there are several palettes available for the environment

// there will be an identifying string in the gamepalette chunk.
// the "REBENVDT"->lookup_child("GAMPALET") will return a list of these chunks,
// so you can look through them to find the one you want
// There should be some sort of convention/restriction/communication
// about the 

// most of the information will be in its children, which can be any of the following

// ENVPALET

// RIFCHILD(s) - the name of RIF file(s)
//	   this is basically a RIF_Name_Chunk, but named differently so as to distinguish it from its own file's name
//     which should have a REBENVDT chunk with BMPNAMES and/or RIFCHILD(s) (even more RIFs)
//     specifying what non-environment specific bitmaps are used, and probably much more data,
//         - they could be sprites, etc.
//     then all the data could be automatically included (but not loaded) by the inclusion of one file

// ENVTXLIT - texture lighting table,
//     but maybe this should a filename to load if required

// CLRLOOKP - 15-bit r;g;b lookup table to get palette entries for coloured polygons on load
//     can have a table or a reference file

// other relevant chunks to be added later
// we may need some sort of BMPNAMES chunk, for flags about which bmps are quantized, etc.


// HOW TO USE - example (supplied without warranty)
// ----------

/*
File_Chunk * environment = $current environment$;

List<Chunk *> envdatalist = environment->lookup_child("REBENVDT");

if (envdatalist.size())
{
	Environment_Data_Chunk * envdata = (Environment_Data_Chunk *)envdatalist.first_entry();

	List<Chunk *> gamemodelist = envdata->lookup_child("GAMEMODE");

	Environment_Game_Mode_Chunk * selected = 0;
	
	for(LIF<Chunk *> li(&gamemodelist); !li.done(); li.next())
	{
		Environment_Game_Mode_Chunk * try_this = (Environment_Game_Mode_Chunk *) li();
		if (try_this->id_equals((const char *)$your identifier$))
		{
			selected = try_this;
			break;
		}
	}

	if (selected)
	{
		List<Chunk *> bmpgrouplist = selected->lookup_child("RIFCHILD");

		String subdir;
		
		List<Chunk *> rifnamechunk = envdata->lookup_child("RIFFNAME");
		if (rifnamechunk.size())
			subdir = ((RIF_Name_Chunk *) rifnamechunk.first_entry())->rif_name;
		else
			subdir = "empty";

		// load graphics loop
		for (LIF<Chunk *> g(&bmpgrouplist); !g.done(); g.next())
		{
			RIF_Child_Chunk * current = (RIF_Child_Chunk *)g();

			const char * mipmap_0;
			const char * mipmap_n;
			String dir;
			
			if ($loading pgms$)
			{
				dir = (String)"Game-Textures\\" + subdir + "\\" + (String)$your identifier$ + "\\";
				if (*current->filename)
				{
					dir += (String)current->rifname + "\\";
				}
				mipmap_0 = ".pg0";
				mipmap_n = ".pg%1d";
			}
			else // loading bm0 to bm6
			{
				dir = (String)"Generic-Textures\\" + current->rifname + "\\";
				mipmap_0 = ".pg0";
				mipmap_n = ".pg%1d";
			}

			// load graphics-set loop
			for (LIF<BMP_Flags> img(&current->bmps); !img.done(); img.next())
			{
				BMP_Flags bmp = img();

				char * imname = new char[strlen(bmp.filename)+5];
				strcpy(imname,bmp.filename);
				char * dotpos = strrchr(imname,'.');
				if (!dotpos) dotpos = imname + strlen(imname);
				strcpy(dotpos,mipmap_0);
				
				String filename = dir + imname;

				$load image$(filename)

				if (bmp.flags & ChunkBMPFlag_MipMapsQuantized)
				{
					// load mipmaps loop
					for (int i = 1 ; i<=6 ; ++i)
					{
						sprintf(dotpos,mipmap_n,i);
						filename = dir + imname;
						$load image$(filename)
					}
				}
				delete [] imname;
			}
		}
	}
	else
	{
		// your identifier is not valid
	}
}
else
{
	// no data
}



*/


#define GameModeFlag_Editable 0x00000001 // game modes are not editable if they are included from another RIF
#define GameModeFlag_Deleted  0x00000002 // so you can click on cancel and invisibly no updating will be done
#define GameModeFlag_Added    0x00000004 // ditto

class Environment_Game_Mode_Chunk;
class Environment_Game_Mode_Header_Chunk;



class Environment_Game_Mode_Chunk : public Chunk_With_Children
{

public:

#if cencon
	// constructor from data
	Environment_Game_Mode_Chunk (Environment_Data_Chunk * const parent, const char * _mode_id);

	// defined in gmodlink
	void remove(class CWnd * const pWnd); // update this copy by finding its original
	void update(class CWnd * const pWnd, BOOL bDoSoftwareTex); // update this copy by finding its original
	void been_updated(class CWnd * const pWnd, BOOL bDoSoftwareTex); // find and update copies from this original
	void definite_update(Environment_Game_Mode_Chunk const * const src, class CWnd * const pWnd, Environment_Data_Chunk * envd, BOOL bDoSoftwareTex);

#endif
	// constructor from buffer
	Environment_Game_Mode_Chunk (Chunk_With_Children * const parent, const char * sdata, size_t const ssize);

	~Environment_Game_Mode_Chunk(){}
															
	Environment_Game_Mode_Header_Chunk * header;
	Environment_Data_Chunk * const envd_parent;
	
	char * ExpandedIdentifier() const; // must delete return value

	inline BOOL operator == (Environment_Game_Mode_Chunk const & m) const;
	inline BOOL operator != (Environment_Game_Mode_Chunk const & m) const;
	// public function for people to check if they have	the game mode they want
	inline BOOL id_equals(const char * s) const;

private:

	friend class Environment_Data_Chunk;
	

	
};

class Environment_Game_Mode_Chunk_Pointer
{
private:
	Environment_Game_Mode_Chunk * p;
	// poor lonely thing has no friends and never will -- aaaahh

private:	
	inline Environment_Game_Mode_Chunk_Pointer(void) : p(0) {};
	friend struct List_Member<Environment_Game_Mode_Chunk_Pointer>;

public:
	// copy constructor from another of this type
	//inline Environment_Game_Mode_Chunk_Pointer(Environment_Game_Mode_Chunk_Pointer const & cp) : p(cp.p) {};
	// cast constructor from C pointer
	inline Environment_Game_Mode_Chunk_Pointer(Environment_Game_Mode_Chunk * const cp) : p(cp) {};
	// cast to C pointer operator
	inline operator Environment_Game_Mode_Chunk * (void) const { return p; }
	// no empty constructor -- p must always be valid

	// equavalence based on contents of pointer, not addresses being the same
	inline BOOL operator == (Environment_Game_Mode_Chunk_Pointer const m) const
	{
		if (!p || !m.p) return 0;
		return *p == *m.p;
	}
	inline BOOL operator != (Environment_Game_Mode_Chunk_Pointer const m) const
	{
		if (!p || !m.p) return 1;
		return *p != *m.p;
	}

};


///////////////////////////////////////////////




class Environment_Game_Mode_Header_Chunk : public Chunk
{
public:
	// constructor from buffer
	Environment_Game_Mode_Header_Chunk (Chunk_With_Children * const parent, const char * pdata, size_t const psize);
	virtual size_t size_chunk ();

	virtual void fill_data_block (char * data_start);

	inline BOOL id_equals(const char * s)
	{
		if (_stricmp(s,mode_identifier))
			return FALSE;
		else
			return TRUE;
	}

	int flags;
	char * mode_identifier;

	inline void add_rif_entry(char const * f)
	{
		char * n = new char[strlen(f)+1];
		strcpy(n,f);
		rif_files.add_entry(n);
	}
	inline const char * get_safe_source(void)
	{
		if (flags & GameModeFlag_Editable)
			return "this.rif";
		if (!rif_files.size())
			return "unknown.rif";
		return rif_files.first_entry();
	}
	
private:

	friend class Environment_Game_Mode_Chunk;
	friend class Cwm_GAMEMODEDlg;
	friend class Cwm_GAMEMODClicked116Dlg;
	friend class GameModeDlg;
	friend class GameModeRifDlg;

	List<char *> rif_files; // where the game mode goes to or comes from
	
	#define ChunkGMod_NumReserved 3
	int reserved[ChunkGMod_NumReserved];

	int version_num;
	
	
	#if cencon
	// constructor from parent
	Environment_Game_Mode_Header_Chunk (Environment_Game_Mode_Chunk * const parent, const char * const _mode_id)
	: Chunk (parent, "GMODHEAD"), version_num(0),
	flags (0), rif_files()
	{
		for (int i=0; i<ChunkGMod_NumReserved; i++)
		{
			reserved[i] = 0;
		}
		mode_identifier = new char[strlen(_mode_id)+1];
		strcpy(mode_identifier,_mode_id);

		parent->header = this;
	}

	inline Environment_Game_Mode_Header_Chunk const & operator = (Environment_Game_Mode_Header_Chunk & s)
	{
		flags = s.flags;
		while (rif_files.size())
		{
			delete[] rif_files.first_entry();
			rif_files.delete_first_entry();
		}
		if (mode_identifier) delete[] mode_identifier;

		mode_identifier = new char[strlen(s.mode_identifier)+1];
		strcpy(mode_identifier,s.mode_identifier);

		for (LIF<char *> src(&s.rif_files); !src.done(); src.next())
		{
			add_rif_entry(src());
		}

		version_num = s.version_num;

		return *this;

	}
	#endif

	// deconstructor
	~Environment_Game_Mode_Header_Chunk();


	
};

//////////////////

inline BOOL Environment_Game_Mode_Chunk::operator == (Environment_Game_Mode_Chunk const & m) const
{
	if ((header->flags | m.header->flags) & GameModeFlag_Deleted) return FALSE;
	return !_stricmp(header->mode_identifier,m.header->mode_identifier);
}
inline BOOL Environment_Game_Mode_Chunk::operator != (Environment_Game_Mode_Chunk const & m) const
{
	if ((header->flags | m.header->flags) & GameModeFlag_Deleted) return TRUE;
	return _stricmp(header->mode_identifier,m.header->mode_identifier);
}
inline BOOL Environment_Game_Mode_Chunk::id_equals(const char * s) const
{
	return header->id_equals(s);
}

	
///////////////////////////////////////////////


class RIF_Child_Chunk;

class BMP_Flags
{
public:
	BMP_Flags(void) : filename(0), flags((BMPN_Flags)0), version_num(0), enum_id(0) {}
	BMP_Flags(const char * const fname) : filename(0), flags((BMPN_Flags)0), version_num(0), enum_id(0)
	{
		if (fname)
		{
			filename = new char[strlen(fname)+1];
			strcpy(filename,fname);
		}
	}
	BMP_Flags(BMP_Name const & bn) : enum_id(bn.enum_id), version_num(bn.version_num), flags((BMPN_Flags)(bn.flags & COPY_BMPN_FLAGS)), filename(0)
	{
		if (bn.filename)
		{
			filename = new char[strlen(bn.filename)+1];
			strcpy(filename,bn.filename);
		}
	}
	BMP_Flags(BMP_Flags const & c) : filename(0), enum_id(c.enum_id), version_num(c.version_num), flags(c.flags)
	{
		if (c.filename)
		{
			filename = new char[strlen(c.filename)+1];
			strcpy(filename,c.filename);
		}
	}
	operator BMP_Name () const
	{
		BMP_Name cast(filename);
		cast.flags = flags;
		cast.version_num = version_num;
		cast.enum_id = enum_id;
		return cast;
	}
	~BMP_Flags()
	{
		if (filename) delete[] filename;
	}
	
	BMP_Flags & operator = (BMP_Flags const & c)
	{
		if (filename) delete[] filename;
		if (c.filename)
		{
			filename = new char[strlen(c.filename)+1];
			strcpy(filename,c.filename);
		}
		else
			filename = 0;
		flags = c.flags;
		version_num = c.version_num;
		enum_id = c.enum_id;
		return *this;
	}


	char * filename;
	BMPN_Flags flags;
	#define BMPFLAGS_VERSION_NUM_MASK 0x000fffff
	#define BMPFLAGS_ENUMID_SHIFT 20
	int version_num;
	int enum_id;

	inline BOOL operator == (BMP_Flags const & c) const
	{
		return !_stricmp(filename,c.filename);
	}
	inline BOOL operator != (BMP_Flags const & c) const
	{
		return _stricmp(filename,c.filename);
	}

	#if cencon
	void DeleteAssociatedFiles(RIF_Child_Chunk const *, Environment_Data_Chunk *) const;
	#endif
};

enum RCC_Flags {
	RCCF_EXTERNSHAPE         = 0x00000001, // bitmaps from shape which is in game mode solely because it was an external shape added to the environment with this game mode
	RCCF_FIXEDPALETTE        = 0x00000002, // pgms are quantized with a fixed constant palette
	RCCF_HISTOGRAMEXISTS     = 0x00000004,
	RCCF_HISTOGRAMV2EXISTS     = 0x00000008,

	RCCF_DEFAULT = 0
};

class RIF_Child_Chunk : public Chunk
{
public:

#if cencon
	RIF_Child_Chunk(Environment_Game_Mode_Chunk	* const parent, const char * fname, class CWnd * const pWnd, BOOL bDoSoftwareTex);

	void update(class CWnd * const, BOOL bDoSoftwareTex);
	void update(class Environment * e, BOOL bDoSoftwareTex); // for where the environment is already loaded
	void DeleteAssociatedFiles(Environment_Data_Chunk *) const;
#endif
// constructor from buffer
	RIF_Child_Chunk (Chunk_With_Children * const parent, const char * sdata, size_t const ssize);
	~RIF_Child_Chunk();

	virtual size_t size_chunk ();

	virtual void fill_data_block (char * data_start);
	
	int const * GetMD5Val(BMP_Flags const & rcbmp);
	void SetMD5Val(BMP_Flags const & rcbmp, int const * md5id);
	void RemoveMD5Val(char const * bname);
	Bitmap_MD5_Chunk * GetMD5Chunk(char const * bname);
	void CreateMD5Chunk(BMP_Flags const & rcbmp, int const * md5id);
	
	Environment_Game_Mode_Chunk * const egm_parent;
	
   	int version_num;

	char * filename;
	char * rifname;

	inline BOOL operator == (RIF_Child_Chunk const & c) const
	{
		return !strcmp(rifname,c.rifname);
	}
	inline BOOL operator != (RIF_Child_Chunk const & c) const
	{
		return strcmp(rifname,c.rifname);
	}

	List<BMP_Flags> bmps;
	
	RCC_Flags flags;
	
	#define ChunkRIFChild_NumReserved 2
	int reserved[ChunkRIFChild_NumReserved];


private:

	friend class Environment_Game_Mode_Chunk;
	
	
};



class Preset_Palette_Store_Chunk : public Chunk
{
public:

#if cencon
	// constructor from Preset_Palette_Chunk
	Preset_Palette_Store_Chunk (Chunk_With_Children * const parent, Preset_Palette_Chunk const * const schunk, const char * const srname)
		: Chunk (parent,"SETPALST")
		, flags(schunk->flags)
		, version_num(schunk->version_num)
		, reserved1(schunk->reserved1)
		, reserved2(schunk->reserved2)
		, reserved3(schunk->reserved3)
		, rifname(new char[strlen(srname)+1])
		, pplist(schunk->pplist)
		{
			strcpy(rifname,srname);
		}

	// empty constructor
	Preset_Palette_Store_Chunk (Chunk_With_Children * const parent, const char * const srname)
		: Chunk (parent,"SETPALST")
		, flags(0)
		, version_num(0)
		, reserved1(0)
		, reserved2(0)
		, reserved3(0)
		, rifname(new char[strlen(srname)+1])
		{
			strcpy(rifname,srname);
		}

#endif
	// constructor from buffer
	Preset_Palette_Store_Chunk (Chunk_With_Children * const parent, char const * sdata, size_t const ssize);
	~Preset_Palette_Store_Chunk ()
	{
		if (rifname) delete[] rifname;
	}

	virtual size_t size_chunk ();

	virtual void fill_data_block (char * data_start);

	int flags;
	int version_num;

	const int reserved1;
	const int reserved2;
	const int reserved3;

	char * rifname;

	inline BOOL operator == (Preset_Palette_Store_Chunk const & c) const
	{
		return !strcmp(rifname,c.rifname);
	}
	inline BOOL operator != (Preset_Palette_Store_Chunk const & c) const
	{
		return strcmp(rifname,c.rifname);
	}

	List<Preset_Palette> pplist;


private:

	friend class Environment_Game_Mode_Chunk;
	

};





///////////////////////////////////////////////



class Coloured_Polygons_Lookup_Chunk : public Chunk
{
public:

#if cencon
	// constructor from data - defined in cencon
	Coloured_Polygons_Lookup_Chunk (Chunk_With_Children * parent, PPM_Header * const palette);
#endif
	// constructor from buffer
	Coloured_Polygons_Lookup_Chunk (Chunk_With_Children * parent, const char * sdata, size_t ssize);

	~Coloured_Polygons_Lookup_Chunk ();
															
	virtual size_t size_chunk ();

	virtual void fill_data_block (char * data_start);
	
	int flags;
	#define ChunkCPLUFlag_ExternalFile 0x00000001

	#define ChunkCPLU_NumReserved 7
	int reserved[ ChunkCPLU_NumReserved ];

	char * filename;
	unsigned char * table;
	
private:

	friend class Environment_Game_Mode_Chunk;
	friend class Environment_Data_Chunk;
	

};



		
	
#endif // !included