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

Merge branch 'nested_assets' into develop

Browse Source
This commit is contained in:
TheApadayo 2016-12-23 11:03:40 -05:00
commit 9945d15b90
12 changed files with 217 additions and 106 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

26
src/Components/Modules/AssetInterfaces/IFxEffectDef.cpp
View File

@ -49,7 +49,7 @@ namespace Assets
{ {
if (visuals->xmodel) if (visuals->xmodel)
{ {
builder->loadAsset(Game::XAssetType::ASSET_TYPE_XMODEL, visuals->xmodel->name); builder->markAsset(Game::XAssetType::ASSET_TYPE_XMODEL, visuals->xmodel);
} }
break; break;
@ -61,7 +61,7 @@ namespace Assets
case 0xA: case 0xA:
{ {
builder->loadAsset(Game::XAssetType::ASSET_TYPE_SOUND, visuals->soundName); //builder->markAsset(Game::XAssetType::ASSET_TYPE_SOUND, visuals->soundName);
break; break;
} }
@ -69,7 +69,7 @@ namespace Assets
{ {
if (visuals->effectDef) if (visuals->effectDef)
{ {
builder->loadAsset(Game::XAssetType::ASSET_TYPE_FX, visuals->effectDef->name); builder->markAsset(Game::XAssetType::ASSET_TYPE_FX, visuals->effectDef);
} }
break; break;
@ -79,7 +79,7 @@ namespace Assets
{ {
if (visuals->material) if (visuals->material)
{ {
builder->loadAsset(Game::XAssetType::ASSET_TYPE_MATERIAL, visuals->material->name); builder->markAsset(Game::XAssetType::ASSET_TYPE_MATERIAL, visuals->material);
} }
break; break;
@ -104,12 +104,12 @@ namespace Assets
{ {
if (elemDef->visuals.markArray[j].data[0]) if (elemDef->visuals.markArray[j].data[0])
{ {
builder->loadAsset(Game::XAssetType::ASSET_TYPE_MATERIAL, elemDef->visuals.markArray[j].data[0]->name); builder->markAsset(Game::XAssetType::ASSET_TYPE_MATERIAL, elemDef->visuals.markArray[j].data[0]);
} }
if (elemDef->visuals.markArray[j].data[1]) if (elemDef->visuals.markArray[j].data[1])
{ {
builder->loadAsset(Game::XAssetType::ASSET_TYPE_MATERIAL, elemDef->visuals.markArray[j].data[1]->name); builder->markAsset(Game::XAssetType::ASSET_TYPE_MATERIAL, elemDef->visuals.markArray[j].data[1]);
} }
} }
} }
@ -132,17 +132,17 @@ namespace Assets
if (elemDef->effectOnImpact) if (elemDef->effectOnImpact)
{ {
builder->loadAsset(Game::XAssetType::ASSET_TYPE_FX, elemDef->effectOnImpact->name); builder->markAsset(Game::XAssetType::ASSET_TYPE_FX, elemDef->effectOnImpact);
} }
if (elemDef->effectOnDeath) if (elemDef->effectOnDeath)
{ {
builder->loadAsset(Game::XAssetType::ASSET_TYPE_FX, elemDef->effectOnDeath->name); builder->markAsset(Game::XAssetType::ASSET_TYPE_FX, elemDef->effectOnDeath);
} }
if (elemDef->effectEmitted) if (elemDef->effectEmitted)
{ {
builder->loadAsset(Game::XAssetType::ASSET_TYPE_FX, elemDef->effectEmitted->name); builder->markAsset(Game::XAssetType::ASSET_TYPE_FX, elemDef->effectEmitted);
} }
} }
} }
@ -157,7 +157,7 @@ namespace Assets
{ {
if (visuals->xmodel) if (visuals->xmodel)
{ {
destVisuals->xmodel = builder->requireAsset(Game::XAssetType::ASSET_TYPE_XMODEL, visuals->xmodel->name).model; destVisuals->xmodel = builder->saveSubAsset(Game::XAssetType::ASSET_TYPE_XMODEL, visuals->xmodel).model;
} }
break; break;
@ -193,7 +193,7 @@ namespace Assets
{ {
if (visuals->material) if (visuals->material)
{ {
destVisuals->material = builder->requireAsset(Game::XAssetType::ASSET_TYPE_MATERIAL, visuals->material->name).material; destVisuals->material = builder->saveSubAsset(Game::XAssetType::ASSET_TYPE_MATERIAL, visuals->material).material;
} }
break; break;
@ -267,12 +267,12 @@ namespace Assets
{ {
if (elemDef->visuals.markArray[j].data[0]) if (elemDef->visuals.markArray[j].data[0])
{ {
destMarkArray[j].data[0] = builder->requireAsset(Game::XAssetType::ASSET_TYPE_MATERIAL, elemDef->visuals.markArray[j].data[0]->name).material; destMarkArray[j].data[0] = builder->saveSubAsset(Game::XAssetType::ASSET_TYPE_MATERIAL, elemDef->visuals.markArray[j].data[0]).material;
} }
if (elemDef->visuals.markArray[j].data[1]) if (elemDef->visuals.markArray[j].data[1])
{ {
destMarkArray[j].data[1] = builder->requireAsset(Game::XAssetType::ASSET_TYPE_MATERIAL, elemDef->visuals.markArray[j].data[1]->name).material; destMarkArray[j].data[1] = builder->saveSubAsset(Game::XAssetType::ASSET_TYPE_MATERIAL, elemDef->visuals.markArray[j].data[1]).material;
} }
} }

12
src/Components/Modules/AssetInterfaces/IFxWorld.cpp
View File

@ -39,17 +39,17 @@ namespace Assets
if (glassDef->physPreset) if (glassDef->physPreset)
{ {
destGlassDef->physPreset = builder->requireAsset(Game::XAssetType::ASSET_TYPE_PHYSPRESET, glassDef->physPreset->name).physPreset; destGlassDef->physPreset = builder->saveSubAsset(Game::XAssetType::ASSET_TYPE_PHYSPRESET, glassDef->physPreset).physPreset;
} }
if (glassDef->material) if (glassDef->material)
{ {
destGlassDef->material = builder->requireAsset(Game::XAssetType::ASSET_TYPE_MATERIAL, glassDef->material->name).material; destGlassDef->material = builder->saveSubAsset(Game::XAssetType::ASSET_TYPE_MATERIAL, glassDef->material).material;
} }
if (glassDef->materialShattered) if (glassDef->materialShattered)
{ {
destGlassDef->materialShattered = builder->requireAsset(Game::XAssetType::ASSET_TYPE_MATERIAL, glassDef->materialShattered->name).material; destGlassDef->materialShattered = builder->saveSubAsset(Game::XAssetType::ASSET_TYPE_MATERIAL, glassDef->materialShattered).material;
} }
} }
@ -164,9 +164,9 @@ namespace Assets
{ {
for (unsigned int i = 0; i < asset->glassSys.defCount; ++i) for (unsigned int i = 0; i < asset->glassSys.defCount; ++i)
{ {
builder->loadAsset(Game::XAssetType::ASSET_TYPE_PHYSPRESET, asset->glassSys.defs[i].physPreset->name); builder->markAsset(Game::XAssetType::ASSET_TYPE_PHYSPRESET, asset->glassSys.defs[i].physPreset);
builder->loadAsset(Game::XAssetType::ASSET_TYPE_MATERIAL, asset->glassSys.defs[i].material->name); builder->markAsset(Game::XAssetType::ASSET_TYPE_MATERIAL, asset->glassSys.defs[i].material);
builder->loadAsset(Game::XAssetType::ASSET_TYPE_MATERIAL, asset->glassSys.defs[i].materialShattered->name); builder->markAsset(Game::XAssetType::ASSET_TYPE_MATERIAL, asset->glassSys.defs[i].materialShattered);
} }
} }
} }

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

