GTestAndEngine: Gbspfile.c Source File

00001 /****************************************************************************************/
00002 /*  GBSPFile.c                                                                          */
00003 /*                                                                                      */
00004 /*  Author: John Pollard                                                                */
00005 /*  Description: BSP loader                                                             */
00006 /*                                                                                      */
00007 /*  The contents of this file are subject to the Genesis3D Public License               */
00008 /*  Version 1.01 (the "License"); you may not use this file except in                   */
00009 /*  compliance with the License. You may obtain a copy of the License at                */
00010 /*  http://www.genesis3d.com                                                            */
00011 /*                                                                                      */
00012 /*  Software distributed under the License is distributed on an "AS IS"                 */
00013 /*  basis, WITHOUT WARRANTY OF ANY KIND, either express or implied.  See                */
00014 /*  the License for the specific language governing rights and limitations              */
00015 /*  under the License.                                                                  */
00016 /*                                                                                      */
00017 /*  The Original Code is Genesis3D, released March 25, 1999.                            */
00018 /*Genesis3D Version 1.1 released November 15, 1999                            */
00019 /*  Copyright (C) 1999 WildTangent, Inc. All Rights Reserved           */
00020 /*                                                                                      */
00021 /****************************************************************************************/
00022 #include <Stdio.h>
00023 #include <assert.h>
00024 
00025 #include "GBSPFile.h"
00026 #include "Vec3d.h"
00027 #include "Ram.h"
00028 #include "System.h"
00029 
00030 #include "ErrorLog.h"
00031 #include "VFile.h"
00032 
00033 static geBoolean LoadMotions(GBSP_BSPData *BSP, geVFile *f)
00034 {
00035         char                    KeyS[100], ValueS[100];
00036         char                    line[200];
00037         int32                   NumMotions, ModelNum, i;
00038         GFX_Model               *Models;
00039 
00040         if      (geVFile_GetS(f, line, sizeof(line)) == GE_FALSE)
00041                 goto fail;
00042 
00043         if (sscanf(line, "%s %s\n", KeyS, ValueS) != 2)
00044                 goto fail;
00045 
00046         if (strcmp(KeyS, "Genesis_Motion_File"))
00047                 goto fail;
00048 
00049         if      (geVFile_GetS(f, line, sizeof(line)) == GE_FALSE)
00050                 goto fail;
00051 
00052         if (sscanf(line, "%s %i\n", KeyS, &NumMotions) != 2)
00053                 goto fail;
00054 
00055         if (strcmp(KeyS, "NumMotions"))
00056                 goto fail;
00057 
00058         Models = BSP->GFXModels;
00059 
00060         for (i=0; i< NumMotions; i++)
00061         {
00062                 if      (geVFile_GetS(f, line, sizeof(line)) == GE_FALSE)
00063                         goto fail;
00064 
00065                 if (sscanf(line, "%s %i\n", KeyS, &ModelNum) != 2)
00066                         goto fail;
00067 
00068                 if (strcmp(KeyS, "ModelNum"))
00069                         goto fail;
00070 
00071                 Models[ModelNum].Motion = geMotion_CreateFromFile(f);
00072 
00073                 if      (!Models[ModelNum].Motion)
00074                         goto fail;
00075         }
00076 
00077         return GE_TRUE;
00078 
00079 fail:
00080         geErrorLog_Add(GE_ERR_INVALID_MODEL_MOTION_FILE, NULL);
00081         return GE_FALSE;
00082 }
00083 
00084 //========================================================================================
00085 // ReadChunkData
00086 //========================================================================================
00087 static geBoolean ReadChunkData(GBSP_Chunk *Chunk, void *Data, geVFile *f)
00088 {
00089         return geVFile_Read(f, Data, Chunk->Size * Chunk->Elements);
00090 }
00091 
00092 //========================================================================================
00093 //      ReadChunk
00094 //========================================================================================
00095 static geBoolean ReadChunk(GBSP_BSPData *BSP, GBSP_Chunk *Chunk, geVFile *f)
00096 {
00097         int     i;
00098 
00099         if (geVFile_Read(f, Chunk, sizeof(GBSP_Chunk)) == GE_FALSE)
00100         {
00101                 return GE_FALSE;
00102         }
00103 
00104         switch(Chunk->Type)
00105         {
00106                 case GBSP_CHUNK_HEADER:
00107                 {
00108 //              printf("GBSP_CHUNK_HEADER\n");
00109                         if (sizeof(GBSP_Header) != Chunk->Size)
00110                         {
00111                                 geErrorLog_Add(GE_ERR_BAD_BSP_FILE_CHUNK_SIZE, NULL);
00112                                 return GE_FALSE;
00113                         }
00114                         if (!ReadChunkData(Chunk, (void*)&BSP->GBSPHeader, f))
00115                                 return GE_FALSE;
00116                         if (strcmp(BSP->GBSPHeader.TAG, "GBSP"))
00117                         {
00118                                 geErrorLog_Add(GE_ERR_INVALID_BSP_TAG, NULL);
00119                                 return GE_FALSE;
00120                         }
00121                         if (BSP->GBSPHeader.Version != GBSP_VERSION)
00122                         {
00123                                 geErrorLog_Add(GE_ERR_INVALID_BSP_VERSION, NULL);
00124                                 return GE_FALSE;
00125                         }
00126                         break;
00127                 }
00128                 case GBSP_CHUNK_MODELS:
00129                 {
00130 //              printf("GBSP_CHUNK_MODELS\n");
00131                         if (sizeof(GFX_Model) != Chunk->Size)
00132                         {
00133                                 geErrorLog_Add(GE_ERR_BAD_BSP_FILE_CHUNK_SIZE, NULL);
00134                                 return GE_FALSE;
00135                         }
00136                         BSP->NumGFXModels = Chunk->Elements;
00137                         BSP->GFXModels = GE_RAM_ALLOCATE_ARRAY(GFX_Model, BSP->NumGFXModels);
00138                         if (!ReadChunkData(Chunk, (void*)BSP->GFXModels, f))
00139                                 return GE_FALSE;
00140                         // Walk the models and zero out the motion pointers
00141                         for     (i = 0; i < BSP->NumGFXModels; i++)
00142                                 BSP->GFXModels[i].Motion = NULL;
00143                         break;
00144                 }
00145                 case GBSP_CHUNK_NODES:
00146                 {
00147 //              printf("GBSP_CHUNK_NODES\n");
00148                         if (sizeof(GFX_Node) != Chunk->Size)
00149                         {
00150                                 geErrorLog_Add(GE_ERR_BAD_BSP_FILE_CHUNK_SIZE, NULL);
00151                                 return GE_FALSE;
00152                         }
00153                         BSP->NumGFXNodes = Chunk->Elements;
00154                         BSP->GFXNodes = (GFX_Node*)geRam_Allocate(sizeof(GFX_Node)*BSP->NumGFXNodes);
00155                         if (!ReadChunkData(Chunk, (void*)BSP->GFXNodes, f))
00156                                 return GE_FALSE;
00157                         break;
00158                 }
00159                 case GBSP_CHUNK_BNODES:
00160                 {
00161 //              printf("GBSP_CHUNK_BNODES\n");
00162                         if (sizeof(GFX_BNode) != Chunk->Size)
00163                         {
00164                                 geErrorLog_Add(GE_ERR_BAD_BSP_FILE_CHUNK_SIZE, NULL);
00165                                 return GE_FALSE;
00166                         }
00167                         BSP->NumGFXBNodes = Chunk->Elements;
00168                         if (BSP->NumGFXBNodes)
00169                         {
00170                                 BSP->GFXBNodes = (GFX_BNode*)geRam_Allocate(sizeof(GFX_BNode)*BSP->NumGFXBNodes);
00171                                 if (!ReadChunkData(Chunk, (void*)BSP->GFXBNodes, f))
00172                                         return GE_FALSE;
00173                         }
00174                         break;
00175                 }
00176                 case GBSP_CHUNK_LEAFS:
00177                 {
00178 //              printf("GBSP_CHUNK_LEAFS\n");
00179                         if (sizeof(GFX_Leaf) != Chunk->Size)
00180                         {
00181                                 geErrorLog_Add(GE_ERR_BAD_BSP_FILE_CHUNK_SIZE, NULL);
00182                                 return GE_FALSE;
00183                         }
00184                         BSP->NumGFXLeafs = Chunk->Elements;
00185                         BSP->GFXLeafs = (GFX_Leaf*)geRam_Allocate(sizeof(GFX_Leaf)*BSP->NumGFXLeafs);
00186                         if (!ReadChunkData(Chunk, (void*)BSP->GFXLeafs, f))
00187                                 return GE_FALSE;
00188                         break;
00189                 }
00190                 case GBSP_CHUNK_CLUSTERS:
00191                 {
00192 //              printf("GBSP_CHUNK_CLUSTERS\n");
00193                         if (sizeof(GFX_Cluster) != Chunk->Size)
00194                         {
00195                                 geErrorLog_Add(GE_ERR_BAD_BSP_FILE_CHUNK_SIZE, NULL);
00196                                 return GE_FALSE;
00197                         }
00198                         BSP->NumGFXClusters = Chunk->Elements;
00199                         //BSP->GFXClusters = GE_RAM_ALLOCATE_ARRAY(GFX_Cluster, BSP->NumGFXClusters);
00200                         BSP->GFXClusters = (GFX_Cluster*)geRam_Allocate(sizeof(GFX_Cluster)*BSP->NumGFXClusters);
00201                         if (!ReadChunkData(Chunk, (void*)BSP->GFXClusters, f))
00202                                 return GE_FALSE;
00203                         break;
00204                 }
00205                 case GBSP_CHUNK_AREAS:
00206                 {
00207 //              printf("GBSP_CHUNK_AREAS\n");
00208                         if (sizeof(GFX_Area) != Chunk->Size)
00209                         {
00210                                 geErrorLog_Add(GE_ERR_BAD_BSP_FILE_CHUNK_SIZE, NULL);
00211                                 return GE_FALSE;
00212                         }
00213                         BSP->NumGFXAreas = Chunk->Elements;
00214                         BSP->GFXAreas = GE_RAM_ALLOCATE_ARRAY(GFX_Area, BSP->NumGFXAreas);
00215                         if (!ReadChunkData(Chunk, BSP->GFXAreas, f))
00216                                 return GE_FALSE;
00217                         break;
00218                 }
00219                 case GBSP_CHUNK_AREA_PORTALS:
00220                 {
00221 //              printf("GBSP_CHUNK_AREA_PORTALS\n");
00222                         if (sizeof(GFX_AreaPortal) != Chunk->Size)
00223                         {
00224                                 geErrorLog_Add(GE_ERR_BAD_BSP_FILE_CHUNK_SIZE, NULL);
00225                                 return GE_FALSE;
00226                         }
00227                         BSP->NumGFXAreaPortals = Chunk->Elements;
00228                         BSP->GFXAreaPortals = GE_RAM_ALLOCATE_ARRAY(GFX_AreaPortal, BSP->NumGFXAreaPortals);
00229                         if (!ReadChunkData(Chunk, BSP->GFXAreaPortals, f))
00230                                 return GE_FALSE;
00231                         break;
00232                 }
00233                 case GBSP_CHUNK_PORTALS:
00234                 {
00235 //              printf("GBSP_CHUNK_PORTALS\n");
00236                         if (sizeof(GFX_Portal) != Chunk->Size)
00237                         {
00238                                 geErrorLog_Add(GE_ERR_BAD_BSP_FILE_CHUNK_SIZE, NULL);
00239                                 return GE_FALSE;
00240                         }
00241                         BSP->NumGFXPortals = Chunk->Elements;
00242                         BSP->GFXPortals = (GFX_Portal*)geRam_Allocate(sizeof(GFX_Portal)*BSP->NumGFXPortals);
00243                         if (!ReadChunkData(Chunk, (void*)BSP->GFXPortals, f))
00244                                 return GE_FALSE;
00245                         break;
00246                 }
00247                 case GBSP_CHUNK_PLANES:
00248                 {
00249 //              printf("GBSP_CHUNK_PLANES\n");
00250                         if (sizeof(GFX_Plane) != Chunk->Size)
00251                         {
00252                                 geErrorLog_Add(GE_ERR_BAD_BSP_FILE_CHUNK_SIZE, NULL);
00253                                 return GE_FALSE;
00254                         }
00255                         BSP->NumGFXPlanes = Chunk->Elements;
00256                         BSP->GFXPlanes = (GFX_Plane*)geRam_Allocate(sizeof(GFX_Plane)*BSP->NumGFXPlanes);
00257                         if (!ReadChunkData(Chunk, (void*)BSP->GFXPlanes, f))
00258                                 return GE_FALSE;
00259                         break;
00260                 }
00261                 case GBSP_CHUNK_FACES:
00262                 {
00263 //              printf("GBSP_CHUNK_FACES\n");
00264                         if (sizeof(GFX_Face) != Chunk->Size)
00265                         {
00266                                 geErrorLog_Add(GE_ERR_BAD_BSP_FILE_CHUNK_SIZE, NULL);
00267                                 return GE_FALSE;
00268                         }
00269                         BSP->NumGFXFaces = Chunk->Elements;
00270                         BSP->GFXFaces = (GFX_Face*)geRam_Allocate(sizeof(GFX_Face)*BSP->NumGFXFaces);
00271                         if (!ReadChunkData(Chunk, (void*)BSP->GFXFaces, f))
00272                                 return GE_FALSE;
00273                         break;
00274                 }
00275                 case GBSP_CHUNK_LEAF_FACES:
00276                 {
00277 //              printf("GBSP_CHUNK_LEAF_FACES\n");
00278                         if (sizeof(int32) != Chunk->Size)
00279                         {
00280                                 geErrorLog_Add(GE_ERR_BAD_BSP_FILE_CHUNK_SIZE, NULL);
00281                                 return GE_FALSE;
00282                         }
00283                         BSP->NumGFXLeafFaces = Chunk->Elements;
00284                         BSP->GFXLeafFaces = (int32*)geRam_Allocate(sizeof(int32)*BSP->NumGFXLeafFaces);
00285                         if (!ReadChunkData(Chunk, (void*)BSP->GFXLeafFaces, f))
00286                                 return GE_FALSE;
00287                         break;
00288                 }
00289                 case GBSP_CHUNK_LEAF_SIDES:
00290                 {
00291 //              printf("GBSP_CHUNK_LEAF_SIDES\n");
00292                         if (sizeof(GFX_LeafSide) != Chunk->Size)
00293                         {
00294                                 geErrorLog_Add(GE_ERR_BAD_BSP_FILE_CHUNK_SIZE, NULL);
00295                                 return GE_FALSE;
00296                         }
00297                         BSP->NumGFXLeafSides = Chunk->Elements;
00298                         BSP->GFXLeafSides = (GFX_LeafSide*)geRam_Allocate(sizeof(GFX_LeafSide)*BSP->NumGFXLeafSides);
00299                         if (!ReadChunkData(Chunk, (void*)BSP->GFXLeafSides, f))
00300                                 return GE_FALSE;
00301                         break;
00302                 }
00303                 case GBSP_CHUNK_VERTS:
00304                 {
00305 //              printf("GBSP_CHUNK_VERTS\n");
00306                         if (sizeof(geVec3d) != Chunk->Size)
00307                         {
00308                                 geErrorLog_Add(GE_ERR_BAD_BSP_FILE_CHUNK_SIZE, NULL);
00309                                 return GE_FALSE;
00310                         }
00311                         BSP->NumGFXVerts = Chunk->Elements;
00312                         BSP->GFXVerts = (geVec3d*)geRam_Allocate(sizeof(geVec3d)*BSP->NumGFXVerts);
00313                         if (!ReadChunkData(Chunk, (void*)BSP->GFXVerts, f))
00314                                 return GE_FALSE;
00315                         break;
00316                 }
00317                 case GBSP_CHUNK_VERT_INDEX:
00318                 {
00319 //              printf("GBSP_CHUNK_VERT_INDEX\n");
00320                         if (sizeof(int32) != Chunk->Size)
00321                         {
00322                                 geErrorLog_Add(GE_ERR_BAD_BSP_FILE_CHUNK_SIZE, NULL);
00323                                 return GE_FALSE;
00324                         }
00325 
00326                         BSP->NumGFXVertIndexList = Chunk->Elements;
00327                         BSP->GFXVertIndexList = (int32*)geRam_Allocate(sizeof(int32)*BSP->NumGFXVertIndexList);
00328                         if (!ReadChunkData(Chunk, (void*)BSP->GFXVertIndexList, f))
00329                                 return GE_FALSE;
00330                         break;
00331                 }
00332 
00333                 case GBSP_CHUNK_RGB_VERTS:
00334                 {
00335 //              printf("GBSP_CHUNK_RGB_VERTS\n");
00336                         if (sizeof(geVec3d) != Chunk->Size)
00337                         {
00338                                 geErrorLog_Add(GE_ERR_BAD_BSP_FILE_CHUNK_SIZE, NULL);
00339                                 return GE_FALSE;
00340                         }
00341                         BSP->NumGFXRGBVerts = Chunk->Elements;
00342                         BSP->GFXRGBVerts = (geVec3d*)geRam_Allocate(sizeof(geVec3d)*BSP->NumGFXRGBVerts);
00343                         if (!ReadChunkData(Chunk, (void*)BSP->GFXRGBVerts, f))
00344                                 return GE_FALSE;
00345                         break;
00346                 }
00347 
00348                 case GBSP_CHUNK_TEXINFO:
00349                 {
00350 //              printf("GBSP_CHUNK_TEXINFO\n");
00351                         if (sizeof(GFX_TexInfo) != Chunk->Size)
00352                         {
00353                                 geErrorLog_Add(GE_ERR_BAD_BSP_FILE_CHUNK_SIZE, NULL);
00354                                 return GE_FALSE;
00355                         }
00356                         BSP->NumGFXTexInfo = Chunk->Elements;
00357                         BSP->GFXTexInfo = (GFX_TexInfo*)geRam_Allocate(sizeof(GFX_TexInfo)*BSP->NumGFXTexInfo);
00358                         if (!ReadChunkData(Chunk, (void*)BSP->GFXTexInfo, f))
00359                                 return GE_FALSE;
00360                         break;
00361                 }
00362 
00363                 case GBSP_CHUNK_TEXTURES:
00364                 {
00365 //              printf("GBSP_CHUNK_TEXTURES\n");
00366                         if (sizeof(GFX_Texture) != Chunk->Size)
00367                         {
00368                                 geErrorLog_Add(GE_ERR_BAD_BSP_FILE_CHUNK_SIZE, NULL);
00369                                 return GE_FALSE;
00370                         }
00371                         BSP->NumGFXTextures = Chunk->Elements;
00372                         BSP->GFXTextures = (GFX_Texture*)geRam_Allocate(sizeof(GFX_Texture)*BSP->NumGFXTextures);
00373                         if (!ReadChunkData(Chunk, (void*)BSP->GFXTextures, f))
00374                                 return GE_FALSE;
00375                         break;
00376                 }
00377 
00378                 case GBSP_CHUNK_TEXDATA:
00379                 {
00380 //              printf("GBSP_CHUNK_TEXDATA\n");
00381                         if (sizeof(uint8) != Chunk->Size)
00382                         {
00383                                 geErrorLog_Add(GE_ERR_BAD_BSP_FILE_CHUNK_SIZE, NULL);
00384                                 return GE_FALSE;
00385                         }
00386                         BSP->NumGFXTexData = Chunk->Elements;
00387                         BSP->GFXTexData = (uint8*)geRam_Allocate(sizeof(uint8)*BSP->NumGFXTexData);
00388                         if (!ReadChunkData(Chunk, (void*)BSP->GFXTexData, f))
00389                                 return GE_FALSE;
00390                         break;
00391                 }
00392                 case GBSP_CHUNK_ENTDATA:
00393                 {
00394 //              printf("GBSP_CHUNK_ENTDATA\n");
00395                         if (sizeof(uint8) != Chunk->Size)
00396                         {
00397                                 geErrorLog_Add(GE_ERR_BAD_BSP_FILE_CHUNK_SIZE, NULL);
00398                                 return GE_FALSE;
00399                         }
00400                         BSP->NumGFXEntData = Chunk->Elements;
00401                         BSP->GFXEntData = (uint8*)geRam_Allocate(sizeof(uint8)*BSP->NumGFXEntData);
00402                         if (!ReadChunkData(Chunk, (void*)BSP->GFXEntData, f))
00403                                 return GE_FALSE;
00404                         break;
00405                 }
00406                 case GBSP_CHUNK_LIGHTDATA:
00407                 {
00408 //              printf("GBSP_CHUNK_LIGHTDATA\n");
00409                         if (sizeof(uint8) != Chunk->Size)
00410                         {
00411                                 geErrorLog_Add(GE_ERR_BAD_BSP_FILE_CHUNK_SIZE, NULL);
00412                                 return GE_FALSE;
00413                         }
00414                         BSP->NumGFXLightData = Chunk->Elements;
00415                         BSP->GFXLightData = (uint8*)geRam_Allocate(sizeof(uint8)*BSP->NumGFXLightData);
00416                         if (!ReadChunkData(Chunk, (void*)BSP->GFXLightData, f))
00417                                 return GE_FALSE;
00418                         break;
00419                 }
00420                 case GBSP_CHUNK_VISDATA:
00421                 {
00422 //              printf("GBSP_CHUNK_VISDATA\n");
00423                         if (sizeof(uint8) != Chunk->Size)
00424                         {
00425                                 geErrorLog_Add(GE_ERR_BAD_BSP_FILE_CHUNK_SIZE, NULL);
00426                                 return GE_FALSE;
00427                         }
00428                         BSP->NumGFXVisData = Chunk->Elements;
00429                         BSP->GFXVisData = (uint8*)geRam_Allocate(sizeof(uint8)*BSP->NumGFXVisData);
00430                         if (!ReadChunkData(Chunk, (void*)BSP->GFXVisData, f))
00431                                 return GE_FALSE;
00432                         break;
00433                 }
00434 
00435                 case GBSP_CHUNK_SKYDATA:
00436                 {
00437 //              printf("GBSP_CHUNK_SKYDATA\n");
00438                         if (sizeof(GFX_SkyData) != Chunk->Size)
00439                         {
00440                                 geErrorLog_Add(GE_ERR_BAD_BSP_FILE_CHUNK_SIZE, NULL);
00441                                 return GE_FALSE;
00442                         }
00443                         if (!ReadChunkData(Chunk, (void*)&BSP->GFXSkyData, f))
00444                                 return GE_FALSE;
00445                         break;
00446                 }
00447 
00448                 case GBSP_CHUNK_PALETTES:
00449                 {
00450 //              printf("GBSP_CHUNK_PALETTES\n");
00451                         if (sizeof(DRV_Palette) != Chunk->Size)
00452                         {
00453                                 geErrorLog_Add(GE_ERR_BAD_BSP_FILE_CHUNK_SIZE, NULL);
00454                                 return GE_FALSE;
00455                         }
00456                         BSP->NumGFXPalettes = Chunk->Elements;
00457                         BSP->GFXPalettes = (DRV_Palette*)geRam_Allocate(sizeof(DRV_Palette)*BSP->NumGFXPalettes);
00458                         if      (BSP->GFXPalettes == NULL)
00459                                 return GE_FALSE;
00460                         if (!ReadChunkData(Chunk, (void*)BSP->GFXPalettes, f))
00461                                 return GE_FALSE;
00462                         break;
00463                 }
00464 
00465                 case GBSP_CHUNK_MOTIONS:
00466                 {
00467 //              printf("GBSP_CHUNK_MOTIONS\n");
00468                         return LoadMotions(BSP, f);
00469                 }
00470 
00471                 case GBSP_CHUNK_END:
00472                 {
00473 //              printf("GBSP_CHUNK_END\n");
00474                         break;
00475                 }
00476                 default:
00477 //              printf("Don't know what this chunk is\n");
00478                         return GE_FALSE;
00479         }
00480 
00481         return TRUE;
00482 }
00483 
00484 //========================================================================================
00485 //      GBSP_LoadGBSPFile
00486 //========================================================================================
00487 BOOL GBSP_LoadGBSPFile(geVFile *File, GBSP_BSPData *BSP)
00488 {
00489         GBSP_Chunk      Chunk;
00490 
00491         assert(File);
00492         assert(BSP);
00493 
00494         while (1)
00495         {
00496                 if (!ReadChunk(BSP, &Chunk, File))
00497                 {
00498                         geErrorLog_Add(GE_ERR_ERROR_READING_BSP_CHUNK, NULL);
00499                         return GE_FALSE;
00500                 }
00501                 
00502                 if (Chunk.Type == GBSP_CHUNK_END)
00503                         break;
00504         }
00505 
00506         return TRUE;
00507 }
00508 
00509 //========================================================================================
00510 //      GBSP_FreeGBSPFile
00511 //========================================================================================
00512 BOOL GBSP_FreeGBSPFile(GBSP_BSPData *BSP)
00513 {
00514         if (BSP->GFXModels)
00515         {
00516                 int i;
00517                 for     (i = 0; i < BSP->NumGFXModels; i++)
00518                         if (BSP->GFXModels[i].Motion != NULL)
00519                                 geMotion_Destroy(&(BSP->GFXModels[i].Motion));
00520                 geRam_Free(BSP->GFXModels);
00521         }
00522 
00523         if (BSP->GFXNodes)
00524                 geRam_Free(BSP->GFXNodes);
00525         if (BSP->GFXBNodes)
00526                 geRam_Free(BSP->GFXBNodes);
00527         if (BSP->GFXLeafs)
00528                 geRam_Free(BSP->GFXLeafs);
00529         if (BSP->GFXClusters)
00530                 geRam_Free(BSP->GFXClusters);
00531         if (BSP->GFXAreas)
00532                 geRam_Free(BSP->GFXAreas);
00533         if (BSP->GFXAreaPortals)
00534                 geRam_Free(BSP->GFXAreaPortals);
00535         if (BSP->GFXPortals)
00536                 geRam_Free(BSP->GFXPortals);
00537         if (BSP->GFXPlanes)
00538                 geRam_Free(BSP->GFXPlanes);
00539         if (BSP->GFXFaces)
00540                 geRam_Free(BSP->GFXFaces);
00541         if (BSP->GFXLeafFaces)
00542                 geRam_Free(BSP->GFXLeafFaces);
00543         if (BSP->GFXLeafSides)
00544                 geRam_Free(BSP->GFXLeafSides);
00545         if (BSP->GFXVerts)
00546                 geRam_Free(BSP->GFXVerts);
00547         if (BSP->GFXVertIndexList)
00548                 geRam_Free(BSP->GFXVertIndexList);
00549         if (BSP->GFXRGBVerts)
00550                 geRam_Free(BSP->GFXRGBVerts);
00551         if (BSP->GFXTextures)
00552                 geRam_Free(BSP->GFXTextures);
00553         if (BSP->GFXTexInfo)
00554                 geRam_Free(BSP->GFXTexInfo);
00555         if (BSP->GFXTexData)
00556                 geRam_Free(BSP->GFXTexData);
00557         if (BSP->GFXPalettes)
00558                 geRam_Free(BSP->GFXPalettes);
00559         if (BSP->GFXEntData)
00560                 geRam_Free(BSP->GFXEntData);
00561         if (BSP->GFXLightData)
00562                 geRam_Free(BSP->GFXLightData);
00563         if (BSP->GFXVisData)
00564                 geRam_Free(BSP->GFXVisData);
00565 
00566         BSP->GFXModels = NULL;
00567         BSP->GFXNodes = NULL;
00568         BSP->GFXBNodes = NULL;
00569         BSP->GFXLeafs = NULL;
00570         BSP->GFXClusters = NULL;
00571         BSP->GFXAreas = NULL;
00572         BSP->GFXAreaPortals = NULL;
00573         BSP->GFXPlanes = NULL;
00574         BSP->GFXFaces = NULL;
00575         BSP->GFXLeafFaces = NULL;
00576         BSP->GFXLeafSides = NULL;
00577         BSP->GFXVerts = NULL;
00578         BSP->GFXVertIndexList = NULL;
00579         BSP->GFXRGBVerts = NULL;
00580         BSP->GFXEntData = NULL;
00581         
00582         BSP->GFXTextures = NULL;
00583         BSP->GFXTexInfo = NULL;
00584         BSP->GFXTexData = NULL;
00585         BSP->GFXPalettes = NULL;
00586 
00587         BSP->GFXLightData = NULL;
00588         BSP->GFXVisData = NULL;
00589         BSP->GFXPortals = NULL;
00590 
00591         BSP->NumGFXModels = 0;
00592         BSP->NumGFXNodes = 0;
00593         BSP->NumGFXBNodes = 0;
00594         BSP->NumGFXLeafs = 0;
00595         BSP->NumGFXClusters = 0;
00596         BSP->NumGFXAreas = 0;
00597         BSP->NumGFXAreaPortals = 0;
00598         BSP->NumGFXPlanes = 0;
00599         BSP->NumGFXFaces = 0;
00600         BSP->NumGFXLeafFaces = 0;
00601         BSP->NumGFXLeafSides = 0;
00602         BSP->NumGFXVerts = 0;
00603         BSP->NumGFXVertIndexList = 0;
00604         BSP->NumGFXRGBVerts = 0;
00605 
00606         BSP->NumGFXEntData = 0;
00607         BSP->NumGFXTexInfo = 0;
00608         BSP->NumGFXTextures = 0;
00609         BSP->NumGFXTexData = 0;
00610 
00611         BSP->NumGFXLightData = 0;
00612         BSP->NumGFXVisData = 0;
00613         BSP->NumGFXPortals = 0;
00614 
00615         return TRUE;
00616 }
00617