//========================================================================================
// 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;
}
void CObjectAnimator::Load(const char * name)
{
m_Name = name;
LoadMotions (name);
SetActiveMotion (0);
}