@ -18,7 +18,7 @@ namespace Assets
{ {
for (unsigned int i = 0; i < asset->worldDraw.reflectionProbeCount; ++i) for (unsigned int i = 0; i < asset->worldDraw.reflectionProbeCount; ++i)
{ {
builder->loadAsset(Game::XAssetType::ASSET_TYPE_IMAGE, asset->worldDraw.reflectionImages[i]->name); builder->markAsset(Game::XAssetType::ASSET_TYPE_IMAGE, asset->worldDraw.reflectionImages[i]);
} }
} }
@ -28,34 +28,34 @@ namespace Assets
{ {
if (asset->worldDraw.lightmaps[i].primary) if (asset->worldDraw.lightmaps[i].primary)
{ {
builder->loadAsset(Game::XAssetType::ASSET_TYPE_IMAGE, asset->worldDraw.lightmaps[i].primary->name); builder->markAsset(Game::XAssetType::ASSET_TYPE_IMAGE, asset->worldDraw.lightmaps[i].primary);
} }
if (asset->worldDraw.lightmaps[i].secondary) if (asset->worldDraw.lightmaps[i].secondary)
{ {
builder->loadAsset(Game::XAssetType::ASSET_TYPE_IMAGE, asset->worldDraw.lightmaps[i].secondary->name); builder->markAsset(Game::XAssetType::ASSET_TYPE_IMAGE, asset->worldDraw.lightmaps[i].secondary);
} }
} }
} }
if (asset->worldDraw.skyImage) if (asset->worldDraw.skyImage)
{ {
builder->loadAsset(Game::XAssetType::ASSET_TYPE_IMAGE, asset->worldDraw.skyImage->name); builder->markAsset(Game::XAssetType::ASSET_TYPE_IMAGE, asset->worldDraw.skyImage);
} }
if (asset->worldDraw.outdoorImage) if (asset->worldDraw.outdoorImage)
{ {
builder->loadAsset(Game::XAssetType::ASSET_TYPE_IMAGE, asset->worldDraw.outdoorImage->name); builder->markAsset(Game::XAssetType::ASSET_TYPE_IMAGE, asset->worldDraw.outdoorImage);
} }
if (asset->sun.spriteMaterial) if (asset->sun.spriteMaterial)
{ {
builder->loadAsset(Game::XAssetType::ASSET_TYPE_MATERIAL, asset->sun.spriteMaterial->name); builder->markAsset(Game::XAssetType::ASSET_TYPE_MATERIAL, asset->sun.spriteMaterial);
} }
if (asset->sun.flareMaterial) if (asset->sun.flareMaterial)
{ {
builder->loadAsset(Game::XAssetType::ASSET_TYPE_MATERIAL, asset->sun.flareMaterial->name); builder->markAsset(Game::XAssetType::ASSET_TYPE_MATERIAL, asset->sun.flareMaterial);
} }
if (asset->skies) if (asset->skies)
@ -64,7 +64,7 @@ namespace Assets
{ {
if (asset->skies[i].skyImage) if (asset->skies[i].skyImage)
{ {
builder->loadAsset(Game::XAssetType::ASSET_TYPE_IMAGE, asset->skies[i].skyImage->name); builder->markAsset(Game::XAssetType::ASSET_TYPE_IMAGE, asset->skies[i].skyImage);
} }
} }
} }
@ -75,14 +75,14 @@ namespace Assets
{ {
if (asset->materialMemory[i].material) if (asset->materialMemory[i].material)
{ {
builder->loadAsset(Game::XAssetType::ASSET_TYPE_MATERIAL, asset->materialMemory[i].material->name); builder->markAsset(Game::XAssetType::ASSET_TYPE_MATERIAL, asset->materialMemory[i].material);
} }
} }
} }
if (asset->unknownImage) if (asset->unknownImage)
{ {
builder->loadAsset(Game::XAssetType::ASSET_TYPE_IMAGE, asset->unknownImage->name); builder->markAsset(Game::XAssetType::ASSET_TYPE_IMAGE, asset->unknownImage);
} }
if (asset->dpvs.surfaces) if (asset->dpvs.surfaces)
@ -91,7 +91,7 @@ namespace Assets
{ {
if (asset->dpvs.surfaces[i].material) if (asset->dpvs.surfaces[i].material)
{ {
builder->loadAsset(Game::XAssetType::ASSET_TYPE_MATERIAL, asset->dpvs.surfaces[i].material->name); builder->markAsset(Game::XAssetType::ASSET_TYPE_MATERIAL, asset->dpvs.surfaces[i].material);
} }
} }
} }
@ -102,7 +102,7 @@ namespace Assets
{ {
if (asset->dpvs.smodelDrawInsts[i].model) if (asset->dpvs.smodelDrawInsts[i].model)
{ {
builder->loadAsset(Game::XAssetType::ASSET_TYPE_XMODEL, asset->dpvs.smodelDrawInsts[i].model->name); builder->markAsset(Game::XAssetType::ASSET_TYPE_XMODEL, asset->dpvs.smodelDrawInsts[i].model);
} }
} }
} }
@ -169,7 +169,7 @@ namespace Assets
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->saveSubAsset(Game::XAssetType::ASSET_TYPE_IMAGE, asset->reflectionImages[i]).image;
} }
Utils::Stream::ClearPointer(&dest->reflectionImages); Utils::Stream::ClearPointer(&dest->reflectionImages);
@ -213,12 +213,12 @@ namespace Assets
if (lightmapArray->primary) if (lightmapArray->primary)
{ {
lightmapArrayDest->primary = builder->requireAsset(Game::XAssetType::ASSET_TYPE_IMAGE, lightmapArray->primary->name).image; lightmapArrayDest->primary = builder->saveSubAsset(Game::XAssetType::ASSET_TYPE_IMAGE, lightmapArray->primary).image;
} }
if (lightmapArray->secondary) if (lightmapArray->secondary)
{ {
lightmapArrayDest->secondary = builder->requireAsset(Game::XAssetType::ASSET_TYPE_IMAGE, lightmapArray->secondary->name).image; lightmapArrayDest->secondary = builder->saveSubAsset(Game::XAssetType::ASSET_TYPE_IMAGE, lightmapArray->secondary).image;
} }
} }
@ -245,12 +245,12 @@ namespace Assets
if (asset->skyImage) if (asset->skyImage)
{ {
dest->skyImage = builder->requireAsset(Game::XAssetType::ASSET_TYPE_IMAGE, asset->skyImage->name).image; dest->skyImage = builder->saveSubAsset(Game::XAssetType::ASSET_TYPE_IMAGE, asset->skyImage).image;
} }
if (asset->outdoorImage) if (asset->outdoorImage)
{ {
dest->outdoorImage = builder->requireAsset(Game::XAssetType::ASSET_TYPE_IMAGE, asset->outdoorImage->name).image; dest->outdoorImage = builder->saveSubAsset(Game::XAssetType::ASSET_TYPE_IMAGE, asset->outdoorImage).image;
} }
// saveGfxWorldVertexData // saveGfxWorldVertexData
@ -334,12 +334,12 @@ namespace Assets
if (asset->spriteMaterial) if (asset->spriteMaterial)
{ {
dest->spriteMaterial = builder->requireAsset(Game::XAssetType::ASSET_TYPE_MATERIAL, asset->spriteMaterial->name).material; dest->spriteMaterial = builder->saveSubAsset(Game::XAssetType::ASSET_TYPE_MATERIAL, asset->spriteMaterial).material;
} }
if (asset->flareMaterial) if (asset->flareMaterial)
{ {
dest->flareMaterial = builder->requireAsset(Game::XAssetType::ASSET_TYPE_MATERIAL, asset->flareMaterial->name).material; dest->flareMaterial = builder->saveSubAsset(Game::XAssetType::ASSET_TYPE_MATERIAL, asset->flareMaterial).material;
} }
SaveLogExit(); SaveLogExit();
@ -405,7 +405,7 @@ namespace Assets
if (surface->material) if (surface->material)
{ {
destSurface->material = builder->requireAsset(Game::XAssetType::ASSET_TYPE_MATERIAL, surface->material->name).material; destSurface->material = builder->saveSubAsset(Game::XAssetType::ASSET_TYPE_MATERIAL, surface->material).material;
} }
} }
@ -436,7 +436,7 @@ namespace Assets
if (model->model) if (model->model)
{ {
destModel->model = builder->requireAsset(Game::XAssetType::ASSET_TYPE_XMODEL, model->model->name).model; destModel->model = builder->saveSubAsset(Game::XAssetType::ASSET_TYPE_XMODEL, model->model).model;
} }
} }
@ -555,7 +555,7 @@ namespace Assets
if (sky->skyImage) if (sky->skyImage)
{ {
destSky->skyImage = builder->requireAsset(Game::XAssetType::ASSET_TYPE_IMAGE, sky->skyImage->name).image; destSky->skyImage = builder->saveSubAsset(Game::XAssetType::ASSET_TYPE_IMAGE, sky->skyImage).image;
} }
} }
@ -705,7 +705,7 @@ namespace Assets
if (materialMemory->material) if (materialMemory->material)
{ {
destMaterialMemory->material = builder->requireAsset(Game::XAssetType::ASSET_TYPE_MATERIAL, materialMemory->material->name).material; destMaterialMemory->material = builder->saveSubAsset(Game::XAssetType::ASSET_TYPE_MATERIAL, materialMemory->material).material;
} }
} }
@ -716,7 +716,7 @@ namespace Assets
if (asset->unknownImage) if (asset->unknownImage)
{ {
dest->unknownImage = builder->requireAsset(Game::XAssetType::ASSET_TYPE_IMAGE, asset->unknownImage->name).image; dest->unknownImage = builder->saveSubAsset(Game::XAssetType::ASSET_TYPE_IMAGE, asset->unknownImage).image;
} }
buffer->pushBlock(Game::XFILE_BLOCK_RUNTIME); buffer->pushBlock(Game::XFILE_BLOCK_RUNTIME);

