2016-12-20 01:47:10 -05:00
# include <STDInclude.hpp>
2016-12-24 21:41:42 -05:00
# define IW4X_GFXMAP_VERSION 1
2017-01-08 13:36:33 -05:00
# ifdef ENABLE_EXPERIMENTAL_MAP_CODE
2016-12-20 01:47:10 -05:00
namespace Assets
{
2016-12-28 18:54:50 -05:00
void IGfxWorld : : loadGfxWorldDpvsStatic ( Game : : GfxWorld * world , Game : : GfxWorldDpvsStatic * asset , Components : : ZoneBuilder : : Zone * builder , Utils : : Stream : : Reader * reader )
2016-12-20 01:47:10 -05:00
{
2016-12-28 18:54:50 -05:00
if ( asset - > sortedSurfIndex )
{
asset - > sortedSurfIndex = reader - > readArray < unsigned short > ( asset - > staticSurfaceCount + asset - > staticSurfaceCountNoDecal ) ;
}
if ( asset - > smodelInsts )
{
asset - > smodelInsts = reader - > readArray < Game : : GfxStaticModelInst > ( asset - > smodelCount ) ;
}
2016-12-24 21:41:42 -05:00
2016-12-28 18:54:50 -05:00
if ( asset - > surfaces )
{
asset - > surfaces = reader - > readArray < Game : : GfxSurface > ( world - > surfaceCount ) ;
2016-12-24 21:41:42 -05:00
2016-12-28 18:54:50 -05:00
for ( unsigned int i = 0 ; i < world - > surfaceCount ; + + i )
{
Game : : GfxSurface * surface = & asset - > surfaces [ i ] ;
2016-12-24 21:41:42 -05:00
2016-12-28 18:54:50 -05:00
if ( surface - > material )
{
world - > dpvs . surfaces [ i ] . material = Components : : AssetHandler : : FindAssetForZone ( Game : : XAssetType : : ASSET_TYPE_MATERIAL , reader - > readString ( ) . data ( ) , builder ) . material ;
}
}
}
if ( asset - > surfacesBounds )
2016-12-25 14:55:42 -05:00
{
2016-12-28 18:54:50 -05:00
asset - > surfacesBounds = reader - > readArray < Game : : GfxSurfaceBounds > ( world - > surfaceCount ) ;
}
if ( asset - > smodelDrawInsts )
{
asset - > smodelDrawInsts = reader - > readArray < Game : : GfxStaticModelDrawInst > ( asset - > smodelCount ) ;
for ( unsigned int i = 0 ; i < asset - > smodelCount ; + + i )
2016-12-25 14:55:42 -05:00
{
2016-12-28 18:54:50 -05:00
Game : : GfxStaticModelDrawInst * model = & asset - > smodelDrawInsts [ i ] ;
if ( model - > model )
{
model - > model = Components : : AssetHandler : : FindAssetForZone ( Game : : XAssetType : : ASSET_TYPE_XMODEL , reader - > readString ( ) . data ( ) , builder ) . model ;
//reader->readString(); model->model = Components::AssetHandler::FindOriginalAsset(Game::XAssetType::ASSET_TYPE_XMODEL, "void").model; // Use red-fx for now
}
}
}
}
void IGfxWorld : : loadGfxWorldDraw ( Game : : GfxWorldDraw * asset , Components : : ZoneBuilder : : Zone * builder , Utils : : Stream : : Reader * reader )
{
if ( asset - > reflectionImages )
{
asset - > reflectionImages = reader - > readArray < Game : : GfxImage * > ( asset - > reflectionProbeCount ) ;
for ( unsigned int i = 0 ; i < asset - > reflectionProbeCount ; + + i )
{
asset - > reflectionImages [ i ] = Components : : AssetHandler : : FindAssetForZone ( Game : : XAssetType : : ASSET_TYPE_IMAGE , reader - > readString ( ) . data ( ) , builder ) . image ;
2016-12-25 14:55:42 -05:00
}
}
2016-12-28 18:54:50 -05:00
if ( asset - > reflectionProbes )
{
asset - > reflectionProbes = reader - > readArray < Game : : GfxReflectionProbe > ( asset - > reflectionProbeCount ) ;
}
2016-12-25 14:55:42 -05:00
2016-12-28 18:54:50 -05:00
if ( asset - > lightmaps )
{
asset - > lightmaps = reader - > readArray < Game : : GfxLightmapArray > ( asset - > lightmapCount ) ;
for ( int i = 0 ; i < asset - > lightmapCount ; + + i )
{
Game : : GfxLightmapArray * lightmapArray = & asset - > lightmaps [ i ] ;
if ( lightmapArray - > primary )
{
lightmapArray - > primary = Components : : AssetHandler : : FindAssetForZone ( Game : : XAssetType : : ASSET_TYPE_IMAGE , reader - > readString ( ) . data ( ) , builder ) . image ;
}
if ( lightmapArray - > secondary )
{
lightmapArray - > secondary = Components : : AssetHandler : : FindAssetForZone ( Game : : XAssetType : : ASSET_TYPE_IMAGE , reader - > readString ( ) . data ( ) , builder ) . image ;
}
}
}
if ( asset - > skyImage )
{
asset - > skyImage = Components : : AssetHandler : : FindAssetForZone ( Game : : XAssetType : : ASSET_TYPE_IMAGE , reader - > readString ( ) . data ( ) , builder ) . image ;
}
if ( asset - > outdoorImage )
{
asset - > outdoorImage = Components : : AssetHandler : : FindAssetForZone ( Game : : XAssetType : : ASSET_TYPE_IMAGE , reader - > readString ( ) . data ( ) , builder ) . image ;
}
// saveGfxWorldVertexData
{
if ( asset - > vd . vertices )
{
asset - > vd . vertices = reader - > readArray < Game : : GfxWorldVertex > ( asset - > vertexCount ) ;
}
}
// saveGfxWorldVertexLayerData
{
if ( asset - > vld . data )
{
// no align for char
asset - > vld . data = reader - > readArray < char > ( asset - > vertexLayerDataSize ) ;
}
}
if ( asset - > indices )
{
asset - > indices = reader - > readArray < unsigned short > ( asset - > indexCount ) ;
}
}
void IGfxWorld : : load ( Game : : XAssetHeader * header , std : : string name , Components : : ZoneBuilder : : Zone * builder )
{
Utils : : String : : Replace ( name , " maps/mp/ " , " " ) ;
Utils : : String : : Replace ( name , " .d3dbsp " , " " ) ;
2017-01-06 09:27:35 -05:00
Components : : FileSystem : : File mapFile ( Utils : : String : : VA ( " gfxworld/%s.iw4xGfxWorld " , name . data ( ) ) ) ;
2016-12-24 21:41:42 -05:00
if ( mapFile . exists ( ) )
{
Utils : : Stream : : Reader reader ( builder - > getAllocator ( ) , mapFile . getBuffer ( ) ) ;
if ( reader . read < __int64 > ( ) ! = * reinterpret_cast < __int64 * > ( " IW4xGfxW " ) )
{
2016-12-28 18:54:50 -05:00
Components : : Logger : : Error ( " Reading gfxworld '%s' failed, header is invalid! " , name . data ( ) ) ;
2016-12-24 21:41:42 -05:00
}
int version = reader . read < int > ( ) ;
if ( version ! = IW4X_GFXMAP_VERSION )
{
2016-12-28 18:54:50 -05:00
Components : : Logger : : Error ( " Reading gfxworld '%s' failed, expected version is %d, but it was %d! " , name . data ( ) , IW4X_GFXMAP_VERSION , version ) ;
}
Game : : GfxWorld * asset = reader . readObject < Game : : GfxWorld > ( ) ;
header - > gfxWorld = asset ;
if ( asset - > name )
{
asset - > name = reader . readCString ( ) ;
2016-12-24 21:41:42 -05:00
}
2016-12-28 18:54:50 -05:00
if ( asset - > baseName )
{
asset - > baseName = reader . readCString ( ) ;
}
if ( asset - > skies )
{
asset - > skies = reader . readArray < Game : : GfxSky > ( asset - > skyCount ) ;
for ( int i = 0 ; i < asset - > skyCount ; + + i )
{
Game : : GfxSky * sky = & asset - > skies [ i ] ;
2016-12-24 21:41:42 -05:00
2016-12-28 18:54:50 -05:00
if ( sky - > skyStartSurfs )
{
sky - > skyStartSurfs = reader . readArray < int > ( sky - > skySurfCount ) ;
}
2016-12-25 14:55:42 -05:00
2016-12-28 18:54:50 -05:00
if ( sky - > skyImage )
{
sky - > skyImage = Components : : AssetHandler : : FindAssetForZone ( Game : : XAssetType : : ASSET_TYPE_IMAGE , reader . readString ( ) . data ( ) , builder ) . image ;
}
}
}
2016-12-25 14:55:42 -05:00
2016-12-28 18:54:50 -05:00
// GfxWorldDpvsPlanes
{
// TODO: Add pointer support
if ( asset - > dpvsPlanes . planes )
{
asset - > dpvsPlanes . planes = reader . readArray < Game : : cplane_t > ( asset - > planeCount ) ;
}
if ( asset - > dpvsPlanes . nodes )
{
asset - > dpvsPlanes . nodes = reader . readArray < unsigned short > ( asset - > nodeCount ) ;
}
}
2016-12-25 14:55:42 -05:00
2016-12-27 10:42:37 -05:00
2016-12-28 18:54:50 -05:00
int cellCount = asset - > dpvsPlanes . cellCount ;
2016-12-27 10:42:37 -05:00
2016-12-28 18:54:50 -05:00
if ( asset - > aabbTreeCounts )
2016-12-25 14:55:42 -05:00
{
2016-12-28 18:54:50 -05:00
asset - > aabbTreeCounts = reader . readArray < Game : : GfxCellTreeCount > ( cellCount ) ;
2016-12-25 14:55:42 -05:00
}
2016-12-28 18:54:50 -05:00
if ( asset - > aabbTrees )
{
asset - > aabbTrees = reader . readArray < Game : : GfxCellTree > ( cellCount ) ;
for ( int i = 0 ; i < cellCount ; + + i )
{
Game : : GfxCellTree * cellTree = & asset - > aabbTrees [ i ] ;
2016-12-25 14:55:42 -05:00
2016-12-28 18:54:50 -05:00
if ( cellTree - > aabbTree )
{
cellTree - > aabbTree = reader . readArray < Game : : GfxAabbTree > ( asset - > aabbTreeCounts [ i ] . aabbTreeCount ) ;
for ( int j = 0 ; j < asset - > aabbTreeCounts [ i ] . aabbTreeCount ; + + j )
{
Game : : GfxAabbTree * aabbTree = & cellTree - > aabbTree [ j ] ;
if ( aabbTree - > smodelIndexes )
{
aabbTree - > smodelIndexes = reader . readArray < unsigned short > ( aabbTree - > smodelIndexCount ) ;
}
}
}
}
}
if ( asset - > cells )
2016-12-25 14:55:42 -05:00
{
2016-12-28 18:54:50 -05:00
asset - > cells = reader . readArray < Game : : GfxCell > ( cellCount ) ;
2016-12-25 14:55:42 -05:00
2016-12-28 18:54:50 -05:00
for ( int i = 0 ; i < cellCount ; + + i )
2016-12-25 14:55:42 -05:00
{
2016-12-28 18:54:50 -05:00
Game : : GfxCell * cell = & asset - > cells [ i ] ;
if ( cell - > portals )
{
cell - > portals = reader . readArray < Game : : GfxPortal > ( cell - > portalCount ) ;
for ( int j = 0 ; j < cell - > portalCount ; + + j )
{
Game : : GfxPortal * portal = & cell - > portals [ j ] ;
if ( portal - > vertices )
{
portal - > vertices = reader . readArray < Game : : vec3_t > ( portal - > vertexCount ) ;
}
}
}
if ( cell - > reflectionProbes )
2016-12-25 20:27:54 -05:00
{
2016-12-28 18:54:50 -05:00
// no align for char
cell - > reflectionProbes = reader . readArray < char > ( cell - > reflectionProbeCount ) ;
2016-12-25 20:27:54 -05:00
}
2016-12-25 14:55:42 -05:00
}
}
2016-12-28 18:54:50 -05:00
this - > loadGfxWorldDraw ( & asset - > draw , builder , & reader ) ;
2016-12-25 14:55:42 -05:00
2016-12-28 18:54:50 -05:00
// GfxLightGrid
{
if ( asset - > lightGrid . rowDataStart )
{
asset - > lightGrid . rowDataStart = reader . readArray < unsigned short > ( ( asset - > lightGrid . maxs [ asset - > lightGrid . rowAxis ] - asset - > lightGrid . mins [ asset - > lightGrid . rowAxis ] ) + 1 ) ;
}
2016-12-25 14:55:42 -05:00
2016-12-28 18:54:50 -05:00
if ( asset - > lightGrid . rawRowData )
{
// no align for char
asset - > lightGrid . rawRowData = reader . readArray < char > ( asset - > lightGrid . rawRowDataSize ) ;
}
2016-12-24 21:41:42 -05:00
2016-12-28 18:54:50 -05:00
if ( asset - > lightGrid . entries )
{
asset - > lightGrid . entries = reader . readArray < Game : : GfxLightGridEntry > ( asset - > lightGrid . entryCount ) ;
}
2016-12-25 14:55:42 -05:00
2016-12-28 18:54:50 -05:00
if ( asset - > lightGrid . colors )
{
asset - > lightGrid . colors = reader . readArray < Game : : GfxLightGridColors > ( asset - > lightGrid . colorCount ) ;
}
}
2016-12-25 14:55:42 -05:00
2016-12-28 18:54:50 -05:00
if ( asset - > models )
2016-12-25 14:55:42 -05:00
{
2016-12-28 18:54:50 -05:00
asset - > models = reader . readArray < Game : : GfxBrushModel > ( asset - > modelCount ) ;
}
if ( asset - > materialMemory )
{
asset - > materialMemory = reader . readArray < Game : : MaterialMemory > ( asset - > materialMemoryCount ) ;
for ( int i = 0 ; i < asset - > materialMemoryCount ; + + i )
{
Game : : MaterialMemory * materialMemory = & asset - > materialMemory [ i ] ;
2016-12-24 21:41:42 -05:00
2016-12-28 18:54:50 -05:00
if ( materialMemory - > material )
{
materialMemory - > material = Components : : AssetHandler : : FindAssetForZone ( Game : : XAssetType : : ASSET_TYPE_MATERIAL , reader . readString ( ) . data ( ) , builder ) . material ;
}
}
2016-12-25 14:55:42 -05:00
}
2016-12-24 21:41:42 -05:00
2016-12-28 18:54:50 -05:00
if ( asset - > sun . spriteMaterial )
2016-12-24 21:41:42 -05:00
{
2016-12-28 18:54:50 -05:00
asset - > sun . spriteMaterial = Components : : AssetHandler : : FindAssetForZone ( Game : : XAssetType : : ASSET_TYPE_MATERIAL , reader . readString ( ) . data ( ) , builder ) . material ;
2016-12-24 21:41:42 -05:00
}
2016-12-28 18:54:50 -05:00
if ( asset - > sun . flareMaterial )
{
asset - > sun . flareMaterial = Components : : AssetHandler : : FindAssetForZone ( Game : : XAssetType : : ASSET_TYPE_MATERIAL , reader . readString ( ) . data ( ) , builder ) . material ;
}
2016-12-24 21:41:42 -05:00
2016-12-28 18:54:50 -05:00
if ( asset - > outdoorImage )
2016-12-24 21:41:42 -05:00
{
2016-12-28 18:54:50 -05:00
asset - > outdoorImage = Components : : AssetHandler : : FindAssetForZone ( Game : : XAssetType : : ASSET_TYPE_IMAGE , reader . readString ( ) . data ( ) , builder ) . image ;
}
2016-12-25 14:55:42 -05:00
2016-12-29 19:30:07 -05:00
if ( asset - > primaryLightCount > 0 )
{
Utils : : Stream : : ClearPointer ( & asset - > primaryLightEntityShadowVis ) ;
}
if ( asset - > dpvsDyn . dynEntClientCount [ 0 ] > 0 )
{
Utils : : Stream : : ClearPointer ( & asset - > sceneDynModel ) ;
Utils : : Stream : : ClearPointer ( & asset - > primaryLightDynEntShadowVis [ 0 ] ) ;
Utils : : Stream : : ClearPointer ( & asset - > nonSunPrimaryLightForModelDynEnt ) ;
}
if ( asset - > dpvsDyn . dynEntClientCount [ 1 ] > 0 )
{
Utils : : Stream : : ClearPointer ( & asset - > sceneDynBrush ) ;
Utils : : Stream : : ClearPointer ( & asset - > primaryLightDynEntShadowVis [ 1 ] ) ;
}
2016-12-28 18:54:50 -05:00
if ( asset - > shadowGeom )
{
asset - > shadowGeom = reader . readArray < Game : : GfxShadowGeometry > ( asset - > primaryLightCount ) ;
2016-12-24 21:41:42 -05:00
2016-12-28 18:54:50 -05:00
for ( unsigned int i = 0 ; i < asset - > primaryLightCount ; + + i )
2016-12-24 21:41:42 -05:00
{
2016-12-28 18:54:50 -05:00
Game : : GfxShadowGeometry * shadowGeometry = & asset - > shadowGeom [ i ] ;
if ( shadowGeometry - > sortedSurfIndex )
{
shadowGeometry - > sortedSurfIndex = reader . readArray < unsigned short > ( shadowGeometry - > surfaceCount ) ;
}
if ( shadowGeometry - > smodelIndex )
{
shadowGeometry - > smodelIndex = reader . readArray < unsigned short > ( shadowGeometry - > smodelCount ) ;
}
2016-12-24 21:41:42 -05:00
}
}
2016-12-20 11:42:15 -05:00
2016-12-28 18:54:50 -05:00
if ( asset - > lightRegion )
{
asset - > lightRegion = reader . readArray < Game : : GfxLightRegion > ( asset - > primaryLightCount ) ;
for ( unsigned int i = 0 ; i < asset - > primaryLightCount ; + + i )
{
Game : : GfxLightRegion * lightRegion = & asset - > lightRegion [ i ] ;
if ( lightRegion - > hulls )
{
lightRegion - > hulls = reader . readArray < Game : : GfxLightRegionHull > ( lightRegion - > hullCount ) ;
for ( unsigned int j = 0 ; j < lightRegion - > hullCount ; + + j )
{
Game : : GfxLightRegionHull * lightRegionHull = & lightRegion - > hulls [ j ] ;
2016-12-25 14:55:42 -05:00
2016-12-28 18:54:50 -05:00
if ( lightRegionHull - > axis )
{
lightRegionHull - > axis = reader . readArray < Game : : GfxLightRegionAxis > ( lightRegionHull - > axisCount ) ;
}
}
}
}
}
2016-12-27 10:42:37 -05:00
2016-12-28 18:54:50 -05:00
this - > loadGfxWorldDpvsStatic ( asset , & asset - > dpvs , builder , & reader ) ;
// Obsolete, IW3 has no support for that
if ( asset - > heroOnlyLights )
{
asset - > heroOnlyLights = reader . readArray < Game : : GfxHeroOnlyLight > ( asset - > heroOnlyLightCount ) ;
}
}
2016-12-20 11:42:15 -05:00
}
2016-12-21 13:18:33 -05:00
void IGfxWorld : : mark ( Game : : XAssetHeader header , Components : : ZoneBuilder : : Zone * builder )
{
Game : : GfxWorld * asset = header . gfxWorld ;
2016-12-25 14:55:42 -05:00
if ( asset - > draw . reflectionImages )
2016-12-21 13:18:33 -05:00
{
2016-12-25 14:55:42 -05:00
for ( unsigned int i = 0 ; i < asset - > draw . reflectionProbeCount ; + + i )
2016-12-21 13:18:33 -05:00
{
2016-12-25 14:55:42 -05:00
builder - > loadAsset ( Game : : XAssetType : : ASSET_TYPE_IMAGE , asset - > draw . reflectionImages [ i ] ) ;
2016-12-21 13:18:33 -05:00
}
}
2016-12-25 14:55:42 -05:00
if ( asset - > draw . lightmaps )
2016-12-21 13:18:33 -05:00
{
2016-12-25 14:55:42 -05:00
for ( int i = 0 ; i < asset - > draw . lightmapCount ; + + i )
2016-12-21 13:18:33 -05:00
{
2016-12-25 14:55:42 -05:00
if ( asset - > draw . lightmaps [ i ] . primary )
2016-12-21 13:18:33 -05:00
{
2016-12-25 14:55:42 -05:00
builder - > loadAsset ( Game : : XAssetType : : ASSET_TYPE_IMAGE , asset - > draw . lightmaps [ i ] . primary ) ;
2016-12-21 13:18:33 -05:00
}
2016-12-25 14:55:42 -05:00
if ( asset - > draw . lightmaps [ i ] . secondary )
2016-12-21 13:18:33 -05:00
{
2016-12-25 14:55:42 -05:00
builder - > loadAsset ( Game : : XAssetType : : ASSET_TYPE_IMAGE , asset - > draw . lightmaps [ i ] . secondary ) ;
2016-12-21 13:18:33 -05:00
}
}
}
2016-12-25 14:55:42 -05:00
if ( asset - > draw . skyImage )
2016-12-21 13:18:33 -05:00
{
2016-12-25 14:55:42 -05:00
builder - > loadAsset ( Game : : XAssetType : : ASSET_TYPE_IMAGE , asset - > draw . skyImage ) ;
2016-12-21 13:18:33 -05:00
}
2016-12-25 14:55:42 -05:00
if ( asset - > draw . outdoorImage )
2016-12-21 13:18:33 -05:00
{
2016-12-25 14:55:42 -05:00
builder - > loadAsset ( Game : : XAssetType : : ASSET_TYPE_IMAGE , asset - > draw . outdoorImage ) ;
2016-12-21 13:18:33 -05:00
}
if ( asset - > sun . spriteMaterial )
{
2016-12-23 15:01:56 -05:00
builder - > loadAsset ( Game : : XAssetType : : ASSET_TYPE_MATERIAL , asset - > sun . spriteMaterial ) ;
2016-12-21 13:18:33 -05:00
}
if ( asset - > sun . flareMaterial )
{
2016-12-23 15:01:56 -05:00
builder - > loadAsset ( Game : : XAssetType : : ASSET_TYPE_MATERIAL , asset - > sun . flareMaterial ) ;
2016-12-21 13:18:33 -05:00
}
2016-12-21 13:26:13 -05:00
if ( asset - > skies )
{
2016-12-25 14:55:42 -05:00
for ( int i = 0 ; i < asset - > skyCount ; + + i )
2016-12-21 13:18:33 -05:00
{
if ( asset - > skies [ i ] . skyImage )
{
2016-12-23 15:01:56 -05:00
builder - > loadAsset ( Game : : XAssetType : : ASSET_TYPE_IMAGE , asset - > skies [ i ] . skyImage ) ;
2016-12-21 13:18:33 -05:00
}
}
}
2016-12-21 13:26:13 -05:00
if ( asset - > materialMemory )
{
2016-12-21 14:56:17 -05:00
for ( int i = 0 ; i < asset - > materialMemoryCount ; + + i )
2016-12-21 13:18:33 -05:00
{
if ( asset - > materialMemory [ i ] . material )
{
2016-12-23 15:01:56 -05:00
builder - > loadAsset ( Game : : XAssetType : : ASSET_TYPE_MATERIAL , asset - > materialMemory [ i ] . material ) ;
2016-12-21 13:18:33 -05:00
}
}
}
2016-12-25 14:55:42 -05:00
if ( asset - > outdoorImage )
2016-12-21 13:18:33 -05:00
{
2016-12-25 14:55:42 -05:00
builder - > loadAsset ( Game : : XAssetType : : ASSET_TYPE_IMAGE , asset - > outdoorImage ) ;
2016-12-21 13:18:33 -05:00
}
if ( asset - > dpvs . surfaces )
{
2016-12-25 14:55:42 -05:00
for ( unsigned int i = 0 ; i < asset - > surfaceCount ; + + i )
2016-12-21 13:18:33 -05:00
{
if ( asset - > dpvs . surfaces [ i ] . material )
{
2016-12-23 15:01:56 -05:00
builder - > loadAsset ( Game : : XAssetType : : ASSET_TYPE_MATERIAL , asset - > dpvs . surfaces [ i ] . material ) ;
2016-12-21 13:18:33 -05:00
}
}
}
if ( asset - > dpvs . smodelDrawInsts )
{
2016-12-21 14:56:17 -05:00
for ( unsigned int i = 0 ; i < asset - > dpvs . smodelCount ; + + i )
2016-12-21 13:18:33 -05:00
{
if ( asset - > dpvs . smodelDrawInsts [ i ] . model )
{
2016-12-23 15:01:56 -05:00
builder - > loadAsset ( Game : : XAssetType : : ASSET_TYPE_XMODEL , asset - > dpvs . smodelDrawInsts [ i ] . model ) ;
2016-12-21 13:18:33 -05:00
}
}
}
}
void IGfxWorld : : saveGfxWorldDpvsPlanes ( Game : : GfxWorld * world , Game : : GfxWorldDpvsPlanes * asset , Game : : GfxWorldDpvsPlanes * dest , Components : : ZoneBuilder : : Zone * builder )
{
2016-12-20 11:42:15 -05:00
AssertSize ( Game : : GfxWorldDpvsPlanes , 16 ) ;
Utils : : Stream * buffer = builder - > getBuffer ( ) ;
2016-12-22 06:53:52 -05:00
SaveLogEnter ( " GfxWorldDpvsPlanes " ) ;
2016-12-20 11:42:15 -05:00
if ( asset - > planes )
{
if ( builder - > hasPointer ( asset - > planes ) )
{
dest - > planes = builder - > getPointer ( asset - > planes ) ;
}
else
{
2016-12-21 13:18:33 -05:00
AssertSize ( Game : : cplane_t , 20 ) ;
2016-12-20 11:42:15 -05:00
buffer - > align ( Utils : : Stream : : ALIGN_4 ) ;
2016-12-24 12:37:27 -05:00
for ( int i = 0 ; i < world - > planeCount ; + + i )
{
builder - > storePointer ( & asset - > planes [ i ] ) ;
buffer - > save ( & asset - > planes [ i ] ) ;
}
2016-12-20 11:42:15 -05:00
Utils : : Stream : : ClearPointer ( & dest - > planes ) ;
}
}
if ( asset - > nodes )
{
buffer - > align ( Utils : : Stream : : ALIGN_2 ) ;
buffer - > saveArray ( asset - > nodes , world - > nodeCount ) ;
Utils : : Stream : : ClearPointer ( & dest - > nodes ) ;
}
buffer - > pushBlock ( Game : : XFILE_BLOCK_RUNTIME ) ;
if ( asset - > sceneEntCellBits )
{
buffer - > align ( Utils : : Stream : : ALIGN_4 ) ;
2016-12-21 18:06:08 -05:00
buffer - > save ( asset - > sceneEntCellBits , 1 , asset - > cellCount < < 11 ) ;
2016-12-20 11:42:15 -05:00
Utils : : Stream : : ClearPointer ( & dest - > sceneEntCellBits ) ;
}
buffer - > popBlock ( ) ;
2016-12-22 06:53:52 -05:00
SaveLogExit ( ) ;
2016-12-20 11:42:15 -05:00
}
void IGfxWorld : : saveGfxWorldDraw ( Game : : GfxWorldDraw * asset , Game : : GfxWorldDraw * dest , Components : : ZoneBuilder : : Zone * builder )
{
AssertSize ( Game : : GfxWorldDraw , 72 ) ;
2016-12-22 06:53:52 -05:00
SaveLogEnter ( " GfxWorldDraw " ) ;
2016-12-20 11:42:15 -05:00
Utils : : Stream * buffer = builder - > getBuffer ( ) ;
if ( asset - > reflectionImages )
{
buffer - > align ( Utils : : Stream : : ALIGN_4 ) ;
Game : : GfxImage * * imageDest = buffer - > dest < Game : : GfxImage * > ( ) ;
buffer - > saveArray ( asset - > reflectionImages , asset - > reflectionProbeCount ) ;
2016-12-21 18:06:08 -05:00
for ( unsigned int i = 0 ; i < asset - > reflectionProbeCount ; + + i )
2016-12-20 11:42:15 -05:00
{
2016-12-23 01:42:56 -05:00
imageDest [ i ] = builder - > saveSubAsset ( Game : : XAssetType : : ASSET_TYPE_IMAGE , asset - > reflectionImages [ i ] ) . image ;
2016-12-20 11:42:15 -05:00
}
2016-12-21 18:06:08 -05:00
Utils : : Stream : : ClearPointer ( & dest - > reflectionImages ) ;
2016-12-20 11:42:15 -05:00
}
if ( asset - > reflectionProbes )
{
2016-12-20 16:23:05 -05:00
AssertSize ( Game : : GfxReflectionProbe , 12 ) ;
2016-12-23 19:02:51 -05:00
SaveLogEnter ( " GfxReflectionProbe " ) ;
2016-12-20 16:23:05 -05:00
2016-12-20 11:42:15 -05:00
buffer - > align ( Utils : : Stream : : ALIGN_4 ) ;
buffer - > saveArray ( asset - > reflectionProbes , asset - > reflectionProbeCount ) ;
Utils : : Stream : : ClearPointer ( & dest - > reflectionProbes ) ;
2016-12-23 19:02:51 -05:00
SaveLogExit ( ) ;
2016-12-20 11:42:15 -05:00
}
buffer - > pushBlock ( Game : : XFILE_BLOCK_RUNTIME ) ;
if ( asset - > reflectionProbeTextures )
{
2016-12-20 16:23:05 -05:00
AssertSize ( Game : : GfxRawTexture , 4 ) ;
2016-12-23 19:02:51 -05:00
SaveLogEnter ( " GfxRawTexture " ) ;
2016-12-20 16:23:05 -05:00
2016-12-20 11:42:15 -05:00
buffer - > align ( Utils : : Stream : : ALIGN_4 ) ;
buffer - > saveArray ( asset - > reflectionProbeTextures , asset - > reflectionProbeCount ) ;
Utils : : Stream : : ClearPointer ( & dest - > reflectionProbeTextures ) ;
2016-12-23 19:02:51 -05:00
SaveLogExit ( ) ;
2016-12-20 11:42:15 -05:00
}
buffer - > popBlock ( ) ;
if ( asset - > lightmaps )
{
2016-12-20 16:23:05 -05:00
AssertSize ( Game : : GfxLightmapArray , 8 ) ;
2016-12-23 19:02:51 -05:00
SaveLogEnter ( " GfxLightmapArray " ) ;
2016-12-20 16:23:05 -05:00
2016-12-20 11:42:15 -05:00
buffer - > align ( Utils : : Stream : : ALIGN_4 ) ;
Game : : GfxLightmapArray * lightmapArrayDestTable = buffer - > dest < Game : : GfxLightmapArray > ( ) ;
buffer - > saveArray ( asset - > lightmaps , asset - > lightmapCount ) ;
2016-12-21 18:06:08 -05:00
for ( int i = 0 ; i < asset - > lightmapCount ; + + i )
2016-12-20 11:42:15 -05:00
{
Game : : GfxLightmapArray * lightmapArrayDest = & lightmapArrayDestTable [ i ] ;
Game : : GfxLightmapArray * lightmapArray = & asset - > lightmaps [ i ] ;
if ( lightmapArray - > primary )
{
2016-12-23 01:42:56 -05:00
lightmapArrayDest - > primary = builder - > saveSubAsset ( Game : : XAssetType : : ASSET_TYPE_IMAGE , lightmapArray - > primary ) . image ;
2016-12-20 11:42:15 -05:00
}
if ( lightmapArray - > secondary )
{
2016-12-23 01:42:56 -05:00
lightmapArrayDest - > secondary = builder - > saveSubAsset ( Game : : XAssetType : : ASSET_TYPE_IMAGE , lightmapArray - > secondary ) . image ;
2016-12-20 11:42:15 -05:00
}
}
2016-12-21 13:26:13 -05:00
2016-12-21 18:06:08 -05:00
Utils : : Stream : : ClearPointer ( & dest - > lightmaps ) ;
2016-12-23 19:02:51 -05:00
SaveLogExit ( ) ;
2016-12-20 11:42:15 -05:00
}
buffer - > pushBlock ( Game : : XFILE_BLOCK_RUNTIME ) ;
if ( asset - > lightmapPrimaryTextures )
{
buffer - > align ( Utils : : Stream : : ALIGN_4 ) ;
buffer - > saveArray ( asset - > lightmapPrimaryTextures , asset - > lightmapCount ) ;
Utils : : Stream : : ClearPointer ( & dest - > lightmapPrimaryTextures ) ;
}
if ( asset - > lightmapSecondaryTextures )
{
buffer - > align ( Utils : : Stream : : ALIGN_4 ) ;
buffer - > saveArray ( asset - > lightmapSecondaryTextures , asset - > lightmapCount ) ;
Utils : : Stream : : ClearPointer ( & dest - > lightmapSecondaryTextures ) ;
}
buffer - > popBlock ( ) ;
if ( asset - > skyImage )
{
2016-12-23 01:42:56 -05:00
dest - > skyImage = builder - > saveSubAsset ( Game : : XAssetType : : ASSET_TYPE_IMAGE , asset - > skyImage ) . image ;
2016-12-20 11:42:15 -05:00
}
if ( asset - > outdoorImage )
{
2016-12-23 01:42:56 -05:00
dest - > outdoorImage = builder - > saveSubAsset ( Game : : XAssetType : : ASSET_TYPE_IMAGE , asset - > outdoorImage ) . image ;
2016-12-20 11:42:15 -05:00
}
// saveGfxWorldVertexData
2016-12-21 13:18:33 -05:00
{
if ( asset - > vd . vertices )
{
2016-12-21 18:06:08 -05:00
AssertSize ( Game : : GfxWorldVertex , 44 ) ;
2016-12-23 19:02:51 -05:00
SaveLogEnter ( " GfxWorldVertex " ) ;
2016-12-21 18:06:08 -05:00
2016-12-21 13:18:33 -05:00
buffer - > align ( Utils : : Stream : : ALIGN_4 ) ;
buffer - > saveArray ( asset - > vd . vertices , asset - > vertexCount ) ;
Utils : : Stream : : ClearPointer ( & dest - > vd . vertices ) ;
2016-12-23 19:02:51 -05:00
SaveLogExit ( ) ;
2016-12-21 13:18:33 -05:00
}
}
2016-12-20 11:42:15 -05:00
// saveGfxWorldVertexLayerData
2016-12-21 13:18:33 -05:00
{
if ( asset - > vld . data )
{
// no align for char
buffer - > saveArray ( asset - > vld . data , asset - > vertexLayerDataSize ) ;
Utils : : Stream : : ClearPointer ( & dest - > vld . data ) ;
}
}
2016-12-20 11:42:15 -05:00
if ( asset - > indices )
{
buffer - > align ( Utils : : Stream : : ALIGN_2 ) ;
buffer - > saveArray ( asset - > indices , asset - > indexCount ) ;
Utils : : Stream : : ClearPointer ( & dest - > indices ) ;
}
2016-12-21 20:58:00 -05:00
2016-12-22 06:53:52 -05:00
SaveLogExit ( ) ;
2016-12-20 11:42:15 -05:00
}
void IGfxWorld : : saveGfxLightGrid ( Game : : GfxLightGrid * asset , Game : : GfxLightGrid * dest , Components : : ZoneBuilder : : Zone * builder )
{
AssertSize ( Game : : GfxLightGrid , 56 ) ;
Utils : : Stream * buffer = builder - > getBuffer ( ) ;
2016-12-22 06:53:52 -05:00
SaveLogEnter ( " GfxLightGrid " ) ;
2016-12-20 11:42:15 -05:00
if ( asset - > rowDataStart )
{
buffer - > align ( Utils : : Stream : : ALIGN_2 ) ;
2016-12-21 18:06:08 -05:00
buffer - > saveArray ( asset - > rowDataStart , ( asset - > maxs [ asset - > rowAxis ] - asset - > mins [ asset - > rowAxis ] ) + 1 ) ;
2016-12-20 11:42:15 -05:00
Utils : : Stream : : ClearPointer ( & dest - > rowDataStart ) ;
}
if ( asset - > rawRowData )
{
// no align for char
buffer - > saveArray ( asset - > rawRowData , asset - > rawRowDataSize ) ;
Utils : : Stream : : ClearPointer ( & dest - > rawRowData ) ;
}
if ( asset - > entries )
{
2016-12-20 16:23:05 -05:00
AssertSize ( Game : : GfxLightGridEntry , 4 ) ;
2016-12-23 19:02:51 -05:00
SaveLogEnter ( " GfxLightGridEntry " ) ;
2016-12-20 16:23:05 -05:00
2016-12-20 11:42:15 -05:00
buffer - > align ( Utils : : Stream : : ALIGN_4 ) ;
buffer - > saveArray ( asset - > entries , asset - > entryCount ) ;
Utils : : Stream : : ClearPointer ( & dest - > entries ) ;
2016-12-23 19:02:51 -05:00
SaveLogExit ( ) ;
2016-12-20 11:42:15 -05:00
}
if ( asset - > colors )
{
2016-12-20 16:23:05 -05:00
AssertSize ( Game : : GfxLightGridColors , 168 ) ;
2016-12-23 19:02:51 -05:00
SaveLogEnter ( " GfxLightGridColors " ) ;
2016-12-20 16:23:05 -05:00
2016-12-20 11:42:15 -05:00
buffer - > align ( Utils : : Stream : : ALIGN_4 ) ;
buffer - > saveArray ( asset - > colors , asset - > colorCount ) ;
Utils : : Stream : : ClearPointer ( & dest - > colors ) ;
2016-12-23 19:02:51 -05:00
SaveLogExit ( ) ;
2016-12-20 11:42:15 -05:00
}
2016-12-22 06:53:52 -05:00
SaveLogExit ( ) ;
2016-12-20 11:42:15 -05:00
}
void IGfxWorld : : savesunflare_t ( Game : : sunflare_t * asset , Game : : sunflare_t * dest , Components : : ZoneBuilder : : Zone * builder )
{
AssertSize ( Game : : sunflare_t , 96 ) ;
2016-12-22 06:53:52 -05:00
SaveLogEnter ( " sunflare_t " ) ;
2016-12-21 20:58:00 -05:00
2016-12-20 11:42:15 -05:00
if ( asset - > spriteMaterial )
{
2016-12-23 01:42:56 -05:00
dest - > spriteMaterial = builder - > saveSubAsset ( Game : : XAssetType : : ASSET_TYPE_MATERIAL , asset - > spriteMaterial ) . material ;
2016-12-20 11:42:15 -05:00
}
if ( asset - > flareMaterial )
{
2016-12-23 01:42:56 -05:00
dest - > flareMaterial = builder - > saveSubAsset ( Game : : XAssetType : : ASSET_TYPE_MATERIAL , asset - > flareMaterial ) . material ;
2016-12-20 11:42:15 -05:00
}
2016-12-23 01:42:56 -05:00
2016-12-22 06:53:52 -05:00
SaveLogExit ( ) ;
2016-12-20 11:42:15 -05:00
}
2016-12-20 22:15:01 -05:00
void IGfxWorld : : saveGfxWorldDpvsStatic ( Game : : GfxWorld * world , Game : : GfxWorldDpvsStatic * asset , Game : : GfxWorldDpvsStatic * dest , int /*planeCount*/ , Components : : ZoneBuilder : : Zone * builder )
2016-12-20 11:42:15 -05:00
{
AssertSize ( Game : : GfxWorldDpvsStatic , 108 ) ;
2016-12-20 16:23:05 -05:00
Utils : : Stream * buffer = builder - > getBuffer ( ) ;
2016-12-22 06:53:52 -05:00
SaveLogEnter ( " GfxWorldDpvsStatic " ) ;
2016-12-20 16:23:05 -05:00
buffer - > pushBlock ( Game : : XFILE_BLOCK_RUNTIME ) ;
for ( int i = 0 ; i < 3 ; + + i )
{
if ( asset - > smodelVisData [ i ] )
{
buffer - > saveArray ( asset - > smodelVisData [ i ] , asset - > smodelCount ) ;
Utils : : Stream : : ClearPointer ( & dest - > smodelVisData [ i ] ) ;
}
}
for ( int i = 0 ; i < 3 ; + + i )
{
if ( asset - > surfaceVisData [ i ] )
{
buffer - > saveArray ( asset - > surfaceVisData [ i ] , asset - > staticSurfaceCount ) ;
Utils : : Stream : : ClearPointer ( & dest - > surfaceVisData [ i ] ) ;
}
}
buffer - > popBlock ( ) ;
if ( asset - > sortedSurfIndex )
{
buffer - > align ( Utils : : Stream : : ALIGN_2 ) ;
2016-12-25 14:55:42 -05:00
buffer - > saveArray ( asset - > sortedSurfIndex , asset - > staticSurfaceCount + asset - > staticSurfaceCountNoDecal ) ;
2016-12-20 16:23:05 -05:00
Utils : : Stream : : ClearPointer ( & dest - > sortedSurfIndex ) ;
}
if ( asset - > smodelInsts )
{
AssertSize ( Game : : GfxStaticModelInst , 36 ) ;
2016-12-23 19:02:51 -05:00
SaveLogEnter ( " GfxStaticModelInst " ) ;
2016-12-20 16:23:05 -05:00
buffer - > align ( Utils : : Stream : : ALIGN_4 ) ;
buffer - > saveArray ( asset - > smodelInsts , asset - > smodelCount ) ;
2016-12-20 22:15:01 -05:00
Utils : : Stream : : ClearPointer ( & dest - > smodelInsts ) ;
2016-12-23 19:02:51 -05:00
SaveLogExit ( ) ;
2016-12-20 16:23:05 -05:00
}
if ( asset - > surfaces )
{
2016-12-20 22:15:01 -05:00
AssertSize ( Game : : GfxSurface , 24 ) ;
2016-12-23 19:02:51 -05:00
SaveLogEnter ( " GfxSurface " ) ;
2016-12-20 22:15:01 -05:00
2016-12-21 13:18:33 -05:00
buffer - > align ( Utils : : Stream : : ALIGN_4 ) ;
Game : : GfxSurface * destSurfaceTable = buffer - > dest < Game : : GfxSurface > ( ) ;
2016-12-25 14:55:42 -05:00
buffer - > saveArray ( asset - > surfaces , world - > surfaceCount ) ;
2016-12-21 13:18:33 -05:00
2016-12-25 14:55:42 -05:00
for ( unsigned int i = 0 ; i < world - > surfaceCount ; + + i )
2016-12-21 13:18:33 -05:00
{
Game : : GfxSurface * surface = & asset - > surfaces [ i ] ;
Game : : GfxSurface * destSurface = & destSurfaceTable [ i ] ;
2016-12-20 22:15:01 -05:00
2016-12-21 13:18:33 -05:00
if ( surface - > material )
{
2016-12-23 01:42:56 -05:00
destSurface - > material = builder - > saveSubAsset ( Game : : XAssetType : : ASSET_TYPE_MATERIAL , surface - > material ) . material ;
2016-12-21 13:18:33 -05:00
}
}
2016-12-20 22:15:01 -05:00
2016-12-21 13:18:33 -05:00
Utils : : Stream : : ClearPointer ( & dest - > surfaces ) ;
2016-12-23 19:02:51 -05:00
SaveLogExit ( ) ;
2016-12-20 16:23:05 -05:00
}
if ( asset - > surfacesBounds )
{
2016-12-21 13:18:33 -05:00
AssertSize ( Game : : GfxSurfaceBounds , 24 ) ;
2016-12-23 19:02:51 -05:00
SaveLogEnter ( " GfxSurfaceBounds " ) ;
2016-12-20 22:15:01 -05:00
2016-12-21 13:18:33 -05:00
buffer - > align ( Utils : : Stream : : ALIGN_4 ) ;
2016-12-25 14:55:42 -05:00
buffer - > saveArray ( asset - > surfacesBounds , world - > surfaceCount ) ;
2016-12-21 13:18:33 -05:00
Utils : : Stream : : ClearPointer ( & dest - > surfacesBounds ) ;
2016-12-23 19:02:51 -05:00
SaveLogExit ( ) ;
2016-12-20 16:23:05 -05:00
}
if ( asset - > smodelDrawInsts )
{
2016-12-21 13:18:33 -05:00
AssertSize ( Game : : GfxStaticModelDrawInst , 76 ) ;
2016-12-23 19:02:51 -05:00
SaveLogEnter ( " GfxStaticModelDrawInst " ) ;
2016-12-20 22:15:01 -05:00
2016-12-21 13:18:33 -05:00
buffer - > align ( Utils : : Stream : : ALIGN_4 ) ;
Game : : GfxStaticModelDrawInst * destModelTable = buffer - > dest < Game : : GfxStaticModelDrawInst > ( ) ;
buffer - > saveArray ( asset - > smodelDrawInsts , asset - > smodelCount ) ;
2016-12-20 22:15:01 -05:00
2016-12-21 19:23:48 -05:00
for ( unsigned int i = 0 ; i < asset - > smodelCount ; + + i )
2016-12-21 13:18:33 -05:00
{
Game : : GfxStaticModelDrawInst * model = & asset - > smodelDrawInsts [ i ] ;
Game : : GfxStaticModelDrawInst * destModel = & destModelTable [ i ] ;
2016-12-20 22:15:01 -05:00
2016-12-21 13:18:33 -05:00
if ( model - > model )
{
2016-12-23 01:42:56 -05:00
destModel - > model = builder - > saveSubAsset ( Game : : XAssetType : : ASSET_TYPE_XMODEL , model - > model ) . model ;
2016-12-21 13:18:33 -05:00
}
}
Utils : : Stream : : ClearPointer ( & dest - > smodelDrawInsts ) ;
2016-12-23 19:02:51 -05:00
SaveLogExit ( ) ;
2016-12-20 16:23:05 -05:00
}
buffer - > pushBlock ( Game : : XFILE_BLOCK_RUNTIME ) ;
if ( asset - > surfaceMaterials )
{
2016-12-20 22:15:01 -05:00
AssertSize ( Game : : GfxDrawSurf , 8 ) ;
2016-12-23 19:02:51 -05:00
SaveLogEnter ( " GfxDrawSurf " ) ;
2016-12-20 22:15:01 -05:00
2016-12-21 13:18:33 -05:00
buffer - > align ( Utils : : Stream : : ALIGN_4 ) ;
2016-12-25 14:55:42 -05:00
buffer - > saveArray ( asset - > surfaceMaterials , world - > surfaceCount ) ;
2016-12-21 13:18:33 -05:00
Utils : : Stream : : ClearPointer ( & dest - > surfaceMaterials ) ;
2016-12-23 19:02:51 -05:00
SaveLogExit ( ) ;
2016-12-20 16:23:05 -05:00
}
if ( asset - > surfaceCastsSunShadow )
{
2016-12-21 13:18:33 -05:00
AssertSize ( Game : : GfxDrawSurf , 8 ) ;
2016-12-23 19:02:51 -05:00
SaveLogEnter ( " GfxDrawSurf " ) ;
2016-12-20 22:15:01 -05:00
2016-12-21 13:18:33 -05:00
buffer - > align ( Utils : : Stream : : ALIGN_128 ) ;
2016-12-29 14:14:55 -05:00
buffer - > save ( asset - > surfaceCastsSunShadow , 4 , asset - > surfaceVisDataCount ) ;
2016-12-30 09:54:25 -05:00
Utils : : Stream : : ClearPointer ( & dest - > surfaceCastsSunShadow ) ;
2016-12-23 19:02:51 -05:00
SaveLogExit ( ) ;
2016-12-20 16:23:05 -05:00
}
buffer - > popBlock ( ) ;
2016-12-22 06:53:52 -05:00
SaveLogExit ( ) ;
2016-12-20 11:42:15 -05:00
}
2016-12-20 16:23:05 -05:00
void IGfxWorld : : saveGfxWorldDpvsDynamic ( Game : : GfxWorldDpvsDynamic * asset , Game : : GfxWorldDpvsDynamic * dest , Components : : ZoneBuilder : : Zone * builder )
2016-12-20 11:42:15 -05:00
{
AssertSize ( Game : : GfxWorldDpvsDynamic , 48 ) ;
Utils : : Stream * buffer = builder - > getBuffer ( ) ;
2016-12-22 06:53:52 -05:00
SaveLogEnter ( " GfxWorldDpvsDynamic " ) ;
2016-12-20 11:42:15 -05:00
buffer - > pushBlock ( Game : : XFILE_BLOCK_RUNTIME ) ;
if ( asset - > dynEntCellBits [ 0 ] )
{
buffer - > align ( Utils : : Stream : : ALIGN_4 ) ;
2016-12-20 16:23:05 -05:00
buffer - > saveArray ( asset - > dynEntCellBits [ 0 ] , asset - > dynEntClientWordCount [ 0 ] ) ;
2016-12-20 11:42:15 -05:00
Utils : : Stream : : ClearPointer ( & dest - > dynEntCellBits [ 0 ] ) ;
}
if ( asset - > dynEntCellBits [ 1 ] )
{
buffer - > align ( Utils : : Stream : : ALIGN_4 ) ;
2016-12-20 16:23:05 -05:00
buffer - > saveArray ( asset - > dynEntCellBits [ 1 ] , asset - > dynEntClientWordCount [ 1 ] ) ;
2016-12-20 11:42:15 -05:00
Utils : : Stream : : ClearPointer ( & dest - > dynEntCellBits [ 1 ] ) ;
}
// this covers [0][0], [1][0], [0][1], [1][1], [0][2], [1][2]
2016-12-21 19:23:48 -05:00
for ( char i = 0 ; i < 3 ; + + i )
2016-12-20 11:42:15 -05:00
{
2016-12-21 19:23:48 -05:00
for ( char j = 0 ; j < 2 ; + + j )
2016-12-20 11:42:15 -05:00
{
if ( asset - > dynEntVisData [ j ] [ i ] )
{
buffer - > align ( Utils : : Stream : : ALIGN_16 ) ;
buffer - > save ( asset - > dynEntVisData [ j ] [ i ] , 32 , asset - > dynEntClientWordCount [ j ] ) ;
Utils : : Stream : : ClearPointer ( & dest - > dynEntVisData [ j ] [ i ] ) ;
}
}
}
buffer - > popBlock ( ) ;
2016-12-22 06:53:52 -05:00
SaveLogExit ( ) ;
2016-12-20 11:42:15 -05:00
}
void IGfxWorld : : save ( Game : : XAssetHeader header , Components : : ZoneBuilder : : Zone * builder )
{
2016-12-21 19:23:48 -05:00
AssertSize ( Game : : GfxWorld , 628 ) ;
2016-12-20 11:42:15 -05:00
Utils : : Stream * buffer = builder - > getBuffer ( ) ;
2016-12-22 06:53:52 -05:00
SaveLogEnter ( " GfxWorld " ) ;
2016-12-21 11:26:16 -05:00
Game : : GfxWorld * asset = header . gfxWorld ;
2016-12-20 11:42:15 -05:00
Game : : GfxWorld * dest = buffer - > dest < Game : : GfxWorld > ( ) ;
buffer - > save ( asset ) ;
buffer - > pushBlock ( Game : : XFILE_BLOCK_VIRTUAL ) ;
if ( asset - > name )
{
buffer - > saveString ( builder - > getAssetName ( this - > getType ( ) , asset - > name ) ) ;
Utils : : Stream : : ClearPointer ( & dest - > name ) ;
}
if ( asset - > baseName )
{
buffer - > saveString ( asset - > baseName ) ;
Utils : : Stream : : ClearPointer ( & dest - > baseName ) ;
}
if ( asset - > skies )
{
AssertSize ( Game : : GfxSky , 16 ) ;
2016-12-23 19:02:51 -05:00
SaveLogEnter ( " GfxSky " ) ;
2016-12-20 01:47:10 -05:00
buffer - > align ( Utils : : Stream : : ALIGN_4 ) ;
Game : : GfxSky * destSkyTable = buffer - > dest < Game : : GfxSky > ( ) ;
buffer - > saveArray ( asset - > skies , asset - > skyCount ) ;
2016-12-25 14:55:42 -05:00
for ( int i = 0 ; i < asset - > skyCount ; + + i )
2016-12-20 01:47:10 -05:00
{
2016-12-20 11:42:15 -05:00
Game : : GfxSky * destSky = & destSkyTable [ i ] ;
Game : : GfxSky * sky = & asset - > skies [ i ] ;
if ( sky - > skyStartSurfs )
{
buffer - > align ( Utils : : Stream : : ALIGN_4 ) ;
buffer - > saveArray ( sky - > skyStartSurfs , sky - > skySurfCount ) ;
Utils : : Stream : : ClearPointer ( & destSky - > skyStartSurfs ) ;
}
2016-12-20 16:23:05 -05:00
if ( sky - > skyImage )
{
2016-12-23 01:42:56 -05:00
destSky - > skyImage = builder - > saveSubAsset ( Game : : XAssetType : : ASSET_TYPE_IMAGE , sky - > skyImage ) . image ;
2016-12-20 11:42:15 -05:00
}
}
Utils : : Stream : : ClearPointer ( & dest - > skies ) ;
2016-12-23 19:02:51 -05:00
SaveLogExit ( ) ;
2016-12-20 11:42:15 -05:00
}
this - > saveGfxWorldDpvsPlanes ( asset , & asset - > dpvsPlanes , & dest - > dpvsPlanes , builder ) ;
2016-12-21 18:06:08 -05:00
int cellCount = asset - > dpvsPlanes . cellCount ;
2016-12-20 11:42:15 -05:00
if ( asset - > aabbTreeCounts )
{
AssertSize ( Game : : GfxCellTreeCount , 4 ) ;
2016-12-23 19:02:51 -05:00
SaveLogEnter ( " GfxCellTreeCount " ) ;
2016-12-20 11:42:15 -05:00
buffer - > align ( Utils : : Stream : : ALIGN_4 ) ;
buffer - > saveArray ( asset - > aabbTreeCounts , cellCount ) ;
Utils : : Stream : : ClearPointer ( & dest - > aabbTreeCounts ) ;
2016-12-23 19:02:51 -05:00
SaveLogExit ( ) ;
2016-12-20 11:42:15 -05:00
}
if ( asset - > aabbTrees )
{
AssertSize ( Game : : GfxCellTree , 4 ) ;
2016-12-23 19:02:51 -05:00
SaveLogEnter ( " GfxCellTree " ) ;
2016-12-20 01:47:10 -05:00
buffer - > align ( Utils : : Stream : : ALIGN_128 ) ;
Game : : GfxCellTree * destCellTreeTable = buffer - > dest < Game : : GfxCellTree > ( ) ;
buffer - > saveArray ( asset - > aabbTrees , cellCount ) ;
2016-12-21 18:06:08 -05:00
for ( int i = 0 ; i < cellCount ; + + i )
2016-12-20 01:47:10 -05:00
{
2016-12-20 11:42:15 -05:00
Game : : GfxCellTree * destCellTree = & destCellTreeTable [ i ] ;
Game : : GfxCellTree * cellTree = & asset - > aabbTrees [ i ] ;
if ( cellTree - > aabbTree )
{
AssertSize ( Game : : GfxAabbTree , 44 ) ;
2016-12-23 19:02:51 -05:00
SaveLogEnter ( " GfxAabbTree " ) ;
2016-12-20 11:42:15 -05:00
buffer - > align ( Utils : : Stream : : ALIGN_4 ) ;
Game : : GfxAabbTree * destAabbTreeTable = buffer - > dest < Game : : GfxAabbTree > ( ) ;
buffer - > saveArray ( cellTree - > aabbTree , asset - > aabbTreeCounts [ i ] . aabbTreeCount ) ;
// ok this one is based on some assumptions because the actual count is this
// *(int *)((char *)&varGfxWorld->aabbTreeCounts->aabbTreeCount + (((char *)varGfxCellTree - (char *)varGfxWorld->aabbTrees) & 0xFFFFFFFC))
// which makes no sense
2016-12-21 13:18:33 -05:00
// what DOES make sense is using the count from the structure
2016-12-20 11:42:15 -05:00
2016-12-20 16:23:05 -05:00
for ( int j = 0 ; j < asset - > aabbTreeCounts [ i ] . aabbTreeCount ; + + j )
2016-12-20 11:42:15 -05:00
{
Game : : GfxAabbTree * destAabbTree = & destAabbTreeTable [ j ] ;
Game : : GfxAabbTree * aabbTree = & cellTree - > aabbTree [ j ] ;
if ( aabbTree - > smodelIndexes )
{
if ( builder - > hasPointer ( aabbTree - > smodelIndexes ) )
{
destAabbTree - > smodelIndexes = builder - > getPointer ( aabbTree - > smodelIndexes ) ;
}
else
{
buffer - > align ( Utils : : Stream : : ALIGN_2 ) ;
2016-12-24 12:37:27 -05:00
for ( int k = 0 ; k < aabbTree - > smodelIndexCount ; + + k )
{
builder - > storePointer ( & aabbTree - > smodelIndexes [ k ] ) ;
buffer - > save ( & aabbTree - > smodelIndexes [ k ] ) ;
}
2016-12-20 11:42:15 -05:00
Utils : : Stream : : ClearPointer ( & destAabbTree - > smodelIndexes ) ;
}
}
}
Utils : : Stream : : ClearPointer ( & destCellTree - > aabbTree ) ;
2016-12-23 19:02:51 -05:00
SaveLogExit ( ) ;
2016-12-20 11:42:15 -05:00
}
}
Utils : : Stream : : ClearPointer ( & dest - > aabbTrees ) ;
2016-12-23 19:02:51 -05:00
SaveLogExit ( ) ;
2016-12-20 11:42:15 -05:00
}
if ( asset - > cells )
{
AssertSize ( Game : : GfxCell , 40 ) ;
2016-12-23 19:02:51 -05:00
SaveLogEnter ( " GfxCell " ) ;
2016-12-20 01:47:10 -05:00
buffer - > align ( Utils : : Stream : : ALIGN_4 ) ;
Game : : GfxCell * destCellTable = buffer - > dest < Game : : GfxCell > ( ) ;
buffer - > saveArray ( asset - > cells , cellCount ) ;
2016-12-21 18:06:08 -05:00
for ( int i = 0 ; i < cellCount ; + + i )
2016-12-20 01:47:10 -05:00
{
2016-12-20 11:42:15 -05:00
Game : : GfxCell * destCell = & destCellTable [ i ] ;
Game : : GfxCell * cell = & asset - > cells [ i ] ;
if ( cell - > portals )
{
AssertSize ( Game : : GfxPortal , 60 ) ;
2016-12-23 19:02:51 -05:00
SaveLogEnter ( " GfxPortal " ) ;
2016-12-20 11:42:15 -05:00
buffer - > align ( Utils : : Stream : : ALIGN_4 ) ;
Game : : GfxPortal * destPortalTable = buffer - > dest < Game : : GfxPortal > ( ) ;
buffer - > saveArray ( cell - > portals , cell - > portalCount ) ;
2016-12-20 16:23:05 -05:00
for ( int j = 0 ; j < cell - > portalCount ; + + j )
2016-12-20 11:42:15 -05:00
{
Game : : GfxPortal * destPortal = & destPortalTable [ j ] ;
Game : : GfxPortal * portal = & cell - > portals [ j ] ;
if ( portal - > vertices )
{
buffer - > align ( Utils : : Stream : : ALIGN_4 ) ;
buffer - > saveArray ( portal - > vertices , portal - > vertexCount ) ;
Utils : : Stream : : ClearPointer ( & destPortal - > vertices ) ;
}
}
Utils : : Stream : : ClearPointer ( & destCell - > portals ) ;
2016-12-23 19:02:51 -05:00
SaveLogExit ( ) ;
2016-12-20 11:42:15 -05:00
}
if ( cell - > reflectionProbes )
{
// no align for char
buffer - > saveArray ( cell - > reflectionProbes , cell - > reflectionProbeCount ) ;
Utils : : Stream : : ClearPointer ( & destCell - > reflectionProbes ) ;
}
}
Utils : : Stream : : ClearPointer ( & dest - > cells ) ;
2016-12-23 19:02:51 -05:00
SaveLogExit ( ) ;
2016-12-20 11:42:15 -05:00
}
2016-12-25 14:55:42 -05:00
this - > saveGfxWorldDraw ( & asset - > draw , & dest - > draw , builder ) ;
2016-12-20 11:42:15 -05:00
this - > saveGfxLightGrid ( & asset - > lightGrid , & dest - > lightGrid , builder ) ;
if ( asset - > models )
{
2016-12-20 16:23:05 -05:00
AssertSize ( Game : : GfxBrushModel , 60 ) ;
2016-12-23 19:02:51 -05:00
SaveLogEnter ( " GfxBrushModel " ) ;
2016-12-20 16:23:05 -05:00
2016-12-20 11:42:15 -05:00
buffer - > align ( Utils : : Stream : : ALIGN_4 ) ;
buffer - > saveArray ( asset - > models , asset - > modelCount ) ;
2016-12-20 16:23:05 -05:00
Utils : : Stream : : ClearPointer ( & dest - > models ) ;
2016-12-23 19:02:51 -05:00
SaveLogExit ( ) ;
2016-12-20 11:42:15 -05:00
}
if ( asset - > materialMemory )
{
AssertSize ( Game : : MaterialMemory , 8 ) ;
2016-12-23 19:02:51 -05:00
SaveLogEnter ( " MaterialMemory " ) ;
2016-12-20 01:47:10 -05:00
buffer - > align ( Utils : : Stream : : ALIGN_4 ) ;
Game : : MaterialMemory * destMaterialMemoryTable = buffer - > dest < Game : : MaterialMemory > ( ) ;
buffer - > saveArray ( asset - > materialMemory , asset - > materialMemoryCount ) ;
2016-12-21 14:56:17 -05:00
for ( int i = 0 ; i < asset - > materialMemoryCount ; + + i )
2016-12-20 01:47:10 -05:00
{
2016-12-20 11:42:15 -05:00
Game : : MaterialMemory * destMaterialMemory = & destMaterialMemoryTable [ i ] ;
Game : : MaterialMemory * materialMemory = & asset - > materialMemory [ i ] ;
if ( materialMemory - > material )
{
2016-12-23 01:42:56 -05:00
destMaterialMemory - > material = builder - > saveSubAsset ( Game : : XAssetType : : ASSET_TYPE_MATERIAL , materialMemory - > material ) . material ;
2016-12-20 11:42:15 -05:00
}
}
Utils : : Stream : : ClearPointer ( & dest - > materialMemory ) ;
2016-12-23 19:02:51 -05:00
SaveLogExit ( ) ;
2016-12-20 11:42:15 -05:00
}
this - > savesunflare_t ( & asset - > sun , & dest - > sun , builder ) ;
2016-12-25 14:55:42 -05:00
if ( asset - > outdoorImage )
2016-12-20 11:42:15 -05:00
{
2016-12-25 14:55:42 -05:00
dest - > outdoorImage = builder - > saveSubAsset ( Game : : XAssetType : : ASSET_TYPE_IMAGE , asset - > outdoorImage ) . image ;
2016-12-20 11:42:15 -05:00
}
buffer - > pushBlock ( Game : : XFILE_BLOCK_RUNTIME ) ;
2016-12-25 14:55:42 -05:00
if ( asset - > cellCasterBits )
2016-12-20 11:42:15 -05:00
{
buffer - > align ( Utils : : Stream : : ALIGN_4 ) ;
2016-12-25 14:55:42 -05:00
buffer - > saveArray ( asset - > cellCasterBits , cellCount * ( ( cellCount + 31 ) > > 5 ) ) ;
Utils : : Stream : : ClearPointer ( & dest - > cellCasterBits ) ;
2016-12-20 11:42:15 -05:00
}
2016-12-25 14:55:42 -05:00
if ( asset - > cellHasSunLitSurfsBits )
2016-12-20 11:42:15 -05:00
{
buffer - > align ( Utils : : Stream : : ALIGN_4 ) ;
2016-12-25 14:55:42 -05:00
buffer - > saveArray ( asset - > cellHasSunLitSurfsBits , ( ( cellCount + 31 ) > > 5 ) ) ;
Utils : : Stream : : ClearPointer ( & dest - > cellHasSunLitSurfsBits ) ;
2016-12-20 11:42:15 -05:00
}
if ( asset - > sceneDynModel )
{
2016-12-20 16:23:05 -05:00
AssertSize ( Game : : GfxSceneDynModel , 6 ) ;
2016-12-20 11:42:15 -05:00
buffer - > align ( Utils : : Stream : : ALIGN_4 ) ;
buffer - > saveArray ( asset - > sceneDynModel , asset - > dpvsDyn . dynEntClientCount [ 0 ] ) ;
Utils : : Stream : : ClearPointer ( & dest - > sceneDynModel ) ;
}
if ( asset - > sceneDynBrush )
{
2016-12-20 16:23:05 -05:00
AssertSize ( Game : : GfxSceneDynBrush , 4 ) ;
2016-12-20 11:42:15 -05:00
buffer - > align ( Utils : : Stream : : ALIGN_4 ) ;
buffer - > saveArray ( asset - > sceneDynBrush , asset - > dpvsDyn . dynEntClientCount [ 1 ] ) ;
Utils : : Stream : : ClearPointer ( & dest - > sceneDynBrush ) ;
}
if ( asset - > primaryLightEntityShadowVis )
{
buffer - > align ( Utils : : Stream : : ALIGN_4 ) ;
2016-12-25 14:55:42 -05:00
buffer - > save ( asset - > primaryLightEntityShadowVis , 1 , ( asset - > primaryLightCount + 0x1FFFF - asset - > lastSunPrimaryLightIndex ) < < 15 ) ;
2016-12-20 11:42:15 -05:00
Utils : : Stream : : ClearPointer ( & dest - > primaryLightEntityShadowVis ) ;
}
if ( asset - > primaryLightDynEntShadowVis [ 0 ] )
{
buffer - > align ( Utils : : Stream : : ALIGN_4 ) ;
2016-12-25 14:55:42 -05:00
buffer - > saveArray ( asset - > primaryLightDynEntShadowVis [ 0 ] , asset - > dpvsDyn . dynEntClientCount [ 0 ] * ( asset - > primaryLightCount - 1 - asset - > lastSunPrimaryLightIndex ) ) ;
2016-12-20 11:42:15 -05:00
Utils : : Stream : : ClearPointer ( & dest - > primaryLightDynEntShadowVis [ 0 ] ) ;
}
if ( asset - > primaryLightDynEntShadowVis [ 1 ] )
{
buffer - > align ( Utils : : Stream : : ALIGN_4 ) ;
2016-12-25 14:55:42 -05:00
buffer - > saveArray ( asset - > primaryLightDynEntShadowVis [ 1 ] , asset - > dpvsDyn . dynEntClientCount [ 1 ] * ( asset - > primaryLightCount - 1 - asset - > lastSunPrimaryLightIndex ) ) ;
2016-12-20 11:42:15 -05:00
Utils : : Stream : : ClearPointer ( & dest - > primaryLightDynEntShadowVis [ 1 ] ) ;
}
2016-12-25 14:55:42 -05:00
if ( asset - > nonSunPrimaryLightForModelDynEnt )
2016-12-20 11:42:15 -05:00
{
// no align cause char
2016-12-25 14:55:42 -05:00
buffer - > saveArray ( asset - > nonSunPrimaryLightForModelDynEnt , asset - > dpvsDyn . dynEntClientCount [ 0 ] ) ;
Utils : : Stream : : ClearPointer ( & dest - > nonSunPrimaryLightForModelDynEnt ) ;
2016-12-20 11:42:15 -05:00
}
buffer - > popBlock ( ) ;
if ( asset - > shadowGeom )
{
AssertSize ( Game : : GfxShadowGeometry , 12 ) ;
2016-12-23 19:02:51 -05:00
SaveLogEnter ( " GfxShadowGeometry " ) ;
2016-12-20 01:47:10 -05:00
buffer - > align ( Utils : : Stream : : ALIGN_4 ) ;
Game : : GfxShadowGeometry * destShadowGeometryTable = buffer - > dest < Game : : GfxShadowGeometry > ( ) ;
2016-12-25 14:55:42 -05:00
buffer - > saveArray ( asset - > shadowGeom , asset - > primaryLightCount ) ;
2016-12-20 01:47:10 -05:00
2016-12-25 14:55:42 -05:00
for ( unsigned int i = 0 ; i < asset - > primaryLightCount ; + + i )
2016-12-20 01:47:10 -05:00
{
2016-12-20 11:42:15 -05:00
Game : : GfxShadowGeometry * destShadowGeometry = & destShadowGeometryTable [ i ] ;
Game : : GfxShadowGeometry * shadowGeometry = & asset - > shadowGeom [ i ] ;
if ( shadowGeometry - > sortedSurfIndex )
{
buffer - > align ( Utils : : Stream : : ALIGN_2 ) ;
buffer - > saveArray ( shadowGeometry - > sortedSurfIndex , shadowGeometry - > surfaceCount ) ;
Utils : : Stream : : ClearPointer ( & destShadowGeometry - > sortedSurfIndex ) ;
}
if ( shadowGeometry - > smodelIndex )
{
buffer - > align ( Utils : : Stream : : ALIGN_2 ) ;
buffer - > saveArray ( shadowGeometry - > smodelIndex , shadowGeometry - > smodelCount ) ;
Utils : : Stream : : ClearPointer ( & destShadowGeometry - > smodelIndex ) ;
}
}
Utils : : Stream : : ClearPointer ( & dest - > shadowGeom ) ;
2016-12-23 19:02:51 -05:00
SaveLogExit ( ) ;
2016-12-20 11:42:15 -05:00
}
if ( asset - > lightRegion )
{
AssertSize ( Game : : GfxLightRegion , 8 ) ;
2016-12-23 19:02:51 -05:00
SaveLogEnter ( " GfxLightRegion " ) ;
2016-12-20 01:47:10 -05:00
buffer - > align ( Utils : : Stream : : ALIGN_4 ) ;
Game : : GfxLightRegion * destLightRegionTable = buffer - > dest < Game : : GfxLightRegion > ( ) ;
2016-12-25 14:55:42 -05:00
buffer - > saveArray ( asset - > lightRegion , asset - > primaryLightCount ) ;
2016-12-20 01:47:10 -05:00
2016-12-25 14:55:42 -05:00
for ( unsigned int i = 0 ; i < asset - > primaryLightCount ; + + i )
2016-12-20 01:47:10 -05:00
{
2016-12-20 11:42:15 -05:00
Game : : GfxLightRegion * destLightRegion = & destLightRegionTable [ i ] ;
Game : : GfxLightRegion * lightRegion = & asset - > lightRegion [ i ] ;
if ( lightRegion - > hulls )
{
AssertSize ( Game : : GfxLightRegionHull , 80 ) ;
2016-12-23 19:02:51 -05:00
SaveLogEnter ( " GfxLightRegionHull " ) ;
2016-12-20 11:42:15 -05:00
buffer - > align ( Utils : : Stream : : ALIGN_4 ) ;
Game : : GfxLightRegionHull * destLightRegionHullTable = buffer - > dest < Game : : GfxLightRegionHull > ( ) ;
buffer - > saveArray ( lightRegion - > hulls , lightRegion - > hullCount ) ;
2016-12-20 16:23:05 -05:00
for ( unsigned int j = 0 ; j < lightRegion - > hullCount ; + + j )
2016-12-20 11:42:15 -05:00
{
Game : : GfxLightRegionHull * destLightRegionHull = & destLightRegionHullTable [ j ] ;
Game : : GfxLightRegionHull * lightRegionHull = & lightRegion - > hulls [ j ] ;
if ( lightRegionHull - > axis )
{
AssertSize ( Game : : GfxLightRegionAxis , 20 ) ;
2016-12-23 19:02:51 -05:00
SaveLogEnter ( " GfxLightRegionAxis " ) ;
2016-12-20 11:42:15 -05:00
buffer - > align ( Utils : : Stream : : ALIGN_4 ) ;
buffer - > saveArray ( lightRegionHull - > axis , lightRegionHull - > axisCount ) ;
Utils : : Stream : : ClearPointer ( & destLightRegionHull - > axis ) ;
2016-12-23 19:02:51 -05:00
SaveLogExit ( ) ;
2016-12-20 11:42:15 -05:00
}
}
Utils : : Stream : : ClearPointer ( & destLightRegion - > hulls ) ;
2016-12-23 19:02:51 -05:00
SaveLogExit ( ) ;
2016-12-20 11:42:15 -05:00
}
}
Utils : : Stream : : ClearPointer ( & dest - > lightRegion ) ;
2016-12-23 19:02:51 -05:00
SaveLogExit ( ) ;
2016-12-20 11:42:15 -05:00
}
2016-12-20 22:15:01 -05:00
this - > saveGfxWorldDpvsStatic ( asset , & asset - > dpvs , & dest - > dpvs , asset - > dpvsPlanes . cellCount , builder ) ;
2016-12-20 16:23:05 -05:00
this - > saveGfxWorldDpvsDynamic ( & asset - > dpvsDyn , & dest - > dpvsDyn , builder ) ;
2016-12-20 11:42:15 -05:00
2016-12-25 14:55:42 -05:00
if ( asset - > heroOnlyLights )
2016-12-20 11:42:15 -05:00
{
2016-12-25 14:55:42 -05:00
AssertSize ( Game : : GfxHeroOnlyLight , 56 ) ;
2016-12-20 11:42:15 -05:00
buffer - > align ( Utils : : Stream : : ALIGN_4 ) ;
2016-12-25 14:55:42 -05:00
buffer - > saveArray ( asset - > heroOnlyLights , asset - > heroOnlyLightCount ) ;
Utils : : Stream : : ClearPointer ( & dest - > heroOnlyLights ) ;
2016-12-20 11:42:15 -05:00
}
buffer - > popBlock ( ) ;
2016-12-22 06:53:52 -05:00
SaveLogExit ( ) ;
2016-12-20 11:42:15 -05:00
}
2016-12-20 01:47:10 -05:00
}
2017-01-08 13:36:33 -05:00
# endif