Rim/iw4x-client
Rim/iw4x-client
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases 2 Wiki Activity

Browse Source
This commit is contained in:
TheApadayo 2016-12-21 20:59:37 -05:00
commit f8a50eda81
11 changed files with 127 additions and 83 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/Components/Modules/AntiCheat.cpp
View File

@ -399,7 +399,7 @@ namespace Components
dwSize += GetLengthSid(psidArray[0]); dwSize += GetLengthSid(psidArray[0]);
dwSize += sizeof(ACCESS_DENIED_ACE) - sizeof(DWORD); dwSize += sizeof(ACCESS_DENIED_ACE) - sizeof(DWORD);
for (UINT i = 1; i < _countof(psidArray); i++) for (UINT i = 1; i < _countof(psidArray); ++i)
{ {
// DWORD is the SidStart field, which is not used for absolute format // DWORD is the SidStart field, which is not used for absolute format
dwSize += GetLengthSid(psidArray[i]); dwSize += GetLengthSid(psidArray[i]);

11
src/Components/Modules/AssetHandler.cpp
View File

@ -134,15 +134,15 @@ namespace Components
// Fix shader const stuff // Fix shader const stuff
if (type == Game::XAssetType::ASSET_TYPE_TECHSET && Zones::Version() >= 359) if (type == Game::XAssetType::ASSET_TYPE_TECHSET && Zones::Version() >= 359)
{ {
for (int i = 0; i < 48; i++) for (int i = 0; i < 48; ++i)
{ {
if (asset.techniqueSet->techniques[i]) if (asset.techniqueSet->techniques[i])
{ {
for (int j = 0; j < asset.techniqueSet->techniques[i]->numPasses; j++) for (int j = 0; j < asset.techniqueSet->techniques[i]->numPasses; ++j)
{ {
Game::MaterialPass* pass = &asset.techniqueSet->techniques[i]->passes[j]; Game::MaterialPass* pass = &asset.techniqueSet->techniques[i]->passes[j];
for (int k = 0; k < (pass->argCount1 + pass->argCount2 + pass->argCount3); k++) for (int k = 0; k < (pass->argCount1 + pass->argCount2 + pass->argCount3); ++k)
{ {
if (pass->argumentDef[k].type == D3DSHADER_PARAM_REGISTER_TYPE::D3DSPR_CONSTINT) if (pass->argumentDef[k].type == D3DSHADER_PARAM_REGISTER_TYPE::D3DSPR_CONSTINT)
{ {
@ -240,7 +240,6 @@ namespace Components
void AssetHandler::OffsetToAlias(Utils::Stream::Offset* offset) void AssetHandler::OffsetToAlias(Utils::Stream::Offset* offset)
{ {
// Same here, reinterpret the value, as we're operating inside the game's environment
void* pointer = (*Game::g_streamBlocks)[offset->getUnpackedBlock()].data + offset->getUnpackedOffset(); void* pointer = (*Game::g_streamBlocks)[offset->getUnpackedBlock()].data + offset->getUnpackedOffset();
if (AssetHandler::Relocations.find(pointer) != AssetHandler::Relocations.end()) if (AssetHandler::Relocations.find(pointer) != AssetHandler::Relocations.end())
@ -249,10 +248,6 @@ namespace Components
} }
offset->pointer = *reinterpret_cast<void**>(pointer); offset->pointer = *reinterpret_cast<void**>(pointer);
#ifdef DEBUG
Game::XAssetHeader zob{ offset->pointer };
#endif
} }
void AssetHandler::ZoneSave(Game::XAsset asset, ZoneBuilder::Zone* builder) void AssetHandler::ZoneSave(Game::XAsset asset, ZoneBuilder::Zone* builder)

18
src/Components/Modules/AssetInterfaces/IGfxImage.cpp
View File

@ -40,7 +40,7 @@ namespace Assets
const Game::GfxImageFileHeader* iwiHeader = reinterpret_cast<const Game::GfxImageFileHeader*>(iwiBuffer.data()); const Game::GfxImageFileHeader* iwiHeader = reinterpret_cast<const Game::GfxImageFileHeader*>(iwiBuffer.data());
image->mapType = 3; image->mapType = Game::MAPTYPE_2D;
image->dataLen1 = iwiHeader->fileSizeForPicmip[0] - 32; image->dataLen1 = iwiHeader->fileSizeForPicmip[0] - 32;
image->dataLen2 = iwiHeader->fileSizeForPicmip[0] - 32; image->dataLen2 = iwiHeader->fileSizeForPicmip[0] - 32;
@ -52,7 +52,7 @@ namespace Assets
std::memcpy(image->loadDef->dimensions, iwiHeader->dimensions, 6); std::memcpy(image->loadDef->dimensions, iwiHeader->dimensions, 6);
image->loadDef->flags = 0; image->loadDef->flags = 0;
image->loadDef->mipLevels = 0; image->loadDef->levelCount = 0;
switch (iwiHeader->format) switch (iwiHeader->format)
{ {
@ -93,6 +93,7 @@ namespace Assets
void IGfxImage::save(Game::XAssetHeader header, Components::ZoneBuilder::Zone* builder) void IGfxImage::save(Game::XAssetHeader header, Components::ZoneBuilder::Zone* builder)
{ {
AssertSize(Game::GfxImage, 32); AssertSize(Game::GfxImage, 32);
AssertSize(Game::MapType, 1);
Utils::Stream* buffer = builder->getBuffer(); Utils::Stream* buffer = builder->getBuffer();
Game::GfxImage* asset = header.image; Game::GfxImage* asset = header.image;
@ -109,21 +110,18 @@ namespace Assets
buffer->pushBlock(Game::XFILE_BLOCK_TEMP); buffer->pushBlock(Game::XFILE_BLOCK_TEMP);
if (asset->texture) if (asset->loadDef)
{ {
buffer->align(Utils::Stream::ALIGN_4); buffer->align(Utils::Stream::ALIGN_4);
Game::GfxImageLoadDef* destTexture = buffer->dest<Game::GfxImageLoadDef>(); Game::GfxImageLoadDef* destTexture = buffer->dest<Game::GfxImageLoadDef>();
buffer->save(asset->loadDef, 16); buffer->save(asset->loadDef, 16, 1);
builder->incrementExternalSize(asset->loadDef->dataSize); builder->incrementExternalSize(asset->loadDef->resourceSize);
// Zero the size! if (destTexture->resourceSize > 0)
destTexture->dataSize = 0;
if (destTexture->dataSize > 0)
{ {
buffer->save(asset->loadDef->data, asset->loadDef->dataSize); buffer->save(asset->loadDef->data, asset->loadDef->resourceSize);
} }
Utils::Stream::ClearPointer(&dest->loadDef); Utils::Stream::ClearPointer(&dest->loadDef);

39
src/Components/Modules/AssetInterfaces/IGfxWorld.cpp
View File

@ -85,8 +85,6 @@ namespace Assets
builder->loadAsset(Game::XAssetType::ASSET_TYPE_IMAGE, asset->unknownImage->name); builder->loadAsset(Game::XAssetType::ASSET_TYPE_IMAGE, asset->unknownImage->name);
} }
if (asset->dpvs.surfaces) if (asset->dpvs.surfaces)
{ {
for (int i = 0; i < asset->dpvsSurfaceCount; ++i) for (int i = 0; i < asset->dpvsSurfaceCount; ++i)
@ -147,7 +145,7 @@ namespace Assets
if (asset->sceneEntCellBits) if (asset->sceneEntCellBits)
{ {
buffer->align(Utils::Stream::ALIGN_4); buffer->align(Utils::Stream::ALIGN_4);
buffer->save(asset->sceneEntCellBits, 2048, asset->cellCount); buffer->save(asset->sceneEntCellBits, 1, asset->cellCount << 11);
Utils::Stream::ClearPointer(&dest->sceneEntCellBits); Utils::Stream::ClearPointer(&dest->sceneEntCellBits);
} }
@ -169,12 +167,12 @@ namespace Assets
Game::GfxImage** imageDest = buffer->dest<Game::GfxImage*>(); Game::GfxImage** imageDest = buffer->dest<Game::GfxImage*>();
buffer->saveArray(asset->reflectionImages, asset->reflectionProbeCount); buffer->saveArray(asset->reflectionImages, asset->reflectionProbeCount);
for (unsigned int i = 0; i < asset->reflectionProbeCount; i++) for (unsigned int i = 0; i < asset->reflectionProbeCount; ++i)
{ {
imageDest[i] = builder->requireAsset(Game::XAssetType::ASSET_TYPE_IMAGE, asset->reflectionImages[i]->name).image; imageDest[i] = builder->requireAsset(Game::XAssetType::ASSET_TYPE_IMAGE, asset->reflectionImages[i]->name).image;
} }
Utils::Stream::ClearPointer(asset->reflectionImages); Utils::Stream::ClearPointer(&dest->reflectionImages);
} }
if (asset->reflectionProbes) if (asset->reflectionProbes)
@ -208,7 +206,7 @@ namespace Assets
Game::GfxLightmapArray* lightmapArrayDestTable = buffer->dest<Game::GfxLightmapArray>(); Game::GfxLightmapArray* lightmapArrayDestTable = buffer->dest<Game::GfxLightmapArray>();
buffer->saveArray(asset->lightmaps, asset->lightmapCount); buffer->saveArray(asset->lightmaps, asset->lightmapCount);
for (int i = 0; i < asset->lightmapCount; i++) for (int i = 0; i < asset->lightmapCount; ++i)
{ {
Game::GfxLightmapArray* lightmapArrayDest = &lightmapArrayDestTable[i]; Game::GfxLightmapArray* lightmapArrayDest = &lightmapArrayDestTable[i];
Game::GfxLightmapArray* lightmapArray = &asset->lightmaps[i]; Game::GfxLightmapArray* lightmapArray = &asset->lightmaps[i];
@ -224,7 +222,7 @@ namespace Assets
} }
} }
Utils::Stream::ClearPointer(asset->reflectionImages); Utils::Stream::ClearPointer(&dest->lightmaps);
} }
buffer->pushBlock(Game::XFILE_BLOCK_RUNTIME); buffer->pushBlock(Game::XFILE_BLOCK_RUNTIME);
@ -259,26 +257,22 @@ namespace Assets
{ {
if (asset->vd.vertices) if (asset->vd.vertices)
{ {
AssertSize(Game::GfxWorldVertex, 44);
buffer->align(Utils::Stream::ALIGN_4); buffer->align(Utils::Stream::ALIGN_4);
buffer->saveArray(asset->vd.vertices, asset->vertexCount); buffer->saveArray(asset->vd.vertices, asset->vertexCount);
Utils::Stream::ClearPointer(&dest->vd.vertices); Utils::Stream::ClearPointer(&dest->vd.vertices);
} }
// this one has no if statement on purpouse
buffer->save(&asset->vd.worldVb, 1, 4);
} }
// saveGfxWorldVertexLayerData // saveGfxWorldVertexLayerData
{ {
if (asset->vld.data) if (asset->vld.data)
{ {
// no align for char // no align for char
buffer->saveArray(asset->vld.data, asset->vertexLayerDataSize); buffer->saveArray(asset->vld.data, asset->vertexLayerDataSize);
Utils::Stream::ClearPointer(&dest->vld.data); Utils::Stream::ClearPointer(&dest->vld.data);
} }
buffer->save(&asset->vld.layerVb, 1, 4);
} }
if (asset->indices) if (asset->indices)
@ -301,7 +295,7 @@ namespace Assets
if (asset->rowDataStart) if (asset->rowDataStart)
{ {
buffer->align(Utils::Stream::ALIGN_2); buffer->align(Utils::Stream::ALIGN_2);
buffer->saveArray(asset->rowDataStart, (asset->maxs[asset->rowAxis] - asset->mins[asset->rowAxis]) + 2); buffer->saveArray(asset->rowDataStart, (asset->maxs[asset->rowAxis] - asset->mins[asset->rowAxis]) + 1);
Utils::Stream::ClearPointer(&dest->rowDataStart); Utils::Stream::ClearPointer(&dest->rowDataStart);
} }
@ -404,7 +398,7 @@ namespace Assets
Game::GfxSurface* destSurfaceTable = buffer->dest<Game::GfxSurface>(); Game::GfxSurface* destSurfaceTable = buffer->dest<Game::GfxSurface>();
buffer->saveArray(asset->surfaces, world->dpvsSurfaceCount); buffer->saveArray(asset->surfaces, world->dpvsSurfaceCount);
for (int i = 0; i < world->dpvsSurfaceCount; i++) for (int i = 0; i < world->dpvsSurfaceCount; ++i)
{ {
Game::GfxSurface* surface = &asset->surfaces[i]; Game::GfxSurface* surface = &asset->surfaces[i];
Game::GfxSurface* destSurface = &destSurfaceTable[i]; Game::GfxSurface* destSurface = &destSurfaceTable[i];
@ -435,7 +429,7 @@ namespace Assets
Game::GfxStaticModelDrawInst* destModelTable = buffer->dest<Game::GfxStaticModelDrawInst>(); Game::GfxStaticModelDrawInst* destModelTable = buffer->dest<Game::GfxStaticModelDrawInst>();
buffer->saveArray(asset->smodelDrawInsts, asset->smodelCount); buffer->saveArray(asset->smodelDrawInsts, asset->smodelCount);
for (unsigned int i = 0; i < asset->smodelCount; i++) for (unsigned int i = 0; i < asset->smodelCount; ++i)
{ {
Game::GfxStaticModelDrawInst* model = &asset->smodelDrawInsts[i]; Game::GfxStaticModelDrawInst* model = &asset->smodelDrawInsts[i];
Game::GfxStaticModelDrawInst* destModel = &destModelTable[i]; Game::GfxStaticModelDrawInst* destModel = &destModelTable[i];
@ -497,9 +491,9 @@ namespace Assets
} }
// this covers [0][0], [1][0], [0][1], [1][1], [0][2], [1][2] // this covers [0][0], [1][0], [0][1], [1][1], [0][2], [1][2]
for (char i = 0; i < 3; i++) for (char i = 0; i < 3; ++i)
{ {
for (char j = 0; j < 2; j++) for (char j = 0; j < 2; ++j)
{ {
if (asset->dynEntVisData[j][i]) if (asset->dynEntVisData[j][i])
{ {
@ -516,7 +510,7 @@ namespace Assets
void IGfxWorld::save(Game::XAssetHeader header, Components::ZoneBuilder::Zone* builder) void IGfxWorld::save(Game::XAssetHeader header, Components::ZoneBuilder::Zone* builder)
{ {
AssertSize(Game::GfxWorld, 0x274); AssertSize(Game::GfxWorld, 628);
Utils::Stream* buffer = builder->getBuffer(); Utils::Stream* buffer = builder->getBuffer();
SAVE_LOG_ENTER("GfxWorld"); SAVE_LOG_ENTER("GfxWorld");
@ -569,7 +563,7 @@ namespace Assets
this->saveGfxWorldDpvsPlanes(asset, &asset->dpvsPlanes, &dest->dpvsPlanes, builder); this->saveGfxWorldDpvsPlanes(asset, &asset->dpvsPlanes, &dest->dpvsPlanes, builder);
uint32_t cellCount = asset->dpvsPlanes.cellCount; int cellCount = asset->dpvsPlanes.cellCount;
if (asset->aabbTreeCounts) if (asset->aabbTreeCounts)
{ {
@ -588,7 +582,7 @@ namespace Assets
Game::GfxCellTree* destCellTreeTable = buffer->dest<Game::GfxCellTree>(); Game::GfxCellTree* destCellTreeTable = buffer->dest<Game::GfxCellTree>();
buffer->saveArray(asset->aabbTrees, cellCount); buffer->saveArray(asset->aabbTrees, cellCount);
for (unsigned int i = 0; i < cellCount; ++i) for (int i = 0; i < cellCount; ++i)
{ {
Game::GfxCellTree* destCellTree = &destCellTreeTable[i]; Game::GfxCellTree* destCellTree = &destCellTreeTable[i];
Game::GfxCellTree* cellTree = &asset->aabbTrees[i]; Game::GfxCellTree* cellTree = &asset->aabbTrees[i];
@ -630,7 +624,6 @@ namespace Assets
Utils::Stream::ClearPointer(&destCellTree->aabbTree); Utils::Stream::ClearPointer(&destCellTree->aabbTree);
} }
} }
Utils::Stream::ClearPointer(&dest->aabbTrees); Utils::Stream::ClearPointer(&dest->aabbTrees);
@ -644,7 +637,7 @@ namespace Assets
Game::GfxCell* destCellTable = buffer->dest<Game::GfxCell>(); Game::GfxCell* destCellTable = buffer->dest<Game::GfxCell>();
buffer->saveArray(asset->cells, cellCount); buffer->saveArray(asset->cells, cellCount);
for (unsigned int i = 0; i < cellCount; ++i) for (int i = 0; i < cellCount; ++i)
{ {
Game::GfxCell* destCell = &destCellTable[i]; Game::GfxCell* destCell = &destCellTable[i];
Game::GfxCell* cell = &asset->cells[i]; Game::GfxCell* cell = &asset->cells[i];

38
src/Components/Modules/AssetInterfaces/IclipMap_t.cpp
View File

@ -29,9 +29,9 @@ namespace Assets
} }
else else
{ {
buffer->align(Utils::Stream::ALIGN_4);
builder->storePointer(asset->cPlanes); builder->storePointer(asset->cPlanes);
buffer->align(Utils::Stream::ALIGN_4);
buffer->saveArray(asset->cPlanes, asset->numCPlanes); buffer->saveArray(asset->cPlanes, asset->numCPlanes);
Utils::Stream::ClearPointer(&dest->cPlanes); Utils::Stream::ClearPointer(&dest->cPlanes);
} }
@ -93,9 +93,9 @@ namespace Assets
} }
else else
{ {
buffer->align(Utils::Stream::ALIGN_4);
builder->storePointer(sides[i].side); builder->storePointer(sides[i].side);
buffer->align(Utils::Stream::ALIGN_4);
buffer->save(sides[i].side); buffer->save(sides[i].side);
Utils::Stream::ClearPointer(&sides[i].side); Utils::Stream::ClearPointer(&sides[i].side);
} }
@ -130,9 +130,9 @@ namespace Assets
} }
else else
{ {
buffer->align(Utils::Stream::ALIGN_4);
builder->storePointer(nodes[i].plane); builder->storePointer(nodes[i].plane);
buffer->align(Utils::Stream::ALIGN_4);
buffer->save(nodes[i].plane); buffer->save(nodes[i].plane);
Utils::Stream::ClearPointer(&nodes[i].plane); Utils::Stream::ClearPointer(&nodes[i].plane);
} }
@ -178,9 +178,9 @@ namespace Assets
} }
else else
{ {
buffer->align(Utils::Stream::ALIGN_2);
builder->storePointer(node[i].data.brushes); builder->storePointer(node[i].data.brushes);
buffer->align(Utils::Stream::ALIGN_2);
buffer->saveArray(node[i].data.brushes, node[i].leafBrushCount); buffer->saveArray(node[i].data.brushes, node[i].leafBrushCount);
Utils::Stream::ClearPointer(&node[i].data.brushes); Utils::Stream::ClearPointer(&node[i].data.brushes);
} }
@ -254,9 +254,9 @@ namespace Assets
} }
else else
{ {
buffer->align(Utils::Stream::ALIGN_4);
builder->storePointer(border[i].borders); builder->storePointer(border[i].borders);
buffer->align(Utils::Stream::ALIGN_4);
buffer->save(border[i].borders); buffer->save(border[i].borders);
Utils::Stream::ClearPointer(&border[i].borders); Utils::Stream::ClearPointer(&border[i].borders);
} }
@ -302,11 +302,11 @@ namespace Assets
} }
else else
{ {
builder->storePointer(brushes[i].brushSide);
AssertSize(Game::cbrushside_t, 8); AssertSize(Game::cbrushside_t, 8);
buffer->align(Utils::Stream::ALIGN_4); buffer->align(Utils::Stream::ALIGN_4);
builder->storePointer(brushes[i].brushSide);
Game::cbrushside_t* side = buffer->dest<Game::cbrushside_t>(); Game::cbrushside_t* side = buffer->dest<Game::cbrushside_t>();
buffer->save(brushes[i].brushSide); buffer->save(brushes[i].brushSide);
@ -318,9 +318,9 @@ namespace Assets
} }
else else
{ {
buffer->align(Utils::Stream::ALIGN_4);
builder->storePointer(brushes[i].brushSide->side); builder->storePointer(brushes[i].brushSide->side);
buffer->align(Utils::Stream::ALIGN_4);
buffer->save(brushes[i].brushSide->side); buffer->save(brushes[i].brushSide->side);
Utils::Stream::ClearPointer(&side->side); Utils::Stream::ClearPointer(&side->side);
} }
@ -416,7 +416,7 @@ namespace Assets
buffer->pushBlock(Game::XFILE_BLOCK_RUNTIME); buffer->pushBlock(Game::XFILE_BLOCK_RUNTIME);
for (int i = 0; i < 2; i++) for (int i = 0; i < 2; ++i)
{ {
if (asset->dynEntPoseList[i]) if (asset->dynEntPoseList[i])
{ {
@ -429,7 +429,7 @@ namespace Assets
} }
} }
for (int i = 0; i < 2; i++) for (int i = 0; i < 2; ++i)
{ {
if (asset->dynEntClientList[i]) if (asset->dynEntClientList[i])
{ {
@ -441,7 +441,7 @@ namespace Assets
} }
} }
for (int i = 0; i < 2; i++) for (int i = 0; i < 2; ++i)
{ {
if (asset->dynEntCollList[i]) if (asset->dynEntCollList[i])
{ {
@ -466,7 +466,7 @@ namespace Assets
builder->loadAsset(Game::XAssetType::ASSET_TYPE_XMODEL, m->name); builder->loadAsset(Game::XAssetType::ASSET_TYPE_XMODEL, m->name);
} }
for (int j = 0; j < 2; j++) for (int j = 0; j < 2; ++j)
{ {
Game::DynEntityDef* def = asset->dynEntDefList[j]; Game::DynEntityDef* def = asset->dynEntDefList[j];

16
src/Components/Modules/Maps.cpp
View File

@ -306,7 +306,7 @@ namespace Components
map.append(fmt::sprintf("mtllib %s.mtl\n\n", world->baseName)); map.append(fmt::sprintf("mtllib %s.mtl\n\n", world->baseName));
Logger::Print("Writing vertices...\n"); Logger::Print("Writing vertices...\n");
for (unsigned int i = 0; i < world->worldDraw.vertexCount; i++) for (unsigned int i = 0; i < world->worldDraw.vertexCount; ++i)
{ {
float x = world->worldDraw.vd.vertices[i].xyz[1]; float x = world->worldDraw.vd.vertices[i].xyz[1];
float y = world->worldDraw.vd.vertices[i].xyz[2]; float y = world->worldDraw.vd.vertices[i].xyz[2];
@ -318,7 +318,7 @@ namespace Components
map.append("\n"); map.append("\n");
Logger::Print("Writing texture coordinates...\n"); Logger::Print("Writing texture coordinates...\n");
for (unsigned int i = 0; i < world->worldDraw.vertexCount; i++) for (unsigned int i = 0; i < world->worldDraw.vertexCount; ++i)
{ {
map.append(fmt::sprintf("vt %.6f %.6f\n", world->worldDraw.vd.vertices[i].texCoord[0], -world->worldDraw.vd.vertices[i].texCoord[1])); map.append(fmt::sprintf("vt %.6f %.6f\n", world->worldDraw.vd.vertices[i].texCoord[0], -world->worldDraw.vd.vertices[i].texCoord[1]));
} }
@ -327,11 +327,11 @@ namespace Components
int materialCount = 0; int materialCount = 0;
Game::Material** materials = allocator.allocateArray<Game::Material*>(world->dpvs.staticSurfaceCount); Game::Material** materials = allocator.allocateArray<Game::Material*>(world->dpvs.staticSurfaceCount);
for (unsigned int i = 0; i < world->dpvs.staticSurfaceCount; i++) for (unsigned int i = 0; i < world->dpvs.staticSurfaceCount; ++i)
{ {
bool isNewMat = true; bool isNewMat = true;
for (int j = 0; j < materialCount; j++) for (int j = 0; j < materialCount; ++j)
{ {
if (world->dpvs.surfaces[i].material == materials[j]) if (world->dpvs.surfaces[i].material == materials[j])
{ {
@ -350,7 +350,7 @@ namespace Components
mtl.append(fmt::sprintf("# Material Count: %d\n", materialCount)); mtl.append(fmt::sprintf("# Material Count: %d\n", materialCount));
Logger::Print("Exporting materials and faces...\n"); Logger::Print("Exporting materials and faces...\n");
for (int m = 0; m < materialCount; m++) for (int m = 0; m < materialCount; ++m)
{ {
std::string name = materials[m]->name; std::string name = materials[m]->name;
@ -377,7 +377,7 @@ namespace Components
} }
std::string _name = fmt::sprintf("raw/mapdump/%s/textures/%s.png", world->baseName, image->name); std::string _name = fmt::sprintf("raw/mapdump/%s/textures/%s.png", world->baseName, image->name);
D3DXSaveTextureToFile(std::wstring(_name.begin(), _name.end()).data(), D3DXIFF_PNG, image->texture, NULL); D3DXSaveTextureToFile(std::wstring(_name.begin(), _name.end()).data(), D3DXIFF_PNG, image->map, NULL);
mtl.append(fmt::sprintf("\nnewmtl %s\n", name.data())); mtl.append(fmt::sprintf("\nnewmtl %s\n", name.data()));
mtl.append("Ka 1.0000 1.0000 1.0000\n"); mtl.append("Ka 1.0000 1.0000 1.0000\n");
@ -386,14 +386,14 @@ namespace Components
mtl.append(fmt::sprintf("map_Ka textures/%s.png\n", image->name)); mtl.append(fmt::sprintf("map_Ka textures/%s.png\n", image->name));
mtl.append(fmt::sprintf("map_Kd textures/%s.png\n", image->name)); mtl.append(fmt::sprintf("map_Kd textures/%s.png\n", image->name));
for (unsigned int i = 0; i < world->dpvs.staticSurfaceCount; i++) for (unsigned int i = 0; i < world->dpvs.staticSurfaceCount; ++i)
{ {
if (world->dpvs.surfaces[i].material != materials[m]) if (world->dpvs.surfaces[i].material != materials[m])
continue; continue;
int vertOffset = world->dpvs.surfaces[i].tris.firstVertex + 1;//+1 cus obj starts at 1 int vertOffset = world->dpvs.surfaces[i].tris.firstVertex + 1;//+1 cus obj starts at 1
int indexOffset = world->dpvs.surfaces[i].tris.baseIndex; int indexOffset = world->dpvs.surfaces[i].tris.baseIndex;
for (unsigned short j = 0; j < world->dpvs.surfaces[i].tris.triCount; j++) for (unsigned short j = 0; j < world->dpvs.surfaces[i].tris.triCount; ++j)
{ {
int a = world->worldDraw.indices[indexOffset + j * 3 + 0] + vertOffset; int a = world->worldDraw.indices[indexOffset + j * 3 + 0] + vertOffset;
int b = world->worldDraw.indices[indexOffset + j * 3 + 1] + vertOffset; int b = world->worldDraw.indices[indexOffset + j * 3 + 1] + vertOffset;

36
src/Components/Modules/ZoneBuilder.cpp
View File

@ -2,6 +2,8 @@
namespace Components namespace Components
{ {
Utils::Memory::Allocator ZoneBuilder::MemAllocator;
std::string ZoneBuilder::TraceZone; std::string ZoneBuilder::TraceZone;
std::vector<std::pair<Game::XAssetType, std::string>> ZoneBuilder::TraceAssets; std::vector<std::pair<Game::XAssetType, std::string>> ZoneBuilder::TraceAssets;
@ -316,7 +318,7 @@ namespace Components
this->buffer.enterCriticalSection(); this->buffer.enterCriticalSection();
Game::XFile* header = reinterpret_cast<Game::XFile*>(this->buffer.data()); Game::XFile* header = reinterpret_cast<Game::XFile*>(this->buffer.data());
header->size = this->buffer.length() - sizeof(Game::XFile); // Write correct data size header->size = this->buffer.length() - sizeof(Game::XFile); // Write correct data size
header->externalSize = 0;//this->externalSize; // This actually stores how much external data has to be loaded. It's used to calculate the loadscreen progress header->externalSize = this->externalSize; // This actually stores how much external data has to be loaded. It's used to calculate the loadscreen progress
// Write stream sizes // Write stream sizes
for (int i = 0; i < Game::MAX_XFILE_COUNT; ++i) for (int i = 0; i < Game::MAX_XFILE_COUNT; ++i)
@ -486,6 +488,25 @@ namespace Components
return AssetTrace; return AssetTrace;
} }
int ZoneBuilder::StoreTexture(Game::GfxImageLoadDef **loadDef, Game::GfxImage *image)
{
size_t size = 16 + (*loadDef)->resourceSize;
void* data = ZoneBuilder::MemAllocator.allocate(size);
std::memcpy(data, *loadDef, size);
image->loadDef = reinterpret_cast<Game::GfxImageLoadDef *>(data);
return 0;
}
void ZoneBuilder::ReleaseTexture(Game::XAssetHeader header)
{
if (header.image && header.image->loadDef)
{
ZoneBuilder::MemAllocator.free(header.image->loadDef);
}
}
ZoneBuilder::ZoneBuilder() ZoneBuilder::ZoneBuilder()
{ {
AssertSize(Game::XFileHeader, 21); AssertSize(Game::XFileHeader, 21);
@ -497,7 +518,13 @@ namespace Components
if (ZoneBuilder::IsEnabled()) if (ZoneBuilder::IsEnabled())
{ {
// Prevent loading textures (preserves loaddef) // Prevent loading textures (preserves loaddef)
Utils::Hook::Set<BYTE>(0x51F4E0, 0xC3); //Utils::Hook::Set<BYTE>(Game::Load_Texture, 0xC3);
// Store the loaddef
Utils::Hook(Game::Load_Texture, StoreTexture, HOOK_JUMP).install()->quick();
// Release the loaddef
Game::DB_ReleaseXAssetHandlers[Game::XAssetType::ASSET_TYPE_IMAGE] = ZoneBuilder::ReleaseTexture;
//r_loadForrenderer = 0 //r_loadForrenderer = 0
Utils::Hook::Set<BYTE>(0x519DDF, 0); Utils::Hook::Set<BYTE>(0x519DDF, 0);
@ -620,4 +647,9 @@ namespace Components
}); });
} }
} }
ZoneBuilder::~ZoneBuilder()
{
assert(ZoneBuilder::MemAllocator.empty());
}
} }

6
src/Components/Modules/ZoneBuilder.hpp
View File

@ -75,6 +75,7 @@ namespace Components
}; };
ZoneBuilder(); ZoneBuilder();
~ZoneBuilder();
#if defined(DEBUG) || defined(FORCE_UNIT_TESTS) #if defined(DEBUG) || defined(FORCE_UNIT_TESTS)
const char* getName() { return "ZoneBuilder"; }; const char* getName() { return "ZoneBuilder"; };
@ -87,5 +88,10 @@ namespace Components
static void BeginAssetTrace(std::string zone); static void BeginAssetTrace(std::string zone);
static std::vector<std::pair<Game::XAssetType, std::string>> EndAssetTrace(); static std::vector<std::pair<Game::XAssetType, std::string>> EndAssetTrace();
private:
static Utils::Memory::Allocator MemAllocator;
static int StoreTexture(Game::GfxImageLoadDef **loadDef, Game::GfxImage *image);
static void ReleaseTexture(Game::XAssetHeader header);
}; };
} }

2
src/Components/Modules/Zones.cpp
View File

@ -1167,7 +1167,7 @@ namespace Components
struct struct
{ {
Game::GfxImageLoadDef* texture; Game::GfxImageLoadDef* texture;
char mapType; Game::MapType mapType;
char semantic; char semantic;
char category; char category;
char flags; char flags;

30
src/Game/Structs.hpp
View File

@ -285,27 +285,41 @@ namespace Game
int fileSizeForPicmip[4]; int fileSizeForPicmip[4];
}; };
struct GfxImageLoadDef // actually a IDirect3DTexture* but this is easier struct __declspec(align(4)) GfxImageLoadDef
{ {
char mipLevels; char levelCount;
char flags; char flags;
short dimensions[3]; __int16 dimensions[3];
int format; // usually the compression Magic int format;
int dataSize; // set to zero to load from IWD int resourceSize;
char data[1]; char data[1];
}; };
enum MapType : char
{
MAPTYPE_NONE = 0x0,
MAPTYPE_INVALID1 = 0x1,
MAPTYPE_INVALID2 = 0x2,
MAPTYPE_2D = 0x3,
MAPTYPE_3D = 0x4,
MAPTYPE_CUBE = 0x5,
MAPTYPE_COUNT = 0x6,
};
struct GfxImage struct GfxImage
{ {
union union
{ {
GfxImageLoadDef* loadDef; GfxImageLoadDef* loadDef;
#ifdef __cplusplus #ifdef __cplusplus
IDirect3DTexture9* texture; IDirect3DBaseTexture9 *basemap;
IDirect3DTexture9 *map;
IDirect3DVolumeTexture9 *volmap;
IDirect3DCubeTexture9 *cubemap;
#endif #endif
}; };
char mapType; // 5 is cube, 4 is 3d, 3 is 2d MapType mapType;
char semantic; char semantic;
char category; char category;
char flags; char flags;
@ -2948,7 +2962,7 @@ namespace Game
{ {
GfxPortalWritable writable; GfxPortalWritable writable;
DpvsPlane plane; DpvsPlane plane;
float(*vertices)[3]; vec3_t* vertices;
char unknown[2]; char unknown[2];
char vertexCount; char vertexCount;
float hullAxis[2][3]; float hullAxis[2][3];

12
src/Utils/Stream.cpp
View File

@ -111,9 +111,15 @@ namespace Utils
char* Stream::save(Game::XFILE_BLOCK_TYPES stream, const void * _str, size_t size, size_t count) char* Stream::save(Game::XFILE_BLOCK_TYPES stream, const void * _str, size_t size, size_t count)
{ {
//if (stream == XFILE_BLOCK_TEMP || stream == XFILE_BLOCK_VIRTUAL || stream == XFILE_BLOCK_PHYSICAL) // Only those seem to actually write data. // Only those seem to actually write data.
// As I'm not sure though, I'll still write the data // As I'm not sure though, I'll still write the data
// Use IncreaseBlockSize to fill virtual streams // Use IncreaseBlockSize to fill virtual streams
if (stream != Game::XFILE_BLOCK_TEMP && stream != Game::XFILE_BLOCK_VIRTUAL && stream != Game::XFILE_BLOCK_PHYSICAL)
{
this->increaseBlockSize(stream, size * count);
return this->at();
}
auto data = this->data(); auto data = this->data();
if (this->isCriticalSection() && this->length() + (size * count) > this->capacity()) if (this->isCriticalSection() && this->length() + (size * count) > this->capacity())