12
src/Components/Modules/AssetInterfaces/IMaterial.cpp
View File

@ -168,7 +168,7 @@ namespace Assets
if (asset->techniqueSet) if (asset->techniqueSet)
{ {
builder->loadAsset(Game::XAssetType::ASSET_TYPE_TECHSET, asset->techniqueSet->name); builder->markAsset(Game::XAssetType::ASSET_TYPE_TECHSET, asset->techniqueSet);
} }
if (asset->textureTable) if (asset->textureTable)
@ -181,12 +181,12 @@ namespace Assets
{ {
if (asset->textureTable[i].info.water->image) if (asset->textureTable[i].info.water->image)
{ {
builder->loadAsset(Game::XAssetType::ASSET_TYPE_IMAGE, asset->textureTable[i].info.water->image->name); builder->markAsset(Game::XAssetType::ASSET_TYPE_IMAGE, asset->textureTable[i].info.water->image);
} }
} }
else else
{ {
builder->loadAsset(Game::XAssetType::ASSET_TYPE_IMAGE, asset->textureTable[i].info.image->name); builder->markAsset(Game::XAssetType::ASSET_TYPE_IMAGE, asset->textureTable[i].info.image);
} }
} }
} }
@ -212,7 +212,7 @@ namespace Assets
if (asset->techniqueSet) if (asset->techniqueSet)
{ {
dest->techniqueSet = builder->requireAsset(Game::XAssetType::ASSET_TYPE_TECHSET, asset->techniqueSet->name).techniqueSet; dest->techniqueSet = builder->saveSubAsset(Game::XAssetType::ASSET_TYPE_TECHSET, asset->techniqueSet).techniqueSet;
} }
if (asset->textureTable) if (asset->textureTable)
@ -267,13 +267,13 @@ namespace Assets
if (water->image) if (water->image)
{ {
destWater->image = builder->requireAsset(Game::XAssetType::ASSET_TYPE_IMAGE, water->image->name).image; destWater->image = builder->saveSubAsset(Game::XAssetType::ASSET_TYPE_IMAGE, water->image).image;
} }
} }
} }
else if (textureDef->info.image) else if (textureDef->info.image)
{ {
destTextureDef->info.image = builder->requireAsset(Game::XAssetType::ASSET_TYPE_IMAGE, textureDef->info.image->name).image; destTextureDef->info.image = builder->saveSubAsset(Game::XAssetType::ASSET_TYPE_IMAGE, textureDef->info.image).image;
} }
} }

