void CLedgeManager::Load( const char* fileName )
{
// Clear in case there is anything left
Reset();
// In editor we don't load exported data, entities will recreate on load
if (m_editorManager.IsInEditorMode())
return;
CCryFile file;
if( false != file.Open( fileName, "rb" ) )
{
// File version
uint32 nFileVersion;
file.ReadType( &nFileVersion );
if (nFileVersion != LEDGE_DATA_FILE_VERSION)
{
GameWarning("!LedgeManager: Level data could not be loaded, file %s has version %d, expected %d. Level needs re-export", fileName, nFileVersion, LEDGE_DATA_FILE_VERSION);
return;
}
// Ledges and markers info
uint32 totalLedgeObjectsCount, totalLedgeMarkersCount;
file.ReadType( &totalLedgeObjectsCount );
file.ReadType( &totalLedgeMarkersCount );
m_levelLedges.Allocate( totalLedgeObjectsCount, totalLedgeMarkersCount );
file.ReadType( &m_levelLedges.m_pLedgeObjects[0], totalLedgeObjectsCount );
file.ReadType( &m_levelLedges.m_pMarkers[0], totalLedgeMarkersCount );
file.Close();
}
}
void CLedgeManagerEdit::Export( const char* fileName ) const
{
const uint32 totalLedgeObjectsCount = m_ledgeObjects.size();
if (totalLedgeObjectsCount > 0)
{
CCryFile file;
if( false != file.Open( fileName, "wb" ) )
{
// Count number of markers ...
uint32 totalLedgeMarkersCount = 0;
for (uint32 objectIdx = 0; objectIdx < totalLedgeObjectsCount; ++objectIdx)
{
totalLedgeMarkersCount += m_ledgeObjects[objectIdx].m_markers.size();
}
// Prepare buffers ...
SLedgeObject ledgeObjectBuffer[MAX_LEDGE_ENTITIES];
SLedgeMarkerBuffer ledgeMarkersBuffer(totalLedgeMarkersCount);
uint32 currentMarkerIdx = 0;
for (uint32 objectIdx = 0; objectIdx < totalLedgeObjectsCount; ++objectIdx)
{
SLedgeObject& ledgeObject = ledgeObjectBuffer[objectIdx];
const SLedgeObjectEditor& ledgeObjectEdit = m_ledgeObjects[objectIdx];
ledgeObject.m_entityId = ((ledgeObjectEdit.m_ledgeFlags[LedgeSide_In] & kLedgeFlag_static) == 0) ? ledgeObjectEdit.m_entityId : 0;
ledgeObject.m_ledgeFlags[LedgeSide_In] = ledgeObjectEdit.m_ledgeFlags[LedgeSide_In];
ledgeObject.m_ledgeFlags[LedgeSide_Out] = ledgeObjectEdit.m_ledgeFlags[LedgeSide_Out];
ledgeObject.m_ledgeCornerEndAdjustAmount = ledgeObjectEdit.m_ledgeCornerEndAdjustAmount;
ledgeObject.m_markersStartIdx = currentMarkerIdx;
ledgeObject.m_markersCount = ledgeObjectEdit.m_markers.size();
CRY_ASSERT((ledgeObject.m_markersStartIdx + ledgeObject.m_markersCount) <= totalLedgeMarkersCount);
for(size_t markerIdx = 0; markerIdx < ledgeObjectEdit.m_markers.size(); ++markerIdx)
{
ledgeMarkersBuffer.InsertAt( ledgeObjectEdit.m_markers[markerIdx], currentMarkerIdx + markerIdx );
}
currentMarkerIdx += ledgeObject.m_markersCount;
}
// Write to file...
// File version
uint32 nFileVersion = LEDGE_DATA_FILE_VERSION;
file.Write( &nFileVersion,sizeof(nFileVersion) );
// Ledges and markers info
file.Write( &totalLedgeObjectsCount, sizeof(totalLedgeObjectsCount) );
file.Write( &totalLedgeMarkersCount, sizeof(totalLedgeMarkersCount) );
file.Write( &ledgeObjectBuffer[0], sizeof(ledgeObjectBuffer[0]) * totalLedgeObjectsCount );
file.Write( &ledgeMarkersBuffer.pMarkers[0], sizeof(ledgeMarkersBuffer.pMarkers[0]) * ledgeMarkersBuffer.bufferSize );
file.Close();
}
}
}
void CGameVolumesManager::Export( const char* fileName ) const
{
CCryFile file;
if( false != file.Open( fileName, "wb" ) )
{
const uint32 maxVertices = 512;
Vec3 writeVertexBuffer[maxVertices];
// File version
uint32 nFileVersion = GAME_VOLUMES_FILE_VERSION;
file.Write( &nFileVersion,sizeof(nFileVersion) );
// Save volume info
uint32 nVolumeCount = (uint32)m_volumesData.size();
file.Write( &nVolumeCount, sizeof(nVolumeCount) );
for (uint32 i = 0; i < nVolumeCount; ++i)
{
const EntityVolume& volumeInfo = m_volumesData[i];
CRY_ASSERT ( volumeInfo.vertices.size() < maxVertices );
uint32 nVertexCount = min( (uint32)volumeInfo.vertices.size(), maxVertices );
uint32 nEntityId = volumeInfo.entityId;
f32 fHeight = volumeInfo.height;
bool bClosed = volumeInfo.closed;
file.Write( &nEntityId, sizeof(nEntityId) );
file.Write( &fHeight, sizeof(fHeight) );
if( nFileVersion > 1 )
{
file.Write( &bClosed, sizeof(bClosed) );
}
file.Write( &nVertexCount, sizeof(nVertexCount) );
if (nVertexCount > 0)
{
for (uint32 v = 0; v < nVertexCount; ++v)
{
writeVertexBuffer[v] = volumeInfo.vertices[v];
}
file.Write( &writeVertexBuffer[0], sizeof(writeVertexBuffer[0]) * nVertexCount );
}
}
file.Close();
}
}
void CGameVolumesManager::Load( const char* fileName )
{
//////////////////////////////////////////////////////////////////////////
/// Free any left data (it should be empty though...)
Reset();
//////////////////////////////////////////////////////////////////////////
/// No need to load in editor
/// The saved entities will restore the data inside the manager
if (gEnv->IsEditor())
return;
CCryFile file;
if( false != file.Open( fileName, "rb" ) )
{
uint32 nFileVersion = GAME_VOLUMES_FILE_VERSION;
file.ReadType( &nFileVersion );
// Verify version...
if ((nFileVersion >= 1) && (nFileVersion <= GAME_VOLUMES_FILE_VERSION))
{
const uint32 maxVertices = 512;
Vec3 readVertexBuffer[maxVertices];
// Read volumes
uint32 nVolumeCount = 0;
file.ReadType( &nVolumeCount );
m_volumesData.resize( nVolumeCount );
for (uint32 i = 0; i < nVolumeCount; ++i)
{
EntityVolume& volumeInfo = m_volumesData[i];
uint32 nVertexCount = 0;
uint32 nEntityId = 0;
f32 fHeight = 0;
bool bClosed = false;
file.ReadType( &nEntityId );
file.ReadType( &fHeight );
if( nFileVersion > 1 )
{
file.ReadType( &bClosed );
}
file.ReadType( &nVertexCount );
volumeInfo.entityId = (EntityId)nEntityId;
volumeInfo.height = fHeight;
volumeInfo.closed = bClosed;
volumeInfo.vertices.resize( nVertexCount );
if (nVertexCount > 0)
{
file.ReadType( &readVertexBuffer[0], nVertexCount );
for (uint32 v = 0; v < nVertexCount; ++v)
{
volumeInfo.vertices[v] = readVertexBuffer[v];
}
}
}
}
else
{
GameWarning("GameVolumesManger:Load - Failed to load file '%s'. Version mis-match, try to re-export your level", fileName);
}
file.Close();
}
}
