#include <Stdio.h>#include <assert.h>#include "GBSPFile.h"#include "Vec3d.h"#include "Ram.h"#include "System.h"#include "ErrorLog.h"#include "VFile.h"Go to the source code of this file.
Functions | |
| geBoolean | LoadMotions (GBSP_BSPData *BSP, geVFile *f) |
| geBoolean | ReadChunkData (GBSP_Chunk *Chunk, void *Data, geVFile *f) |
| geBoolean | ReadChunk (GBSP_BSPData *BSP, GBSP_Chunk *Chunk, geVFile *f) |
| BOOL | GBSP_LoadGBSPFile (geVFile *File, GBSP_BSPData *BSP) |
| BOOL | GBSP_FreeGBSPFile (GBSP_BSPData *BSP) |
|
|
||||||||||||
|
Definition at line 487 of file Gbspfile.c. References GBSP_CHUNK_END, GE_ERR_ERROR_READING_BSP_CHUNK, GE_FALSE, geErrorLog_Add, NULL, ReadChunk(), TRUE, and GBSP_Chunk::Type. Referenced by CreateGBSP().
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 }
|
|
||||||||||||
|
Definition at line 33 of file Gbspfile.c. References GE_ERR_INVALID_MODEL_MOTION_FILE, GE_FALSE, GE_TRUE, geBoolean, geErrorLog_Add, geMotion_CreateFromFile(), geVFile_GetS(), GBSP_BSPData::GFXModels, int32, GFX_Model::Motion, and NULL. Referenced by ReadChunk().
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 }
|
|
||||||||||||||||
|
Definition at line 95 of file Gbspfile.c. References GBSP_Chunk::Elements, GBSP_CHUNK_AREA_PORTALS, GBSP_CHUNK_AREAS, GBSP_CHUNK_BNODES, GBSP_CHUNK_CLUSTERS, GBSP_CHUNK_END, GBSP_CHUNK_ENTDATA, GBSP_CHUNK_FACES, GBSP_CHUNK_HEADER, GBSP_CHUNK_LEAF_FACES, GBSP_CHUNK_LEAF_SIDES, GBSP_CHUNK_LEAFS, GBSP_CHUNK_LIGHTDATA, GBSP_CHUNK_MODELS, GBSP_CHUNK_MOTIONS, GBSP_CHUNK_NODES, GBSP_CHUNK_PALETTES, GBSP_CHUNK_PLANES, GBSP_CHUNK_PORTALS, GBSP_CHUNK_RGB_VERTS, GBSP_CHUNK_SKYDATA, GBSP_CHUNK_TEXDATA, GBSP_CHUNK_TEXINFO, GBSP_CHUNK_TEXTURES, GBSP_CHUNK_VERT_INDEX, GBSP_CHUNK_VERTS, GBSP_CHUNK_VISDATA, GBSP_VERSION, GBSP_BSPData::GBSPHeader, GE_ERR_BAD_BSP_FILE_CHUNK_SIZE, GE_ERR_INVALID_BSP_TAG, GE_ERR_INVALID_BSP_VERSION, GE_FALSE, GE_RAM_ALLOCATE_ARRAY, geBoolean, geErrorLog_Add, geRam_Allocate, geVFile_Read(), GBSP_BSPData::GFXAreaPortals, GBSP_BSPData::GFXAreas, GBSP_BSPData::GFXBNodes, GBSP_BSPData::GFXClusters, GBSP_BSPData::GFXEntData, GBSP_BSPData::GFXFaces, GBSP_BSPData::GFXLeafFaces, GBSP_BSPData::GFXLeafs, GBSP_BSPData::GFXLeafSides, GBSP_BSPData::GFXLightData, GBSP_BSPData::GFXModels, GBSP_BSPData::GFXNodes, GBSP_BSPData::GFXPalettes, GBSP_BSPData::GFXPlanes, GBSP_BSPData::GFXPortals, GBSP_BSPData::GFXRGBVerts, GBSP_BSPData::GFXSkyData, GBSP_BSPData::GFXTexData, GBSP_BSPData::GFXTexInfo, GBSP_BSPData::GFXTextures, GBSP_BSPData::GFXVertIndexList, GBSP_BSPData::GFXVerts, GBSP_BSPData::GFXVisData, int32, LoadMotions(), GFX_Model::Motion, NULL, GBSP_BSPData::NumGFXAreaPortals, GBSP_BSPData::NumGFXAreas, GBSP_BSPData::NumGFXBNodes, GBSP_BSPData::NumGFXClusters, GBSP_BSPData::NumGFXEntData, GBSP_BSPData::NumGFXFaces, GBSP_BSPData::NumGFXLeafFaces, GBSP_BSPData::NumGFXLeafs, GBSP_BSPData::NumGFXLeafSides, GBSP_BSPData::NumGFXLightData, GBSP_BSPData::NumGFXModels, GBSP_BSPData::NumGFXNodes, GBSP_BSPData::NumGFXPalettes, GBSP_BSPData::NumGFXPlanes, GBSP_BSPData::NumGFXPortals, GBSP_BSPData::NumGFXRGBVerts, GBSP_BSPData::NumGFXTexData, GBSP_BSPData::NumGFXTexInfo, GBSP_BSPData::NumGFXTextures, GBSP_BSPData::NumGFXVertIndexList, GBSP_BSPData::NumGFXVerts, GBSP_BSPData::NumGFXVisData, ReadChunkData(), GBSP_Chunk::Size, GBSP_Header::TAG, TRUE, GBSP_Chunk::Type, uint8, and GBSP_Header::Version. Referenced by GBSP_LoadGBSPFile().
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 }
|
|
||||||||||||||||
|
Definition at line 87 of file Gbspfile.c. References GBSP_Chunk::Elements, geBoolean, geVFile_Read(), and GBSP_Chunk::Size. Referenced by ReadChunk().
00088 {
00089 return geVFile_Read(f, Data, Chunk->Size * Chunk->Elements);
00090 }
|
1.3.2