12
src/Components/Modules/AssetInterfaces/IMaterialTechniqueSet.cpp
View File

@ -18,17 +18,17 @@ namespace Assets
if (pass->vertexDecl) if (pass->vertexDecl)
{ {
builder->loadAsset(Game::XAssetType::ASSET_TYPE_VERTEXDECL, pass->vertexDecl->name); builder->markAsset(Game::XAssetType::ASSET_TYPE_VERTEXDECL, pass->vertexDecl);
} }
if (pass->vertexShader) if (pass->vertexShader)
{ {
builder->loadAsset(Game::XAssetType::ASSET_TYPE_VERTEXSHADER, pass->vertexShader->name); builder->markAsset(Game::XAssetType::ASSET_TYPE_VERTEXSHADER, pass->vertexShader);
} }
if (pass->pixelShader) if (pass->pixelShader)
{ {
builder->loadAsset(Game::XAssetType::ASSET_TYPE_PIXELSHADER, pass->pixelShader->name); builder->markAsset(Game::XAssetType::ASSET_TYPE_PIXELSHADER, pass->pixelShader);
} }
} }
} }
@ -86,17 +86,17 @@ namespace Assets
if (pass->vertexDecl) if (pass->vertexDecl)
{ {
destPass->vertexDecl = builder->requireAsset(Game::XAssetType::ASSET_TYPE_VERTEXDECL, pass->vertexDecl->name).vertexDecl; destPass->vertexDecl = builder->saveSubAsset(Game::XAssetType::ASSET_TYPE_VERTEXDECL, pass->vertexDecl).vertexDecl;
} }
if (pass->vertexShader) if (pass->vertexShader)
{ {
destPass->vertexShader = builder->requireAsset(Game::XAssetType::ASSET_TYPE_VERTEXSHADER, pass->vertexShader->name).vertexShader; destPass->vertexShader = builder->saveSubAsset(Game::XAssetType::ASSET_TYPE_VERTEXSHADER, pass->vertexShader).vertexShader;
} }
if (pass->pixelShader) if (pass->pixelShader)
{ {
destPass->pixelShader = builder->requireAsset(Game::XAssetType::ASSET_TYPE_PIXELSHADER, pass->pixelShader->name).pixelShader; destPass->pixelShader = builder->saveSubAsset(Game::XAssetType::ASSET_TYPE_PIXELSHADER, pass->pixelShader).pixelShader;
} }
if (pass->argumentDef) if (pass->argumentDef)

16
src/Components/Modules/AssetInterfaces/IXModel.cpp
View File

