1502 lines
44 KiB
C++
Executable File
1502 lines
44 KiB
C++
Executable File
//-----------------------------------------------------------------------------
|
|
// Torque Game Engine
|
|
// Copyright (C) GarageGames.com, Inc.
|
|
//-----------------------------------------------------------------------------
|
|
|
|
#include "interior/interior.h"
|
|
#include "core/bitVector.h"
|
|
#include "core/stream.h"
|
|
#include "math/mathIO.h"
|
|
#include "dgl/gBitmap.h"
|
|
#include "dgl/materialList.h"
|
|
#include "interior/interiorSubObject.h"
|
|
#include "platform/platformGL.h"
|
|
#include "console/console.h"
|
|
#include "core/frameAllocator.h"
|
|
|
|
int QSORT_CALLBACK cmpU32(const void* p1, const void* p2)
|
|
{
|
|
return S32(*((U32*)p1)) - S32(*((U32*)p2));
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
//-------------------------------------- PERSISTENCE IMPLEMENTATION
|
|
//
|
|
U32 Interior::smFileVersion = 13;
|
|
|
|
bool Interior::read(Stream& stream)
|
|
{
|
|
AssertFatal(stream.hasCapability(Stream::StreamRead), "Interior::read: non-read capable stream passed");
|
|
AssertFatal(stream.getStatus() == Stream::Ok, "Interior::read: Error, stream in inconsistent state");
|
|
|
|
S32 i;
|
|
|
|
// Version this stream. We only load stream of the current version
|
|
U32 fileVersion;
|
|
stream.read(&fileVersion);
|
|
|
|
// We need to store the version in case there is any post processing that
|
|
// needs to take place that is dependent on the file version
|
|
mFileVersion = fileVersion;
|
|
|
|
if (fileVersion > smFileVersion) {
|
|
Con::errorf(ConsoleLogEntry::General, "Interior::read: incompatible file version found.");
|
|
return false;
|
|
}
|
|
|
|
// Geometry factors...
|
|
stream.read(&mDetailLevel);
|
|
|
|
stream.read(&mMinPixels);
|
|
mathRead(stream, &mBoundingBox);
|
|
mathRead(stream, &mBoundingSphere);
|
|
stream.read(&mHasAlarmState);
|
|
stream.read(&mNumLightStateEntries);
|
|
|
|
// Now read in our data vectors.
|
|
S32 vectorSize;
|
|
|
|
// mPlanes
|
|
readPlaneVector(stream);
|
|
|
|
// mPoints
|
|
stream.read(&vectorSize);
|
|
mPoints.setSize(vectorSize);
|
|
for (i = 0; i < mPoints.size(); i++)
|
|
mathRead(stream, &mPoints[i].point);
|
|
|
|
// mPointVisibility
|
|
stream.read(&vectorSize);
|
|
mPointVisibility.setSize(vectorSize);
|
|
stream.read(vectorSize, mPointVisibility.address());
|
|
|
|
// mTexGenEQs
|
|
stream.read(&vectorSize);
|
|
mTexGenEQs.setSize(vectorSize);
|
|
for(i = 0; i < mTexGenEQs.size(); i++)
|
|
{
|
|
mathRead(stream, &mTexGenEQs[i].planeX);
|
|
mathRead(stream, &mTexGenEQs[i].planeY);
|
|
}
|
|
|
|
// mBSPNodes;
|
|
stream.read(&vectorSize);
|
|
mBSPNodes.setSize(vectorSize);
|
|
for(i = 0; i < mBSPNodes.size(); i++)
|
|
{
|
|
stream.read(&mBSPNodes[i].planeIndex);
|
|
stream.read(&mBSPNodes[i].frontIndex);
|
|
stream.read(&mBSPNodes[i].backIndex);
|
|
}
|
|
|
|
// mBSPSolidLeaves
|
|
stream.read(&vectorSize);
|
|
mBSPSolidLeaves.setSize(vectorSize);
|
|
for(i = 0; i < mBSPSolidLeaves.size(); i++)
|
|
{
|
|
stream.read(&mBSPSolidLeaves[i].surfaceIndex);
|
|
stream.read(&mBSPSolidLeaves[i].surfaceCount);
|
|
}
|
|
|
|
// MaterialList
|
|
if(mMaterialList != NULL)
|
|
delete mMaterialList;
|
|
mMaterialList = new MaterialList;
|
|
mMaterialList->read(stream);
|
|
|
|
// mWindings
|
|
stream.read(&vectorSize);
|
|
mWindings.setSize(vectorSize);
|
|
for(i = 0; i < mWindings.size(); i++)
|
|
{
|
|
stream.read(&mWindings[i]);
|
|
}
|
|
|
|
// mWindingIndices
|
|
stream.read(&vectorSize);
|
|
mWindingIndices.setSize(vectorSize);
|
|
for(i = 0; i < mWindingIndices.size(); i++)
|
|
{
|
|
stream.read(&mWindingIndices[i].windingStart);
|
|
stream.read(&mWindingIndices[i].windingCount);
|
|
}
|
|
|
|
// mEdges
|
|
if (fileVersion >= 12)
|
|
{
|
|
stream.read(&vectorSize);
|
|
|
|
mEdges.setSize(vectorSize);
|
|
for (i = 0; i < mEdges.size(); i++)
|
|
{
|
|
stream.read(&mEdges[i].vertexes[0]);
|
|
stream.read(&mEdges[i].vertexes[1]);
|
|
stream.read(&mEdges[i].faces[0]);
|
|
stream.read(&mEdges[i].faces[1]);
|
|
}
|
|
}
|
|
|
|
// mZones
|
|
stream.read(&vectorSize);
|
|
mZones.setSize(vectorSize);
|
|
for(i = 0; i < mZones.size(); i++)
|
|
{
|
|
stream.read(&mZones[i].portalStart);
|
|
stream.read(&mZones[i].portalCount);
|
|
stream.read(&mZones[i].surfaceStart);
|
|
stream.read(&mZones[i].surfaceCount);
|
|
|
|
if (fileVersion >= 12)
|
|
{
|
|
stream.read(&mZones[i].staticMeshStart);
|
|
stream.read(&mZones[i].staticMeshCount);
|
|
}
|
|
|
|
stream.read(&mZones[i].flags);
|
|
mZones[i].zoneId = 0;
|
|
}
|
|
|
|
// Zone surfaces
|
|
stream.read(&vectorSize);
|
|
mZoneSurfaces.setSize(vectorSize);
|
|
for(i = 0; i < mZoneSurfaces.size(); i++)
|
|
stream.read(&mZoneSurfaces[i]);
|
|
|
|
// Zone static meshes
|
|
if (fileVersion >= 12)
|
|
{
|
|
stream.read(&vectorSize);
|
|
|
|
mZoneStaticMeshes.setSize(vectorSize);
|
|
for (i = 0; i < mZoneStaticMeshes.size(); i++)
|
|
stream.read(&mZoneStaticMeshes[i]);
|
|
}
|
|
|
|
// mZonePortalList;
|
|
stream.read(&vectorSize);
|
|
mZonePortalList.setSize(vectorSize);
|
|
for(i = 0; i < mZonePortalList.size(); i++)
|
|
stream.read(&mZonePortalList[i]);
|
|
|
|
// mPortals
|
|
stream.read(&vectorSize);
|
|
mPortals.setSize(vectorSize);
|
|
for(i = 0; i < mPortals.size(); i++)
|
|
{
|
|
stream.read(&mPortals[i].planeIndex);
|
|
stream.read(&mPortals[i].triFanCount);
|
|
stream.read(&mPortals[i].triFanStart);
|
|
stream.read(&mPortals[i].zoneFront);
|
|
stream.read(&mPortals[i].zoneBack);
|
|
}
|
|
|
|
// mSurfaces
|
|
stream.read(&vectorSize);
|
|
mSurfaces.setSize(vectorSize);
|
|
mLMTexGenEQs.setSize(vectorSize);
|
|
for(i = 0; i < mSurfaces.size(); i++)
|
|
{
|
|
stream.read(&mSurfaces[i].windingStart);
|
|
|
|
if (fileVersion >= 13)
|
|
stream.read(&mSurfaces[i].windingCount);
|
|
else
|
|
{
|
|
U8 count;
|
|
stream.read(&count);
|
|
mSurfaces[i].windingCount = (U32)count;
|
|
}
|
|
|
|
stream.read(&mSurfaces[i].planeIndex);
|
|
stream.read(&mSurfaces[i].textureIndex);
|
|
stream.read(&mSurfaces[i].texGenIndex);
|
|
stream.read(&mSurfaces[i].surfaceFlags);
|
|
stream.read(&mSurfaces[i].fanMask);
|
|
readLMapTexGen(stream, mLMTexGenEQs[i].planeX, mLMTexGenEQs[i].planeY);
|
|
|
|
stream.read(&mSurfaces[i].lightCount);
|
|
stream.read(&mSurfaces[i].lightStateInfoStart);
|
|
|
|
if (fileVersion >= 13)
|
|
{
|
|
stream.read(&mSurfaces[i].mapOffsetX);
|
|
stream.read(&mSurfaces[i].mapOffsetY);
|
|
stream.read(&mSurfaces[i].mapSizeX);
|
|
stream.read(&mSurfaces[i].mapSizeY);
|
|
}
|
|
else
|
|
{
|
|
U8 offX, offY, sizeX, sizeY;
|
|
stream.read(&offX);
|
|
stream.read(&offY);
|
|
stream.read(&sizeX);
|
|
stream.read(&sizeY);
|
|
|
|
mSurfaces[i].mapOffsetX = (U32)offX;
|
|
mSurfaces[i].mapOffsetY = (U32)offY;
|
|
mSurfaces[i].mapSizeX = (U32)sizeX;
|
|
mSurfaces[i].mapSizeY = (U32)sizeY;
|
|
}
|
|
|
|
if (fileVersion == 1 || fileVersion >= 12)
|
|
stream.read(&mSurfaces[i].unused);
|
|
}
|
|
|
|
// NormalLMapIndices
|
|
stream.read(&vectorSize);
|
|
mNormalLMapIndices.setSize(vectorSize);
|
|
for (U32 i = 0; i < mNormalLMapIndices.size(); i++)
|
|
{
|
|
if (fileVersion >= 13)
|
|
stream.read(&mNormalLMapIndices[i]);
|
|
else
|
|
{
|
|
U8 index = 0;
|
|
stream.read(&index);
|
|
|
|
mNormalLMapIndices[i] = (U32)index;
|
|
}
|
|
}
|
|
|
|
// AlarmLMapIndices
|
|
stream.read(&vectorSize);
|
|
mAlarmLMapIndices.setSize(vectorSize);
|
|
for (U32 i = 0; i < mAlarmLMapIndices.size(); i++)
|
|
{
|
|
if (fileVersion >= 13)
|
|
stream.read(&mAlarmLMapIndices[i]);
|
|
else
|
|
{
|
|
U8 index = 0;
|
|
stream.read(&index);
|
|
|
|
mAlarmLMapIndices[i] = (U32)index;
|
|
}
|
|
}
|
|
|
|
// mNullSurfaces
|
|
stream.read(&vectorSize);
|
|
mNullSurfaces.setSize(vectorSize);
|
|
for(i = 0; i < mNullSurfaces.size(); i++)
|
|
{
|
|
stream.read(&mNullSurfaces[i].windingStart);
|
|
stream.read(&mNullSurfaces[i].planeIndex);
|
|
stream.read(&mNullSurfaces[i].surfaceFlags);
|
|
|
|
if (fileVersion >= 13)
|
|
stream.read(&mNullSurfaces[i].windingCount);
|
|
else
|
|
{
|
|
U8 count;
|
|
stream.read(&count);
|
|
mNullSurfaces[i].windingCount = (U32)count;
|
|
}
|
|
}
|
|
|
|
// mLightmaps
|
|
stream.read(&vectorSize);
|
|
mLightmaps.setSize(vectorSize);
|
|
mLightDirMaps.setSize(vectorSize);
|
|
mLightmapKeep.setSize(vectorSize);
|
|
for(i = 0; i < mLightmaps.size(); i++)
|
|
{
|
|
mLightmaps[i] = new GBitmap;
|
|
mLightmaps[i]->readPNG(stream);
|
|
|
|
if (fileVersion == 1 || fileVersion >= 12)
|
|
{
|
|
mLightDirMaps[i] = new GBitmap;
|
|
mLightDirMaps[i]->readPNG(stream);
|
|
}
|
|
else
|
|
{
|
|
mLightDirMaps[i] = new GBitmap(*mLightmaps[i]);
|
|
|
|
VectorF normal(0.0f, 0.0f, 1.0f);
|
|
for (U32 j = 0; j < mLightDirMaps[i]->getHeight(); j++)
|
|
{
|
|
for (U32 k = 0; k < mLightDirMaps[i]->getWidth(); k++)
|
|
{
|
|
U8 * data = mLightDirMaps[i]->getAddress(j,k);
|
|
data[0] = 127 + normal.x * 128;
|
|
data[1] = 127 + normal.y * 128;
|
|
data[2] = 127 + normal.z * 128;
|
|
}
|
|
}
|
|
}
|
|
|
|
stream.read(&mLightmapKeep[i]);
|
|
}
|
|
|
|
|
|
// mSolidLeafSurfaces
|
|
stream.read(&vectorSize);
|
|
mSolidLeafSurfaces.setSize(vectorSize);
|
|
for(i = 0; i < mSolidLeafSurfaces.size(); i++)
|
|
{
|
|
stream.read(&mSolidLeafSurfaces[i]);
|
|
}
|
|
|
|
// mAnimatedLights
|
|
mNumTriggerableLights = 0;
|
|
stream.read(&vectorSize);
|
|
mAnimatedLights.setSize(vectorSize);
|
|
for(i = 0; i < mAnimatedLights.size(); i++)
|
|
{
|
|
stream.read(&mAnimatedLights[i].nameIndex);
|
|
stream.read(&mAnimatedLights[i].stateIndex);
|
|
stream.read(&mAnimatedLights[i].stateCount);
|
|
stream.read(&mAnimatedLights[i].flags);
|
|
stream.read(&mAnimatedLights[i].duration);
|
|
|
|
if((mAnimatedLights[i].flags & AnimationAmbient) == 0)
|
|
mNumTriggerableLights++;
|
|
}
|
|
|
|
// mLightStates
|
|
stream.read(&vectorSize);
|
|
mLightStates.setSize(vectorSize);
|
|
for(i = 0; i < mLightStates.size(); i++)
|
|
{
|
|
stream.read(&mLightStates[i].red);
|
|
stream.read(&mLightStates[i].green);
|
|
stream.read(&mLightStates[i].blue);
|
|
stream.read(&mLightStates[i].activeTime);
|
|
stream.read(&mLightStates[i].dataIndex);
|
|
stream.read(&mLightStates[i].dataCount);
|
|
}
|
|
|
|
// mStateData
|
|
stream.read(&vectorSize);
|
|
mStateData.setSize(vectorSize);
|
|
for(i = 0; i < mStateData.size(); i++)
|
|
{
|
|
stream.read(&mStateData[i].surfaceIndex);
|
|
stream.read(&mStateData[i].mapIndex);
|
|
stream.read(&mStateData[i].lightStateIndex);
|
|
}
|
|
|
|
// mStateDataBuffer
|
|
stream.read(&vectorSize);
|
|
mStateDataBuffer.setSize(vectorSize);
|
|
U32 flags;
|
|
stream.read(&flags);
|
|
stream.read(mStateDataBuffer.size(), mStateDataBuffer.address());
|
|
|
|
// mNameBuffer
|
|
stream.read(&vectorSize);
|
|
mNameBuffer.setSize(vectorSize);
|
|
stream.read(mNameBuffer.size(), mNameBuffer.address());
|
|
|
|
// mSubObjects
|
|
stream.read(&vectorSize);
|
|
mSubObjects.setSize(vectorSize);
|
|
for (i = 0; i < mSubObjects.size(); i++) {
|
|
InteriorSubObject* iso = InteriorSubObject::readISO(stream);
|
|
AssertFatal(iso != NULL, "Error, bad sub object in stream!");
|
|
mSubObjects[i] = iso;
|
|
}
|
|
|
|
// Convex hulls
|
|
stream.read(&vectorSize);
|
|
mConvexHulls.setSize(vectorSize);
|
|
for(i = 0; i < mConvexHulls.size(); i++)
|
|
{
|
|
stream.read(&mConvexHulls[i].hullStart);
|
|
stream.read(&mConvexHulls[i].hullCount);
|
|
stream.read(&mConvexHulls[i].minX);
|
|
stream.read(&mConvexHulls[i].maxX);
|
|
stream.read(&mConvexHulls[i].minY);
|
|
stream.read(&mConvexHulls[i].maxY);
|
|
stream.read(&mConvexHulls[i].minZ);
|
|
stream.read(&mConvexHulls[i].maxZ);
|
|
stream.read(&mConvexHulls[i].surfaceStart);
|
|
stream.read(&mConvexHulls[i].surfaceCount);
|
|
stream.read(&mConvexHulls[i].planeStart);
|
|
stream.read(&mConvexHulls[i].polyListPlaneStart);
|
|
stream.read(&mConvexHulls[i].polyListPointStart);
|
|
stream.read(&mConvexHulls[i].polyListStringStart);
|
|
|
|
if (fileVersion >= 12)
|
|
stream.read(&mConvexHulls[i].staticMesh);
|
|
}
|
|
|
|
// Convex hull emit strings
|
|
stream.read(&vectorSize);
|
|
mConvexHullEmitStrings.setSize(vectorSize);
|
|
stream.read(mConvexHullEmitStrings.size(), mConvexHullEmitStrings.address());
|
|
|
|
// Hull indices
|
|
stream.read(&vectorSize);
|
|
mHullIndices.setSize(vectorSize);
|
|
for(i = 0; i < mHullIndices.size(); i++)
|
|
stream.read(&mHullIndices[i]);
|
|
|
|
// Hull plane indices
|
|
stream.read(&vectorSize);
|
|
mHullPlaneIndices.setSize(vectorSize);
|
|
for(i = 0; i < mHullPlaneIndices.size(); i++)
|
|
stream.read(&mHullPlaneIndices[i]);
|
|
|
|
// Hull emit string indices
|
|
stream.read(&vectorSize);
|
|
mHullEmitStringIndices.setSize(vectorSize);
|
|
for(i = 0; i < mHullEmitStringIndices.size(); i++)
|
|
stream.read(&mHullEmitStringIndices[i]);
|
|
|
|
// Hull surface indices
|
|
stream.read(&vectorSize);
|
|
mHullSurfaceIndices.setSize(vectorSize);
|
|
for(i = 0; i < mHullSurfaceIndices.size(); i++)
|
|
stream.read(&mHullSurfaceIndices[i]);
|
|
|
|
// PolyList planes
|
|
stream.read(&vectorSize);
|
|
mPolyListPlanes.setSize(vectorSize);
|
|
for(i = 0; i < mPolyListPlanes.size(); i++)
|
|
stream.read(&mPolyListPlanes[i]);
|
|
|
|
// PolyList points
|
|
stream.read(&vectorSize);
|
|
mPolyListPoints.setSize(vectorSize);
|
|
for(i = 0; i < mPolyListPoints.size(); i++)
|
|
stream.read(&mPolyListPoints[i]);
|
|
|
|
// PolyList strings
|
|
stream.read(&vectorSize);
|
|
mPolyListStrings.setSize(vectorSize);
|
|
for(i = 0; i < mPolyListStrings.size(); i++)
|
|
stream.read(&mPolyListStrings[i]);
|
|
|
|
// Coord bins
|
|
for(i = 0; i < NumCoordBins * NumCoordBins; i++)
|
|
{
|
|
stream.read(&mCoordBins[i].binStart);
|
|
stream.read(&mCoordBins[i].binCount);
|
|
}
|
|
|
|
// Coord bin indices
|
|
stream.read(&vectorSize);
|
|
mCoordBinIndices.setSize(vectorSize);
|
|
for(i = 0; i < mCoordBinIndices.size(); i++)
|
|
stream.read(&mCoordBinIndices[i]);
|
|
|
|
// Coord bin mode
|
|
stream.read(&mCoordBinMode);
|
|
|
|
// Ambient colors
|
|
stream.read(&mBaseAmbient);
|
|
stream.read(&mAlarmAmbient);
|
|
|
|
if (fileVersion >= 10)
|
|
{
|
|
// Static meshes
|
|
stream.read(&vectorSize);
|
|
|
|
mStaticMeshes.setSize(vectorSize);
|
|
for (i = 0; i < mStaticMeshes.size(); i++)
|
|
{
|
|
mStaticMeshes[i] = new ConstructorSimpleMesh;
|
|
mStaticMeshes[i]->read(stream);
|
|
}
|
|
}
|
|
|
|
if (fileVersion >= 11)
|
|
{
|
|
// Normals
|
|
stream.read(&vectorSize);
|
|
|
|
mNormals.setSize(vectorSize);
|
|
for (i = 0; i < mNormals.size(); i++)
|
|
mathRead(stream, &mNormals[i]);
|
|
|
|
// TexMatrices
|
|
stream.read(&vectorSize);
|
|
|
|
mTexMatrices.setSize(vectorSize);
|
|
for (i = 0; i < mTexMatrices.size(); i++)
|
|
{
|
|
stream.read(&mTexMatrices[i].T);
|
|
stream.read(&mTexMatrices[i].N);
|
|
stream.read(&mTexMatrices[i].B);
|
|
}
|
|
|
|
// TexMatIndices
|
|
stream.read(&vectorSize);
|
|
|
|
mTexMatIndices.setSize(vectorSize);
|
|
for (i = 0; i < mTexMatIndices.size(); i++)
|
|
stream.read(&mTexMatIndices[i]);
|
|
}
|
|
|
|
// For future expandability
|
|
U32 dummy;
|
|
if (fileVersion < 10)
|
|
{
|
|
stream.read(&dummy); if (dummy != 0) return false;
|
|
}
|
|
if (fileVersion < 11)
|
|
{
|
|
stream.read(&dummy); if (dummy != 0) return false;
|
|
stream.read(&dummy); if (dummy != 0) return false;
|
|
}
|
|
|
|
//
|
|
// Support for interior light map border sizes.
|
|
//
|
|
U32 extendedlightmapdata;
|
|
stream.read(&extendedlightmapdata);
|
|
if(extendedlightmapdata == 1)
|
|
{
|
|
stream.read(&mLightMapBorderSize);
|
|
|
|
//future expansion under current block (avoid using too
|
|
//many of the above expansion slots by allowing nested
|
|
//blocks)...
|
|
stream.read(&dummy); if (dummy != 0) return false;
|
|
}
|
|
|
|
|
|
// Setup the zone planes
|
|
setupZonePlanes();
|
|
truncateZoneTree();
|
|
|
|
buildSurfaceZones();
|
|
|
|
return (stream.getStatus() == Stream::Ok);
|
|
}
|
|
|
|
bool Interior::write(Stream& stream) const
|
|
{
|
|
AssertFatal(stream.hasCapability(Stream::StreamWrite), "Interior::write: non-write capable stream passed");
|
|
AssertFatal(stream.getStatus() == Stream::Ok, "Interior::write: Error, stream in inconsistent state");
|
|
|
|
U32 i;
|
|
|
|
// Version this stream
|
|
stream.write(smFileVersion);
|
|
|
|
stream.write(mDetailLevel);
|
|
stream.write(mMinPixels);
|
|
mathWrite(stream, mBoundingBox);
|
|
mathWrite(stream, mBoundingSphere);
|
|
|
|
stream.write(mHasAlarmState);
|
|
stream.write(mNumLightStateEntries);
|
|
|
|
// Now write out our data vectors. Remember, for cross-platform capability, no
|
|
// structure writing is allowed...
|
|
|
|
// mPlanes
|
|
writePlaneVector(stream);
|
|
|
|
// mPoints
|
|
stream.write(mPoints.size());
|
|
for (i = 0; i < mPoints.size(); i++)
|
|
mathWrite(stream, mPoints[i].point);
|
|
|
|
// mPointVisibility
|
|
stream.write(mPointVisibility.size());
|
|
stream.write(mPointVisibility.size(), mPointVisibility.address());
|
|
|
|
// mTexGenEQs
|
|
stream.write(mTexGenEQs.size());
|
|
for (i = 0; i < mTexGenEQs.size(); i++) {
|
|
mathWrite(stream, mTexGenEQs[i].planeX);
|
|
mathWrite(stream, mTexGenEQs[i].planeY);
|
|
}
|
|
|
|
// mBSPNodes;
|
|
stream.write(mBSPNodes.size());
|
|
for (i = 0; i < mBSPNodes.size(); i++) {
|
|
stream.write(mBSPNodes[i].planeIndex);
|
|
stream.write(mBSPNodes[i].frontIndex);
|
|
stream.write(mBSPNodes[i].backIndex);
|
|
}
|
|
|
|
// mBSPSolidLeaves
|
|
stream.write(mBSPSolidLeaves.size());
|
|
for (i = 0; i < mBSPSolidLeaves.size(); i++) {
|
|
stream.write(mBSPSolidLeaves[i].surfaceIndex);
|
|
stream.write(mBSPSolidLeaves[i].surfaceCount);
|
|
}
|
|
|
|
// MaterialList
|
|
mMaterialList->write(stream);
|
|
|
|
// mWindings
|
|
stream.write(mWindings.size());
|
|
for (i = 0; i < mWindings.size(); i++) {
|
|
stream.write(mWindings[i]);
|
|
}
|
|
|
|
// mWindingIndices
|
|
stream.write(mWindingIndices.size());
|
|
for (i = 0; i < mWindingIndices.size(); i++) {
|
|
stream.write(mWindingIndices[i].windingStart);
|
|
stream.write(mWindingIndices[i].windingCount);
|
|
}
|
|
|
|
// mEdges
|
|
if (smFileVersion >= 12)
|
|
{
|
|
stream.write(mEdges.size());
|
|
for (i = 0; i < mEdges.size(); i++)
|
|
{
|
|
stream.write(mEdges[i].vertexes[0]);
|
|
stream.write(mEdges[i].vertexes[1]);
|
|
stream.write(mEdges[i].faces[0]);
|
|
stream.write(mEdges[i].faces[1]);
|
|
}
|
|
}
|
|
|
|
// mZones
|
|
stream.write(mZones.size());
|
|
for (i = 0; i < mZones.size(); i++) {
|
|
stream.write(mZones[i].portalStart);
|
|
stream.write(mZones[i].portalCount);
|
|
stream.write(mZones[i].surfaceStart);
|
|
stream.write(mZones[i].surfaceCount);
|
|
|
|
if (smFileVersion >= 12)
|
|
{
|
|
stream.write(mZones[i].staticMeshStart);
|
|
stream.write(mZones[i].staticMeshCount);
|
|
}
|
|
|
|
stream.write(mZones[i].flags);
|
|
}
|
|
|
|
// Zone surfaces
|
|
stream.write(mZoneSurfaces.size());
|
|
for (i = 0; i < mZoneSurfaces.size(); i++)
|
|
stream.write(mZoneSurfaces[i]);
|
|
|
|
// Zone static meshes
|
|
if (smFileVersion >= 12)
|
|
{
|
|
stream.write(mZoneStaticMeshes.size());
|
|
for (i = 0; i < mZoneStaticMeshes.size(); i++)
|
|
stream.write(mZoneStaticMeshes[i]);
|
|
}
|
|
|
|
// mZonePortalList;
|
|
stream.write(mZonePortalList.size());
|
|
for (i = 0; i < mZonePortalList.size(); i++)
|
|
stream.write(mZonePortalList[i]);
|
|
|
|
// mPortals
|
|
stream.write(mPortals.size());
|
|
for (i = 0; i < mPortals.size(); i++) {
|
|
stream.write(mPortals[i].planeIndex);
|
|
stream.write(mPortals[i].triFanCount);
|
|
stream.write(mPortals[i].triFanStart);
|
|
stream.write(mPortals[i].zoneFront);
|
|
stream.write(mPortals[i].zoneBack);
|
|
}
|
|
|
|
// mSurfaces
|
|
stream.write(mSurfaces.size());
|
|
for (i = 0; i < mSurfaces.size(); i++) {
|
|
stream.write(mSurfaces[i].windingStart);
|
|
|
|
if (smFileVersion >= 13)
|
|
stream.write(mSurfaces[i].windingCount);
|
|
else
|
|
{
|
|
U8 count = (U8)mSurfaces[i].windingCount;
|
|
stream.write(count);
|
|
}
|
|
|
|
stream.write(mSurfaces[i].planeIndex);
|
|
stream.write(mSurfaces[i].textureIndex);
|
|
stream.write(mSurfaces[i].texGenIndex);
|
|
stream.write(mSurfaces[i].surfaceFlags);
|
|
stream.write(mSurfaces[i].fanMask);
|
|
writeLMapTexGen(stream, mLMTexGenEQs[i].planeX, mLMTexGenEQs[i].planeY);
|
|
|
|
stream.write(mSurfaces[i].lightCount);
|
|
stream.write(mSurfaces[i].lightStateInfoStart);
|
|
|
|
if (smFileVersion >= 13)
|
|
{
|
|
stream.write(mSurfaces[i].mapOffsetX);
|
|
stream.write(mSurfaces[i].mapOffsetY);
|
|
stream.write(mSurfaces[i].mapSizeX);
|
|
stream.write(mSurfaces[i].mapSizeY);
|
|
}
|
|
else
|
|
{
|
|
U8 offX, offY, sizeX, sizeY;
|
|
offX = (U8)mSurfaces[i].mapOffsetX;
|
|
offY = (U8)mSurfaces[i].mapOffsetY;
|
|
sizeX = (U8)mSurfaces[i].mapSizeX;
|
|
sizeY = (U8)mSurfaces[i].mapSizeY;
|
|
|
|
stream.write(offX);
|
|
stream.write(offY);
|
|
stream.write(sizeX);
|
|
stream.write(sizeY);
|
|
}
|
|
|
|
if (smFileVersion == 1 || smFileVersion >= 12)
|
|
stream.write(mSurfaces[i].unused);
|
|
}
|
|
// NormalLMapIndices
|
|
stream.write(mNormalLMapIndices.size());
|
|
for (U32 i = 0; i < mNormalLMapIndices.size(); i++)
|
|
{
|
|
if (smFileVersion >= 13)
|
|
stream.write(mNormalLMapIndices[i]);
|
|
else
|
|
{
|
|
U8 index = (U8)mNormalLMapIndices[i];
|
|
stream.write(index);
|
|
}
|
|
}
|
|
|
|
// AlarmLMapIndices
|
|
stream.write(mAlarmLMapIndices.size());
|
|
for (U32 i = 0; i < mAlarmLMapIndices.size(); i++)
|
|
{
|
|
if (smFileVersion >= 13)
|
|
stream.write(mAlarmLMapIndices[i]);
|
|
else
|
|
{
|
|
U8 index = (U8)mAlarmLMapIndices[i];
|
|
stream.write(index);
|
|
}
|
|
}
|
|
|
|
|
|
// mNullSurfaces
|
|
stream.write(mNullSurfaces.size());
|
|
for (i = 0; i < mNullSurfaces.size(); i++) {
|
|
stream.write(mNullSurfaces[i].windingStart);
|
|
stream.write(mNullSurfaces[i].planeIndex);
|
|
stream.write(mNullSurfaces[i].surfaceFlags);
|
|
|
|
if (smFileVersion >= 13)
|
|
stream.write(mNullSurfaces[i].windingCount);
|
|
else
|
|
{
|
|
U8 count = (U8)mNullSurfaces[i].windingCount;
|
|
stream.write(count);
|
|
}
|
|
}
|
|
|
|
// mLightmaps
|
|
stream.write(mLightmaps.size());
|
|
for(i = 0; i < mLightmaps.size(); i++)
|
|
{
|
|
mLightmaps[i]->writePNG(stream);
|
|
|
|
if (smFileVersion == 1 || smFileVersion >= 12)
|
|
mLightDirMaps[i]->writePNG(stream);
|
|
stream.write(mLightmapKeep[i]);
|
|
}
|
|
|
|
// mSolidLeafSurfaces
|
|
stream.write(mSolidLeafSurfaces.size());
|
|
for(i = 0; i < mSolidLeafSurfaces.size(); i++)
|
|
{
|
|
stream.write(mSolidLeafSurfaces[i]);
|
|
}
|
|
|
|
|
|
// Animated lights
|
|
stream.write(mAnimatedLights.size());
|
|
for(i = 0; i < mAnimatedLights.size(); i++)
|
|
{
|
|
stream.write(mAnimatedLights[i].nameIndex);
|
|
stream.write(mAnimatedLights[i].stateIndex);
|
|
stream.write(mAnimatedLights[i].stateCount);
|
|
stream.write(mAnimatedLights[i].flags);
|
|
stream.write(mAnimatedLights[i].duration);
|
|
}
|
|
|
|
stream.write(mLightStates.size());
|
|
for(i = 0; i < mLightStates.size(); i++)
|
|
{
|
|
stream.write(mLightStates[i].red);
|
|
stream.write(mLightStates[i].green);
|
|
stream.write(mLightStates[i].blue);
|
|
stream.write(mLightStates[i].activeTime);
|
|
stream.write(mLightStates[i].dataIndex);
|
|
stream.write(mLightStates[i].dataCount);
|
|
}
|
|
|
|
// mStateData
|
|
stream.write(mStateData.size());
|
|
for(i = 0; i < mStateData.size(); i++)
|
|
{
|
|
stream.write(mStateData[i].surfaceIndex);
|
|
stream.write(mStateData[i].mapIndex);
|
|
stream.write(mStateData[i].lightStateIndex);
|
|
}
|
|
|
|
// mStateDataBuffer: Note: superfluous 0 is for flags in future versions.
|
|
// that may add compression. This way, we can maintain
|
|
// compatability with previous versions.
|
|
stream.write(mStateDataBuffer.size());
|
|
stream.write(U32(0));
|
|
stream.write(mStateDataBuffer.size(), mStateDataBuffer.address());
|
|
|
|
// mNameBuffer
|
|
stream.write(mNameBuffer.size());
|
|
stream.write(mNameBuffer.size(), mNameBuffer.address());
|
|
|
|
// mSubObjects
|
|
stream.write(mSubObjects.size());
|
|
for (i = 0; i < mSubObjects.size(); i++) {
|
|
bool writeSuccess = mSubObjects[i]->writeISO(stream);
|
|
AssertFatal(writeSuccess == true, "Error writing sub object to stream!");
|
|
}
|
|
|
|
// Convex hulls
|
|
stream.write(mConvexHulls.size());
|
|
for(i = 0; i < mConvexHulls.size(); i++)
|
|
{
|
|
stream.write(mConvexHulls[i].hullStart);
|
|
stream.write(mConvexHulls[i].hullCount);
|
|
stream.write(mConvexHulls[i].minX);
|
|
stream.write(mConvexHulls[i].maxX);
|
|
stream.write(mConvexHulls[i].minY);
|
|
stream.write(mConvexHulls[i].maxY);
|
|
stream.write(mConvexHulls[i].minZ);
|
|
stream.write(mConvexHulls[i].maxZ);
|
|
stream.write(mConvexHulls[i].surfaceStart);
|
|
stream.write(mConvexHulls[i].surfaceCount);
|
|
stream.write(mConvexHulls[i].planeStart);
|
|
stream.write(mConvexHulls[i].polyListPlaneStart);
|
|
stream.write(mConvexHulls[i].polyListPointStart);
|
|
stream.write(mConvexHulls[i].polyListStringStart);
|
|
|
|
if (smFileVersion >= 12)
|
|
stream.write(mConvexHulls[i].staticMesh);
|
|
}
|
|
|
|
stream.write(mConvexHullEmitStrings.size());
|
|
stream.write(mConvexHullEmitStrings.size(), mConvexHullEmitStrings.address());
|
|
|
|
stream.write(mHullIndices.size());
|
|
for(i = 0; i < mHullIndices.size(); i++)
|
|
stream.write(mHullIndices[i]);
|
|
|
|
stream.write(mHullPlaneIndices.size());
|
|
for(i = 0; i < mHullPlaneIndices.size(); i++)
|
|
stream.write(mHullPlaneIndices[i]);
|
|
|
|
stream.write(mHullEmitStringIndices.size());
|
|
for(i = 0; i < mHullEmitStringIndices.size(); i++)
|
|
stream.write(mHullEmitStringIndices[i]);
|
|
|
|
stream.write(mHullSurfaceIndices.size());
|
|
for(i = 0; i < mHullSurfaceIndices.size(); i++)
|
|
stream.write(mHullSurfaceIndices[i]);
|
|
|
|
stream.write(mPolyListPlanes.size());
|
|
for(i = 0; i < mPolyListPlanes.size(); i++)
|
|
stream.write(mPolyListPlanes[i]);
|
|
|
|
stream.write(mPolyListPoints.size());
|
|
for(i = 0; i < mPolyListPoints.size(); i++)
|
|
stream.write(mPolyListPoints[i]);
|
|
|
|
stream.write(mPolyListStrings.size());
|
|
for(i = 0; i < mPolyListStrings.size(); i++)
|
|
stream.write(mPolyListStrings[i]);
|
|
|
|
// Coord bins
|
|
for(i = 0; i < NumCoordBins * NumCoordBins; i++)
|
|
{
|
|
stream.write(mCoordBins[i].binStart);
|
|
stream.write(mCoordBins[i].binCount);
|
|
}
|
|
stream.write(mCoordBinIndices.size());
|
|
for(i = 0; i < mCoordBinIndices.size(); i++)
|
|
stream.write(mCoordBinIndices[i]);
|
|
stream.write(mCoordBinMode);
|
|
|
|
// Ambient colors...
|
|
stream.write(mBaseAmbient);
|
|
stream.write(mAlarmAmbient);
|
|
|
|
if (smFileVersion >= 10)
|
|
{
|
|
// Static meshes
|
|
stream.write(mStaticMeshes.size());
|
|
for (i = 0; i < mStaticMeshes.size(); i++)
|
|
mStaticMeshes[i]->write(stream);
|
|
}
|
|
else
|
|
stream.write(U32(0));
|
|
|
|
if (smFileVersion >= 11)
|
|
{
|
|
// Normals
|
|
stream.write(mNormals.size());
|
|
for (i = 0; i < mNormals.size(); i++)
|
|
mathWrite(stream, mNormals[i]);
|
|
|
|
// TexMatrices
|
|
stream.write(mTexMatrices.size());
|
|
for (i = 0; i < mTexMatrices.size(); i++)
|
|
{
|
|
stream.write(mTexMatrices[i].T);
|
|
stream.write(mTexMatrices[i].N);
|
|
stream.write(mTexMatrices[i].B);
|
|
}
|
|
|
|
// TexMatIndices
|
|
stream.write(mTexMatIndices.size());
|
|
for (i = 0; i < mTexMatIndices.size(); i++)
|
|
stream.write(mTexMatIndices[i]);
|
|
}
|
|
else
|
|
{
|
|
stream.write(U32(0));
|
|
stream.write(U32(0));
|
|
}
|
|
|
|
//
|
|
// Support for interior light map border sizes.
|
|
//
|
|
if(mLightMapBorderSize > 0)
|
|
{
|
|
stream.write(U32(1));//flag new block...
|
|
stream.write(U32(mLightMapBorderSize));//new block data..
|
|
|
|
//future expansion under current block (avoid using too
|
|
//many of the above expansion slots by allowing nested
|
|
//blocks)...
|
|
stream.write(U32(0));
|
|
}
|
|
else
|
|
{
|
|
stream.write(U32(0));
|
|
}
|
|
|
|
return stream.getStatus() == Stream::Ok;
|
|
}
|
|
|
|
bool Interior::readVehicleCollision(Stream& stream)
|
|
{
|
|
AssertFatal(stream.hasCapability(Stream::StreamRead), "Interior::read: non-read capable stream passed");
|
|
AssertFatal(stream.getStatus() == Stream::Ok, "Interior::read: Error, stream in inconsistent state");
|
|
|
|
S32 i;
|
|
|
|
// Version this stream. We only load stream of the current version
|
|
U32 fileVersion;
|
|
stream.read(&fileVersion);
|
|
if (fileVersion > smFileVersion) {
|
|
Con::errorf(ConsoleLogEntry::General, "Interior::read: incompatible file version found.");
|
|
return false;
|
|
}
|
|
|
|
U32 vectorSize;
|
|
|
|
// Convex hulls
|
|
stream.read(&vectorSize);
|
|
mVehicleConvexHulls.setSize(vectorSize);
|
|
for(i = 0; i < mVehicleConvexHulls.size(); i++)
|
|
{
|
|
stream.read(&mVehicleConvexHulls[i].hullStart);
|
|
stream.read(&mVehicleConvexHulls[i].hullCount);
|
|
stream.read(&mVehicleConvexHulls[i].minX);
|
|
stream.read(&mVehicleConvexHulls[i].maxX);
|
|
stream.read(&mVehicleConvexHulls[i].minY);
|
|
stream.read(&mVehicleConvexHulls[i].maxY);
|
|
stream.read(&mVehicleConvexHulls[i].minZ);
|
|
stream.read(&mVehicleConvexHulls[i].maxZ);
|
|
stream.read(&mVehicleConvexHulls[i].surfaceStart);
|
|
stream.read(&mVehicleConvexHulls[i].surfaceCount);
|
|
stream.read(&mVehicleConvexHulls[i].planeStart);
|
|
stream.read(&mVehicleConvexHulls[i].polyListPlaneStart);
|
|
stream.read(&mVehicleConvexHulls[i].polyListPointStart);
|
|
stream.read(&mVehicleConvexHulls[i].polyListStringStart);
|
|
}
|
|
|
|
stream.read(&vectorSize);
|
|
mVehicleConvexHullEmitStrings.setSize(vectorSize);
|
|
stream.read(mVehicleConvexHullEmitStrings.size(), mVehicleConvexHullEmitStrings.address());
|
|
|
|
stream.read(&vectorSize);
|
|
mVehicleHullIndices.setSize(vectorSize);
|
|
for(i = 0; i < mVehicleHullIndices.size(); i++)
|
|
stream.read(&mVehicleHullIndices[i]);
|
|
|
|
stream.read(&vectorSize);
|
|
mVehicleHullPlaneIndices.setSize(vectorSize);
|
|
for(i = 0; i < mVehicleHullPlaneIndices.size(); i++)
|
|
stream.read(&mVehicleHullPlaneIndices[i]);
|
|
|
|
stream.read(&vectorSize);
|
|
mVehicleHullEmitStringIndices.setSize(vectorSize);
|
|
for(i = 0; i < mVehicleHullEmitStringIndices.size(); i++)
|
|
stream.read(&mVehicleHullEmitStringIndices[i]);
|
|
|
|
stream.read(&vectorSize);
|
|
mVehicleHullSurfaceIndices.setSize(vectorSize);
|
|
for(i = 0; i < mVehicleHullSurfaceIndices.size(); i++)
|
|
stream.read(&mVehicleHullSurfaceIndices[i]);
|
|
|
|
stream.read(&vectorSize);
|
|
mVehiclePolyListPlanes.setSize(vectorSize);
|
|
for(i = 0; i < mVehiclePolyListPlanes.size(); i++)
|
|
stream.read(&mVehiclePolyListPlanes[i]);
|
|
|
|
stream.read(&vectorSize);
|
|
mVehiclePolyListPoints.setSize(vectorSize);
|
|
for(i = 0; i < mVehiclePolyListPoints.size(); i++)
|
|
stream.read(&mVehiclePolyListPoints[i]);
|
|
|
|
stream.read(&vectorSize);
|
|
mVehiclePolyListStrings.setSize(vectorSize);
|
|
for(i = 0; i < mVehiclePolyListStrings.size(); i++)
|
|
stream.read(&mVehiclePolyListStrings[i]);
|
|
|
|
stream.read(&vectorSize);
|
|
mVehicleNullSurfaces.setSize(vectorSize);
|
|
for(i = 0; i < mVehicleNullSurfaces.size(); i++)
|
|
{
|
|
stream.read(&mVehicleNullSurfaces[i].windingStart);
|
|
stream.read(&mVehicleNullSurfaces[i].planeIndex);
|
|
stream.read(&mVehicleNullSurfaces[i].surfaceFlags);
|
|
stream.read(&mVehicleNullSurfaces[i].windingCount);
|
|
}
|
|
|
|
stream.read(&vectorSize);
|
|
mVehiclePoints.setSize(vectorSize);
|
|
for(i = 0; i < mVehiclePoints.size(); i++)
|
|
mathRead(stream, &mVehiclePoints[i].point);
|
|
|
|
stream.read(&vectorSize);
|
|
mVehiclePlanes.setSize(vectorSize);
|
|
for(i = 0; i < mVehiclePlanes.size(); i++)
|
|
mathRead(stream, &mVehiclePlanes[i]);
|
|
|
|
stream.read(&vectorSize);
|
|
mVehicleWindings.setSize(vectorSize);
|
|
for(i = 0; i < mVehicleWindings.size(); i++)
|
|
{
|
|
stream.read(&mVehicleWindings[i]);
|
|
}
|
|
|
|
stream.read(&vectorSize);
|
|
mVehicleWindingIndices.setSize(vectorSize);
|
|
for(i = 0; i < mVehicleWindingIndices.size(); i++)
|
|
{
|
|
stream.read(&mVehicleWindingIndices[i].windingStart);
|
|
stream.read(&mVehicleWindingIndices[i].windingCount);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool Interior::writeVehicleCollision(Stream& stream) const
|
|
{
|
|
AssertFatal(stream.hasCapability(Stream::StreamWrite), "Interior::write: non-write capable stream passed");
|
|
AssertFatal(stream.getStatus() == Stream::Ok, "Interior::write: Error, stream in inconsistent state");
|
|
|
|
U32 i;
|
|
|
|
// Version this stream
|
|
stream.write(smFileVersion);
|
|
|
|
// Convex hulls
|
|
stream.write(mVehicleConvexHulls.size());
|
|
for(i = 0; i < mVehicleConvexHulls.size(); i++)
|
|
{
|
|
stream.write(mVehicleConvexHulls[i].hullStart);
|
|
stream.write(mVehicleConvexHulls[i].hullCount);
|
|
stream.write(mVehicleConvexHulls[i].minX);
|
|
stream.write(mVehicleConvexHulls[i].maxX);
|
|
stream.write(mVehicleConvexHulls[i].minY);
|
|
stream.write(mVehicleConvexHulls[i].maxY);
|
|
stream.write(mVehicleConvexHulls[i].minZ);
|
|
stream.write(mVehicleConvexHulls[i].maxZ);
|
|
stream.write(mVehicleConvexHulls[i].surfaceStart);
|
|
stream.write(mVehicleConvexHulls[i].surfaceCount);
|
|
stream.write(mVehicleConvexHulls[i].planeStart);
|
|
stream.write(mVehicleConvexHulls[i].polyListPlaneStart);
|
|
stream.write(mVehicleConvexHulls[i].polyListPointStart);
|
|
stream.write(mVehicleConvexHulls[i].polyListStringStart);
|
|
}
|
|
|
|
stream.write(mVehicleConvexHullEmitStrings.size());
|
|
stream.write(mVehicleConvexHullEmitStrings.size(), mVehicleConvexHullEmitStrings.address());
|
|
|
|
stream.write(mVehicleHullIndices.size());
|
|
for(i = 0; i < mVehicleHullIndices.size(); i++)
|
|
stream.write(mVehicleHullIndices[i]);
|
|
|
|
stream.write(mVehicleHullPlaneIndices.size());
|
|
for(i = 0; i < mVehicleHullPlaneIndices.size(); i++)
|
|
stream.write(mVehicleHullPlaneIndices[i]);
|
|
|
|
stream.write(mVehicleHullEmitStringIndices.size());
|
|
for(i = 0; i < mVehicleHullEmitStringIndices.size(); i++)
|
|
stream.write(mVehicleHullEmitStringIndices[i]);
|
|
|
|
stream.write(mVehicleHullSurfaceIndices.size());
|
|
for(i = 0; i < mVehicleHullSurfaceIndices.size(); i++)
|
|
stream.write(mVehicleHullSurfaceIndices[i]);
|
|
|
|
stream.write(mVehiclePolyListPlanes.size());
|
|
for(i = 0; i < mVehiclePolyListPlanes.size(); i++)
|
|
stream.write(mVehiclePolyListPlanes[i]);
|
|
|
|
stream.write(mVehiclePolyListPoints.size());
|
|
for(i = 0; i < mVehiclePolyListPoints.size(); i++)
|
|
stream.write(mVehiclePolyListPoints[i]);
|
|
|
|
stream.write(mVehiclePolyListStrings.size());
|
|
for(i = 0; i < mVehiclePolyListStrings.size(); i++)
|
|
stream.write(mVehiclePolyListStrings[i]);
|
|
|
|
stream.write(mVehicleNullSurfaces.size());
|
|
for(i = 0; i < mVehicleNullSurfaces.size(); i++)
|
|
{
|
|
stream.write(mVehicleNullSurfaces[i].windingStart);
|
|
stream.write(mVehicleNullSurfaces[i].planeIndex);
|
|
stream.write(mVehicleNullSurfaces[i].surfaceFlags);
|
|
stream.write(mVehicleNullSurfaces[i].windingCount);
|
|
}
|
|
|
|
stream.write(mVehiclePoints.size());
|
|
for(i = 0; i < mVehiclePoints.size(); i++)
|
|
mathWrite(stream, mVehiclePoints[i].point);
|
|
|
|
stream.write(mVehiclePlanes.size());
|
|
for(i = 0; i < mVehiclePlanes.size(); i++)
|
|
mathWrite(stream, mVehiclePlanes[i]);
|
|
|
|
stream.write(mVehicleWindings.size());
|
|
for(i = 0; i < mVehicleWindings.size(); i++)
|
|
stream.write(mVehicleWindings[i]);
|
|
|
|
stream.write(mVehicleWindingIndices.size());
|
|
for(i = 0; i < mVehicleWindingIndices.size(); i++)
|
|
{
|
|
stream.write(mVehicleWindingIndices[i].windingStart);
|
|
stream.write(mVehicleWindingIndices[i].windingCount);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
bool Interior::readLMapTexGen(Stream& stream, PlaneF& planeX, PlaneF& planeY)
|
|
{
|
|
F32 genX[4];
|
|
F32 genY[4];
|
|
|
|
for(U32 i = 0; i < 4; i++)
|
|
{
|
|
genX[i] = 0.0f;
|
|
genY[i] = 0.0f;
|
|
}
|
|
|
|
U16 finalWord;
|
|
stream.read(&finalWord);
|
|
stream.read(&genX[3]);
|
|
stream.read(&genY[3]);
|
|
|
|
// Unpack the final word.
|
|
U32 logScaleY = (finalWord >> 0) & ((1 << 6) - 1);
|
|
U32 logScaleX = (finalWord >> 6) & ((1 << 6) - 1);
|
|
U16 stEnc = (finalWord >> 13) & 7;
|
|
|
|
S32 sc, tc;
|
|
switch(stEnc)
|
|
{
|
|
case 0: sc = 0; tc = 1; break;
|
|
case 1: sc = 0; tc = 2; break;
|
|
case 2: sc = 1; tc = 0; break;
|
|
case 3: sc = 1; tc = 2; break;
|
|
case 4: sc = 2; tc = 0; break;
|
|
case 5: sc = 2; tc = 1; break;
|
|
|
|
default:
|
|
AssertISV(false, "Invalid st coord encoding in Interior::readLMapTG");
|
|
}
|
|
|
|
U32 invScaleX = 1 << logScaleX;
|
|
U32 invScaleY = 1 << logScaleY;
|
|
|
|
genX[sc] = F32(1.0 / F64(invScaleX));
|
|
genY[tc] = F32(1.0 / F64(invScaleY));
|
|
|
|
planeX.x = genX[0];
|
|
planeX.y = genX[1];
|
|
planeX.z = genX[2];
|
|
planeX.d = genX[3];
|
|
planeY.x = genY[0];
|
|
planeY.y = genY[1];
|
|
planeY.z = genY[2];
|
|
planeY.d = genY[3];
|
|
|
|
return stream.getStatus() == Stream::Ok;
|
|
}
|
|
|
|
bool Interior::writeLMapTexGen(Stream& stream, const PlaneF& planeX, const PlaneF& planeY) const
|
|
{
|
|
F32 genX[4], genY[4];
|
|
|
|
genX[0] = planeX.x;
|
|
genX[1] = planeX.y;
|
|
genX[2] = planeX.z;
|
|
genX[3] = planeX.d;
|
|
genY[0] = planeY.x;
|
|
genY[1] = planeY.y;
|
|
genY[2] = planeY.z;
|
|
genY[3] = planeY.d;
|
|
|
|
// The tex gen for lmaps is a special case.
|
|
// there are only 4 parameters that matter,
|
|
// an inverse power of 2 in the x and y, and the
|
|
// fp offsets in x and y. We can encode the
|
|
// scales completely in U16 and we'll just write out
|
|
// the offsets. First, determine which coords we're
|
|
// writing...
|
|
//
|
|
S32 sc = -1;
|
|
S32 tc = -1;
|
|
if(genX[0] != 0.0) sc = 0;
|
|
else if(genX[1] != 0.0) sc = 1;
|
|
else if(genX[2] != 0.0) sc = 2;
|
|
|
|
if(genY[0] != 0.0) tc = 0;
|
|
else if(genY[1] != 0.0) tc = 1;
|
|
else if(genY[2] != 0.0) tc = 2;
|
|
AssertFatal(sc != -1 && tc != -1 && sc != tc, "Hm, something wrong here.");
|
|
|
|
U32 invScaleX = U32((1.0f / genX[sc]) + 0.5);
|
|
U32 invScaleY = U32((1.0f / genY[tc]) + 0.5);
|
|
AssertISV(invScaleX && isPow2(invScaleX) && invScaleY && isPow2(invScaleY), "Not a power of 2? Something wrong");
|
|
|
|
U32 logScaleX = getBinLog2(invScaleX);
|
|
U32 logScaleY = getBinLog2(invScaleY);
|
|
AssertFatal(logScaleX < 63 && logScaleY < 63, "Error, you've set the lightmap scale WAAYYY to high!");
|
|
|
|
// We need 3 bits to encode sc and tc, which leaves us 6 bits for logScaleX
|
|
// and logScaleY
|
|
S16 stEnc = -1;
|
|
if(sc == 0 && tc == 1) stEnc = 0;
|
|
else if(sc == 0 && tc == 2) stEnc = 1;
|
|
else if(sc == 1 && tc == 0) stEnc = 2;
|
|
else if(sc == 1 && tc == 2) stEnc = 3;
|
|
else if(sc == 2 && tc == 0) stEnc = 4;
|
|
else if(sc == 2 && tc == 1) stEnc = 5;
|
|
AssertFatal(stEnc != -1, avar("Hm. This should never happen. (%d, %d)", sc, tc));
|
|
|
|
U16 finalWord = U16(stEnc) << 13;
|
|
finalWord |= logScaleX << 6;
|
|
finalWord |= logScaleY << 0;
|
|
|
|
stream.write(finalWord);
|
|
stream.write(genX[3]);
|
|
stream.write(genY[3]);
|
|
|
|
return stream.getStatus() == Stream::Ok;
|
|
}
|
|
|
|
bool Interior::writePlaneVector(Stream& stream) const
|
|
{
|
|
// This is pretty slow, but who cares?
|
|
//
|
|
Vector<Point3F> uniqueNormals(mPlanes.size());
|
|
Vector<U16> uniqueIndices(mPlanes.size());
|
|
|
|
U32 i;
|
|
|
|
for(i = 0; i < mPlanes.size(); i++)
|
|
{
|
|
bool inserted = false;
|
|
for(U32 j = 0; j < uniqueNormals.size(); j++)
|
|
{
|
|
if(mPlanes[i] == uniqueNormals[j])
|
|
{
|
|
// Hah! Already have this one...
|
|
uniqueIndices.push_back(j);
|
|
inserted = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if(inserted == false)
|
|
{
|
|
// Gotta do it ourselves...
|
|
uniqueIndices.push_back(uniqueNormals.size());
|
|
uniqueNormals.push_back(Point3F(mPlanes[i].x, mPlanes[i].y, mPlanes[i].z));
|
|
}
|
|
}
|
|
|
|
// Ok, what we have now, is a list of unique normals, a set of indices into
|
|
// that vector, and the distances that we still have to write out by hand.
|
|
// Hop to it!
|
|
stream.write(uniqueNormals.size());
|
|
for(i = 0; i < uniqueNormals.size(); i++)
|
|
mathWrite(stream, uniqueNormals[i]);
|
|
|
|
stream.write(mPlanes.size());
|
|
for(i = 0; i < mPlanes.size(); i++)
|
|
{
|
|
stream.write(uniqueIndices[i]);
|
|
stream.write(mPlanes[i].d);
|
|
}
|
|
|
|
return(stream.getStatus() == Stream::Ok);
|
|
}
|
|
|
|
bool Interior::readPlaneVector(Stream& stream)
|
|
{
|
|
U32 vectorSize;
|
|
|
|
stream.read(&vectorSize);
|
|
Point3F* normals = new Point3F[vectorSize];
|
|
U32 i;
|
|
for(i = 0; i < vectorSize; i++)
|
|
mathRead(stream, &normals[i]);
|
|
|
|
U16 index;
|
|
stream.read(&vectorSize);
|
|
mPlanes.setSize(vectorSize);
|
|
for(i = 0; i < mPlanes.size(); i++)
|
|
{
|
|
stream.read(&index);
|
|
stream.read(&mPlanes[i].d);
|
|
mPlanes[i].x = normals[index].x;
|
|
mPlanes[i].y = normals[index].y;
|
|
mPlanes[i].z = normals[index].z;
|
|
}
|
|
|
|
delete [] normals;
|
|
|
|
return(stream.getStatus() == Stream::Ok);
|
|
}
|
|
|
|
|
|
bool Interior::getUnifiedZone(const U16 index, S32* zone)
|
|
{
|
|
if(isBSPLeafIndex(index))
|
|
{
|
|
if(isBSPSolidLeaf(index))
|
|
*zone = -1;
|
|
else
|
|
*zone = S32(getBSPEmptyLeafZone(index));
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
S32 frontZone, backZone;
|
|
bool frontUnified = getUnifiedZone(mBSPNodes[index].frontIndex, &frontZone);
|
|
bool backUnified = getUnifiedZone(mBSPNodes[index].backIndex, &backZone);
|
|
if(frontUnified && backUnified)
|
|
{
|
|
if(frontZone == backZone)
|
|
{
|
|
*zone = frontZone;
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
if(frontZone == -1 || backZone == -1)
|
|
{
|
|
// DMMFIX: Once the interior file format is able to distinguish
|
|
// between structural and detail nodes in the runtime bsp,
|
|
// we can make this work a little better.
|
|
return false;
|
|
}
|
|
else
|
|
{
|
|
// Not equal, and neither is -1, no unified zone possible
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
|
|
void Interior::truncateZoneNode(const U16 index)
|
|
{
|
|
S32 unifiedZone;
|
|
bool unified = getUnifiedZone(index, &unifiedZone);
|
|
if(unified)
|
|
{
|
|
// Aha!
|
|
if(isBSPLeafIndex(index))
|
|
return;
|
|
|
|
if(unifiedZone == -1)
|
|
mBSPNodes[index].terminalZone = U16(0xFFFF);
|
|
else
|
|
mBSPNodes[index].terminalZone = U16(0x8000) | U16(unifiedZone);
|
|
}
|
|
else
|
|
{
|
|
// Sigh.
|
|
if(isBSPLeafIndex(mBSPNodes[index].frontIndex) == false)
|
|
truncateZoneNode(mBSPNodes[index].frontIndex);
|
|
if(isBSPLeafIndex(mBSPNodes[index].backIndex) == false)
|
|
truncateZoneNode(mBSPNodes[index].backIndex);
|
|
}
|
|
}
|
|
|
|
void Interior::truncateZoneTree()
|
|
{
|
|
for(U32 i = 0; i < mBSPNodes.size(); i++)
|
|
{
|
|
mBSPNodes[i].terminalZone = 0;
|
|
}
|
|
|
|
if(mBSPNodes.size() > 0)
|
|
truncateZoneNode(0);
|
|
}
|
|
|
|
|
|
void Interior::setupZonePlanes()
|
|
{
|
|
U16* temp = new U16[mPlanes.size() * mZones.size()];
|
|
U32 tempSize = 0;
|
|
|
|
for(U32 i = 0; i < mZones.size(); i++)
|
|
{
|
|
Zone& rZone = mZones[i];
|
|
|
|
BitVector usedPlanes;
|
|
usedPlanes.setSize(mPlanes.size());
|
|
usedPlanes.clear();
|
|
|
|
U32 j;
|
|
for(j = 0; j < rZone.surfaceCount; j++)
|
|
{
|
|
Surface& rSurface = mSurfaces[mZoneSurfaces[rZone.surfaceStart + j]];
|
|
usedPlanes.set(getPlaneIndex(rSurface.planeIndex));
|
|
}
|
|
|
|
rZone.planeStart = tempSize;
|
|
for(j = 0; j < mPlanes.size(); j++)
|
|
{
|
|
if(usedPlanes.test(j))
|
|
{
|
|
AssertFatal(tempSize < mPlanes.size() * mZones.size(), "Error, out of bounds plane list!");
|
|
temp[tempSize++] = j;
|
|
}
|
|
}
|
|
rZone.planeCount = tempSize - rZone.planeStart;
|
|
}
|
|
|
|
mZonePlanes.setSize(tempSize);
|
|
for(U32 j = 0; j < tempSize; j++)
|
|
mZonePlanes[j] = temp[j];
|
|
|
|
delete [] temp;
|
|
}
|