path: root/src/win95/chnktexi.cpp

#include <string.h>

#include "fixer.h"

#include "string.hpp"
#ifndef DB_LEVEL
	#define DB_LEVEL 4
#endif
#include "db.h"

#include "awtexld.h"

#include "chnkload.hpp"
#include "chunkpal.hpp"

#ifndef CL_SUPPORT_FASTFILE
	#error "Please #define CL_SUPPORT_FASTFILE to 0 or 1 in projload.hpp"
#endif
#if CL_SUPPORT_FASTFILE
	#include "ffstdio.h"
#endif

//#ifndef CL_SUPPORT_ALTTAB
//	#error "Please #define CL_SUPPORT_ALTTAB to 0 or 1 in projload.hpp"
//#endif
//#if CL_SUPPORT_ALTTAB
//	#include "alt_tab.h"
//#endif

#include "chnktexi.h"

#if !defined(NDEBUG) && defined(_CPPRTTI)
	#include <typeinfo.h>
#else
	#define dynamic_cast static_cast
#endif
	
char const * cl_pszGameMode = NULL;

// used to determine if the display is palettized
// currently assuming that if this is <= 8 then all
// surfaces et. except d3d textures have a global palette
extern "C" {
	extern int VideoModeColourDepth;
};

// useful filename handling functions

// returns pointer into string pointing to filename without dirname
template <class C> // C can be char or char const
static C * StripPath(C * n)
{
	C * rm = strrchr(n,':');
	if (rm) n = rm+1;
	rm = strrchr(n,'/');
	if (rm) n = rm+1;
	rm = strrchr(n,'\\');
	if (rm) n = rm+1;

	return n;
}

// removes any .extension from filename by inserting null character
static void StripFileExtension(char * n)
{
	char * dotpos = strrchr(n,'.');
	if (dotpos) *dotpos = 0;
}

static char * StripFileExtension(char const * n)
{
	char * nn = new char[strlen(n)+1];
	strcpy(nn,n);
	StripFileExtension(nn);
	return nn;
}

// get the directory associated with the riff - free with delete[]
static char * RiffBasename(Chunk_With_Children * pEnvDataChunk)
{
	Chunk * pChunk = pEnvDataChunk->lookup_single_child("RIFFNAME");
	
	if (pChunk)
	{
		RIF_Name_Chunk * pRifNameChunk = dynamic_cast<RIF_Name_Chunk *>(pChunk);
		
		const char * pszRifName = StripPath(pRifNameChunk->rif_name);

		char * pszBaseName = new char[strlen(pszRifName)+1];
		strcpy(pszBaseName,pszRifName);
		StripFileExtension(pszBaseName);

		return pszBaseName;
	}
	const char * pszDefault = "empty";
	char * pszBaseName = new char [strlen(pszDefault)+1];
	strcpy(pszBaseName,pszDefault);

	return pszBaseName;
}

#if CL_SUPPORT_FASTFILE
static inline bool IsFileInFastFile(char const * pszFileName)
{
	unsigned nLen;
	return ffreadbuf(pszFileName,&nLen) ? true : false;
}
#endif

