//========================================================================================
// ReadChunkData
//========================================================================================
geBoolean ReadChunkData(GBSP_Chunk *Chunk, void *Data, geVFile *f)
{
if (geVFile_Read(f, Data, Chunk->Size * Chunk->Elements) != GE_TRUE)
return GE_FALSE;
return GE_TRUE;
}
DirTree *DirTree_CreateFromFile(geVFile *File)
{
DirTree * Res;
DirTree_Header Header;
long StartPosition;
long EndPosition;
if (geVFile_Tell(File, &StartPosition) == GE_FALSE)
return GE_FALSE;
if (geVFile_Read(File, &Header, sizeof(Header)) == GE_FALSE)
return NULL;
if (Header.Signature != DIRTREE_FILE_SIGNATURE)
return GE_FALSE;
if (ReadTree(File, &Res) == GE_FALSE)
return NULL;
geVFile_Tell(File, &EndPosition);
if (Header.Size != EndPosition - StartPosition)
{
DirTree_Destroy(Res);
return NULL;
}
return Res;
}
//static BOOL GetSoundData( char* Name, unsigned char** dataPtr)
static BOOL GetSoundData( geVFile *File, unsigned char** dataPtr)
{
// FILE * f;
int32 Size;
uint8 *data;
// int32 CurPos;
#if 0
f = fopen(Name, "rb");
if (!f)
{
geErrorLog_Add(GE_ERR_FILE_OPEN_ERROR, NULL);
return FALSE;
}
#endif
#if 0
CurPos = ftell (f); // Save the startinf pos into this function
fseek (f, 0, SEEK_END); // Seek to end
Size = ftell (f); // Get End (this will be the size)
fseek (f, CurPos, SEEK_SET); // Restore file position
#endif
if (geVFile_Size(File, &Size) == GE_FALSE)
return FALSE;
data = geRam_Allocate(Size);
if (!data)
{
geErrorLog_Add(GE_ERR_OUT_OF_MEMORY, NULL);
return FALSE;
}
if (geVFile_Read(File, data, Size) == GE_FALSE)
{
geRam_Free(data);
return FALSE;
}
// fread(data, Size, 1, f);
// fclose(f);
*dataPtr = data;
return( TRUE );
}
//========================================================================================
// ReadChunk
//========================================================================================
static geBoolean ReadChunk(GBSP_BSPData *BSP, GBSP_Chunk *Chunk, geVFile *f)
{
int i;
if (geVFile_Read(f, Chunk, sizeof(GBSP_Chunk)) == GE_FALSE)
{
return GE_FALSE;
}
switch(Chunk->Type)
{
case GBSP_CHUNK_HEADER:
{
// printf("GBSP_CHUNK_HEADER\n");
if (sizeof(GBSP_Header) != Chunk->Size)
{
geErrorLog_Add(GE_ERR_BAD_BSP_FILE_CHUNK_SIZE, NULL);
return GE_FALSE;
}
if (!ReadChunkData(Chunk, (void*)&BSP->GBSPHeader, f))
return GE_FALSE;
if (strcmp(BSP->GBSPHeader.TAG, "GBSP"))
{
geErrorLog_Add(GE_ERR_INVALID_BSP_TAG, NULL);
return GE_FALSE;
}
if (BSP->GBSPHeader.Version != GBSP_VERSION)
{
geErrorLog_Add(GE_ERR_INVALID_BSP_VERSION, NULL);
return GE_FALSE;
}
break;
}
case GBSP_CHUNK_MODELS:
{
// printf("GBSP_CHUNK_MODELS\n");
if (sizeof(GFX_Model) != Chunk->Size)
{
geErrorLog_Add(GE_ERR_BAD_BSP_FILE_CHUNK_SIZE, NULL);
return GE_FALSE;
}
BSP->NumGFXModels = Chunk->Elements;
BSP->GFXModels = GE_RAM_ALLOCATE_ARRAY(GFX_Model, BSP->NumGFXModels);
if (!ReadChunkData(Chunk, (void*)BSP->GFXModels, f))
return GE_FALSE;
// Walk the models and zero out the motion pointers
for (i = 0; i < BSP->NumGFXModels; i++)
BSP->GFXModels[i].Motion = NULL;
break;
}
case GBSP_CHUNK_NODES:
{
// printf("GBSP_CHUNK_NODES\n");
if (sizeof(GFX_Node) != Chunk->Size)
{
geErrorLog_Add(GE_ERR_BAD_BSP_FILE_CHUNK_SIZE, NULL);
return GE_FALSE;
}
BSP->NumGFXNodes = Chunk->Elements;
BSP->GFXNodes = (GFX_Node*)geRam_Allocate(sizeof(GFX_Node)*BSP->NumGFXNodes);
if (!ReadChunkData(Chunk, (void*)BSP->GFXNodes, f))
return GE_FALSE;
break;
}
case GBSP_CHUNK_BNODES:
{
// printf("GBSP_CHUNK_BNODES\n");
if (sizeof(GFX_BNode) != Chunk->Size)
{
geErrorLog_Add(GE_ERR_BAD_BSP_FILE_CHUNK_SIZE, NULL);
return GE_FALSE;
}
BSP->NumGFXBNodes = Chunk->Elements;
if (BSP->NumGFXBNodes)
{
BSP->GFXBNodes = (GFX_BNode*)geRam_Allocate(sizeof(GFX_BNode)*BSP->NumGFXBNodes);
if (!ReadChunkData(Chunk, (void*)BSP->GFXBNodes, f))
return GE_FALSE;
}
break;
}
case GBSP_CHUNK_LEAFS:
{
// printf("GBSP_CHUNK_LEAFS\n");
if (sizeof(GFX_Leaf) != Chunk->Size)
{
geErrorLog_Add(GE_ERR_BAD_BSP_FILE_CHUNK_SIZE, NULL);
return GE_FALSE;
}
BSP->NumGFXLeafs = Chunk->Elements;
BSP->GFXLeafs = (GFX_Leaf*)geRam_Allocate(sizeof(GFX_Leaf)*BSP->NumGFXLeafs);
if (!ReadChunkData(Chunk, (void*)BSP->GFXLeafs, f))
return GE_FALSE;
break;
}
case GBSP_CHUNK_CLUSTERS:
{
// printf("GBSP_CHUNK_CLUSTERS\n");
if (sizeof(GFX_Cluster) != Chunk->Size)
{
geErrorLog_Add(GE_ERR_BAD_BSP_FILE_CHUNK_SIZE, NULL);
return GE_FALSE;
}
BSP->NumGFXClusters = Chunk->Elements;
//BSP->GFXClusters = GE_RAM_ALLOCATE_ARRAY(GFX_Cluster, BSP->NumGFXClusters);
BSP->GFXClusters = (GFX_Cluster*)geRam_Allocate(sizeof(GFX_Cluster)*BSP->NumGFXClusters);
if (!ReadChunkData(Chunk, (void*)BSP->GFXClusters, f))
return GE_FALSE;
break;
}
case GBSP_CHUNK_AREAS:
{
// printf("GBSP_CHUNK_AREAS\n");
if (sizeof(GFX_Area) != Chunk->Size)
{
geErrorLog_Add(GE_ERR_BAD_BSP_FILE_CHUNK_SIZE, NULL);
return GE_FALSE;
}
BSP->NumGFXAreas = Chunk->Elements;
BSP->GFXAreas = GE_RAM_ALLOCATE_ARRAY(GFX_Area, BSP->NumGFXAreas);
if (!ReadChunkData(Chunk, BSP->GFXAreas, f))
return GE_FALSE;
break;
}
case GBSP_CHUNK_AREA_PORTALS:
{
// printf("GBSP_CHUNK_AREA_PORTALS\n");
if (sizeof(GFX_AreaPortal) != Chunk->Size)
{
geErrorLog_Add(GE_ERR_BAD_BSP_FILE_CHUNK_SIZE, NULL);
return GE_FALSE;
}
BSP->NumGFXAreaPortals = Chunk->Elements;
BSP->GFXAreaPortals = GE_RAM_ALLOCATE_ARRAY(GFX_AreaPortal, BSP->NumGFXAreaPortals);
if (!ReadChunkData(Chunk, BSP->GFXAreaPortals, f))
return GE_FALSE;
break;
}
case GBSP_CHUNK_PORTALS:
{
// printf("GBSP_CHUNK_PORTALS\n");
if (sizeof(GFX_Portal) != Chunk->Size)
{
geErrorLog_Add(GE_ERR_BAD_BSP_FILE_CHUNK_SIZE, NULL);
return GE_FALSE;
}
BSP->NumGFXPortals = Chunk->Elements;
BSP->GFXPortals = (GFX_Portal*)geRam_Allocate(sizeof(GFX_Portal)*BSP->NumGFXPortals);
if (!ReadChunkData(Chunk, (void*)BSP->GFXPortals, f))
return GE_FALSE;
break;
}
case GBSP_CHUNK_PLANES:
{
// printf("GBSP_CHUNK_PLANES\n");
if (sizeof(GFX_Plane) != Chunk->Size)
{
geErrorLog_Add(GE_ERR_BAD_BSP_FILE_CHUNK_SIZE, NULL);
return GE_FALSE;
}
BSP->NumGFXPlanes = Chunk->Elements;
BSP->GFXPlanes = (GFX_Plane*)geRam_Allocate(sizeof(GFX_Plane)*BSP->NumGFXPlanes);
if (!ReadChunkData(Chunk, (void*)BSP->GFXPlanes, f))
return GE_FALSE;
break;
}
case GBSP_CHUNK_FACES:
{
// printf("GBSP_CHUNK_FACES\n");
if (sizeof(GFX_Face) != Chunk->Size)
{
geErrorLog_Add(GE_ERR_BAD_BSP_FILE_CHUNK_SIZE, NULL);
return GE_FALSE;
}
BSP->NumGFXFaces = Chunk->Elements;
BSP->GFXFaces = (GFX_Face*)geRam_Allocate(sizeof(GFX_Face)*BSP->NumGFXFaces);
if (!ReadChunkData(Chunk, (void*)BSP->GFXFaces, f))
return GE_FALSE;
break;
}
case GBSP_CHUNK_LEAF_FACES:
{
// printf("GBSP_CHUNK_LEAF_FACES\n");
if (sizeof(int32) != Chunk->Size)
{
geErrorLog_Add(GE_ERR_BAD_BSP_FILE_CHUNK_SIZE, NULL);
return GE_FALSE;
}
BSP->NumGFXLeafFaces = Chunk->Elements;
BSP->GFXLeafFaces = (int32*)geRam_Allocate(sizeof(int32)*BSP->NumGFXLeafFaces);
if (!ReadChunkData(Chunk, (void*)BSP->GFXLeafFaces, f))
return GE_FALSE;
break;
}
case GBSP_CHUNK_LEAF_SIDES:
{
// printf("GBSP_CHUNK_LEAF_SIDES\n");
if (sizeof(GFX_LeafSide) != Chunk->Size)
{
geErrorLog_Add(GE_ERR_BAD_BSP_FILE_CHUNK_SIZE, NULL);
return GE_FALSE;
}
BSP->NumGFXLeafSides = Chunk->Elements;
BSP->GFXLeafSides = (GFX_LeafSide*)geRam_Allocate(sizeof(GFX_LeafSide)*BSP->NumGFXLeafSides);
if (!ReadChunkData(Chunk, (void*)BSP->GFXLeafSides, f))
return GE_FALSE;
break;
}
case GBSP_CHUNK_VERTS:
{
// printf("GBSP_CHUNK_VERTS\n");
if (sizeof(geVec3d) != Chunk->Size)
{
geErrorLog_Add(GE_ERR_BAD_BSP_FILE_CHUNK_SIZE, NULL);
return GE_FALSE;
}
BSP->NumGFXVerts = Chunk->Elements;
BSP->GFXVerts = (geVec3d*)geRam_Allocate(sizeof(geVec3d)*BSP->NumGFXVerts);
if (!ReadChunkData(Chunk, (void*)BSP->GFXVerts, f))
return GE_FALSE;
break;
}
case GBSP_CHUNK_VERT_INDEX:
{
// printf("GBSP_CHUNK_VERT_INDEX\n");
if (sizeof(int32) != Chunk->Size)
{
geErrorLog_Add(GE_ERR_BAD_BSP_FILE_CHUNK_SIZE, NULL);
return GE_FALSE;
}
BSP->NumGFXVertIndexList = Chunk->Elements;
BSP->GFXVertIndexList = (int32*)geRam_Allocate(sizeof(int32)*BSP->NumGFXVertIndexList);
if (!ReadChunkData(Chunk, (void*)BSP->GFXVertIndexList, f))
return GE_FALSE;
break;
}
case GBSP_CHUNK_RGB_VERTS:
{
// printf("GBSP_CHUNK_RGB_VERTS\n");
if (sizeof(geVec3d) != Chunk->Size)
{
geErrorLog_Add(GE_ERR_BAD_BSP_FILE_CHUNK_SIZE, NULL);
return GE_FALSE;
}
BSP->NumGFXRGBVerts = Chunk->Elements;
BSP->GFXRGBVerts = (geVec3d*)geRam_Allocate(sizeof(geVec3d)*BSP->NumGFXRGBVerts);
if (!ReadChunkData(Chunk, (void*)BSP->GFXRGBVerts, f))
return GE_FALSE;
break;
}
case GBSP_CHUNK_TEXINFO:
{
// printf("GBSP_CHUNK_TEXINFO\n");
if (sizeof(GFX_TexInfo) != Chunk->Size)
{
geErrorLog_Add(GE_ERR_BAD_BSP_FILE_CHUNK_SIZE, NULL);
return GE_FALSE;
}
BSP->NumGFXTexInfo = Chunk->Elements;
BSP->GFXTexInfo = (GFX_TexInfo*)geRam_Allocate(sizeof(GFX_TexInfo)*BSP->NumGFXTexInfo);
if (!ReadChunkData(Chunk, (void*)BSP->GFXTexInfo, f))
return GE_FALSE;
break;
}
case GBSP_CHUNK_TEXTURES:
{
// printf("GBSP_CHUNK_TEXTURES\n");
if (sizeof(GFX_Texture) != Chunk->Size)
{
geErrorLog_Add(GE_ERR_BAD_BSP_FILE_CHUNK_SIZE, NULL);
return GE_FALSE;
}
BSP->NumGFXTextures = Chunk->Elements;
BSP->GFXTextures = (GFX_Texture*)geRam_Allocate(sizeof(GFX_Texture)*BSP->NumGFXTextures);
if (!ReadChunkData(Chunk, (void*)BSP->GFXTextures, f))
return GE_FALSE;
break;
}
case GBSP_CHUNK_TEXDATA:
{
// printf("GBSP_CHUNK_TEXDATA\n");
if (sizeof(uint8) != Chunk->Size)
{
geErrorLog_Add(GE_ERR_BAD_BSP_FILE_CHUNK_SIZE, NULL);
return GE_FALSE;
}
BSP->NumGFXTexData = Chunk->Elements;
BSP->GFXTexData = (uint8*)geRam_Allocate(sizeof(uint8)*BSP->NumGFXTexData);
if (!ReadChunkData(Chunk, (void*)BSP->GFXTexData, f))
return GE_FALSE;
break;
}
case GBSP_CHUNK_ENTDATA:
{
// printf("GBSP_CHUNK_ENTDATA\n");
if (sizeof(uint8) != Chunk->Size)
{
geErrorLog_Add(GE_ERR_BAD_BSP_FILE_CHUNK_SIZE, NULL);
return GE_FALSE;
}
BSP->NumGFXEntData = Chunk->Elements;
BSP->GFXEntData = (uint8*)geRam_Allocate(sizeof(uint8)*BSP->NumGFXEntData);
if (!ReadChunkData(Chunk, (void*)BSP->GFXEntData, f))
return GE_FALSE;
break;
}
case GBSP_CHUNK_LIGHTDATA:
{
// printf("GBSP_CHUNK_LIGHTDATA\n");
if (sizeof(uint8) != Chunk->Size)
{
geErrorLog_Add(GE_ERR_BAD_BSP_FILE_CHUNK_SIZE, NULL);
return GE_FALSE;
}
BSP->NumGFXLightData = Chunk->Elements;
BSP->GFXLightData = (uint8*)geRam_Allocate(sizeof(uint8)*BSP->NumGFXLightData);
if (!ReadChunkData(Chunk, (void*)BSP->GFXLightData, f))
return GE_FALSE;
break;
}
case GBSP_CHUNK_VISDATA:
{
// printf("GBSP_CHUNK_VISDATA\n");
if (sizeof(uint8) != Chunk->Size)
{
geErrorLog_Add(GE_ERR_BAD_BSP_FILE_CHUNK_SIZE, NULL);
return GE_FALSE;
}
BSP->NumGFXVisData = Chunk->Elements;
BSP->GFXVisData = (uint8*)geRam_Allocate(sizeof(uint8)*BSP->NumGFXVisData);
if (!ReadChunkData(Chunk, (void*)BSP->GFXVisData, f))
return GE_FALSE;
break;
}
case GBSP_CHUNK_SKYDATA:
{
// printf("GBSP_CHUNK_SKYDATA\n");
if (sizeof(GFX_SkyData) != Chunk->Size)
{
geErrorLog_Add(GE_ERR_BAD_BSP_FILE_CHUNK_SIZE, NULL);
return GE_FALSE;
}
if (!ReadChunkData(Chunk, (void*)&BSP->GFXSkyData, f))
return GE_FALSE;
break;
}
case GBSP_CHUNK_PALETTES:
{
// printf("GBSP_CHUNK_PALETTES\n");
if (sizeof(DRV_Palette) != Chunk->Size)
{
geErrorLog_Add(GE_ERR_BAD_BSP_FILE_CHUNK_SIZE, NULL);
return GE_FALSE;
}
BSP->NumGFXPalettes = Chunk->Elements;
BSP->GFXPalettes = (DRV_Palette*)geRam_Allocate(sizeof(DRV_Palette)*BSP->NumGFXPalettes);
if (BSP->GFXPalettes == NULL)
return GE_FALSE;
if (!ReadChunkData(Chunk, (void*)BSP->GFXPalettes, f))
return GE_FALSE;
break;
}
case GBSP_CHUNK_MOTIONS:
{
// printf("GBSP_CHUNK_MOTIONS\n");
return LoadMotions(BSP, f);
}
case GBSP_CHUNK_END:
{
// printf("GBSP_CHUNK_END\n");
break;
}
default:
// printf("Don't know what this chunk is\n");
return GE_FALSE;
}
return TRUE;
}
//========================================================================================
// ReadChunkData
//========================================================================================
static geBoolean ReadChunkData(GBSP_Chunk *Chunk, void *Data, geVFile *f)
{
return geVFile_Read(f, Data, Chunk->Size * Chunk->Elements);
}
//========================================================================================
// ReadChunk
//========================================================================================
geBoolean ReadChunk(GBSP_Chunk *Chunk, geVFile *f)
{
if (geVFile_Read(f, Chunk, sizeof(GBSP_Chunk)) != GE_TRUE)
{
return GE_FALSE;
}
#ifdef DEBUGCHUNKS
if (Chunk->Type != GBSP_CHUNK_END)
{
long Pos;
geVFile_Tell(f, &Pos);
GHook.Printf(" ReadChunk: @%08x '%s', %d elements of %d size\n", Pos,
ChunkNames[Chunk->Type], Chunk->Elements, Chunk->Size);
}
else
{
long Pos;
geVFile_Tell(f, &Pos);
GHook.Printf(" ReadChunk: @%08x 'GBSP_CHUNK_END', %d elements of %d size\n", Pos, Chunk->Elements, Chunk->Size);
}
#endif
switch(Chunk->Type)
{
case GBSP_CHUNK_HEADER:
{
if (!ReadChunkData(Chunk, (void*)&GBSPHeader, f))
return GE_FALSE;
if (strcmp(GBSPHeader.TAG, "GBSP"))
return GE_FALSE;
if (GBSPHeader.Version != GBSP_VERSION)
return GE_FALSE;
break;
}
case GBSP_CHUNK_MODELS:
{
NumGFXModels = Chunk->Elements;
GFXModels = GE_RAM_ALLOCATE_ARRAY(GFX_Model, NumGFXModels);
if (!ReadChunkData(Chunk, GFXModels, f))
return GE_FALSE;
break;
}
case GBSP_CHUNK_NODES:
{
NumGFXNodes = Chunk->Elements;
GFXNodes = GE_RAM_ALLOCATE_ARRAY(GFX_Node,NumGFXNodes);
if (!ReadChunkData(Chunk, GFXNodes, f))
return GE_FALSE;
break;
}
case GBSP_CHUNK_BNODES:
{
NumGFXBNodes = Chunk->Elements;
GFXBNodes = GE_RAM_ALLOCATE_ARRAY(GFX_BNode,NumGFXBNodes);
if (!ReadChunkData(Chunk, GFXBNodes, f))
return GE_FALSE;
break;
}
case GBSP_CHUNK_LEAFS:
{
NumGFXLeafs = Chunk->Elements;
GFXLeafs = GE_RAM_ALLOCATE_ARRAY(GFX_Leaf,NumGFXLeafs);
if (!ReadChunkData(Chunk, GFXLeafs, f))
return GE_FALSE;
break;
}
case GBSP_CHUNK_CLUSTERS:
{
NumGFXClusters = Chunk->Elements;
GFXClusters = GE_RAM_ALLOCATE_ARRAY(GFX_Cluster,NumGFXClusters);
if (!ReadChunkData(Chunk, GFXClusters, f))
return GE_FALSE;
break;
}
case GBSP_CHUNK_AREAS:
{
NumGFXAreas = Chunk->Elements;
GFXAreas = GE_RAM_ALLOCATE_ARRAY(GFX_Area,NumGFXAreas);
if (!ReadChunkData(Chunk, GFXAreas, f))
return GE_FALSE;
break;
}
case GBSP_CHUNK_AREA_PORTALS:
{
NumGFXAreaPortals = Chunk->Elements;
GFXAreaPortals = GE_RAM_ALLOCATE_ARRAY(GFX_AreaPortal,NumGFXAreaPortals);
if (!ReadChunkData(Chunk, GFXAreaPortals, f))
return GE_FALSE;
break;
}
case GBSP_CHUNK_PORTALS:
{
NumGFXPortals = Chunk->Elements;
GFXPortals = GE_RAM_ALLOCATE_ARRAY(GFX_Portal,NumGFXPortals);
if (!ReadChunkData(Chunk, GFXPortals, f))
return GE_FALSE;
break;
}
case GBSP_CHUNK_PLANES:
{
NumGFXPlanes = Chunk->Elements;
GFXPlanes = GE_RAM_ALLOCATE_ARRAY(GFX_Plane,NumGFXPlanes);
if (!ReadChunkData(Chunk, GFXPlanes, f))
return GE_FALSE;
break;
}
case GBSP_CHUNK_FACES:
{
NumGFXFaces = Chunk->Elements;
GFXFaces = GE_RAM_ALLOCATE_ARRAY(GFX_Face,NumGFXFaces);
if (!ReadChunkData(Chunk, GFXFaces, f))
return GE_FALSE;
break;
}
case GBSP_CHUNK_LEAF_FACES:
{
NumGFXLeafFaces = Chunk->Elements;
GFXLeafFaces = GE_RAM_ALLOCATE_ARRAY(int32,NumGFXLeafFaces);
if (!ReadChunkData(Chunk, GFXLeafFaces, f))
return GE_FALSE;
break;
}
case GBSP_CHUNK_LEAF_SIDES:
{
NumGFXLeafSides = Chunk->Elements;
GFXLeafSides = GE_RAM_ALLOCATE_ARRAY(GFX_LeafSide,NumGFXLeafSides);
if (!ReadChunkData(Chunk, GFXLeafSides, f))
return GE_FALSE;
break;
}
case GBSP_CHUNK_VERTS:
{
NumGFXVerts = Chunk->Elements;
GFXVerts = GE_RAM_ALLOCATE_ARRAY(geVec3d,NumGFXVerts);
if (!ReadChunkData(Chunk, GFXVerts, f))
return GE_FALSE;
break;
}
case GBSP_CHUNK_VERT_INDEX:
{
NumGFXVertIndexList = Chunk->Elements;
GFXVertIndexList = GE_RAM_ALLOCATE_ARRAY(int32,NumGFXVertIndexList);
if (!ReadChunkData(Chunk, GFXVertIndexList, f))
return GE_FALSE;
break;
}
case GBSP_CHUNK_RGB_VERTS:
{
NumGFXRGBVerts = Chunk->Elements;
GFXRGBVerts = GE_RAM_ALLOCATE_ARRAY(geVec3d,NumGFXRGBVerts);
if (!ReadChunkData(Chunk, GFXRGBVerts, f))
return GE_FALSE;
break;
}
case GBSP_CHUNK_TEXINFO:
{
NumGFXTexInfo = Chunk->Elements;
GFXTexInfo = GE_RAM_ALLOCATE_ARRAY(GFX_TexInfo,NumGFXTexInfo);
if (!ReadChunkData(Chunk, GFXTexInfo, f))
return GE_FALSE;
break;
}
case GBSP_CHUNK_TEXTURES:
{
NumGFXTextures = Chunk->Elements;
GFXTextures = GE_RAM_ALLOCATE_ARRAY(GFX_Texture,NumGFXTextures);
if (!ReadChunkData(Chunk, GFXTextures, f))
return GE_FALSE;
break;
}
case GBSP_CHUNK_TEXDATA:
{
// GHook.Printf(" Reading TEXDATA: %d bytes of %d size \n", Chunk->Elements, Chunk->Size);
NumGFXTexData = Chunk->Elements;
GFXTexData = GE_RAM_ALLOCATE_ARRAY(uint8,NumGFXTexData);
if (!ReadChunkData(Chunk, GFXTexData, f))
return GE_FALSE;
break;
}
case GBSP_CHUNK_ENTDATA:
{
NumGFXEntData = Chunk->Elements;
GFXEntData = GE_RAM_ALLOCATE_ARRAY(uint8,NumGFXEntData);
if (!ReadChunkData(Chunk, GFXEntData, f))
return GE_FALSE;
break;
}
case GBSP_CHUNK_LIGHTDATA:
{
NumGFXLightData = Chunk->Elements;
GFXLightData = GE_RAM_ALLOCATE_ARRAY(uint8,NumGFXLightData);
if (!ReadChunkData(Chunk, GFXLightData, f))
return GE_FALSE;
break;
}
case GBSP_CHUNK_VISDATA:
{
NumGFXVisData = Chunk->Elements;
GFXVisData = GE_RAM_ALLOCATE_ARRAY(uint8,NumGFXVisData);
if (!ReadChunkData(Chunk, GFXVisData, f))
return GE_FALSE;
break;
}
case GBSP_CHUNK_SKYDATA:
{
if (!ReadChunkData(Chunk, &GFXSkyData, f))
return GE_FALSE;
break;
}
case GBSP_CHUNK_PALETTES:
{
NumGFXPalettes = Chunk->Elements;
GFXPalettes = GE_RAM_ALLOCATE_ARRAY(DRV_Palette,NumGFXPalettes);
if (!GFXPalettes)
return GE_FALSE;
if (!ReadChunkData(Chunk, GFXPalettes, f))
return GE_FALSE;
break;
}
case GBSP_CHUNK_MOTIONS:
{
// GHook.Printf(" Reading motions: %d Elements of %d size\n", Chunk->Elements, Chunk->Size);
NumGFXMotionBytes = Chunk->Elements;
GFXMotionData = GE_RAM_ALLOCATE_ARRAY(uint8,NumGFXMotionBytes);
if (!ReadChunkData(Chunk, GFXMotionData, f))
return GE_FALSE;
break;
}
case GBSP_CHUNK_END:
{
break;
}
default:
return GE_FALSE;
}
return GE_TRUE;
}
//=======================================================================================
// LoadPortalFile
//=======================================================================================
geBoolean LoadPortalFile(char *FileName)
{
int32 LeafFrom, LeafTo;
VIS_Portal *pPortal;
VIS_Leaf *pLeaf;
GBSP_Poly *pPoly;
int32 i, NumVerts;
char TAG[13];
geVFile *f;
pPoly = NULL;
// open the file
f = geVFile_OpenNewSystem(NULL, GE_VFILE_TYPE_DOS, FileName, NULL, GE_VFILE_OPEN_READONLY);
if (!f) // opps
{
GHook.Error("LoadPortalFile: Could not open %s for reading.\n", FileName);
goto ExitWithError;
}
//
// Check the TAG
//
if (geVFile_Read(f, TAG, sizeof(char) * 12) != GE_TRUE)
{
GHook.Error("LoadPortalFile: Error reading portal file TAG.\n");
goto ExitWithError;
}
if (strncmp(TAG, "GBSP_PRTFILE", 12))
{
GHook.Error("LoadPortalFile: %s is not a GBSP Portal file.\n", FileName);
goto ExitWithError;
}
//
// Get the number of portals
//
if (geVFile_Read(f, &NumVisPortals, sizeof(int32)) != GE_TRUE)
{
GHook.Error("LoadPortalFile: Error reading NumVisPortals.\n");
goto ExitWithError;
}
if (NumVisPortals >= MAX_TEMP_PORTALS)
{
GHook.Error("LoadPortalFile: Max portals for temp buffers.\n");
goto ExitWithError;
}
VisPortals = GE_RAM_ALLOCATE_ARRAY(VIS_Portal,NumVisPortals);
if (!VisPortals)
{
GHook.Error("LoadPortalFile: Out of memory for VisPortals.\n");
goto ExitWithError;
}
memset(VisPortals, 0, sizeof(VIS_Portal)*NumVisPortals);
VisSortedPortals = GE_RAM_ALLOCATE_ARRAY(pVIS_Portal,NumVisPortals);
if (!VisSortedPortals)
{
GHook.Error("LoadPortalFile: Out of memory for VisSortedPortals.\n");
goto ExitWithError;
}
//
// Get the number of leafs
//
if (geVFile_Read(f, &NumVisLeafs, sizeof(int32)) != GE_TRUE)
{
GHook.Error("LoadPortalFile: Error reading NumVisLeafs.\n");
goto ExitWithError;
}
if (NumVisLeafs > NumGFXLeafs)
goto ExitWithError;
VisLeafs = GE_RAM_ALLOCATE_ARRAY(VIS_Leaf,NumVisLeafs);
if (!VisLeafs)
{
GHook.Error("LoadPortalFile: Out of memory for VisLeafs.\n");
goto ExitWithError;
}
memset(VisLeafs, 0, sizeof(VIS_Leaf)*NumVisLeafs);
//
// Load in the portals
//
for (i=0; i< NumVisPortals; i++)
{
if (geVFile_Read(f, &NumVerts, sizeof(int32)) != GE_TRUE)
{
GHook.Error("LoadPortalFile: Error reading NumVerts.\n");
goto ExitWithError;
}
pPoly = AllocPoly(NumVerts);
if (!pPoly)
goto ExitWithError;
if (geVFile_Read(f, pPoly->Verts, sizeof(geVec3d) * NumVerts) != GE_TRUE)
{
GHook.Error("LoadPortalFile: Error reading portal vertices.\n");
goto ExitWithError;
}
if (geVFile_Read(f, &LeafFrom, sizeof(int32)) != GE_TRUE)
{
GHook.Error("LoadPortalFile: Error reading portal LeafFrom.\n");
goto ExitWithError;
}
if (geVFile_Read(f, &LeafTo, sizeof(int32)) != GE_TRUE)
{
GHook.Error("LoadPortalFile: Error reading portal LeafTo.\n");
goto ExitWithError;
}
if (LeafFrom >= NumVisLeafs || LeafFrom < 0)
{
GHook.Error("LoadPortalFile: Invalid LeafFrom: %i.\n", LeafFrom);
goto ExitWithError;
}
if (LeafTo >= NumVisLeafs || LeafTo < 0)
{
GHook.Error("LoadPortalFile: Invalid LeafTo: %i.\n", LeafTo);
goto ExitWithError;
}
pLeaf = &VisLeafs[LeafFrom];
pPortal = &VisPortals[i];
pPortal->Poly = pPoly;
pPortal->Leaf = LeafTo;
PlaneFromVerts(pPoly->Verts, &pPortal->Plane);
pPortal->Next = pLeaf->Portals;
pLeaf->Portals = pPortal;
CalcPortalInfo(pPortal);
}
NumVisLeafBytes = ((NumVisLeafs+63)&~63) >> 3;
NumVisPortalBytes = ((NumVisPortals+63)&~63) >> 3;
NumVisPortalLongs = NumVisPortalBytes/sizeof(uint32);
NumVisLeafLongs = NumVisLeafBytes/sizeof(uint32);
geVFile_Close(f);
return GE_TRUE;
// ==== ERROR ===
ExitWithError:
{
if (f)
geVFile_Close(f);
if (VisPortals)
geRam_Free(VisPortals);
if (VisSortedPortals)
geRam_Free(VisSortedPortals);
if (VisLeafs)
geRam_Free(VisLeafs);
if (pPoly)
FreePoly(pPoly);
VisPortals = NULL;
VisSortedPortals = NULL;
VisLeafs = NULL;
pPoly = NULL;
return GE_FALSE;
}
}
/* ------------------------------------------------------------------------------------ */
CAnimGif::CAnimGif(const char *szFile, int fileformat)
{
long Size;
GifSize = GlobalColorSize = 0;
Active = false;
Texture = false;
GlobalColorTable = NULL;
if(!CCD->OpenRFFile(&MainFS, fileformat, szFile, GE_VFILE_OPEN_READONLY))
return;
geVFile_Size(MainFS, &Size);
Palette = geBitmap_Palette_Create(GE_PIXELFORMAT_32BIT_XRGB, 256);
theBmp = NULL;
pcGif = NULL;
if(geVFile_Read(MainFS, buffer, 13) == GE_TRUE)
{
if(!strncmp((char *)buffer, "GIF89a", 6) || !strncmp((char *)buffer, "GIF87a", 6))
{
nWidth = *(WORD*)(buffer+6);
nWidth = ((nWidth-1)|0x3)+1;
nHeight = *(WORD*)(buffer+8);
BackgroundColor = *(buffer+11);
if(buffer[10]&0x80)
{
GlobalColorSize = 0x01<<((buffer[10]&0x07)+1);
GlobalColorTable = new BYTE[3*GlobalColorSize];
if(geVFile_Read(MainFS, GlobalColorTable, 3*GlobalColorSize) != GE_TRUE)
{
delete[] GlobalColorTable;
geVFile_Close(MainFS);
geBitmap_Palette_Destroy(&Palette);
return;
}
}
GifSize = Size-3*GlobalColorSize-12;
pcGifTrack=pcGif = new BYTE[GifSize];
if(geVFile_Read(MainFS, pcGif, GifSize) == GE_TRUE)
{
TotalReadByte = 0;
FirstFrame = true;
theBmp = geBitmap_Create(nWidth, nHeight, 1, GE_PIXELFORMAT_8BIT);
geBitmap_SetPreferredFormat(theBmp, GE_PIXELFORMAT_8BIT);
geEngine_AddBitmap(CCD->Engine()->Engine(), theBmp);
geBitmap_GetInfo(theBmp,&Info,NULL);
geBitmap_ClearMips(theBmp);
if(GetImage(false))
{
Active = true;
}
}
}
}
geVFile_Close(MainFS);
return;
}
static geBoolean ReadTree(geVFile *File, DirTree **TreePtr)
{
int Terminator;
int Length;
DirTree * Tree;
if (geVFile_Read(File, &Terminator, sizeof(Terminator)) == GE_FALSE)
return GE_FALSE;
if (Terminator == DIRTREE_LIST_TERMINATED)
{
*TreePtr = NULL;
return GE_TRUE;
}
Tree = geRam_Allocate(sizeof(*Tree));
if (!Tree)
return GE_FALSE;
memset(Tree, 0, sizeof(*Tree));
// Read the name
if (geVFile_Read(File, &Length, sizeof(Length)) == GE_FALSE)
goto fail;
assert(Length > 0);
Tree->Name = geRam_Allocate(Length);
if (!Tree->Name)
{
geRam_Free(Tree);
return GE_FALSE;
}
if (geVFile_Read(File, Tree->Name, Length) == GE_FALSE)
goto fail;
//printf("Reading '%s'\n", Tree->Name);
// Read out the attribute information
if (geVFile_Read(File, &Tree->Time, sizeof(Tree->Time)) == GE_FALSE)
goto fail;
if (geVFile_Read(File, &Tree->AttributeFlags, sizeof(Tree->AttributeFlags)) == GE_FALSE)
goto fail;
if (geVFile_Read(File, &Tree->Size, sizeof(Tree->Size)) == GE_FALSE)
goto fail;
if (geVFile_Read(File, &Tree->Offset, sizeof(Tree->Offset)) == GE_FALSE)
goto fail;
if (geVFile_Read(File, &Tree->Hints.HintDataLength, sizeof(Tree->Hints.HintDataLength)) == GE_FALSE)
goto fail;
if (Tree->Hints.HintDataLength != 0)
{
Tree->Hints.HintData = geRam_Allocate(Tree->Hints.HintDataLength);
if (!Tree->Hints.HintData)
goto fail;
//bug fix. someone got copy happy and forgot to remove the & from Tree->Hints.HintData
if (geVFile_Read(File, Tree->Hints.HintData, Tree->Hints.HintDataLength) == GE_FALSE)
goto fail;
}
//printf("Reading children of '%s'\n", Tree->Name);
// Read the children
if (ReadTree(File, &Tree->Children) == GE_FALSE)
goto fail;
//printf("Reading siblings of '%s'\n", Tree->Name);
// Read the Siblings
if (ReadTree(File, &Tree->Siblings) == GE_FALSE)
goto fail;
//DirTree_Dump(Tree);
*TreePtr = Tree;
return GE_TRUE;
fail:
DirTree_Destroy(Tree);
return GE_FALSE;
}
