bool P_LoadBuildMap (BYTE *data, size_t len, FMapThing **sprites, int *numspr) { if (len < 26) { return false; } // Check for a Blood map. if (*(DWORD *)data == MAKE_ID('B','L','M','\x1a')) { return P_LoadBloodMap (data, len, sprites, numspr); } const int numsec = LittleShort(*(WORD *)(data + 20)); int numwalls; int numsprites; if (len < 26 + numsec*sizeof(sectortype) || (numwalls = LittleShort(*(WORD *)(data + 22 + numsec*sizeof(sectortype))), len < 24 + numsec*sizeof(sectortype) + numwalls*sizeof(walltype)) || LittleLong(*(DWORD *)data) != 7 || LittleShort(*(WORD *)(data + 16)) >= 2048) { // Can't possibly be a version 7 BUILD map return false; } numsectors = numsec; LoadSectors ((sectortype *)(data + 22)); LoadWalls ((walltype *)(data + 24 + numsectors*sizeof(sectortype)), numwalls, (sectortype *)(data + 22)); numsprites = *(WORD *)(data + 24 + numsectors*sizeof(sectortype) + numwalls*sizeof(walltype)); *sprites = new FMapThing[numsprites + 1]; CreateStartSpot ((fixed_t *)(data + 4), *sprites); *numspr = 1 + LoadSprites ((spritetype *)(data + 26 + numsectors*sizeof(sectortype) + numwalls*sizeof(walltype)), NULL, numsprites, (sectortype *)(data + 22), *sprites + 1); return true; }
void CRender::level_Load(IReader* fs) { R_ASSERT (0!=g_pGameLevel); R_ASSERT (!b_loaded); // Begin pApp->LoadBegin (); dxRenderDeviceRender::Instance().Resources->DeferredLoad (TRUE); IReader* chunk; // Shaders // g_pGamePersistent->LoadTitle ("st_loading_shaders"); g_pGamePersistent->LoadTitle (); { chunk = fs->open_chunk (fsL_SHADERS); R_ASSERT2 (chunk,"Level doesn't builded correctly."); u32 count = chunk->r_u32 (); Shaders.resize (count); for(u32 i=0; i<count; i++) // skip first shader as "reserved" one { string512 n_sh,n_tlist; LPCSTR n = LPCSTR(chunk->pointer()); chunk->skip_stringZ (); if (0==n[0]) continue; xr_strcpy (n_sh,n); LPSTR delim = strchr(n_sh,'/'); *delim = 0; xr_strcpy (n_tlist,delim+1); Shaders[i] = dxRenderDeviceRender::Instance().Resources->Create(n_sh,n_tlist); } chunk->close(); } // Components Wallmarks = xr_new<CWallmarksEngine> (); Details = xr_new<CDetailManager> (); if (!g_dedicated_server) { // VB,IB,SWI // g_pGamePersistent->LoadTitle("st_loading_geometry"); g_pGamePersistent->LoadTitle(); { CStreamReader *geom = FS.rs_open("$level$","level.geom"); R_ASSERT2 (geom, "level.geom"); LoadBuffers (geom,FALSE); LoadSWIs (geom); FS.r_close (geom); } //...and alternate/fast geometry { CStreamReader *geom = FS.rs_open("$level$","level.geomx"); R_ASSERT2 (geom, "level.geomX"); LoadBuffers (geom,TRUE); FS.r_close (geom); } // Visuals // g_pGamePersistent->LoadTitle("st_loading_spatial_db"); g_pGamePersistent->LoadTitle(); chunk = fs->open_chunk(fsL_VISUALS); LoadVisuals (chunk); chunk->close (); // Details // g_pGamePersistent->LoadTitle("st_loading_details"); g_pGamePersistent->LoadTitle(); Details->Load (); } // Sectors // g_pGamePersistent->LoadTitle("st_loading_sectors_portals"); g_pGamePersistent->LoadTitle(); LoadSectors (fs); // 3D Fluid Load3DFluid (); // HOM HOM.Load (); // Lights // pApp->LoadTitle ("Loading lights..."); LoadLights (fs); // End pApp->LoadEnd (); // sanity-clear lstLODs.clear (); lstLODgroups.clear (); mapLOD.clear (); // signal loaded b_loaded = TRUE ; }
static bool P_LoadBloodMap (BYTE *data, size_t len, FMapThing **mapthings, int *numspr) { BYTE infoBlock[37]; int mapver = data[5]; DWORD matt; int numRevisions, numWalls, numsprites, skyLen, visibility, parallaxType; int i; int k; if (mapver != 6 && mapver != 7) { return false; } matt = *(DWORD *)(data + 28); if (matt != 0 && matt != MAKE_ID('M','a','t','t') && matt != MAKE_ID('t','t','a','M')) { Decrypt (infoBlock, data + 6, 37, 0x7474614d); } else { memcpy (infoBlock, data + 6, 37); } skyLen = 2 << LittleShort(*(WORD *)(infoBlock + 16)); visibility = LittleLong(*(DWORD *)(infoBlock + 18)); parallaxType = infoBlock[26]; numRevisions = LittleLong(*(DWORD *)(infoBlock + 27)); numsectors = LittleShort(*(WORD *)(infoBlock + 31)); numWalls = LittleShort(*(WORD *)(infoBlock + 33)); numsprites = LittleShort(*(WORD *)(infoBlock + 35)); Printf("Visibility: %d\n", visibility); if (mapver == 7) { // Version 7 has some extra stuff after the info block. This // includes a copyright, and I have no idea what the rest of // it is. data += 171; } else { data += 43; } // Skip the sky info. data += skyLen; sectortype *bsec = new sectortype[numsectors]; walltype *bwal = new walltype[numWalls]; spritetype *bspr = new spritetype[numsprites]; Xsprite *xspr = new Xsprite[numsprites]; // Read sectors k = numRevisions * sizeof(sectortype); for (i = 0; i < numsectors; ++i) { if (mapver == 7) { Decrypt (&bsec[i], data, sizeof(sectortype), k); } else { memcpy (&bsec[i], data, sizeof(sectortype)); } data += sizeof(sectortype); if (bsec[i].extra > 0) // skip Xsector { data += 60; } } // Read walls k |= 0x7474614d; for (i = 0; i < numWalls; ++i) { if (mapver == 7) { Decrypt (&bwal[i], data, sizeof(walltype), k); } else { memcpy (&bwal[i], data, sizeof(walltype)); } data += sizeof(walltype); if (bwal[i].extra > 0) // skip Xwall { data += 24; } } // Read sprites k = (numRevisions * sizeof(spritetype)) | 0x7474614d; for (i = 0; i < numsprites; ++i) { if (mapver == 7) { Decrypt (&bspr[i], data, sizeof(spritetype), k); } else { memcpy (&bspr[i], data, sizeof(spritetype)); } data += sizeof(spritetype); if (bspr[i].extra > 0) // copy Xsprite { assert(sizeof(Xsprite) == 56); memcpy(&xspr[i], data, sizeof(Xsprite)); data += sizeof(Xsprite); } else { memset(&xspr[i], 0, sizeof(Xsprite)); } } // Now convert to Doom format, since we've extracted all the standard // BUILD info from the map we need. (Sprites are ignored.) LoadSectors (bsec); LoadWalls (bwal, numWalls, bsec); *mapthings = new FMapThing[numsprites]; *numspr = LoadSprites (bspr, xspr, numsprites, bsec, *mapthings); delete[] bsec; delete[] bwal; delete[] bspr; delete[] xspr; return true; }
Bool BSPRooFileLoad(char *fname, room_type *room) { int i, temp; BYTE byte; WORD num_nodes, num_walls, num_sectors, num_sidedefs; int node_pos, wall_pos, sidedef_pos, sector_pos, offset_adjust; file_node f; if (!MappedFileOpenCopy(fname, &f)) return False; // Check magic number and version for (i = 0; i < 4; i++) if (CliMappedFileRead(&f, &byte, 1) != 1 || byte != room_magic[i]) { MappedFileClose(&f); debug(("%s is not a roo file\n", fname)); return False; } security = 0; if (CliMappedFileRead(&f, &room_version, 4) != 4 || room_version < ROO_VERSION) { MappedFileClose(&f); debug(("Bad roo version %d; expecting %d\n", room_version, ROO_VERSION)); return False; } security += room_version; if (CliMappedFileRead(&f, &room->security, 4) != 4) { MappedFileClose(&f); return False; } // Read pointer to main info in file, and go there if (CliMappedFileRead(&f, &temp, 4) != 4) { MappedFileClose(&f); return False; } MappedFileGoto(&f, temp); // Read size of room if (CliMappedFileRead(&f, &room->width, 4) != 4) { MappedFileClose(&f); return False; } offset_adjust = 0; room->cols = room->width >> LOG_FINENESS; if (CliMappedFileRead(&f, &room->height, 4) != 4) { MappedFileClose(&f); return False; } room->rows = room->height >> LOG_FINENESS; // Read pointers to file sections if (CliMappedFileRead(&f, &node_pos, 4) != 4) { MappedFileClose(&f); return False; } if (CliMappedFileRead(&f, &wall_pos, 4) != 4) { MappedFileClose(&f); return False; } if (CliMappedFileRead(&f, &temp, 4) != 4) { MappedFileClose(&f); return False; } if (CliMappedFileRead(&f, &sidedef_pos, 4) != 4) { MappedFileClose(&f); return False; } if (CliMappedFileRead(&f, §or_pos, 4) != 4) { MappedFileClose(&f); return False; } node_pos += offset_adjust; wall_pos += offset_adjust; sidedef_pos += offset_adjust; sector_pos += offset_adjust; // Read nodes MappedFileGoto(&f, node_pos); if (CliMappedFileRead(&f, &num_nodes, 2) != 2) { MappedFileClose(&f); return False; } if (LoadNodes(&f, room, num_nodes) == False) { debug(("Failure loading %d nodes\n", num_nodes)); MappedFileClose(&f); return False; } // Read walls MappedFileGoto(&f, wall_pos); if (CliMappedFileRead(&f, &num_walls, 2) != 2) { MappedFileClose(&f); return False; } if (LoadWalls(&f, room, num_walls) == False) { debug(("Failure loading %d walls\n", num_walls)); MappedFileClose(&f); return False; } // Read sidedefs MappedFileGoto(&f, sidedef_pos); if (CliMappedFileRead(&f, &num_sidedefs, 2) != 2) { MappedFileClose(&f); return False; } if (LoadSidedefs(&f, room, num_sidedefs) == False) { debug(("Failure loading %d sidedefs\n", num_sidedefs)); MappedFileClose(&f); return False; } // Read sectors MappedFileGoto(&f, sector_pos); if (CliMappedFileRead(&f, &num_sectors, 2) != 2) { MappedFileClose(&f); return False; } if (LoadSectors(&f, room, num_sectors) == False) { debug(("Failure loading %d sectors\n", num_sectors)); MappedFileClose(&f); return False; } MappedFileClose(&f); if (num_nodes == 0) { debug(("LoadRoom found room with no nodes!\n")); room->tree = NULL; } else room->tree = &room->nodes[0]; if (RoomSwizzle(room, room->tree, num_nodes, num_walls, num_sidedefs, num_sectors) == False) { debug(("RoomSwizzle failed\n")); BSPRoomFree(room); return False; } security ^= 0x89ab786c; if (security != room->security) { debug(("Room security mismatch (got %d, expecting %d)!\n", security, room->security)); BSPRoomFree(room); return False; } room->num_nodes = num_nodes; room->num_walls = num_walls; room->num_sectors = num_sectors; room->num_sidedefs = num_sidedefs; // BSPDumpTree(room->tree, 0); // D3DGeometryBuild(room); gD3DRedrawAll |= D3DRENDER_REDRAW_ALL; SandstormInit(); playerOldPos.x = 0; playerOldPos.y = 0; playerOldPos.z = 0; CacheReport(); return True; }