static bool DoesFileExist(char const * pszFileName)
{
	DWORD dwFileAttributes = GetFileAttributes(pszFileName);
	
	if (0xffffffff == dwFileAttributes || dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
		return false;
	else
		return true;
}

static char * GetPath(char * pszFileNameBuf, unsigned nBufSize, ImageDescriptor const & idsc, Chunk_With_Children * pEnvDataChunk, bool bGloballyPalettized)
{
	// set the name
	char const * pszRawName = StripPath(idsc.filename);
	char * pszName = new char[strlen(pszRawName)+1];
	strcpy(pszName,pszRawName);
	StripFileExtension(pszName);
					
	// load this image
	char const * pg0ext = ".PG0";
	
	if (!bGloballyPalettized)
	{
		char const * dir2 = idsc.flags & IDSCF_SPRITE ? "Sprites\\" : idsc.flags & IDSCF_SUBSHAPE ? SubShps_Directory : "";
		char * riffname = RiffBasename(pEnvDataChunk);
		char const * dir3 = idsc.flags & IDSCF_INCLUDED ? idsc.rifname : riffname;
		if (nBufSize < strlen(GenTex_Directory)+strlen(dir2)+strlen(dir3)+1+strlen(pszName)+5)
		{
			db_log1("CL_LoadImageOnce(): ERROR: buffer not big enough for filename");
			pszFileNameBuf = NULL;
		}
		else
		{
			strcpy(pszFileNameBuf,GenTex_Directory);
			strcat(pszFileNameBuf,dir2);
			strcat(pszFileNameBuf,dir3);
			strcat(pszFileNameBuf,"\\");
			strcat(pszFileNameBuf,pszName);
			strcat(pszFileNameBuf,".BM0");
		}
		delete[] riffname;
	}
	else
	{
		if (idsc.flags & IDSCF_FIXEDPALETTE)
		{
			char const * dir2 = idsc.fixrifname ? *idsc.fixrifname ? idsc.fixrifname : 0 : 0;
			char const * dir3 = idsc.flags & IDSCF_SPRITE ? "Sprites\\" : "";
			char * riffname = RiffBasename(pEnvDataChunk);
			char const * dir4 = idsc.flags & IDSCF_INCLUDED ? idsc.rifname : riffname;
			if (nBufSize < strlen(FixTex_Directory)+(dir2 ? strlen(dir2)+1 : 0)+strlen(dir3)+strlen(dir4)+1+strlen(pszName)+5)
			{
				db_log1("CL_LoadImageOnce(): ERROR: buffer not big enough for filename");
				pszFileNameBuf = NULL;
			}
			else
			{
				strcpy(pszFileNameBuf,FixTex_Directory);
				if (dir2)
				{
					strcat(pszFileNameBuf,dir2);
					strcat(pszFileNameBuf,"\\");
				}
				strcat(pszFileNameBuf,dir3);
				strcat(pszFileNameBuf,dir4);
				strcat(pszFileNameBuf,"\\");
				strcat(pszFileNameBuf,pszName);
				strcat(pszFileNameBuf,pg0ext);
			}
			delete[] riffname;
		}
		else
		{
			char const * dir1 = cl_pszGameMode ? GameTex_Directory : ToolsTex_Directory;
			char * dir2 = RiffBasename(pEnvDataChunk);
			char const * dir4 = idsc.flags & IDSCF_SPRITE ? "Sprites\\" : "";
			char const * dir5 = idsc.flags & IDSCF_INCLUDED ? idsc.rifname : 0;
			if (nBufSize < strlen(dir1)+strlen(dir2)+1+(cl_pszGameMode ? strlen(cl_pszGameMode)+1 : 0)+strlen(dir4)+(dir5 ? strlen(dir5)+1 : 0)+strlen(pszName)+5)
			{
				db_log1("CL_LoadImageOnce(): ERROR: buffer not big enough for filename");
				pszFileNameBuf = NULL;
			}
			else
			{
				strcpy(pszFileNameBuf,dir1);
				strcat(pszFileNameBuf,dir2);
				strcat(pszFileNameBuf,"\\");
				if (cl_pszGameMode)
				{
					strcat(pszFileNameBuf,cl_pszGameMode);
					strcat(pszFileNameBuf,"\\");
				}
				strcat(pszFileNameBuf,dir4);
				if (dir5)
				{
					strcat(pszFileNameBuf,dir5);
					strcat(pszFileNameBuf,"\\");
				}
				strcat(pszFileNameBuf,pszName);
				strcat(pszFileNameBuf,pg0ext);
			}
			delete[] dir2;
		}
	}

	if (pszFileNameBuf)
		db_logf4(("\tfile expected to be '%s'",pszFileNameBuf));
		
	delete[] pszName;
		
	return pszFileNameBuf;
}

char * CL_GetImageFileName(char * pszDestBuf, unsigned nBufSize, char const * pszFileName, unsigned fFlagsEtc)
{
	db_assert1(pszFileName);
	db_assert1(pszDestBuf);
	db_assert1(nBufSize>0);
	db_logf4(("CL_LoadImageOnce(): Getting the full pathname for %s",pszFileName));
	switch (fFlagsEtc & _LIO_PATHTYPEMASK)
	{
		case LIO_ABSOLUTEPATH:
			db_log4("\t(which is an absolute path)");
			if (strlen(pszFileName)<nBufSize)
			{
				strcpy(pszDestBuf,pszFileName);
				return pszDestBuf;
			}
			else
			{
				db_log1("CL_LoadImageOnce(): ERROR: buffer not large enough to hold filename");
				return NULL;
			}
		case LIO_RELATIVEPATH:
			db_logf4(("\t(which is a path relative to %s or %s)",
				FirstTex_Directory ? FirstTex_Directory : "<not-specified>",
				SecondTex_Directory ? SecondTex_Directory : "<not-specified>"));
			#define _GET_RELATIVE_PATH(pszDirectory,fnDoesExist) \
				if (pszDirectory) { \
					String str = pszDirectory; \
					if (str.length()) { \
						int chLast = str.get_at(str.length()-1); \
						if (chLast != '\\' && chLast != '/') \
							str += '\\'; \
						str += pszFileName; \
						if (fnDoesExist(str)) { \
							if (str.length() < nBufSize) { \
								strcpy(pszDestBuf,str); \
								return pszDestBuf; \
							} else { \
								db_log1("CL_LoadImageOnce(): ERROR: buffer not large enough to hold filename"); \
								return NULL; /* fail because the buffer isnt big enough */ \
				}	}	}	}
				
			#if CL_SUPPORT_FASTFILE
			_GET_RELATIVE_PATH(FirstTex_Directory,IsFileInFastFile)
			_GET_RELATIVE_PATH(SecondTex_Directory,IsFileInFastFile)
			#endif
			#if !defined(CL_SUPPORTONLY_FASTFILE) || !CL_SUPPORTONLY_FASTFILE
			_GET_RELATIVE_PATH(FirstTex_Directory,DoesFileExist)
			_GET_RELATIVE_PATH(SecondTex_Directory,DoesFileExist)
			#endif
			db_log1("CL_LoadImageOnce(): ERROR: file not found in relative path");
			return NULL;
		case LIO_RIFFPATH:
		{
			int enum_id = -1; // may be supported at a later date, valid when pszFileName is NULL
			
			bool bGloballyPalettized = VideoModeColourDepth <= 8 && (fFlagsEtc & _LIO_SURFTYPEMASK) != LIO_D3DTEXTURE;
			
			db_log4("\t(whose path is determined by the current .RIF file)");
			if (!Env_Chunk)
			{
				db_log1("CL_LoadImageOnce(): ERROR: no RIF file");
				return NULL;
			}
			Chunk * pChunk = Env_Chunk->lookup_single_child("REBENVDT");
			if (!pChunk)
			{
				db_log1("CL_LoadImageOnce(): ERROR: no environment data chunk");
				return NULL;
			}
			Chunk_With_Children * pEnvDataChunk = dynamic_cast<Chunk_With_Children *>(pChunk);
			db_assert1(pEnvDataChunk);
			
			Environment_Game_Mode_Chunk * pGameModeChunk = NULL;
			if (cl_pszGameMode)
			{
				if (*cl_pszGameMode)
				{
					List<Chunk *> listGmChunks;
					pEnvDataChunk->lookup_child("GAMEMODE",listGmChunks);
					
					for (LIF<Chunk *> itGmChunks(&listGmChunks); !itGmChunks.done(); itGmChunks.next())
					{
						Environment_Game_Mode_Chunk * pGmChunk = dynamic_cast<Environment_Game_Mode_Chunk *>(itGmChunks());
						db_assert1(pGmChunk);
						if (pGmChunk->id_equals(cl_pszGameMode))
						{
							pGameModeChunk = pGmChunk;
							break;
						}
					}

					if (!pGameModeChunk)
						db_logf3(("CL_LoadImageOnce(): WARNING: Game Mode '%s' not found",cl_pszGameMode));
				}
			}

			char * pszName = StripFileExtension(StripPath(pszFileName));
			
			char * pszSubName = 0;
			if (pszFileName)
			{
				if (strchr(pszFileName,'\\'))
				{
					pszSubName = new char[strlen(pszFileName)+1];
					strcpy(pszSubName,pszFileName);
					*strchr(pszSubName,'\\')=0;
				}
				else if (strchr(pszFileName,'/'))
				{
					pszSubName = new char[strlen(pszFileName)+1];
					strcpy(pszSubName,pszFileName);
					*strchr(pszSubName,'/')=0;
				}
			}

			if (pGameModeChunk)
			{
				bool bShapeInGm = pszSubName ? false : true;
				// Get the matching image 'Processor' chunk
				Chunk * pMiChunk = pGameModeChunk->lookup_single_child("MATCHIMG");
				Matching_Images_Chunk * pMatchImageChunk = NULL;
				
				if (pMiChunk)
				{
					pMatchImageChunk = dynamic_cast<Matching_Images_Chunk *>(pMiChunk);
					db_assert1(pMatchImageChunk);
				}
				
				List<Chunk *> listRifChildChunks;
				pGameModeChunk->lookup_child("RIFCHILD",listRifChildChunks);
				
				for (LIF<Chunk *> itRifChildChunks(&listRifChildChunks); !itRifChildChunks.done(); itRifChildChunks.next())
				{
					RIF_Child_Chunk * pRifChildChunk = dynamic_cast<RIF_Child_Chunk *>(itRifChildChunks());
					db_assert1(pRifChildChunk);

					if (pszSubName)
					{
						if (_stricmp(pszSubName,pRifChildChunk->rifname) && (*pszSubName || *pRifChildChunk->filename))
							continue;
						bShapeInGm = true;
					}

					for (LIF<BMP_Flags> itBmpFlags(&pRifChildChunk->bmps); !itBmpFlags.done(); itBmpFlags.next())
					{
						BMP_Flags bmpfTemp(itBmpFlags());
						StripFileExtension(bmpfTemp.filename);

						if (pszFileName ? !_stricmp(pszName,StripPath(bmpfTemp.filename)) : enum_id == bmpfTemp.enum_id)
						{
							// select image descriptor
							ImageDescriptor const idsc
								(
									*pRifChildChunk->filename ? 
										(IDscFlags)((bmpfTemp.flags & ChunkBMPFlag_FixedPalette ?
											IDSCF_FIXEDPALETTE
										:
											IDSCF_0)
										|IDSCF_INCLUDED)
									:
										IDSCF_0,
									itBmpFlags().filename,
									*pRifChildChunk->filename ? pRifChildChunk->rifname : 0
								);
							ImageDescriptor const * pIdsc = &idsc;

							if (pMatchImageChunk) pIdsc = &pMatchImageChunk->GetLoadImage(idsc);
							else db_logf3(("CL_LoadImageOnce(): WARNING! no rule to find matching images in game mode '%s'\n",pGameModeChunk->header->mode_identifier));

							// load this image
							if (GetPath(pszDestBuf,nBufSize,*pIdsc,pEnvDataChunk,bGloballyPalettized))
							{
								if (pszSubName)
								{
									delete[] pszSubName;
								}
								delete[] pszName;
								return pszDestBuf;
							}
						}
					}
				}
				
				List<Chunk *> listExtShapes;
				pGameModeChunk->lookup_child("SHBMPNAM",listExtShapes);

				for (LIF<Chunk *> itExtShapes(&listExtShapes); !itExtShapes.done(); itExtShapes.next())
				{
					External_Shape_BMPs_Store_Chunk * pShapeBmpsChunk = dynamic_cast<External_Shape_BMPs_Store_Chunk *>(itExtShapes());
					db_assert1(pShapeBmpsChunk);

					if (pszSubName)
						if (_stricmp(pszSubName,pShapeBmpsChunk->shapename) && *pszSubName)
							continue;

					for (LIF<BMP_Name> itBmpNames(&pShapeBmpsChunk->bmps); !itBmpNames.done(); itBmpNames.next())
					{
						BMP_Name bmpnTemp(itBmpNames());
						StripFileExtension(bmpnTemp.filename);

						if (pszFileName ? !_stricmp(pszName,StripPath(bmpnTemp.filename)) : enum_id == bmpnTemp.enum_id)
						{

							// select image descriptor
							ImageDescriptor const idsc
								(
									(IDscFlags)((bmpnTemp.flags & ChunkBMPFlag_FixedPalette ?
										IDSCF_FIXEDPALETTE
									:
										IDSCF_0)
									|(pShapeBmpsChunk->GetExtendedData()->flags & GBF_SPRITE ?
										IDSCF_SPRITE
									:
										IDSCF_SUBSHAPE)
									|IDSCF_INCLUDED),
									itBmpNames().filename,
									pShapeBmpsChunk->shapename,
									bmpnTemp.flags & ChunkBMPFlag_FixedPalette ? pShapeBmpsChunk->rifname : 0
								);
							ImageDescriptor const * pIdsc = &idsc;

							if (pMatchImageChunk) pIdsc = &pMatchImageChunk->GetLoadImage(idsc);
							else db_logf3(("WARNING! no rule to find matching images in game mode %s\n",pGameModeChunk->header->mode_identifier));

							// load this image
							if (GetPath(pszDestBuf,nBufSize,*pIdsc,pEnvDataChunk,bGloballyPalettized))
							{
								if (pszSubName)
								{
									delete[] pszSubName;
								}
								delete[] pszName;
								return pszDestBuf;
							}
						}
					}
				}
				
				if (pszSubName)
				{
					if (!bShapeInGm)
						db_logf3(("CL_LoadImageOnce(): WARNING! shape/sprite %s not found in this RIF file\n",pszSubName));
					else
						db_logf3(("CL_LoadImageOnce(): WARNING! shape/sprite %s does not appear to list %s\n",pszSubName,pszName));
				}

			}

			List<Chunk *> listMatchImageChunk;
			pEnvDataChunk->lookup_child("MATCHIMG",listMatchImageChunk);
			
			Matching_Images_Chunk * pMicFix = NULL;
			Matching_Images_Chunk * pMicNorm = NULL;
			
			for (LIF<Chunk *> itMatchImageChunk(&listMatchImageChunk); !itMatchImageChunk.done(); itMatchImageChunk.next())
			{
				Matching_Images_Chunk * pMatchImageChunk = dynamic_cast<Matching_Images_Chunk *>(itMatchImageChunk());
				db_assert1(pMatchImageChunk);
				if (pMatchImageChunk->flags & MICF_FIXEDPALETTE)
					pMicFix = pMatchImageChunk;
				else
					pMicNorm = pMatchImageChunk;
			}
				
			List<Chunk_With_Children *> listShapesSprites;
			
			List<Chunk *> listShapes;
			Env_Chunk->lookup_child("REBSHAPE",listShapes);
			for (LIF<Chunk *> itShapes(&listShapes); !itShapes.done(); itShapes.next())
			{	
				Shape_Chunk * pShapeChunk = dynamic_cast<Shape_Chunk *>(itShapes());
				db_assert1(pShapeChunk);
				Chunk * pSxfnChunk = pShapeChunk->lookup_single_child("SHPEXTFL");
				if (pSxfnChunk)
				{
					Shape_External_File_Chunk * pShpExtFnameChunk = dynamic_cast<Shape_External_File_Chunk *>(pSxfnChunk);
					db_assert1(pShpExtFnameChunk);
					listShapesSprites.add_entry(pShpExtFnameChunk);
				}
			}
			Chunk * pSprChunk = Env_Chunk->lookup_single_child("RSPRITES");
			if (pSprChunk)
			{
				Chunk_With_Children * pSpritesChunk = dynamic_cast<Chunk_With_Children *>(pSprChunk);
				db_assert1(pSpritesChunk);
				
				List<Chunk *> listSprHeadChunks;
				pSpritesChunk->lookup_child("SPRIHEAD",listSprHeadChunks);
				
				for (LIF<Chunk *> itSprites(&listSprHeadChunks); !itSprites.done(); itSprites.next())
				{	
					Chunk_With_Children * pSpriteHead = dynamic_cast<Chunk_With_Children *>(itSprites());
					db_assert1(pSpriteHead);
					listShapesSprites.add_entry(pSpriteHead);
				}
			}

			int bShapeFound = pszSubName ? false : true;
			
			for (LIF<Chunk_With_Children *> itShapesSprites(&listShapesSprites); !itShapesSprites.done(); itShapesSprites.next())
			{	
				char * pszSubRifName = RiffBasename(itShapesSprites());

				if (pszSubName)
				{
					if (_stricmp(pszSubRifName,pszSubName)) // must match shapes name exactly
					{
						delete[] pszSubRifName;
						continue;
					}
					bShapeFound = true;
				}
				
				Chunk * pBmpLstStChunk = itShapesSprites()->lookup_single_child("BMPLSTST");
				if (pBmpLstStChunk)
				{
					Bitmap_List_Store_Chunk * pBmpListStoreChunk = dynamic_cast<Bitmap_List_Store_Chunk *>(pBmpLstStChunk);
					db_assert1(pBmpListStoreChunk);

					for (LIF<BMP_Name> itBmpName(&pBmpListStoreChunk->bmps); !itBmpName.done(); itBmpName.next())
					{
						BMP_Name bmpnTemp(itBmpName());
						StripFileExtension(bmpnTemp.filename);

						if (pszFileName ? !_stricmp(pszName,StripPath(bmpnTemp.filename)) : enum_id == bmpnTemp.enum_id)
						{
						
							// select image descriptor
							char * pszRifName = RiffBasename(pEnvDataChunk);
							ImageDescriptor const idsc
								(
									(IDscFlags)((bmpnTemp.flags & ChunkBMPFlag_FixedPalette ?
										IDSCF_FIXEDPALETTE
									:
										IDSCF_0)
									|(pBmpListStoreChunk->GetExtendedData()->flags & GBF_SPRITE ?
										IDSCF_SPRITE
									:
										IDSCF_SUBSHAPE)
									|IDSCF_INCLUDED),
									itBmpName().filename,
									pszSubRifName,
									bmpnTemp.flags & ChunkBMPFlag_FixedPalette ? pszRifName : 0
								);
							ImageDescriptor const * pIdsc = &idsc;
							delete[] pszRifName;

							if (bmpnTemp.flags & ChunkBMPFlag_FixedPalette)
							{
								if (pMicFix) pIdsc = &pMicFix->GetLoadImage(idsc);
								else db_log3("CL_LoadImageOnce(): WARNING! no rule to find fixed palette matching images in environment data\n");
							}
							else
							{
								if (pMicNorm) pIdsc = &pMicNorm->GetLoadImage(idsc);
								else db_log3("CL_LoadImageOnce(): WARNING! no rule to find matching images in environment data (interface engine?)\n");
							}

							// load this image
							if (GetPath(pszDestBuf,nBufSize,*pIdsc,pEnvDataChunk,bGloballyPalettized))
							{
								delete[] pszSubRifName;
								if (pszSubName)
								{
									delete[] pszSubName;
								}
								delete[] pszName;
								return pszDestBuf;
							}
						}
					}
				}
				delete[] pszSubRifName;
			}

			if (pszSubName)
			{
				if (!bShapeFound)
					db_logf3(("CL_LoadImageOnce(): WARNING! shape/sprite %s not found in this RIF file\n",pszSubName));
				else
					db_logf3(("CL_LoadImageOnce(): WARNING! shape/sprite %s does not appear to list %s\n",pszSubName,pszName));
				delete[] pszSubName;
			}
			
			// not found in game textures, so look in default
			
			else // but only if there is no virtual shape directory
			{
				Chunk * pBmpNames = pEnvDataChunk->lookup_single_child("BMPNAMES");
				if (pBmpNames)
				{
					Global_BMP_Name_Chunk * pGbnc = dynamic_cast<Global_BMP_Name_Chunk *>(pBmpNames);
					db_assert1(pGbnc);

					for (LIF<BMP_Name> itBmpName(&pGbnc->bmps); !itBmpName.done(); itBmpName.next())
					{
						BMP_Name bmpnTemp(itBmpName());
						StripFileExtension(bmpnTemp.filename);

						if (pszFileName ? !_stricmp(pszName,StripPath(bmpnTemp.filename)) : enum_id == bmpnTemp.enum_id)
						{
							// select image descriptor
							ImageDescriptor const idsc (bmpnTemp.flags & ChunkBMPFlag_FixedPalette ? IDSCF_FIXEDPALETTE : IDSCF_0, itBmpName().filename);
							ImageDescriptor const * pIdsc = &idsc;

							if (bmpnTemp.flags & ChunkBMPFlag_FixedPalette)
							{
								if (pMicFix) pIdsc = &pMicFix->GetLoadImage(idsc);
								else db_log3("CL_LoadImageOnce(): WARNING! no rule to find fixed palette matching images in environment data\n");
							}
							else
							{
								if (pMicNorm) pIdsc = &pMicNorm->GetLoadImage(idsc);
								else db_log3("CL_LoadImageOnce(): WARNING! no rule to find matching images in environment data (interface engine?)\n");
							}

							// load this image
							if (GetPath(pszDestBuf,nBufSize,*pIdsc,pEnvDataChunk,bGloballyPalettized))
							{
								delete[] pszName;
								return pszDestBuf;
							}
						}
					}
				}
			}
			delete[] pszName;
			return NULL;
		}
		default: // invalid arguments
			db_log1("CL_LoadImageOnce(): ERROR: invalid parameter passed to CL_GetImageFileName()");
			return NULL;
	}
}

extern "C" {
	extern void CheckForWindowsMessages(void);
};

int CL_LoadImageOnce(char const * pszFileName, unsigned fFlagsEtc)
{
	// safe to handle windows messages at this point (I think - JCWH)
	CheckForWindowsMessages();
	
	// get the filename
	char szBuf[MAX_PATH];
	if (!CL_GetImageFileName(szBuf,sizeof szBuf/sizeof szBuf[0],pszFileName,fFlagsEtc))
	{
		db_log1("CL_LoadImageOnce(): ERROR: unable to determine path of file");
		return GEI_NOTLOADED;
	}
	
	db_logf4(("\tLoading '%s'",szBuf));
	
	// already loaded ?
	int iExistingImage = GetExistingImageNum(szBuf);
	if (GEI_NOTLOADED != iExistingImage)
	{
		db_logf4(("\tImage already loaded to image number %d",iExistingImage));
		return iExistingImage;
	}
	
	// what flags do we want?
	unsigned fAwLoad = AW_TLF_DEFAULT;
	if (fFlagsEtc & LIO_VIDMEM)
		fAwLoad |= AW_TLF_VIDMEM;
	if (fFlagsEtc & LIO_TRANSPARENT)
		fAwLoad |= AW_TLF_TRANSP;
	if (fFlagsEtc & LIO_CHROMAKEY)
		fAwLoad |= AW_TLF_CHROMAKEY;
	if (fFlagsEtc & LIO_LOADMIPMAPS)
		db_log1("CL_LoadImageOnce(): WARNING: mip maps not supported yet - will not be created/loaded");

	// what are we loading into ?
	switch (fFlagsEtc & _LIO_SURFTYPEMASK)
	{
		case LIO_CHIMAGE:
		{
			db_log1("CL_LoadImageOnce(): WARNING: having to call LoadImageCH()");
			IMAGEHEADER * pImageHdr = GetImageHeader();
			db_assert1(pImageHdr);
			memset(pImageHdr,0,sizeof(IMAGEHEADER));
			if (LoadImageCH(szBuf,pImageHdr))
				return NumImages-1;
			else
			{
				db_log1("CL_LoadImageOnce(): ERROR: LoadImageCH() failed");
				return GEI_NOTLOADED;
			}
		}
		case LIO_DDSURFACE:
		{
			#if CL_SUPPORT_FASTFILE
			unsigned nFastFileLen;
			void const * pFastFileData = ffreadbuf(szBuf,&nFastFileLen);
			if (pFastFileData)
			{
				db_log4("\tfile is in a fast file");
				unsigned nWidth, nHeight;
				AW_BACKUPTEXTUREHANDLE hBackup = NULL;
				DDSurface * pSurface =
					AwCreateSurface
					(
						fFlagsEtc & LIO_RESTORABLE ? "pxfXYB" : "pxfXY",
						pFastFileData,
						nFastFileLen,
						fAwLoad,
						&nWidth,
						&nHeight,
						&hBackup
					);
				if (pSurface)
				{
					IMAGEHEADER * pImageHdr = GetImageHeader();
					db_assert1(pImageHdr);
					memset(pImageHdr,0,sizeof(IMAGEHEADER));
					pImageHdr->ImageWidth = nWidth;
					pImageHdr->ImageHeight = nHeight;
					db_assert1(sizeof pImageHdr->ImageName / sizeof pImageHdr->ImageName[0] > strlen(szBuf));
					strcpy(pImageHdr->ImageName,szBuf);
					pImageHdr->DDSurface = pSurface;
					pImageHdr->hBackup = hBackup;
					db_logf4(("\tloaded to image number %d",NumImages-1));
					#if CL_SUPPORT_ALTTAB
						if (fFlagsEtc & LIO_RESTORABLE)
						#ifdef NDEBUG
							ATIncludeSurface(pSurface,hBackup);
						#else
						{
							char szDbInf[512];
							sprintf(szDbInf,"Name \"%s\" Number %d",szBuf,NumImages-1);
							ATIncludeSurfaceDb(pSurface,hBackup,szDbInf);
						}
						#endif
					#endif // CL_SUPPORT_ALTTAB
					return NumImages-1;
				}
				else
				{
					db_log1("CL_LoadImageOnce(): ERROR copying data to surface");
					return GEI_NOTLOADED;
				}
			}
			else
			#endif // CL_SUPPORT_FASTFILE
			{
				#if !defined(CL_SUPPORTONLY_FASTFILE) || !CL_SUPPORTONLY_FASTFILE
				db_log4("\tloading the actual file");
				unsigned nWidth, nHeight;
				AW_BACKUPTEXTUREHANDLE hBackup = NULL;
				DDSurface * pSurface =
					AwCreateSurface
					(
						fFlagsEtc & LIO_RESTORABLE ? "sfXYB" : "sfXY",
						&szBuf[0],
						fAwLoad,
						&nWidth,
						&nHeight,
						&hBackup
					);
				if (pSurface)
				{
					IMAGEHEADER * pImageHdr = GetImageHeader();
					db_assert1(pImageHdr);
					memset(pImageHdr,0,sizeof(IMAGEHEADER));
					pImageHdr->ImageWidth = nWidth;
					pImageHdr->ImageHeight = nHeight;
					db_assert1(sizeof pImageHdr->ImageName / sizeof pImageHdr->ImageName[0] > strlen(szBuf));
					strcpy(pImageHdr->ImageName,szBuf);
					pImageHdr->DDSurface = pSurface;
					pImageHdr->hBackup = hBackup;
					db_logf4(("\tloaded to image number %d",NumImages-1));
					db_logf4(("\t\tsurface:%p",pSurface));
					#if CL_SUPPORT_ALTTAB
						if (fFlagsEtc & LIO_RESTORABLE)
						#ifdef NDEBUG
							ATIncludeSurface(pSurface,hBackup);
						#else
						{
							char szDbInf[512];
							sprintf(szDbInf,"Name \"%s\" Number %d",szBuf,NumImages-1);
							ATIncludeSurfaceDb(pSurface,hBackup,szDbInf);
						}
						#endif
					#endif // CL_SUPPORT_ALTTAB
					return NumImages-1;
				}
				else
				{
					db_log1("CL_LoadImageOnce(): ERROR copying data to surface");
					return GEI_NOTLOADED;
				}
				#elif !CL_SUPPORT_FASTFILE
					#error "CL_SUPPORTONLY_FASTFILE set but CL_SUPPORT_FASTFILE not set"
				#endif // !CL_SUPPORTONLY_FASTFILE
			}
			//db_msg1("THIS CODE SHOULD BE UNREACHABLE");
		}
		case LIO_D3DTEXTURE:
		{
			fAwLoad |= AW_TLF_COMPRESS; // required on some cards!!
			#if CL_SUPPORT_FASTFILE
			unsigned nFastFileLen;
			void const * pFastFileData = ffreadbuf(szBuf,&nFastFileLen);
			if (pFastFileData)
			{
				db_log4("\tfile is in a fast file");
				unsigned nWidth, nHeight;
				AW_BACKUPTEXTUREHANDLE hBackup = NULL;
				D3DTexture * pTexture =
					AwCreateTexture
					(
						fFlagsEtc & LIO_RESTORABLE ? "pxfWHB" : "pxfWH",
						pFastFileData,
						nFastFileLen,
						fAwLoad,
						&nWidth,
						&nHeight,
						&hBackup
					);
				if (pTexture)
				{
					IMAGEHEADER * pImageHdr = GetImageHeader();
					db_assert1(pImageHdr);
					memset(pImageHdr,0,sizeof(IMAGEHEADER));
					pImageHdr->ImageWidth = nWidth;
					pImageHdr->ImageHeight = nHeight;
					db_assert1(sizeof pImageHdr->ImageName / sizeof pImageHdr->ImageName[0] > strlen(szBuf));
					strcpy(pImageHdr->ImageName,szBuf);
					pImageHdr->D3DTexture = pTexture;
					pImageHdr->hBackup = hBackup;
					db_logf4(("\tloaded to image number %d",NumImages-1));

					/* KJL 16:05:50 26/02/98 - attempt to get a texture handle */
					{
						int gotTextureHandle = GetTextureHandle(pImageHdr);
						db_assert1(gotTextureHandle==TRUE);
					}
					
					#if CL_SUPPORT_ALTTAB
						if (fFlagsEtc & LIO_RESTORABLE)
						#ifdef NDEBUG
							ATIncludeTexture(pTexture,hBackup);
						#else
						{
							char szDbInf[512];
							sprintf(szDbInf,"Name \"%s\" Number %d",szBuf,NumImages-1);
							ATIncludeTextureDb(pTexture,hBackup,szDbInf);
						}
						#endif
					#endif // CL_SUPPORT_ALTTAB
					return NumImages-1;
				}
				else
				{
					db_log1("CL_LoadImageOnce(): ERROR copying data to texture");
					return GEI_NOTLOADED;
				}
			}
			else
			#endif // CL_SUPPORT_FASTFILE
			{
				#if !defined(CL_SUPPORTONLY_FASTFILE) || !CL_SUPPORTONLY_FASTFILE
				db_log4("\tloading the actual file");
				unsigned nWidth, nHeight;
				AW_BACKUPTEXTUREHANDLE hBackup = NULL;
				D3DTexture * pTexture =
					AwCreateTexture
					(
						fFlagsEtc & LIO_RESTORABLE ? "sfWHB" : "sfWH",
						&szBuf[0],
						fAwLoad,
						&nWidth,
						&nHeight,
						&hBackup
					);
				if (pTexture)
				{
					IMAGEHEADER * pImageHdr = GetImageHeader();
					db_assert1(pImageHdr);
					memset(pImageHdr,0,sizeof(IMAGEHEADER));
					pImageHdr->ImageWidth = nWidth;
					pImageHdr->ImageHeight = nHeight;
					db_assert1(sizeof pImageHdr->ImageName / sizeof pImageHdr->ImageName[0] > strlen(szBuf));
					strcpy(pImageHdr->ImageName,szBuf);
					pImageHdr->D3DTexture = pTexture;
					pImageHdr->hBackup = hBackup;
					db_logf4(("\tloaded to image number %d",NumImages-1));

					/* KJL 16:05:50 26/02/98 - attempt to get a texture handle */
					{
						int gotTextureHandle = GetTextureHandle(pImageHdr);
						db_assert1(gotTextureHandle==TRUE);
					}

					#if CL_SUPPORT_ALTTAB
						if (fFlagsEtc & LIO_RESTORABLE)
						#ifdef NDEBUG
							ATIncludeTexture(pTexture,hBackup);
						#else
						{
							char szDbInf[512];
							sprintf(szDbInf,"Name \"%s\" Number %d",szBuf,NumImages-1);
							ATIncludeTextureDb(pTexture,hBackup,szDbInf);
						}
						#endif
					#endif // CL_SUPPORT_ALTTAB
					return NumImages-1;
				}
				else
				{
					db_log1("CL_LoadImageOnce(): ERROR copying data to texture");
					return GEI_NOTLOADED;
				}
				#elif !CL_SUPPORT_FASTFILE
					#error "CL_SUPPORTONLY_FASTFILE set but CL_SUPPORT_FASTFILE not set"
				#endif // !CL_SUPPORTONLY_FASTFILE
			}
			//db_msg1("THIS CODE SHOULD BE UNREACHABLE");
		}
		default:
			db_log1("CL_LoadImageOnce(): ERROR: Invalid destination surface specification");
			return GEI_NOTLOADED;
	}
}