AssetObjectT BSPSector::read(IResource* resource, AssetObjectM& assetObjects)
{
ChunkHeader sectorHeader( resource );
if( sectorHeader.type != BA_SECTOR ) throw Exception( "Unexpected chunk type" );
if( sectorHeader.size != sizeof(Chunk) ) throw Exception( "Incompatible binary asset version" );
Chunk chunk;
fread( &chunk, sizeof(Chunk), 1, resource->getFile() );
AssetObjectI assetObjectI = assetObjects.find( chunk.bspId );
assert( assetObjectI != assetObjects.end() );
BSP* bsp = reinterpret_cast<BSP*>( assetObjectI->second );
BSPSector* parentSector = NULL;
assetObjectI = assetObjects.find( chunk.parentId );
if( assetObjectI != assetObjects.end() ) parentSector = reinterpret_cast<BSPSector*>( assetObjectI->second );
Geometry* geometry = NULL;
if( chunk.hasGeometry )
{
AssetObjectT assetObjectT = Geometry::read( resource, assetObjects );
geometry = reinterpret_cast<Geometry*>( assetObjectT.second );
geometry->setShaders( bsp->getShaders() );
geometry->instance();
assetObjects.insert( assetObjectT );
}
BSPSector* sector = new BSPSector( bsp, parentSector, chunk.boundingBox, geometry );
return AssetObjectT( chunk.id, sector );
}
AssetObjectT Frame::read(IResource* resource, AssetObjectM& assetObjects)
{
ChunkHeader frameHeader( resource );
if( frameHeader.type != BA_FRAME ) throw Exception( "Unexpected chunk type" );
if( frameHeader.size != sizeof(Chunk) ) throw Exception( "Incompatible binary asset version" );
Chunk chunk;
fread( &chunk, sizeof(chunk), 1, resource->getFile() );
printf(" Frame: %s\n", chunk.name);
Frame* frame = new Frame( chunk.name );
frame->TransformationMatrix = chunk.matrix;
AssetObjectI assetObjectI = assetObjects.find( chunk.parent );
if( assetObjectI != assetObjects.end() )
{
frame->setParent( reinterpret_cast<Frame*>( assetObjectI->second ) );
}
return AssetObjectT( chunk.id, frame );
}
AssetObjectT Shader::read(IResource* resource, AssetObjectM& assetObjects)
{
ChunkHeader shaderHeader( resource );
if( shaderHeader.type != BA_SHADER ) throw Exception( "Unexpected chunk type" );
if( shaderHeader.size != sizeof(Chunk) ) throw Exception( "Incompatible binary asset version" );
Chunk chunk;
fread( &chunk, sizeof(Chunk), 1, resource->getFile() );
Shader* shader = new Shader( chunk.numLayers, chunk.name );
for( int i=0; i<chunk.numLayers; i++ )
{
AssetObjectI assetObjectI = assetObjects.find( chunk.layerTexture[i] );
if( assetObjectI != assetObjects.end() )
{
shader->setLayerTexture( i, reinterpret_cast<Texture*>( assetObjectI->second ) );
}
shader->_layerUV[i] = chunk.layerUV[i];
shader->_layerBlending[i] = chunk.layerBlending[i];
shader->_layerConstant[i] = chunk.layerConstant[i];
}
shader->_materialColor = chunk.materialColor;
AssetObjectI assetObjectI = assetObjects.find( chunk.normalMap );
if( assetObjectI != assetObjects.end() )
{
shader->setNormalMap( reinterpret_cast<Texture*>( assetObjectI->second ) );
}
shader->_normalMapUV = chunk.normalMapUV;
assetObjectI = assetObjects.find( chunk.environmentMap );
if( assetObjectI != assetObjects.end() )
{
shader->setEnvironmentMap( reinterpret_cast<Texture*>( assetObjectI->second ) );
}
shader->_flags = chunk.flags | engine::sfCaching | engine::sfLighting;
shader->_lightset = chunk.lightset;
shader->_alphaTestFunction = chunk.alphaTestFunction;
shader->_alphaTestRef = chunk.alphaTestRef;
shader->_blendOp = chunk.blendOp;
shader->_srcBlend = chunk.srcBlend;
shader->_dstBlend = chunk.dstBlend;
if( chunk.hasEffect )
{
AssetObjectT assetObjectT = Effect::read( resource, assetObjects );
shader->setEffect( reinterpret_cast<Effect*>( assetObjectT.second ) );
assetObjects.insert( assetObjectT );
}
return AssetObjectT( chunk.id, shader );
}
AssetObjectT BSP::read(IResource* resource, AssetObjectM& assetObjects)
{
ChunkHeader bspHeader( resource );
if( bspHeader.type != BA_BSP ) throw Exception( "Unexpected chunk type" );
if( bspHeader.size != sizeof(Chunk) ) throw Exception( "Incompatible binary asset version" );
Chunk chunk;
fread( &chunk, sizeof(Chunk), 1, resource->getFile() );
printf(" Bsp: %s, shaders: %d, sectors: %d\n", chunk.name, chunk.numShaders, chunk.numSectors);
BSP* bsp = new BSP( chunk.name, chunk.boundingBox, chunk.numShaders );
bsp->_fogMode = chunk.fogMode;
bsp->_fogStart = chunk.fogStart;
bsp->_fogEnd = chunk.fogEnd;
bsp->_fogDensity = chunk.fogDensity;
bsp->_fogColor = chunk.fogColor;
// read shaders
int i;
for( i=0; i<chunk.numShaders; i++ )
{
AssetObjectT assetObjectT = Shader::read( resource, assetObjects );
bsp->setShader( i, reinterpret_cast<Shader*>( assetObjectT.second ) );
assetObjects.insert( assetObjectT );
}
assetObjects.insert( AssetObjectT( chunk.id, bsp ) );
// read sectors
for( i=0; i<chunk.numSectors; i++ )
{
assetObjects.insert( BSPSector::read( resource, assetObjects ) );
}
return AssetObjectT( AssetObjectT( chunk.id, bsp ) );
}
AssetObjectT Geometry::read(IResource* resource, AssetObjectM& assetObjects)
{
ChunkHeader geometryHeader( resource );
if( geometryHeader.type != BA_GEOMETRY ) throw Exception( "Unexpected chunk type" );
if( geometryHeader.size != sizeof(Chunk) ) throw Exception( "Incompatible binary asset version" );
Chunk chunk;
fread( &chunk, sizeof(Chunk), 1, resource->getFile() );
// read shaders
if( !chunk.sharedShaders ) for( int i=0; i<chunk.numShaders; i++ )
{
assetObjects.insert( Shader::read( resource, assetObjects ) );
}
// create geometry
Geometry* geometry = new Geometry( chunk.numVertices, chunk.numTriangles, chunk.numUVSets, chunk.numShaders, chunk.numPrelights, chunk.sharedShaders, chunk.name );
// read vertices
ChunkHeader verticesHeader( resource );
if( verticesHeader.type != BA_BINARY ) throw Exception( "Unexpected chunk type" );
if( verticesHeader.size != sizeof(Vector)*chunk.numVertices ) throw Exception( "Incompatible binary asset version" );
fread( geometry->getVertices(), verticesHeader.size, 1, resource->getFile() );
// f**k up vertices
//Vector* vertices = geometry->getVertices();
//for (int i = 0; i < chunk.numVertices; ++i) {
// getCore()->logMessage( "%s %3.3f, %3.3f, %3.3f", resource->getName(), vertices[i].x, vertices[i].y, vertices[i].z);
// //if (strcmp(resource->getName(), "./res/dropzone/dropzone.ba") == 0) {
// //if (vertices[i].y == 401000.0f) vertices[i].y = 701000.0f;
// //vertices[i] *= 3.0f;
// //}
//}
// read normals
ChunkHeader normalsHeader( resource );
if( normalsHeader.type != BA_BINARY ) throw Exception( "Unexpected chunk type" );
if( normalsHeader.size != sizeof(Vector)*chunk.numVertices ) throw Exception( "Incompatible binary asset version" );
fread( geometry->getNormals(), normalsHeader.size, 1, resource->getFile() );
// read UV-sets
int i;
for( i=0; i<geometry->getNumUVSets(); i++ )
{
ChunkHeader uvsHeader( resource );
if( uvsHeader.type != BA_BINARY ) throw Exception( "Unexpected chunk type" );
if( uvsHeader.size != sizeof(Flector)*chunk.numVertices ) throw Exception( "Incompatible binary asset version" );
fread( geometry->getUVSet(i), uvsHeader.size, 1, resource->getFile() );
}
// read prelights
for( i=0; i<geometry->getNumPrelights(); i++ )
{
ChunkHeader prelightsHeader( resource );
if( prelightsHeader.type != BA_BINARY ) throw Exception( "Unexpected chunk type" );
if( prelightsHeader.size != sizeof(Color)*chunk.numVertices ) throw Exception( "Incompatible binary asset version" );
fread( geometry->getPrelights(i), prelightsHeader.size, 1, resource->getFile() );
}
// read triangles
ChunkHeader trianglesHeader( resource );
if( trianglesHeader.type != BA_BINARY ) throw Exception( "Unexpected chunk type" );
if( trianglesHeader.size != sizeof(Triangle)*chunk.numTriangles ) throw Exception( "Incompatible binary asset version" );
fread( geometry->getTriangles(), trianglesHeader.size, 1, resource->getFile() );
// read shaders
if( !chunk.sharedShaders )
{
ChunkHeader shadersHeader( resource );
if( shadersHeader.type != BA_BINARY ) throw Exception( "Unexpected chunk type" );
if( shadersHeader.size != sizeof(auid)*chunk.numShaders ) throw Exception( "Incompatible binary asset version" );
auid* shaders = new auid[chunk.numShaders];
fread( shaders, shadersHeader.size, 1, resource->getFile() );
for( i=0; i<chunk.numShaders; i++ )
{
AssetObjectI assetObjectI = assetObjects.find( shaders[i] );
if( assetObjectI != assetObjects.end() )
{
geometry->setShader( i, reinterpret_cast<Shader*>( assetObjectI->second ) );
}
}
delete[] shaders;
}
assetObjects.insert( AssetObjectT( chunk.id, geometry ) );
// read octree
if( chunk.numOcTreeSectors )
{
for( int i=0; i<chunk.numOcTreeSectors; i++ )
{
AssetObjectT assetObjectT = OcTreeSector::read( resource, assetObjects );
if( i == 0 ) geometry->_ocTreeRoot = reinterpret_cast<OcTreeSector*>( assetObjectT.second );
assetObjects.insert( assetObjectT );
}
assert( geometry->_ocTreeRoot->checkConsistency() );
}
// read effect
if( chunk.hasEffect )
{
AssetObjectT assetObjectT = Effect::read( resource, assetObjects );
assetObjects.insert( assetObjectT );
geometry->setEffect( reinterpret_cast<Effect*>( assetObjectT.second ) );
}
return AssetObjectT( chunk.id, geometry );
}