@ -195,7 +195,7 @@ namespace Assets
{ {
if (asset->materials[i]) if (asset->materials[i])
{ {
builder->loadAsset(Game::XAssetType::ASSET_TYPE_MATERIAL, asset->materials[i]->name); builder->markAsset(Game::XAssetType::ASSET_TYPE_MATERIAL, asset->materials[i]);
} }
} }
} }
@ -205,7 +205,7 @@ namespace Assets
if (asset->lods[i].surfaces) if (asset->lods[i].surfaces)
{ {
// We're not supposed to include xmodelsurfs as standalone asset // We're not supposed to include xmodelsurfs as standalone asset
//builder->loadAsset(Game::XAssetType::ASSET_TYPE_XMODELSURFS, asset->lods[i].surfaces->name); //builder->markAsset(Game::XAssetType::ASSET_TYPE_XMODELSURFS, asset->lods[i].surfaces->name);
IXModelSurfs().mark({ asset->lods[i].surfaces }, builder); IXModelSurfs().mark({ asset->lods[i].surfaces }, builder);
} }
@ -213,12 +213,12 @@ namespace Assets
if (asset->physPreset) if (asset->physPreset)
{ {
builder->loadAsset(Game::XAssetType::ASSET_TYPE_PHYSPRESET, asset->physPreset->name); builder->markAsset(Game::XAssetType::ASSET_TYPE_PHYSPRESET, asset->physPreset);
} }
if (asset->physCollmap) if (asset->physCollmap)
{ {
builder->loadAsset(Game::XAssetType::ASSET_TYPE_PHYS_COLLMAP, asset->physCollmap->name); builder->markAsset(Game::XAssetType::ASSET_TYPE_PHYS_COLLMAP, asset->physCollmap);
} }
} }
@ -304,7 +304,7 @@ namespace Assets
{ {
if (asset->materials[i]) if (asset->materials[i])
{ {
destMaterials[i] = builder->requireAsset(Game::XAssetType::ASSET_TYPE_MATERIAL, asset->materials[i]->name).material; destMaterials[i] = builder->saveSubAsset(Game::XAssetType::ASSET_TYPE_MATERIAL, asset->materials[i]).material;
} }
} }
@ -320,7 +320,7 @@ namespace Assets
if (asset->lods[i].surfaces) if (asset->lods[i].surfaces)
{ {
// Requiring this asset is not possible, it has to be loaded as part of the model // Requiring this asset is not possible, it has to be loaded as part of the model
//dest->lods[i].surfaces = builder->requireAsset(Game::XAssetType::ASSET_TYPE_XMODELSURFS, asset->lods[i].surfaces->name).surfaces; //dest->lods[i].surfaces = builder->saveSubAsset(Game::XAssetType::ASSET_TYPE_XMODELSURFS, asset->lods[i].surfaces).surfaces;
buffer->pushBlock(Game::XFILE_BLOCK_TEMP); buffer->pushBlock(Game::XFILE_BLOCK_TEMP);
buffer->align(Utils::Stream::ALIGN_4); buffer->align(Utils::Stream::ALIGN_4);
@ -372,12 +372,12 @@ namespace Assets
if (asset->physPreset) if (asset->physPreset)
{ {
dest->physPreset = builder->requireAsset(Game::XAssetType::ASSET_TYPE_PHYSPRESET, asset->physPreset->name).physPreset; dest->physPreset = builder->saveSubAsset(Game::XAssetType::ASSET_TYPE_PHYSPRESET, asset->physPreset).physPreset;
} }
if (asset->physCollmap) if (asset->physCollmap)
{ {
dest->physCollmap = builder->requireAsset(Game::XAssetType::ASSET_TYPE_PHYS_COLLMAP, asset->physCollmap->name).physCollmap; dest->physCollmap = builder->saveSubAsset(Game::XAssetType::ASSET_TYPE_PHYS_COLLMAP, asset->physCollmap).physCollmap;
} }
buffer->popBlock(); buffer->popBlock();

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

@ -56,7 +56,7 @@ namespace Assets
{ {
if (asset->staticModelList[i].xmodel) if (asset->staticModelList[i].xmodel)
{ {
destStaticModelList[i].xmodel = builder->requireAsset(Game::XAssetType::ASSET_TYPE_XMODEL, asset->staticModelList[i].xmodel->name).model; destStaticModelList[i].xmodel = builder->saveSubAsset(Game::XAssetType::ASSET_TYPE_XMODEL, asset->staticModelList[i].xmodel).model;
} }
} }
@ -90,7 +90,12 @@ namespace Assets
buffer->align(Utils::Stream::ALIGN_4); buffer->align(Utils::Stream::ALIGN_4);
Game::cbrushside_t* sides = buffer->dest<Game::cbrushside_t>(); Game::cbrushside_t* sides = buffer->dest<Game::cbrushside_t>();
buffer->saveArray(asset->cBrushSides, asset->numCBrushSides); // we need the pointer to each of these to be stored so we can't write them all at once
for(int i = 0; i < asset->numCBrushSides; ++i)
{
builder->storePointer(&asset->cBrushSides[i]); // for reference in cBrush
buffer->save(&asset->cBrushSides[i]);
}
for (int i = 0; i < asset->numCBrushSides; ++i) for (int i = 0; i < asset->numCBrushSides; ++i)
{ {
@ -350,6 +355,8 @@ namespace Assets
{ {
AssertSize(Game::cbrushside_t, 8); AssertSize(Game::cbrushside_t, 8);
MessageBoxA(0, "BrushSide shouldn't be written in cBrush!", "WARNING", MB_ICONEXCLAMATION);
buffer->align(Utils::Stream::ALIGN_4); buffer->align(Utils::Stream::ALIGN_4);
builder->storePointer(brush->brushSide); builder->storePointer(brush->brushSide);
@ -427,7 +434,7 @@ namespace Assets
if (asset->mapEnts) if (asset->mapEnts)
{ {
dest->mapEnts = builder->requireAsset(Game::XAssetType::ASSET_TYPE_MAP_ENTS, asset->name).mapEnts; dest->mapEnts = builder->saveSubAsset(Game::XAssetType::ASSET_TYPE_MAP_ENTS, asset->mapEnts).mapEnts;
} }
for (int i = 0; i < 2; ++i) for (int i = 0; i < 2; ++i)
@ -445,17 +452,17 @@ namespace Assets
{ {
if (dynEnt[j].xModel) if (dynEnt[j].xModel)
{ {
dynEntDest[j].xModel = builder->requireAsset(Game::XAssetType::ASSET_TYPE_XMODEL, dynEnt[j].xModel->name).model; dynEntDest[j].xModel = builder->saveSubAsset(Game::XAssetType::ASSET_TYPE_XMODEL, dynEnt[j].xModel).model;
} }
if (dynEnt[j].destroyFx) if (dynEnt[j].destroyFx)
{ {
dynEntDest[j].destroyFx = builder->requireAsset(Game::XAssetType::ASSET_TYPE_FX, dynEnt[j].destroyFx->name).fx; dynEntDest[j].destroyFx = builder->saveSubAsset(Game::XAssetType::ASSET_TYPE_FX, dynEnt[j].destroyFx).fx;
} }
if (dynEnt[j].physPreset) if (dynEnt[j].physPreset)
{ {
dynEntDest[j].physPreset = builder->requireAsset(Game::XAssetType::ASSET_TYPE_PHYSPRESET, dynEnt[j].physPreset->name).physPreset; dynEntDest[j].physPreset = builder->saveSubAsset(Game::XAssetType::ASSET_TYPE_PHYSPRESET, dynEnt[j].physPreset).physPreset;
} }
} }
@ -514,7 +521,7 @@ namespace Assets
for (int i = 0; i < asset->numStaticModels; ++i) for (int i = 0; i < asset->numStaticModels; ++i)
{ {
Game::XModel* m = asset->staticModelList[i].xmodel; Game::XModel* m = asset->staticModelList[i].xmodel;
builder->loadAsset(Game::XAssetType::ASSET_TYPE_XMODEL, m->name); builder->markAsset(Game::XAssetType::ASSET_TYPE_XMODEL, m);
} }
for (int j = 0; j < 2; ++j) for (int j = 0; j < 2; ++j)
@ -525,21 +532,21 @@ namespace Assets
{ {
if (def[i].xModel) if (def[i].xModel)
{ {
builder->loadAsset(Game::XAssetType::ASSET_TYPE_XMODEL, def[i].xModel->name); builder->markAsset(Game::XAssetType::ASSET_TYPE_XMODEL, def[i].xModel);
} }
if (def[i].destroyFx) if (def[i].destroyFx)
{ {
builder->loadAsset(Game::XAssetType::ASSET_TYPE_FX, def[i].destroyFx->name); builder->markAsset(Game::XAssetType::ASSET_TYPE_FX, def[i].destroyFx);
} }
if (def[i].physPreset) if (def[i].physPreset)
{ {
builder->loadAsset(Game::XAssetType::ASSET_TYPE_PHYSPRESET, def[i].physPreset->name); builder->markAsset(Game::XAssetType::ASSET_TYPE_PHYSPRESET, def[i].physPreset);
} }
} }
} }
builder->loadAsset(Game::XAssetType::ASSET_TYPE_MAP_ENTS, asset->name); builder->markAsset(Game::XAssetType::ASSET_TYPE_MAP_ENTS, asset);
} }
void IclipMap_t::load(Game::XAssetHeader* /*header*/, std::string name, Components::ZoneBuilder::Zone* /*builder*/) void IclipMap_t::load(Game::XAssetHeader* /*header*/, std::string name, Components::ZoneBuilder::Zone* /*builder*/)

8
src/Components/Modules/AssetInterfaces/Isnd_alias_list_t.cpp
View File

@ -12,12 +12,12 @@ namespace Assets
if (alias->soundFile && alias->soundFile->type == Game::snd_alias_type_t::SAT_LOADED) if (alias->soundFile && alias->soundFile->type == Game::snd_alias_type_t::SAT_LOADED)
{ {
builder->loadAsset(Game::XAssetType::ASSET_TYPE_LOADED_SOUND, alias->soundFile->data.loaded->name); builder->markAsset(Game::XAssetType::ASSET_TYPE_LOADED_SOUND, alias->soundFile->data.loaded);
} }
if (alias->volumeFalloffCurve) if (alias->volumeFalloffCurve)
{ {
builder->loadAsset(Game::XAssetType::ASSET_TYPE_SNDCURVE, alias->volumeFalloffCurve->filename); builder->markAsset(Game::XAssetType::ASSET_TYPE_SNDCURVE, alias->volumeFalloffCurve);
} }
} }
} }
@ -110,7 +110,7 @@ namespace Assets
{ {
if (alias->soundFile->type == Game::snd_alias_type_t::SAT_LOADED) if (alias->soundFile->type == Game::snd_alias_type_t::SAT_LOADED)
{ {
destSoundFile->data.loaded = builder->requireAsset(Game::XAssetType::ASSET_TYPE_LOADED_SOUND, alias->soundFile->data.loaded->name).loadSnd; destSoundFile->data.loaded = builder->saveSubAsset(Game::XAssetType::ASSET_TYPE_LOADED_SOUND, alias->soundFile->data.loaded).loadSnd;
} }
else else
{ {
@ -137,7 +137,7 @@ namespace Assets
if (alias->volumeFalloffCurve) if (alias->volumeFalloffCurve)
{ {
destAlias->volumeFalloffCurve = builder->requireAsset(Game::XAssetType::ASSET_TYPE_SNDCURVE, alias->volumeFalloffCurve->filename).sndCurve; destAlias->volumeFalloffCurve = builder->saveSubAsset(Game::XAssetType::ASSET_TYPE_SNDCURVE, alias->volumeFalloffCurve).sndCurve;
} }
if (alias->speakerMap) if (alias->speakerMap)

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

@ -160,10 +160,11 @@ namespace Components
asset.type = type; asset.type = type;
asset.header = assetHeader; asset.header = assetHeader;
// Handle script strings and referenced assets this->loadedAssets.push_back(asset);
// Handle script strings
AssetHandler::ZoneMark(asset, this); AssetHandler::ZoneMark(asset, this);
this->loadedAssets.push_back(asset);
return true; return true;
} }
@ -196,33 +197,95 @@ namespace Components
return nullptr; return nullptr;
} }
uint32_t ZoneBuilder::Zone::getAssetOffset(int index) uint32_t ZoneBuilder::Zone::getAssetTableOffset(int index)
{ {
Utils::Stream::Offset offset; Utils::Stream::Offset offset;
offset.block = Game::XFILE_BLOCK_VIRTUAL; offset.block = Game::XFILE_BLOCK_VIRTUAL;
offset.offset = (this->indexStart + (index * sizeof(Game::XAsset)) + 4); offset.offset = (this->indexStart + (index * sizeof(Game::XAsset)) + 4);
return offset.getPackedOffset(); return offset.getPackedOffset();
} }
/*
void ZoneBuilder::Zone::pushAliasBase()
{
this->aliasBaseStack.push_back(this->buffer.getBlockSize(Game::XFILE_BLOCK_VIRTUAL));
}
Game::XAssetHeader ZoneBuilder::Zone::requireAsset(Game::XAssetType type, const char* name) void ZoneBuilder::Zone::popAliasBase()
{
if (!this->aliasBaseStack.empty())
{
this->aliasBaseStack.pop_back();
}
}
unsigned int ZoneBuilder::Zone::getAliasBase()
{
return this->aliasBaseStack.back();
}
*/
Game::XAssetHeader ZoneBuilder::Zone::saveSubAsset(Game::XAssetType type, void* ptr)
{ {
Game::XAssetHeader header; Game::XAssetHeader header;
Utils::Stream::ClearPointer(&header.data); header.data = ptr;
int assetIndex = this->findAsset(type, name); int assetIndex = this->findAsset(type, Game::DB_GetXAssetNameHandlers[type](&header));
if (assetIndex == -1) // nested asset
if (assetIndex != -1)
{ {
header.data = reinterpret_cast<void*>(this->getAssetOffset(assetIndex)); const auto& cmp = header.data;
// already written. find alias and store in ptr
if(std::find_if(this->savedAssets.begin(), this->savedAssets.end(), [&cmp] (const Game::XAssetHeader& s) { return cmp == s.data; } ) != this->savedAssets.end())
{
#ifdef DEBUG
//Components::Logger::Print("Using alias for (%s): %s\n", Game::DB_GetXAssetTypeName(asset->type), Game::DB_GetXAssetName(asset));
#endif
Utils::Stream::Offset off;
off.block = Game::XFILE_BLOCK_VIRTUAL;
off.offset = this->getAlias(ptr);
header.data = reinterpret_cast<void*>(off.getPackedOffset());
}
else
{
#ifdef DEBUG
Components::Logger::Print("Saving Require (%s): %s\n", Game::DB_GetXAssetTypeName(type), Game::DB_GetXAssetNameHandlers[type](&header));
#endif
Game::XAsset assetToSave;
assetToSave.header = header;
assetToSave.type = type;
// we alias the next 4 (aligned) bytes of the stream b/c DB_InsertPointer gives us a nice pointer to use as the alias
// otherwise it would be a fuckfest trying to figure out where the alias is in the stream
this->buffer.align(Utils::Stream::ALIGN_4);
this->storeAlias(ptr, this->buffer.getBlockSize(Game::XFILE_BLOCK_VIRTUAL));
this->buffer.increaseBlockSize(Game::XFILE_BLOCK_VIRTUAL, 4);
this->buffer.pushBlock(Game::XFILE_BLOCK_TEMP);
AssetHandler::ZoneSave(assetToSave, this);
this->buffer.popBlock();
this->savedAssets.push_back(header);
header.data = reinterpret_cast<void*>(-2); // DB_InsertPointer marker
}
} }
else else
{ {
Logger::Error("Missing required asset '%s' (%s). Export failed!", name, Game::DB_GetXAssetTypeName(type)); // asset was written normally. not sure this is even possible but its here
header.data = reinterpret_cast<void*>(this->getAssetTableOffset(assetIndex));
} }
return header; return header;
} }
void ZoneBuilder::Zone::markAsset(Game::XAssetType type, void* ptr)
{
Game::XAsset asset;
asset.header.data = ptr;
asset.type = type;
AssetHandler::ZoneMark(asset, this);
}
void ZoneBuilder::Zone::writeZone() void ZoneBuilder::Zone::writeZone()
{ {
FILETIME fileTime; FILETIME fileTime;
@ -252,7 +315,7 @@ namespace Components
Utils::IO::WriteFile(outFile, outBuffer); Utils::IO::WriteFile(outFile, outBuffer);
Logger::Print("done.\n"); Logger::Print("done.\n");
Logger::Print("Zone '%s' written with %d assets\n", outFile.data(), this->loadedAssets.size()); Logger::Print("Zone '%s' written with %d assets and %d script strings\n", outFile.data(), this->savedAssets.size(), this->scriptStrings.size());
} }
void ZoneBuilder::Zone::saveData() void ZoneBuilder::Zone::saveData()
@ -312,16 +375,30 @@ namespace Components
// Assets // Assets
for (auto asset : this->loadedAssets) for (auto asset : this->loadedAssets)
{ {
/*
const auto& cmp = asset.header.data;
if(std::find_if(this->savedAssets.begin(), this->savedAssets.end(), [&cmp] (const Game::XAsset& s) { return cmp == s.header.data; } ) != this->savedAssets.end())
{
#ifdef DEBUG
Components::Logger::Print("Skipping (%s): %s\n", Game::DB_GetXAssetTypeName(asset.type), Game::DB_GetXAssetNameHandlers[type](header));
#endif
continue;
}
*/
this->buffer.pushBlock(Game::XFILE_BLOCK_TEMP); this->buffer.pushBlock(Game::XFILE_BLOCK_TEMP);
this->buffer.align(Utils::Stream::ALIGN_4); this->buffer.align(Utils::Stream::ALIGN_4);
#ifdef DEBUG #ifdef DEBUG
Components::Logger::Print("Saving (%s): %s\n", Game::DB_GetXAssetTypeName(asset.type), Game::DB_GetXAssetName(&asset)); Components::Logger::Print("Saving (%s): %s\n", Game::DB_GetXAssetTypeName(asset.type), Game::DB_GetXAssetNameHandlers[asset.type](&asset.header));
#endif #endif
this->store(asset.header); this->store(asset.header);
AssetHandler::ZoneSave(asset, this); AssetHandler::ZoneSave(asset, this);
savedAssets.push_back(asset.header);
this->buffer.popBlock(); this->buffer.popBlock();
} }
@ -364,7 +441,7 @@ namespace Components
} }
// Get stored offset for given file pointer // Get stored offset for given file pointer
uint32_t ZoneBuilder::Zone::safeGetPointer(const void* pointer) unsigned int ZoneBuilder::Zone::safeGetPointer(const void* pointer)
{ {
if (this->hasPointer(pointer)) if (this->hasPointer(pointer))
{ {
@ -379,6 +456,21 @@ namespace Components
this->pointerMap[pointer] = this->buffer.getPackedOffset(); this->pointerMap[pointer] = this->buffer.getPackedOffset();
} }
void ZoneBuilder::Zone::storeAlias(const void* ptr, unsigned int alias)
{
this->aliasMap[ptr] = alias;
}
unsigned int ZoneBuilder::Zone::getAlias(const void* ptr)
{
if((this->aliasMap.find(ptr) != this->aliasMap.end()))
{
return this->aliasMap[ptr];
}
Logger::Print("Warning: Missing Alias for pointer! Export will almost certainly fail!\n");
return 0;
}
int ZoneBuilder::Zone::addScriptString(std::string str) int ZoneBuilder::Zone::addScriptString(std::string str)
{ {
return this->addScriptString(Game::SL_GetString(str.data(), 0)); return this->addScriptString(Game::SL_GetString(str.data(), 0));

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

@ -2,6 +2,9 @@
#define XFILE_VERSION 276 #define XFILE_VERSION 276
#define XFILE_VERSION_IW4X 0x78345749 // 'IW4x' #define XFILE_VERSION_IW4X 0x78345749 // 'IW4x'
#define GET_ALIAS_OFFSET(_s, _m) offsetof((_s), (_m))
#define GET_ALIAS_OFFSET_ARRAY(_s, _m, _loop) (offsetof((_s), (_m)) + (sizeof(_s) * (_loop)))
namespace Components namespace Components
{ {
class ZoneBuilder : public Component class ZoneBuilder : public Component
@ -20,15 +23,17 @@ namespace Components
bool hasPointer(const void* pointer); bool hasPointer(const void* pointer);
void storePointer(const void* pointer); void storePointer(const void* pointer);
void storePointer(const void* pointer, Utils::Stream::Offset offset);
template<typename T> template<typename T>
inline T* getPointer(const T* pointer) { return reinterpret_cast<T*>(this->safeGetPointer(pointer)); } inline T* getPointer(const T* pointer) { return reinterpret_cast<T*>(this->safeGetPointer(pointer)); }
int findAsset(Game::XAssetType type, std::string name); int findAsset(Game::XAssetType type, std::string name);
Game::XAsset* getAsset(int index); Game::XAsset* getAsset(int index);
uint32_t getAssetOffset(int index); uint32_t getAssetTableOffset(int index);
Game::XAssetHeader requireAsset(Game::XAssetType type, const char* name); Game::XAssetHeader saveSubAsset(Game::XAssetType type, void* ptr);
bool loadAsset(Game::XAssetType type, std::string name); bool loadAsset(Game::XAssetType type, std::string name);
void markAsset(Game::XAssetType type, void* ptr);
int addScriptString(unsigned short gameIndex); int addScriptString(unsigned short gameIndex);
int addScriptString(std::string str); int addScriptString(std::string str);
@ -52,6 +57,9 @@ namespace Components
void saveData(); void saveData();
void writeZone(); void writeZone();
unsigned int getAlias(const void* pointer);
void storeAlias(const void* pointer, unsigned int alias);
void addBranding(); void addBranding();
uint32_t safeGetPointer(const void* pointer); uint32_t safeGetPointer(const void* pointer);
@ -66,10 +74,13 @@ namespace Components
Utils::Memory::Allocator memAllocator; Utils::Memory::Allocator memAllocator;
std::vector<Game::XAsset> loadedAssets; std::vector<Game::XAsset> loadedAssets;
std::vector<Game::XAssetHeader> savedAssets;
std::vector<std::string> scriptStrings; std::vector<std::string> scriptStrings;
std::map<unsigned short, unsigned int> scriptStringMap; std::map<unsigned short, unsigned int> scriptStringMap;
std::map<std::string, std::string> renameMap[Game::XAssetType::ASSET_TYPE_COUNT]; std::map<std::string, std::string> renameMap[Game::XAssetType::ASSET_TYPE_COUNT];
std::map<const void*, uint32_t> pointerMap; std::map<const void*, uint32_t> pointerMap;
std::vector<uint32_t> aliasBaseStack;
std::map<const void*, uint32_t> aliasMap;
Game::RawFile branding; Game::RawFile branding;
}; };

6
src/Utils/Stream.cpp
View File

@ -63,7 +63,7 @@ namespace Utils
{ {
memset(this->blockSize, 0, sizeof(this->blockSize)); memset(this->blockSize, 0, sizeof(this->blockSize));
#ifdef DEBUG #ifdef WRITE_LOGS
this->structLevel = 0; this->structLevel = 0;
Utils::IO::WriteFile("userraw/logs/zb_writes.log", "", false); Utils::IO::WriteFile("userraw/logs/zb_writes.log", "", false);
#endif #endif
@ -235,7 +235,7 @@ namespace Utils
this->blockSize[stream] += size; this->blockSize[stream] += size;
} }
#ifdef DEBUG #ifdef WRITE_LOGS
std::string data = fmt::sprintf("%*s%d\n", this->structLevel, "", size); std::string data = fmt::sprintf("%*s%d\n", this->structLevel, "", size);
if(stream == Game::XFILE_BLOCK_RUNTIME) data = fmt::sprintf("%*s(%d)\n", this->structLevel, "", size); if(stream == Game::XFILE_BLOCK_RUNTIME) data = fmt::sprintf("%*s(%d)\n", this->structLevel, "", size);
Utils::IO::WriteFile("userraw/logs/zb_writes.log", data, true); Utils::IO::WriteFile("userraw/logs/zb_writes.log", data, true);
@ -321,7 +321,7 @@ namespace Utils
return (this->criticalSectionState != 0); return (this->criticalSectionState != 0);
} }
#ifdef DEBUG #ifdef WRITE_LOGS
void Stream::enterStruct(const char* structName) void Stream::enterStruct(const char* structName)
{ {
if (this->structLevel >= 0) if (this->structLevel >= 0)

5
src/Utils/Stream.hpp
View File

@ -1,5 +1,6 @@
// write logs for ZoneBuilder // write logs for ZoneBuilder
#ifndef DEBUG //#define WRITE_LOGS
#ifndef WRITE_LOGS // they take forever to run so only enable if needed
#define SaveLogEnter(x) #define SaveLogEnter(x)
#define SaveLogExit() #define SaveLogExit()
#else #else
@ -131,7 +132,7 @@ namespace Utils
bool isCriticalSection(); bool isCriticalSection();
// for recording zb writes // for recording zb writes
#ifdef DEBUG #ifdef WRITE_LOGS
int structLevel; int structLevel;
void enterStruct(const char* structName); void enterStruct(const char* structName);
void leaveStruct(); void leaveStruct();