2099 lines
68 KiB
C++
Executable File
2099 lines
68 KiB
C++
Executable File
//-----------------------------------------------------------------------------
|
|
// Torque Game Engine
|
|
// Copyright (C) GarageGames.com, Inc.
|
|
//-----------------------------------------------------------------------------
|
|
|
|
#include "interior/interiorInstance.h"
|
|
#include "interior/lightUpdateGrouper.h"
|
|
#include "interior/interior.h"
|
|
#include "interior/interiorSubObject.h"
|
|
#include "interior/pathedInterior.h"
|
|
#include "console/consoleTypes.h"
|
|
#include "sceneGraph/sceneGraph.h"
|
|
#include "sceneGraph/sceneState.h"
|
|
#include "core/bitStream.h"
|
|
#include "dgl/dgl.h"
|
|
#include "dgl/gBitmap.h"
|
|
#include "math/mathIO.h"
|
|
#include "dgl/materialList.h"
|
|
#include "editor/editor.h"
|
|
#include "interior/interiorResObjects.h"
|
|
#include "game/trigger.h"
|
|
#include "sim/simPath.h"
|
|
#include "interior/forceField.h"
|
|
#include "dgl/materialList.h"
|
|
#include "sceneGraph/lightManager.h"
|
|
#include "collision/convex.h"
|
|
#include "audio/audioDataBlock.h"
|
|
#include "core/frameAllocator.h"
|
|
|
|
#include "sim/netConnection.h"
|
|
#include "platform/profiler.h"
|
|
|
|
//--------------------------------------------------------------------------
|
|
//-------------------------------------- Local classes, data, and functions
|
|
//
|
|
const U32 csgMaxZoneSize = 256;
|
|
bool sgScopeBoolArray[256];
|
|
|
|
class InteriorRenderImage : public SceneRenderImage
|
|
{
|
|
public:
|
|
InteriorRenderImage() : mDetailLevel(0) { }
|
|
|
|
U32 mDetailLevel;
|
|
U32 mBaseZone;
|
|
};
|
|
|
|
ConsoleFunctionGroupBegin(Interiors, "");
|
|
|
|
#if defined(TORQUE_DEBUG) || defined (INTERNAL_RELEASE)
|
|
ConsoleFunction( setInteriorRenderMode, void, 2, 2, "(int modeNum)")
|
|
{
|
|
S32 mode = dAtoi(argv[1]);
|
|
if (mode < 0 || mode > Interior::ShowDetailLevel)
|
|
mode = 0;
|
|
|
|
Interior::smRenderMode = mode;
|
|
}
|
|
|
|
ConsoleFunction( setInteriorFocusedDebug, void, 2, 2, "(bool enable)")
|
|
{
|
|
if (dAtob(argv[1])) {
|
|
Interior::smFocusedDebug = true;
|
|
} else {
|
|
Interior::smFocusedDebug = false;
|
|
}
|
|
}
|
|
|
|
#endif
|
|
|
|
ConsoleFunction( isPointInside, bool, 2, 4, "(Point3F pos) or (float x, float y, float z)")
|
|
{
|
|
static bool lastValue = false;
|
|
|
|
if(!(argc == 2 || argc == 4))
|
|
{
|
|
Con::errorf(ConsoleLogEntry::General, "cIsPointInside: invalid parameters");
|
|
return(lastValue);
|
|
}
|
|
|
|
Point3F pos;
|
|
if(argc == 2)
|
|
dSscanf(argv[1], "%g %g %g", &pos.x, &pos.y, &pos.z);
|
|
else
|
|
{
|
|
pos.x = dAtof(argv[1]);
|
|
pos.y = dAtof(argv[2]);
|
|
pos.z = dAtof(argv[3]);
|
|
}
|
|
|
|
RayInfo collision;
|
|
if(gClientContainer.castRay(pos, Point3F(pos.x, pos.y, pos.z - 2000.f), InteriorObjectType, &collision))
|
|
{
|
|
if(collision.face == -1)
|
|
Con::errorf(ConsoleLogEntry::General, "cIsPointInside: failed to find hit face on interior");
|
|
else
|
|
{
|
|
InteriorInstance * interior = dynamic_cast<InteriorInstance *>(collision.object);
|
|
if(interior)
|
|
lastValue = !interior->getDetailLevel(0)->isSurfaceOutsideVisible(collision.face);
|
|
else
|
|
Con::errorf(ConsoleLogEntry::General, "cIsPointInside: invalid interior on collision");
|
|
}
|
|
}
|
|
|
|
return(lastValue);
|
|
}
|
|
|
|
|
|
ConsoleFunctionGroupEnd(Interiors);
|
|
|
|
ConsoleMethod( InteriorInstance, setAlarmMode, void, 3, 3, "(string mode) Mode is 'On' or 'Off'")
|
|
{
|
|
bool alarm;
|
|
if (dStricmp(argv[2], "On") == 0)
|
|
alarm = true;
|
|
else
|
|
alarm = false;
|
|
|
|
if (object->isClientObject()) {
|
|
Con::errorf(ConsoleLogEntry::General, "InteriorInstance: client objects may not receive console commands. Ignored");
|
|
return;
|
|
}
|
|
|
|
object->setAlarmMode(alarm);
|
|
}
|
|
|
|
ConsoleMethod( InteriorInstance, activateLight, void, 3, 3, "(string lightName)")
|
|
{
|
|
if (object->isClientObject()) {
|
|
Con::errorf(ConsoleLogEntry::General, "InteriorInstance: client objects may not receive console commands. Ignored");
|
|
return;
|
|
}
|
|
|
|
const char* pLightName = argv[2];
|
|
object->activateLight(pLightName);
|
|
}
|
|
|
|
ConsoleMethod( InteriorInstance, deactivateLight, void, 3, 3, "(string lightName)")
|
|
{
|
|
if (object->isClientObject()) {
|
|
Con::errorf(ConsoleLogEntry::General, "InteriorInstance: client objects may not receive console commands. Ignored");
|
|
return;
|
|
}
|
|
|
|
const char* pLightName = argv[2];
|
|
object->deactivateLight(pLightName);
|
|
}
|
|
|
|
ConsoleMethod( InteriorInstance, echoTriggerableLights, void, 2, 2, "List lights usable with activateLight()/deactivateLight().")
|
|
{
|
|
if (object->isClientObject()) {
|
|
Con::errorf(ConsoleLogEntry::General, "InteriorInstance: client objects may not receive console commands. Ignored");
|
|
return;
|
|
}
|
|
|
|
object->echoTriggerableLights();
|
|
}
|
|
|
|
ConsoleMethod( InteriorInstance, magicButton, void, 2, 2, "@deprecated unimplemented")
|
|
{
|
|
if (object->isClientObject()) {
|
|
Con::errorf(ConsoleLogEntry::General, "InteriorInstance: client objects may not receive console commands. Ignored");
|
|
return;
|
|
}
|
|
|
|
object->addChildren();
|
|
}
|
|
|
|
ConsoleMethod( InteriorInstance, setSkinBase, void, 3, 3, "(string basename)")
|
|
{
|
|
if (object->isClientObject()) {
|
|
Con::errorf(ConsoleLogEntry::General, "InteriorInstance: client objects may not receive console commands. Ignored");
|
|
return;
|
|
}
|
|
|
|
object->setSkinBase(argv[2]);
|
|
}
|
|
|
|
ConsoleMethod( InteriorInstance, getNumDetailLevels, S32, 2, 2, "")
|
|
{
|
|
return(object->getNumDetailLevels());
|
|
}
|
|
|
|
ConsoleMethod( InteriorInstance, setDetailLevel, void, 3, 3, "(int level)")
|
|
{
|
|
if(object->isServerObject())
|
|
{
|
|
NetConnection * toServer = NetConnection::getConnectionToServer();
|
|
NetConnection * toClient = NetConnection::getLocalClientConnection();
|
|
if(!toClient || !toServer)
|
|
return;
|
|
|
|
S32 index = toClient->getGhostIndex(object);
|
|
if(index == -1)
|
|
return;
|
|
|
|
InteriorInstance * clientInstance = dynamic_cast<InteriorInstance*>(toServer->resolveGhost(index));
|
|
if(clientInstance)
|
|
clientInstance->setDetailLevel(dAtoi(argv[2]));
|
|
}
|
|
else
|
|
object->setDetailLevel(dAtoi(argv[2]));
|
|
}
|
|
|
|
//--------------------------------------------------------------------------
|
|
//-------------------------------------- Static functions
|
|
//
|
|
IMPLEMENT_CO_NETOBJECT_V1(InteriorInstance);
|
|
|
|
//------------------------------------------------------------------------------
|
|
//-------------------------------------- InteriorInstance
|
|
//
|
|
bool InteriorInstance::smDontRestrictOutside = false;
|
|
bool InteriorInstance::smRenderDynamicLights = true;
|
|
U32 InteriorInstance::smLightUpdatePeriod = 66; // 66 ms between updates
|
|
F32 InteriorInstance::smDetailModification = 1.0f;
|
|
|
|
|
|
InteriorInstance::InteriorInstance()
|
|
{
|
|
mAlarmState = false;
|
|
mDoSimpleDynamicRender = false;
|
|
mUseGLLighting = false;
|
|
|
|
mInteriorFileName = NULL;
|
|
mTypeMask = InteriorObjectType | StaticObjectType | StaticRenderedObjectType;
|
|
mNetFlags.set(Ghostable | ScopeAlways);
|
|
|
|
mUpdateGrouper = NULL;
|
|
|
|
mShowTerrainInside = false;
|
|
|
|
mSkinBase = StringTable->insert("base");
|
|
mAudioProfile = 0;
|
|
mAudioEnvironment = 0;
|
|
mForcedDetailLevel = -1;
|
|
|
|
mConvexList = new Convex;
|
|
mCRC = 0;
|
|
}
|
|
|
|
InteriorInstance::~InteriorInstance()
|
|
{
|
|
U32 i;
|
|
|
|
for (i = 0; i < mLightInfo.size(); i++)
|
|
destructInPlace(&mLightInfo[i]);
|
|
|
|
for (i = 0; i < mInteriorSubObjects.size(); i++)
|
|
{
|
|
// DMM: Fix for first-class objects...
|
|
for (U32 j = 0; j < mInteriorSubObjects[i].size(); j++)
|
|
delete (mInteriorSubObjects[i])[j];
|
|
|
|
destructInPlace(&mInteriorSubObjects[i]);
|
|
}
|
|
delete mUpdateGrouper;
|
|
|
|
delete mConvexList;
|
|
mConvexList = NULL;
|
|
|
|
for (i = 0; i < mVertexColorsNormal.size(); i++)
|
|
{
|
|
delete mVertexColorsNormal[i];
|
|
mVertexColorsNormal[i] = NULL;
|
|
}
|
|
|
|
for (i = 0; i < mVertexColorsAlarm.size(); i++)
|
|
{
|
|
delete mVertexColorsAlarm[i];
|
|
mVertexColorsAlarm[i] = NULL;
|
|
}
|
|
|
|
for (i = 0; i < mMaterialMaps.size(); i++)
|
|
{
|
|
delete mMaterialMaps[i];
|
|
mMaterialMaps[i] = NULL;
|
|
}
|
|
}
|
|
|
|
|
|
void InteriorInstance::init()
|
|
{
|
|
// Does nothing for the moment
|
|
}
|
|
|
|
|
|
void InteriorInstance::destroy()
|
|
{
|
|
// Also does nothing for the moment
|
|
}
|
|
|
|
|
|
//--------------------------------------------------------------------------
|
|
// Inspection
|
|
static AudioProfile * saveAudioProfile = 0;
|
|
static AudioEnvironment * saveAudioEnvironment = 0;
|
|
void InteriorInstance::inspectPreApply()
|
|
{
|
|
saveAudioProfile = mAudioProfile;
|
|
saveAudioEnvironment = mAudioEnvironment;
|
|
}
|
|
|
|
void InteriorInstance::inspectPostApply()
|
|
{
|
|
if((mAudioProfile != saveAudioProfile) || (mAudioEnvironment != saveAudioEnvironment))
|
|
setMaskBits(AudioMask);
|
|
|
|
// Update the Transform on Editor Apply.
|
|
setMaskBits(TransformMask);
|
|
}
|
|
|
|
void InteriorInstance::onStaticModified( const char* slotName )
|
|
{
|
|
if( (!dStricmp( slotName, "position") || !dStricmp( slotName, "rotation") || !dStricmp( slotName, "scale")) && !mUseGLLighting )
|
|
Con::executef( 1, "onNeedRelight" );
|
|
|
|
if( !dStricmp( slotName, "useGLLighting" ))
|
|
setMaskBits(InitMask);
|
|
}
|
|
|
|
//--------------------------------------------------------------------------
|
|
//-------------------------------------- Console functionality
|
|
//
|
|
void InteriorInstance::initPersistFields()
|
|
{
|
|
Parent::initPersistFields();
|
|
|
|
addGroup("Media");
|
|
addField("interiorFile", TypeFilename, Offset(mInteriorFileName, InteriorInstance));
|
|
endGroup("Media");
|
|
|
|
addGroup("Audio");
|
|
addField("audioProfile", TypeAudioProfilePtr, Offset(mAudioProfile, InteriorInstance));
|
|
addField("audioEnvironment", TypeAudioEnvironmentPtr, Offset(mAudioEnvironment, InteriorInstance));
|
|
endGroup("Audio");
|
|
|
|
addGroup("Misc");
|
|
addField("useGLLighting", TypeBool, Offset(mUseGLLighting, InteriorInstance));
|
|
addField("showTerrainInside", TypeBool, Offset(mShowTerrainInside, InteriorInstance));
|
|
endGroup("Misc");
|
|
|
|
}
|
|
|
|
void InteriorInstance::consoleInit()
|
|
{
|
|
Con::addVariable("pref::Interior::LightUpdatePeriod", TypeS32, &smLightUpdatePeriod);
|
|
Con::addVariable("pref::Interior::ShowEnvironmentMaps", TypeBool, &Interior::smRenderEnvironmentMaps);
|
|
Con::addVariable("pref::Interior::DynamicLights", TypeBool, &smRenderDynamicLights);
|
|
Con::addVariable("pref::Interior::VertexLighting", TypeBool, &Interior::smUseVertexLighting);
|
|
Con::addVariable("pref::Interior::TexturedFog", TypeBool, &Interior::smUseTexturedFog);
|
|
Con::addVariable("pref::Interior::lockArrays", TypeBool, &Interior::smLockArrays);
|
|
|
|
Con::addVariable("pref::Interior::detailAdjust", TypeF32, &InteriorInstance::smDetailModification);
|
|
|
|
// DEBUG ONLY!!!
|
|
#ifdef TORQUE_DEBUG
|
|
Con::addVariable("Interior::DontRestrictOutside", TypeBool, &smDontRestrictOutside);
|
|
#endif
|
|
}
|
|
|
|
//--------------------------------------------------------------------------
|
|
void InteriorInstance::renewOverlays()
|
|
{
|
|
StringTableEntry baseName = dStricmp(mSkinBase, "base") == 0 ? "blnd" : mSkinBase;
|
|
|
|
for (U32 i = 0; i < mMaterialMaps.size(); i++)
|
|
{
|
|
MaterialList* pMatList = mMaterialMaps[i];
|
|
|
|
for (U32 j = 0; j < pMatList->mMaterialNames.size(); j++)
|
|
{
|
|
const char* pName = pMatList->mMaterialNames[j];
|
|
const U32 len = dStrlen(pName);
|
|
if (len < 6)
|
|
continue;
|
|
|
|
const char* possible = pName + (len - 5);
|
|
if (dStricmp(".blnd", possible) == 0)
|
|
{
|
|
char newName[256];
|
|
AssertFatal(len < 200, "InteriorInstance::renewOverlays: Error, len exceeds allowed name length");
|
|
|
|
dStrncpy(newName, pName, possible - pName);
|
|
newName[possible - pName] = '\0';
|
|
dStrcat(newName, ".");
|
|
dStrcat(newName, baseName);
|
|
|
|
TextureHandle test = TextureHandle(newName, MeshTexture, false);
|
|
if (test.getGLName() != 0)
|
|
{
|
|
pMatList->mMaterials[j] = test;
|
|
}
|
|
else
|
|
{
|
|
pMatList->mMaterials[j] = TextureHandle(pName, MeshTexture, false);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
//--------------------------------------------------------------------------
|
|
void InteriorInstance::setSkinBase(const char* newBase)
|
|
{
|
|
if (dStricmp(mSkinBase, newBase) == 0)
|
|
return;
|
|
|
|
mSkinBase = StringTable->insert(newBase);
|
|
|
|
if (isServerObject())
|
|
setMaskBits(SkinBaseMask);
|
|
else
|
|
renewOverlays();
|
|
}
|
|
|
|
|
|
//--------------------------------------------------------------------------
|
|
// from resManager.cc
|
|
extern U32 calculateCRC(void * buffer, S32 len, U32 crcVal );
|
|
|
|
bool InteriorInstance::onAdd()
|
|
{
|
|
U32 i;
|
|
|
|
// Load resource
|
|
mInteriorRes = ResourceManager->load(mInteriorFileName, true);
|
|
|
|
if (bool(mInteriorRes) == false)
|
|
{
|
|
Con::errorf(ConsoleLogEntry::General, "Unable to load interior: %s", mInteriorFileName);
|
|
NetConnection::setLastError("Unable to load interior: %s", mInteriorFileName);
|
|
return false;
|
|
}
|
|
|
|
if(isClientObject())
|
|
{
|
|
if(mCRC != mInteriorRes.getCRC())
|
|
{
|
|
NetConnection::setLastError("Local interior file '%s' does not match version on server.", mInteriorFileName);
|
|
return false;
|
|
}
|
|
|
|
for (i = 0; i < mInteriorRes->getNumDetailLevels(); i++)
|
|
{
|
|
// ok, if the material list load failed...
|
|
// if this is a local connection, we'll assume that's ok
|
|
// and just have white textures...
|
|
// otherwise we want to return false.
|
|
Interior* pInterior = mInteriorRes->getDetailLevel(i);
|
|
if(!pInterior->prepForRendering(mInteriorRes.getFilePath()) )
|
|
return false;
|
|
}
|
|
}
|
|
else
|
|
mCRC = mInteriorRes.getCRC();
|
|
|
|
if(!Parent::onAdd())
|
|
return false;
|
|
|
|
// Set up vertex lighting.
|
|
mVertexColorsNormal.setSize(mInteriorRes->getNumDetailLevels());
|
|
mVertexColorsAlarm.setSize(mInteriorRes->getNumDetailLevels());
|
|
for (i = 0; i < mInteriorRes->getNumDetailLevels(); i++)
|
|
{
|
|
mVertexColorsNormal[i] = new Vector<ColorI>;
|
|
mVertexColorsAlarm[i] = new Vector<ColorI>;
|
|
VECTOR_SET_ASSOCIATION((*mVertexColorsNormal[i]));
|
|
VECTOR_SET_ASSOCIATION((*mVertexColorsAlarm[i]));
|
|
}
|
|
|
|
// Ok, everything's groovy! Let's cache our hashed filename for renderimage sorting...
|
|
mInteriorFileHash = _StringTable::hashString(mInteriorFileName);
|
|
|
|
// Setup bounding information
|
|
mObjBox = mInteriorRes->getDetailLevel(0)->getBoundingBox();
|
|
resetWorldBox();
|
|
setRenderTransform(mObjToWorld);
|
|
|
|
// Setup mLightInfo structure
|
|
mLightInfo.setSize(mInteriorRes->getNumDetailLevels());
|
|
|
|
for (i = 0; i < mInteriorRes->getNumDetailLevels(); i++)
|
|
{
|
|
Interior* pInterior = mInteriorRes->getDetailLevel(i);
|
|
constructInPlace(&mLightInfo[i]);
|
|
LightInfo& rInfo = mLightInfo[i];
|
|
|
|
rInfo.mSurfaceInvalid.setSize(pInterior->mSurfaces.size());
|
|
rInfo.mSurfaceInvalid.clear();
|
|
|
|
rInfo.mStateDataInfo.setSize(pInterior->mNumLightStateEntries);
|
|
dMemset(rInfo.mStateDataInfo.address(), 0x00,
|
|
sizeof(LightInfo::StateDataInfo) * rInfo.mStateDataInfo.size());
|
|
|
|
rInfo.mLights.setSize(pInterior->mAnimatedLights.size());
|
|
for (U32 j = 0; j < rInfo.mLights.size(); j++)
|
|
{
|
|
LightInfo::Light& rLight = rInfo.mLights[j];
|
|
rLight.curState = 0;
|
|
rLight.curTime = 0;
|
|
|
|
Interior::LightState& rState = pInterior->mLightStates[pInterior->mAnimatedLights[j].stateIndex];
|
|
rLight.curColor.set(rState.red, rState.green, rState.blue);
|
|
rLight.active = false;
|
|
rLight.alarm = (pInterior->mAnimatedLights[j].flags & Interior::AlarmLight) != 0;
|
|
|
|
installLight(i, j);
|
|
}
|
|
}
|
|
|
|
// Setup lightgrouper
|
|
mUpdateGrouper = new LightUpdateGrouper(LightUpdateBitStart, LightUpdateBitEnd);
|
|
for (U32 d = 0; d < mInteriorRes->getNumDetailLevels(); d++)
|
|
{
|
|
Interior* pInterior = mInteriorRes->getDetailLevel(d);
|
|
|
|
for (U32 j = 0; j < pInterior->mNumTriggerableLights; j++)
|
|
mUpdateGrouper->addKey(makeUpdateKey(d, j));
|
|
}
|
|
|
|
if (isClientObject())
|
|
{
|
|
// create all the subObjects
|
|
mInteriorSubObjects.setSize(mInteriorRes->getNumDetailLevels());
|
|
for (i = 0; i < mInteriorRes->getNumDetailLevels(); i++)
|
|
{
|
|
constructInPlace(&mInteriorSubObjects[i]);
|
|
|
|
Interior* pInterior = mInteriorRes->getDetailLevel(i);
|
|
for (U32 j = 0; j < pInterior->mSubObjects.size(); j++)
|
|
mInteriorSubObjects[i].push_back(pInterior->mSubObjects[j]->clone(this));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// creates all subobjects
|
|
mInteriorSubObjects.setSize(mInteriorRes->getNumDetailLevels());
|
|
for (i = 0; i < mInteriorRes->getNumDetailLevels(); i++)
|
|
{
|
|
constructInPlace(&mInteriorSubObjects[i]);
|
|
|
|
Interior* pInterior = mInteriorRes->getDetailLevel(i);
|
|
|
|
for (U32 j = 0; j < pInterior->mSubObjects.size(); j++)
|
|
mInteriorSubObjects[i].push_back(pInterior->mSubObjects[j]->clone(this));
|
|
}
|
|
}
|
|
|
|
// Do any handle loading, etc. required.
|
|
|
|
if (isClientObject())
|
|
{
|
|
setLightUpdatedTime(Platform::getVirtualMilliseconds());
|
|
|
|
for (i = 0; i < mInteriorRes->getNumDetailLevels(); i++)
|
|
{
|
|
Interior* pInterior = mInteriorRes->getDetailLevel(i);
|
|
|
|
// Force the lightmap manager to download textures if we're
|
|
// running the mission editor. Normally they are only
|
|
// downloaded after the whole scene is lit.
|
|
gInteriorLMManager.addInstance(pInterior->getLMHandle(), mLMHandle, this);
|
|
if (gEditingMission)
|
|
{
|
|
gInteriorLMManager.useBaseTextures(pInterior->getLMHandle(), mLMHandle);
|
|
gInteriorLMManager.downloadGLTextures(pInterior->getLMHandle());
|
|
}
|
|
|
|
// Install material list
|
|
mMaterialMaps.push_back(new MaterialList(pInterior->mMaterialList));
|
|
|
|
// A client interior starts up it's ambient animations on add. Ambients
|
|
// are just past the triggerables.
|
|
for (U32 j = pInterior->mNumTriggerableLights; j < pInterior->mAnimatedLights.size(); j++)
|
|
activateLight(i, j);
|
|
}
|
|
|
|
renewOverlays();
|
|
}
|
|
else
|
|
{
|
|
// WTF goes here? -- BJG
|
|
}
|
|
|
|
addToScene();
|
|
return true;
|
|
}
|
|
|
|
|
|
void InteriorInstance::onRemove()
|
|
{
|
|
// Kill our convexes.
|
|
mConvexList->nukeList();
|
|
|
|
// Clean up our lightmaps.
|
|
if(isClientObject())
|
|
{
|
|
if(bool(mInteriorRes) && mLMHandle != 0xFFFFFFFF)
|
|
{
|
|
for(U32 i = 0; i < mInteriorRes->getNumDetailLevels(); i++)
|
|
{
|
|
Interior * pInterior = mInteriorRes->getDetailLevel(i);
|
|
if (pInterior->getLMHandle() != 0xFFFFFFFF)
|
|
gInteriorLMManager.removeInstance(pInterior->getLMHandle(), mLMHandle);
|
|
}
|
|
}
|
|
}
|
|
|
|
removeFromScene();
|
|
Parent::onRemove();
|
|
}
|
|
|
|
|
|
//--------------------------------------------------------------------------
|
|
bool InteriorInstance::onSceneAdd(SceneGraph* pGraph)
|
|
{
|
|
AssertFatal(mInteriorRes, "Error, should not have been added to the scene if there's no interior!");
|
|
|
|
if (Parent::onSceneAdd(pGraph) == false)
|
|
return false;
|
|
|
|
if (mInteriorRes->getDetailLevel(0)->mZones.size() > 1)
|
|
{
|
|
AssertWarn(getNumCurrZones() == 1, "There should be one and only one zone for an interior that manages zones");
|
|
mSceneManager->registerZones(this, (mInteriorRes->getDetailLevel(0)->mZones.size() - 1));
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
//--------------------------------------------------------------------------
|
|
void InteriorInstance::onSceneRemove()
|
|
{
|
|
AssertFatal(mInteriorRes, "Error, should not have been added to the scene if there's no interior!");
|
|
|
|
if (isManagingZones())
|
|
mSceneManager->unregisterZones(this);
|
|
|
|
Parent::onSceneRemove();
|
|
}
|
|
|
|
|
|
//--------------------------------------------------------------------------
|
|
bool InteriorInstance::getOverlappingZones(SceneObject* obj,
|
|
U32* zones,
|
|
U32* numZones)
|
|
{
|
|
MatrixF xForm(true);
|
|
Point3F invScale(1.0f / getScale().x,
|
|
1.0f / getScale().y,
|
|
1.0f / getScale().z);
|
|
xForm.scale(invScale);
|
|
xForm.mul(getWorldTransform());
|
|
xForm.mul(obj->getTransform());
|
|
xForm.scale(obj->getScale());
|
|
|
|
U32 waterMark = FrameAllocator::getWaterMark();
|
|
|
|
U16* zoneVector = (U16*)FrameAllocator::alloc(mInteriorRes->getDetailLevel(0)->mZones.size() * sizeof(U16));
|
|
U32 numRetZones = 0;
|
|
|
|
bool outsideToo = mInteriorRes->getDetailLevel(0)->scanZones(obj->getObjBox(),
|
|
xForm,
|
|
zoneVector,
|
|
&numRetZones);
|
|
if (numRetZones > SceneObject::MaxObjectZones)
|
|
{
|
|
Con::warnf(ConsoleLogEntry::General, "Too many zones returned for query on %s. Returning first %d",
|
|
mInteriorFileName, SceneObject::MaxObjectZones);
|
|
}
|
|
|
|
for (U32 i = 0; i < getMin(numRetZones, U32(SceneObject::MaxObjectZones)); i++)
|
|
zones[i] = zoneVector[i] + mZoneRangeStart - 1;
|
|
*numZones = numRetZones;
|
|
|
|
FrameAllocator::setWaterMark(waterMark);
|
|
|
|
return outsideToo;
|
|
}
|
|
|
|
|
|
//--------------------------------------------------------------------------
|
|
U32 InteriorInstance::getPointZone(const Point3F& p)
|
|
{
|
|
AssertFatal(mInteriorRes, "Error, no interior!");
|
|
|
|
Point3F osPoint = p;
|
|
mWorldToObj.mulP(osPoint);
|
|
osPoint.convolveInverse(mObjScale);
|
|
|
|
const S32 zone = mInteriorRes->getDetailLevel(0)->getZoneForPoint(osPoint);
|
|
|
|
// If we're in solid (-1) or outside, we need to return 0
|
|
if (zone == -1 || zone == 0)
|
|
return 0;
|
|
|
|
return (zone-1) + mZoneRangeStart;
|
|
}
|
|
|
|
// does a hack check to determine how much a point is 'inside'.. should have
|
|
// portals prebuilt with the transfer energy to each other portal in the zone
|
|
// from the neighboring zone.. these values can be used to determine the factor
|
|
// from within an individual zone.. also, each zone could be marked with
|
|
// average material property for eax environment audio
|
|
// ~0: outside -> 1: inside
|
|
bool InteriorInstance::getPointInsideScale(const Point3F & pos, F32 * pScale)
|
|
{
|
|
AssertFatal(mInteriorRes, "InteriorInstance::getPointInsideScale: no interior");
|
|
|
|
Interior * interior = mInteriorRes->getDetailLevel(0);
|
|
|
|
Point3F p = pos;
|
|
mWorldToObj.mulP(p);
|
|
p.convolveInverse(mObjScale);
|
|
|
|
U32 zoneIndex = interior->getZoneForPoint(p);
|
|
if(zoneIndex == -1) // solid?
|
|
{
|
|
*pScale = 1.f;
|
|
return(true);
|
|
}
|
|
else if(zoneIndex == 0) // outside?
|
|
{
|
|
*pScale = 0.f;
|
|
return(true);
|
|
}
|
|
|
|
U32 waterMark = FrameAllocator::getWaterMark();
|
|
const Interior::Portal** portals = (const Interior::Portal**)FrameAllocator::alloc(256 * sizeof(const Interior::Portal*));
|
|
U32 numPortals = 0;
|
|
|
|
Interior::Zone & zone = interior->mZones[zoneIndex];
|
|
|
|
U32 i;
|
|
for(i = 0; i < zone.portalCount; i++)
|
|
{
|
|
const Interior::Portal & portal = interior->mPortals[interior->mZonePortalList[zone.portalStart + i]];
|
|
if(portal.zoneBack == 0 || portal.zoneFront == 0)
|
|
{
|
|
AssertFatal(numPortals < 256, "Error, overflow in temporary portal buffer!");
|
|
portals[numPortals++] = &portal;
|
|
}
|
|
}
|
|
|
|
// inside?
|
|
if(numPortals == 0)
|
|
{
|
|
*pScale = 1.f;
|
|
|
|
FrameAllocator::setWaterMark(waterMark);
|
|
return(true);
|
|
}
|
|
|
|
Point3F* portalCenters = (Point3F*)FrameAllocator::alloc(numPortals * sizeof(Point3F));
|
|
U32 numPortalCenters = 0;
|
|
|
|
// scale using the distances to the portals in this zone...
|
|
for(i = 0; i < numPortals; i++)
|
|
{
|
|
const Interior::Portal * portal = portals[i];
|
|
if(!portal->triFanCount)
|
|
continue;
|
|
|
|
Point3F center(0, 0, 0);
|
|
for(U32 j = 0; j < portal->triFanCount; j++)
|
|
{
|
|
const Interior::TriFan & fan = interior->mWindingIndices[portal->triFanStart + j];
|
|
const U32 numPoints = fan.windingCount;
|
|
|
|
if(!numPoints)
|
|
continue;
|
|
|
|
for(U32 k = 0; k < numPoints; k++)
|
|
{
|
|
const Point3F & a = interior->mPoints[interior->mWindings[fan.windingStart + k]].point;
|
|
center += a;
|
|
}
|
|
|
|
center /= numPoints;
|
|
portalCenters[numPortalCenters++] = center;
|
|
}
|
|
}
|
|
|
|
// 'magic' check here...
|
|
F32 magic = Con::getFloatVariable("Interior::insideDistanceFalloff", 10.f);
|
|
|
|
F32 val = 0.f;
|
|
for(i = 0; i < numPortalCenters; i++)
|
|
val += 1.f - mClampF(Point3F(portalCenters[i] - p).len() / magic, 0.f, 1.f);
|
|
|
|
*pScale = 1.f - mClampF(val, 0.f, 1.f);
|
|
|
|
FrameAllocator::setWaterMark(waterMark);
|
|
return(true);
|
|
}
|
|
|
|
//--------------------------------------------------------------------------
|
|
ColorF gInteriorFogColor(1, 1, 1);
|
|
|
|
void InteriorInstance::renderObject(SceneState* state, SceneRenderImage* sceneImage)
|
|
{
|
|
AssertFatal(dglIsInCanonicalState(), "Error, GL not in canonical state on entry");
|
|
|
|
if(gEditingMission && isHidden())
|
|
return;
|
|
|
|
PROFILE_START(InteriorRenderObject);
|
|
|
|
PROFILE_START(IRO_GetZones);
|
|
U32 storedWaterMark = FrameAllocator::getWaterMark();
|
|
dglSetRenderPrimType(2);
|
|
|
|
InteriorRenderImage* interiorImage = static_cast<InteriorRenderImage*>(sceneImage);
|
|
|
|
Point3F osPoint = state->getCameraPosition();
|
|
mRenderWorldToObj.mulP(osPoint);
|
|
osPoint.convolveInverse(mObjScale);
|
|
|
|
// Get the object space y vector
|
|
Point3F osCamVector;
|
|
state->mModelview.getColumn(1, &osCamVector);
|
|
mRenderWorldToObj.mulV(osCamVector);
|
|
osCamVector.convolve(getScale());
|
|
osCamVector.normalize();
|
|
|
|
Point3F osZVec(0, 0, 1);
|
|
mRenderWorldToObj.mulV(osZVec);
|
|
osZVec.convolve(getScale());
|
|
|
|
// First, we want to test the planes and setup the fog...
|
|
U32 zoneOffset = mZoneRangeStart != 0xFFFFFFFF ? mZoneRangeStart : 0;
|
|
|
|
Interior* pInterior = mInteriorRes->getDetailLevel(interiorImage->mDetailLevel);
|
|
|
|
U32 baseZone = 0xFFFFFFFF;
|
|
if (getNumCurrZones() == 1)
|
|
{
|
|
baseZone = getCurrZone(0);
|
|
}
|
|
else
|
|
{
|
|
for (U32 i = 0; i < getNumCurrZones(); i++)
|
|
{
|
|
if (state->getZoneState(getCurrZone(i)).render == true)
|
|
{
|
|
if (baseZone == 0xFFFFFFFF)
|
|
{
|
|
baseZone = getCurrZone(i);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (baseZone == 0xFFFFFFFF)
|
|
baseZone = getCurrZone(0);
|
|
}
|
|
PROFILE_END();
|
|
|
|
|
|
PROFILE_START(IRO_ComputeActivePolys);
|
|
Point3F worldOrigin;
|
|
getRenderTransform().getColumn(3, &worldOrigin);
|
|
|
|
ZoneVisDeterminer zoneVis;
|
|
|
|
if (interiorImage->mDetailLevel == 0)
|
|
{
|
|
zoneVis.runFromState(state, zoneOffset, baseZone);
|
|
pInterior->setupActivePolyList(zoneVis, state, osPoint, osCamVector, osZVec, worldOrigin.z, getScale());
|
|
}
|
|
else
|
|
{
|
|
// Something else...
|
|
pInterior->prepTempRender(state,
|
|
getCurrZone(0),
|
|
0,
|
|
mRenderObjToWorld, mObjScale,
|
|
state->mFlipCull);
|
|
zoneVis.runFromRects(state, zoneOffset, baseZone);
|
|
pInterior->setupActivePolyList(zoneVis, state, osPoint, osCamVector, osZVec, worldOrigin.z, getScale());
|
|
}
|
|
PROFILE_END();
|
|
|
|
PROFILE_START(IRO_UpdateAnimatedLights);
|
|
|
|
// Update the animated lights...
|
|
if (!Interior::smUseVertexLighting)
|
|
{
|
|
LightInfo& rLightInfo = mLightInfo[interiorImage->mDetailLevel];
|
|
downloadLightmaps(state, pInterior, rLightInfo);
|
|
}
|
|
|
|
PROFILE_END();
|
|
|
|
PROFILE_START(IRO_RenderSolids);
|
|
|
|
if(mDoSimpleDynamicRender)
|
|
installLights();
|
|
|
|
// Set up the model view and the global render state...
|
|
RectI viewport;
|
|
dglGetViewport(&viewport);
|
|
glMatrixMode(GL_PROJECTION);
|
|
glPushMatrix();
|
|
glMatrixMode(GL_MODELVIEW);
|
|
glPushMatrix();
|
|
dglMultMatrix(&mRenderObjToWorld);
|
|
glScalef(mObjScale.x, mObjScale.y, mObjScale.z);
|
|
|
|
glEnable(GL_BLEND);
|
|
glDisable(GL_CULL_FACE);
|
|
glEnable(GL_TEXTURE_2D);
|
|
|
|
// We need to decide if we're going to use the low-res textures
|
|
Point3F camPoint = state->getCameraPosition();
|
|
Point3F closestPoint = getRenderWorldBox().getClosestPoint(camPoint);
|
|
F32 dist = (camPoint - closestPoint).len();
|
|
if (dist != 0.0)
|
|
{
|
|
F32 length = dglProjectRadius(dist, 1.0f / pInterior->mAveTexGenLength);
|
|
if (length < (1.0 / 16.0))
|
|
{
|
|
TextureManager::setSmallTexturesActive(true);
|
|
}
|
|
}
|
|
|
|
pInterior->setupFog(state);
|
|
pInterior->setOSCamPosition(osPoint);
|
|
if (interiorImage->mBaseZone != 0)
|
|
state->setupZoneProjection(interiorImage->mBaseZone + mZoneRangeStart - 1);
|
|
else
|
|
state->setupObjectProjection(this);
|
|
|
|
gInteriorFogColor = state->getFogColor();
|
|
|
|
// make sure to build vertex color information in case interiors were
|
|
// added after the relight scene
|
|
if(&((*mVertexColorsNormal[interiorImage->mDetailLevel])[0]) == NULL)
|
|
rebuildVertexColors();
|
|
|
|
if(mDoSimpleDynamicRender)
|
|
{
|
|
pInterior->renderAsShape();
|
|
}
|
|
else
|
|
{
|
|
pInterior->render(mAlarmState, mMaterialMaps[interiorImage->mDetailLevel], mLMHandle,
|
|
mVertexColorsNormal[interiorImage->mDetailLevel],
|
|
mVertexColorsAlarm[interiorImage->mDetailLevel]);
|
|
}
|
|
|
|
pInterior->clearFog();
|
|
|
|
if(mDoSimpleDynamicRender)
|
|
uninstallLights();
|
|
|
|
PROFILE_END();
|
|
PROFILE_START(IRO_RenderDynamicLights);
|
|
|
|
// Do dynamic lights if appropriate.
|
|
if (smRenderDynamicLights == true)
|
|
{
|
|
// Are there any lights?
|
|
const S32 numLights = gClientSceneGraph->getLightManager()->getNumLights();
|
|
if (numLights > 0)
|
|
{
|
|
// Read out light info...
|
|
U32 lightWaterMark = FrameAllocator::getWaterMark();
|
|
::LightInfo** lightArray = (::LightInfo**)FrameAllocator::alloc(sizeof(::LightInfo*) * numLights);
|
|
gClientSceneGraph->getLightManager()->getLights(lightArray);
|
|
|
|
for (U32 i = 0; i < numLights; i++)
|
|
{
|
|
// Only consider point lights.
|
|
if (lightArray[i]->mType != ::LightInfo::Point)
|
|
continue;
|
|
|
|
Point3F lightPoint = lightArray[i]->mPos;
|
|
mRenderWorldToObj.mulP(lightPoint);
|
|
lightPoint.convolveInverse(mObjScale);
|
|
|
|
Box3F box;
|
|
box.min = lightPoint;
|
|
box.max = lightPoint;
|
|
box.min -= Point3F(lightArray[i]->mRadius, lightArray[i]->mRadius, lightArray[i]->mRadius);
|
|
box.max += Point3F(lightArray[i]->mRadius, lightArray[i]->mRadius, lightArray[i]->mRadius);
|
|
|
|
// TODO: Account for scale...
|
|
if (mObjBox.isOverlapped(box) == false)
|
|
continue;
|
|
|
|
// The number of light surfaces cannot exceed the total number of non-null surfaces in
|
|
// interior...
|
|
U32 subWaterMark = FrameAllocator::getWaterMark();
|
|
U32* lightSurfaces = (U32*)FrameAllocator::alloc(pInterior->mSurfaces.size() * sizeof(U32));
|
|
U32 numLightSurfaces = 0;
|
|
if (pInterior->buildLightPolyList(lightSurfaces, &numLightSurfaces,
|
|
box, mRenderWorldToObj, getScale()) == false)
|
|
{
|
|
FrameAllocator::setWaterMark(subWaterMark);
|
|
continue;
|
|
}
|
|
|
|
pInterior->renderLights(lightArray[i], mRenderWorldToObj, getScale(), lightSurfaces, numLightSurfaces);
|
|
FrameAllocator::setWaterMark(subWaterMark);
|
|
}
|
|
|
|
FrameAllocator::setWaterMark(lightWaterMark);
|
|
}
|
|
}
|
|
PROFILE_END();
|
|
|
|
glDisable(GL_BLEND);
|
|
if (dglDoesSupportARBMultitexture())
|
|
{
|
|
glActiveTextureARB(GL_TEXTURE1_ARB);
|
|
glDisable(GL_TEXTURE_2D);
|
|
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
|
|
glActiveTextureARB(GL_TEXTURE0_ARB);
|
|
glDisable(GL_TEXTURE_2D);
|
|
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
|
|
}
|
|
else
|
|
{
|
|
glDisable(GL_TEXTURE_2D);
|
|
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
|
|
}
|
|
|
|
glMatrixMode(GL_PROJECTION);
|
|
glPopMatrix();
|
|
dglSetViewport(viewport);
|
|
|
|
glMatrixMode(GL_MODELVIEW);
|
|
glPopMatrix();
|
|
|
|
AssertFatal(dglIsInCanonicalState(), "Error, GL not in canonical state on exit");
|
|
|
|
FrameAllocator::setWaterMark(storedWaterMark);
|
|
dglSetRenderPrimType(0);
|
|
|
|
// Reset the small textures...
|
|
TextureManager::setSmallTexturesActive(false);
|
|
|
|
PROFILE_END();
|
|
}
|
|
|
|
|
|
//--------------------------------------------------------------------------
|
|
bool InteriorInstance::scopeObject(const Point3F& rootPosition,
|
|
const F32 /*rootDistance*/,
|
|
bool* zoneScopeState)
|
|
{
|
|
AssertFatal(isManagingZones(), "Error, should be a zone manager if we are called on to scope the scene!");
|
|
if (bool(mInteriorRes) == false)
|
|
return false;
|
|
|
|
Interior* pInterior = getDetailLevel(0);
|
|
AssertFatal(pInterior->mZones.size() <= csgMaxZoneSize, "Error, too many zones! Increase max");
|
|
bool* pInteriorScopingState = sgScopeBoolArray;
|
|
dMemset(pInteriorScopingState, 0, sizeof(bool) * pInterior->mZones.size());
|
|
|
|
// First, let's transform the point into the interior's space
|
|
Point3F interiorRoot = rootPosition;
|
|
getWorldTransform().mulP(interiorRoot);
|
|
interiorRoot.convolveInverse(getScale());
|
|
|
|
S32 realStartZone = getPointZone(rootPosition);
|
|
if (realStartZone != 0)
|
|
realStartZone = realStartZone - mZoneRangeStart + 1;
|
|
|
|
bool continueOut = pInterior->scopeZones(realStartZone,
|
|
interiorRoot,
|
|
pInteriorScopingState);
|
|
|
|
// Copy pInteriorScopingState to zoneScopeState
|
|
for (S32 i = 1; i < pInterior->mZones.size(); i++)
|
|
zoneScopeState[i + mZoneRangeStart - 1] = pInteriorScopingState[i];
|
|
|
|
return continueOut;
|
|
}
|
|
|
|
|
|
//--------------------------------------------------------------------------
|
|
U32 InteriorInstance::calcDetailLevel(SceneState* state, const Point3F& wsPoint)
|
|
{
|
|
AssertFatal(mInteriorRes, "Error, should not try to calculate the deatil level without a resource to work with!");
|
|
AssertFatal(getNumCurrZones() > 0, "Error, must belong to a zone for this to work");
|
|
|
|
if (smDetailModification < 0.3)
|
|
smDetailModification = 0.3;
|
|
if (smDetailModification > 1.0)
|
|
smDetailModification = 1.0;
|
|
|
|
// Early out for simple interiors
|
|
if (mInteriorRes->getNumDetailLevels() == 1)
|
|
return 0;
|
|
|
|
if((mForcedDetailLevel >= 0) && (mForcedDetailLevel < mInteriorRes->getNumDetailLevels()))
|
|
return(mForcedDetailLevel);
|
|
|
|
Point3F osPoint = wsPoint;
|
|
mRenderWorldToObj.mulP(osPoint);
|
|
osPoint.convolveInverse(mObjScale);
|
|
|
|
// First, see if the point is in the object space bounding box of the highest detail
|
|
// If it is, then the detail level is zero.
|
|
if (mObjBox.isContained(osPoint))
|
|
return 0;
|
|
|
|
// Otherwise, we're going to have to do some ugly trickery to get the projection.
|
|
// I've stolen the worldToScreenScale from dglMatrix, we'll have to calculate the
|
|
// projection of the bounding sphere of the lowest detail level.
|
|
// worldToScreenScale = (near * view.extent.x) / (right - left)
|
|
RectI viewport;
|
|
F64 frustum[4] = { 1e10, -1e10, 1e10, -1e10 };
|
|
|
|
bool init = false;
|
|
SceneObjectRef* pWalk = mZoneRefHead;
|
|
AssertFatal(pWalk != NULL, "Error, object must exist in at least one zone to call this!");
|
|
while (pWalk)
|
|
{
|
|
const SceneState::ZoneState& rState = state->getZoneState(pWalk->zone);
|
|
if (rState.render == true)
|
|
{
|
|
// frustum
|
|
if (rState.frustum[0] < frustum[0]) frustum[0] = rState.frustum[0];
|
|
if (rState.frustum[1] > frustum[1]) frustum[1] = rState.frustum[1];
|
|
if (rState.frustum[2] < frustum[2]) frustum[2] = rState.frustum[2];
|
|
if (rState.frustum[3] > frustum[3]) frustum[3] = rState.frustum[3];
|
|
|
|
// viewport
|
|
if (init == false)
|
|
viewport = rState.viewport;
|
|
else
|
|
viewport.unionRects(rState.viewport);
|
|
|
|
init = true;
|
|
}
|
|
pWalk = pWalk->nextInObj;
|
|
}
|
|
|
|
AssertFatal(init, "InteriorInstance::calcDetailLevel - Error, at least one zone must be rendered here!");
|
|
|
|
const F32 worldToScreenScale = (state->getNearPlane() * viewport.extent.x) / (frustum[1] - frustum[0]);
|
|
const SphereF& lowSphere = mInteriorRes->getDetailLevel(mInteriorRes->getNumDetailLevels() - 1)->mBoundingSphere;
|
|
const F32 dist = (lowSphere.center - osPoint).len();
|
|
F32 projRadius = (lowSphere.radius / dist) * worldToScreenScale;
|
|
|
|
// Scale the projRadius based on the objects maximum scale axis
|
|
projRadius *= getMax(mFabs(mObjScale.x), getMax(mFabs(mObjScale.y), mFabs(mObjScale.z)));
|
|
|
|
// Multiply based on detail preference...
|
|
projRadius *= smDetailModification;
|
|
|
|
// Ok, now we have the projected radius, we need to search through the interiors to
|
|
// find the largest interior that will support this projection.
|
|
U32 final = mInteriorRes->getNumDetailLevels() - 1;
|
|
for (U32 i = 0; i< mInteriorRes->getNumDetailLevels() - 1; i++)
|
|
{
|
|
Interior* pDetail = mInteriorRes->getDetailLevel(i);
|
|
|
|
if (pDetail->mMinPixels < projRadius)
|
|
{
|
|
final = i;
|
|
break;
|
|
}
|
|
}
|
|
|
|
// Ok, that's it.
|
|
return final;
|
|
}
|
|
|
|
|
|
//--------------------------------------------------------------------------
|
|
bool InteriorInstance::prepRenderImage(SceneState* state, const U32 stateKey,
|
|
const U32 startZone, const bool modifyBaseState)
|
|
{
|
|
if (isLastState(state, stateKey))
|
|
return false;
|
|
|
|
PROFILE_START(InteriorPrepRenderImage);
|
|
|
|
setLastState(state, stateKey);
|
|
|
|
U32 realStartZone;
|
|
if (startZone != 0xFFFFFFFF)
|
|
{
|
|
AssertFatal(startZone != 0, "Hm. This really shouldn't happen. Should only get inside zones here");
|
|
AssertFatal(isManagingZones(), "Must be managing zones if we're here...");
|
|
|
|
realStartZone = startZone - mZoneRangeStart + 1;
|
|
}
|
|
else
|
|
{
|
|
realStartZone = getPointZone(state->getCameraPosition());
|
|
if (realStartZone != 0)
|
|
realStartZone = realStartZone - mZoneRangeStart + 1;
|
|
}
|
|
|
|
bool render = true;
|
|
if (modifyBaseState == false)
|
|
{
|
|
// Regular query. We only return a render zone if our parent zone is rendered.
|
|
// Otherwise, we always render
|
|
if (state->isObjectRendered(this) == false)
|
|
{
|
|
PROFILE_END();
|
|
return false;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (mShowTerrainInside == true)
|
|
state->enableTerrainOverride();
|
|
}
|
|
|
|
U32 detailLevel = 0;
|
|
if (startZone == 0xFFFFFFFF)
|
|
detailLevel = calcDetailLevel(state, state->getCameraPosition());
|
|
|
|
if (!Interior::smUseVertexLighting)
|
|
{
|
|
// Since we're rendering: update the lights and the alarm state
|
|
U32 msSinceLightsUpdated = Platform::getVirtualMilliseconds() - getLightUpdatedTime();
|
|
if (msSinceLightsUpdated > smLightUpdatePeriod)
|
|
{
|
|
setLightUpdatedTime(Platform::getVirtualMilliseconds());
|
|
updateAllLights(msSinceLightsUpdated);
|
|
}
|
|
}
|
|
|
|
U32 baseZoneForPrep = getCurrZone(0);
|
|
bool multipleZones = false;
|
|
if (getNumCurrZones() > 1)
|
|
{
|
|
U32 numRenderedZones = 0;
|
|
baseZoneForPrep = 0xFFFFFFFF;
|
|
for (U32 i = 0; i < getNumCurrZones(); i++)
|
|
{
|
|
if (state->getZoneState(getCurrZone(i)).render == true)
|
|
{
|
|
numRenderedZones++;
|
|
if (baseZoneForPrep == 0xFFFFFFFF)
|
|
baseZoneForPrep = getCurrZone(i);
|
|
}
|
|
}
|
|
|
|
if (numRenderedZones > 1)
|
|
multipleZones = true;
|
|
}
|
|
|
|
bool continueOut = mInteriorRes->getDetailLevel(0)->prepRender(state,
|
|
baseZoneForPrep,
|
|
realStartZone, mZoneRangeStart,
|
|
mRenderObjToWorld, mObjScale,
|
|
modifyBaseState & !smDontRestrictOutside,
|
|
smDontRestrictOutside | multipleZones,
|
|
state->mFlipCull);
|
|
if (smDontRestrictOutside)
|
|
continueOut = true;
|
|
|
|
InteriorRenderImage* image = new InteriorRenderImage;
|
|
image->obj = this;
|
|
image->mDetailLevel = detailLevel;
|
|
image->mBaseZone = realStartZone;
|
|
image->textureSortKey = mInteriorFileHash;
|
|
state->insertRenderImage(image);
|
|
|
|
// Add renderimages for any sub-objects, first the independant subs, then the dependants
|
|
// for this detail...
|
|
Point3F osPoint = state->getCameraPosition();
|
|
mRenderWorldToObj.mulP(osPoint);
|
|
osPoint.convolveInverse(mObjScale);
|
|
|
|
U32 i;
|
|
for (i = 0; i < mInteriorSubObjects[0].size(); i++)
|
|
{
|
|
InteriorSubObject* iso = (mInteriorSubObjects[0])[i];
|
|
|
|
if (iso->renderDetailDependant() == false)
|
|
{
|
|
// We want to check the zone that this object is in. If we are traversing upwards
|
|
// though, we have no information about our parent zone, and must return the
|
|
// render image regardless.
|
|
if (modifyBaseState && iso->getZone() == 0)
|
|
{
|
|
// Must return
|
|
}
|
|
else
|
|
{
|
|
U32 realZone;
|
|
if (iso->getZone() == 0)
|
|
realZone = getCurrZone(0);
|
|
else
|
|
realZone = iso->getZone() + mZoneRangeStart - 1;
|
|
|
|
if (state->getZoneState(realZone).render == false)
|
|
{
|
|
// Nuke it...
|
|
continue;
|
|
}
|
|
}
|
|
|
|
// Register the render image, if any, for this ISO.
|
|
SubObjectRenderImage* sri = iso->getRenderImage(state, osPoint);
|
|
if (sri)
|
|
{
|
|
sri->mDetailLevel = 0;
|
|
state->insertRenderImage(sri);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Condier any ISOs from the current LOD.
|
|
for (i = 0; i < mInteriorSubObjects[detailLevel].size(); i++)
|
|
{
|
|
InteriorSubObject* iso = (mInteriorSubObjects[detailLevel])[i];
|
|
|
|
if (iso->renderDetailDependant() == true)
|
|
{
|
|
// We want to check the zone that this object is in. If we are traversing upwards
|
|
// though, we have no information about our parent zone, and must return the
|
|
// render image regardless.
|
|
if (modifyBaseState && iso->getZone() == 0)
|
|
{
|
|
// Must return
|
|
}
|
|
else
|
|
{
|
|
U32 realZone;
|
|
if (iso->getZone() == 0)
|
|
realZone = getCurrZone(0);
|
|
else
|
|
realZone = iso->getZone() + mZoneRangeStart - 1;
|
|
|
|
if (state->getZoneState(realZone).render == false)
|
|
{
|
|
// Nuke it...
|
|
continue;
|
|
}
|
|
}
|
|
|
|
SubObjectRenderImage* sri = iso->getRenderImage(state, osPoint);
|
|
if (sri)
|
|
{
|
|
sri->mDetailLevel = detailLevel;
|
|
state->insertRenderImage(sri);
|
|
}
|
|
}
|
|
}
|
|
|
|
PROFILE_END();
|
|
return continueOut;
|
|
}
|
|
|
|
|
|
//--------------------------------------------------------------------------
|
|
bool InteriorInstance::castRay(const Point3F& s, const Point3F& e, RayInfo* info)
|
|
{
|
|
info->object = this;
|
|
return mInteriorRes->getDetailLevel(0)->castRay(s, e, info);
|
|
}
|
|
|
|
|
|
//------------------------------------------------------------------------------
|
|
void InteriorInstance::setTransform(const MatrixF & mat)
|
|
{
|
|
Parent::setTransform(mat);
|
|
|
|
// Since the interior is a static object, it's render transform changes 1 to 1
|
|
// with it's collision transform
|
|
setRenderTransform(mat);
|
|
|
|
// Notify subobjects that care about the transform change...
|
|
if (bool(mInteriorRes))
|
|
{
|
|
for (U32 i = 0; i < mInteriorSubObjects.size(); i++)
|
|
{
|
|
for (U32 j = 0; j < mInteriorSubObjects[i].size(); j++)
|
|
(mInteriorSubObjects[i])[j]->noteTransformChange();
|
|
}
|
|
}
|
|
|
|
if (isServerObject())
|
|
setMaskBits(TransformMask);
|
|
}
|
|
|
|
|
|
//------------------------------------------------------------------------------
|
|
bool InteriorInstance::buildPolyList(AbstractPolyList* list, const Box3F& wsBox, const SphereF&)
|
|
{
|
|
if (bool(mInteriorRes) == false)
|
|
return false;
|
|
|
|
// Setup collision state data
|
|
list->setTransform(&getTransform(), getScale());
|
|
list->setObject(this);
|
|
|
|
return mInteriorRes->getDetailLevel(0)->buildPolyList(list, wsBox, mWorldToObj, getScale());
|
|
}
|
|
|
|
|
|
|
|
void InteriorInstance::buildConvex(const Box3F& box, Convex* convex)
|
|
{
|
|
if (bool(mInteriorRes) == false)
|
|
return;
|
|
|
|
mConvexList->collectGarbage();
|
|
|
|
Box3F realBox = box;
|
|
mWorldToObj.mul(realBox);
|
|
realBox.min.convolveInverse(mObjScale);
|
|
realBox.max.convolveInverse(mObjScale);
|
|
|
|
if (realBox.isOverlapped(getObjBox()) == false)
|
|
return;
|
|
|
|
U32 waterMark = FrameAllocator::getWaterMark();
|
|
|
|
if ((convex->getObject()->getType() & VehicleObjectType) &&
|
|
mInteriorRes->getDetailLevel(0)->mVehicleConvexHulls.size() > 0)
|
|
{
|
|
// Can never have more hulls than there are hulls in the interior...
|
|
U16* hulls = (U16*)FrameAllocator::alloc(mInteriorRes->getDetailLevel(0)->mVehicleConvexHulls.size() * sizeof(U16));
|
|
U32 numHulls = 0;
|
|
|
|
Interior* pInterior = mInteriorRes->getDetailLevel(0);
|
|
if (pInterior->getIntersectingVehicleHulls(realBox, hulls, &numHulls) == false)
|
|
{
|
|
FrameAllocator::setWaterMark(waterMark);
|
|
return;
|
|
}
|
|
|
|
for (U32 i = 0; i < numHulls; i++)
|
|
{
|
|
// See if this hull exists in the working set already...
|
|
Convex* cc = 0;
|
|
CollisionWorkingList& wl = convex->getWorkingList();
|
|
for (CollisionWorkingList* itr = wl.wLink.mNext; itr != &wl; itr = itr->wLink.mNext)
|
|
{
|
|
if (itr->mConvex->getType() == InteriorConvexType &&
|
|
(static_cast<InteriorConvex*>(itr->mConvex)->getObject() == this &&
|
|
static_cast<InteriorConvex*>(itr->mConvex)->hullId == -S32(hulls[i] + 1)))
|
|
{
|
|
cc = itr->mConvex;
|
|
break;
|
|
}
|
|
}
|
|
if (cc)
|
|
continue;
|
|
|
|
// Create a new convex.
|
|
InteriorConvex* cp = new InteriorConvex;
|
|
mConvexList->registerObject(cp);
|
|
convex->addToWorkingList(cp);
|
|
cp->mObject = this;
|
|
cp->pInterior = pInterior;
|
|
cp->hullId = -S32(hulls[i] + 1);
|
|
cp->box.min.x = pInterior->mVehicleConvexHulls[hulls[i]].minX;
|
|
cp->box.min.y = pInterior->mVehicleConvexHulls[hulls[i]].minY;
|
|
cp->box.min.z = pInterior->mVehicleConvexHulls[hulls[i]].minZ;
|
|
cp->box.max.x = pInterior->mVehicleConvexHulls[hulls[i]].maxX;
|
|
cp->box.max.y = pInterior->mVehicleConvexHulls[hulls[i]].maxY;
|
|
cp->box.max.z = pInterior->mVehicleConvexHulls[hulls[i]].maxZ;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// Can never have more hulls than there are hulls in the interior...
|
|
U16* hulls = (U16*)FrameAllocator::alloc(mInteriorRes->getDetailLevel(0)->mConvexHulls.size() * sizeof(U16));
|
|
U32 numHulls = 0;
|
|
|
|
Interior* pInterior = mInteriorRes->getDetailLevel(0);
|
|
if (pInterior->getIntersectingHulls(realBox, hulls, &numHulls) == false)
|
|
{
|
|
FrameAllocator::setWaterMark(waterMark);
|
|
return;
|
|
}
|
|
|
|
for (U32 i = 0; i < numHulls; i++)
|
|
{
|
|
// See if this hull exists in the working set already...
|
|
Convex* cc = 0;
|
|
CollisionWorkingList& wl = convex->getWorkingList();
|
|
for (CollisionWorkingList* itr = wl.wLink.mNext; itr != &wl; itr = itr->wLink.mNext)
|
|
{
|
|
if (itr->mConvex->getType() == InteriorConvexType &&
|
|
(static_cast<InteriorConvex*>(itr->mConvex)->getObject() == this &&
|
|
static_cast<InteriorConvex*>(itr->mConvex)->hullId == hulls[i]))
|
|
{
|
|
cc = itr->mConvex;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (cc)
|
|
continue;
|
|
|
|
// Create a new convex.
|
|
InteriorConvex* cp = new InteriorConvex;
|
|
mConvexList->registerObject(cp);
|
|
convex->addToWorkingList(cp);
|
|
cp->mObject = this;
|
|
cp->pInterior = pInterior;
|
|
cp->hullId = hulls[i];
|
|
cp->box.min.x = pInterior->mConvexHulls[hulls[i]].minX;
|
|
cp->box.min.y = pInterior->mConvexHulls[hulls[i]].minY;
|
|
cp->box.min.z = pInterior->mConvexHulls[hulls[i]].minZ;
|
|
cp->box.max.x = pInterior->mConvexHulls[hulls[i]].maxX;
|
|
cp->box.max.y = pInterior->mConvexHulls[hulls[i]].maxY;
|
|
cp->box.max.z = pInterior->mConvexHulls[hulls[i]].maxZ;
|
|
}
|
|
}
|
|
FrameAllocator::setWaterMark(waterMark);
|
|
}
|
|
|
|
|
|
//------------------------------------------------------------------------------
|
|
U32 InteriorInstance::packUpdate(NetConnection* c, U32 mask, BitStream* stream)
|
|
{
|
|
U32 retMask = Parent::packUpdate(c, mask, stream);
|
|
|
|
if (stream->writeFlag((mask & InitMask) != 0))
|
|
{
|
|
// Initial update, write the whole kit and kaboodle
|
|
stream->write(mCRC);
|
|
|
|
stream->writeString(mInteriorFileName);
|
|
stream->writeFlag(mShowTerrainInside);
|
|
|
|
// Write the transform (do _not_ use writeAffineTransform. Since this is a static
|
|
// object, the transform must be RIGHT THE *&)*$&^ ON or it will goof up the
|
|
// synchronization between the client and the server.
|
|
mathWrite(*stream, mObjToWorld);
|
|
mathWrite(*stream, mObjScale);
|
|
|
|
// Write the alarm state
|
|
stream->writeFlag(mAlarmState);
|
|
|
|
// Write the skinbase
|
|
stream->writeString(mSkinBase);
|
|
|
|
// audio profile
|
|
if(stream->writeFlag(mAudioProfile))
|
|
stream->writeRangedU32(mAudioProfile->getId(), DataBlockObjectIdFirst, DataBlockObjectIdLast);
|
|
|
|
// audio environment:
|
|
if(stream->writeFlag(mAudioEnvironment))
|
|
stream->writeRangedU32(mAudioEnvironment->getId(), DataBlockObjectIdFirst, DataBlockObjectIdLast);
|
|
|
|
// Lighting behavior.
|
|
stream->writeFlag(mUseGLLighting);
|
|
}
|
|
else
|
|
{
|
|
if (stream->writeFlag((mask & TransformMask) != 0))
|
|
{
|
|
mathWrite(*stream, mObjToWorld);
|
|
mathWrite(*stream, mObjScale);
|
|
}
|
|
|
|
stream->writeFlag(mAlarmState);
|
|
|
|
// Check the lights to see if we need to update any of their states
|
|
LightUpdateGrouper::BitIterator itr;
|
|
for (itr = mUpdateGrouper->begin(); itr.valid() && itr.getNumKeys(); itr++)
|
|
{
|
|
if (stream->writeFlag((mask & itr.getMask()) != 0))
|
|
{
|
|
LightUpdateGrouper::BitIterator::iterator kItr;
|
|
for (kItr = itr.begin(); kItr != itr.end(); kItr++)
|
|
{
|
|
U32 key = *kItr;
|
|
U32 detail = detailFromUpdateKey(key);
|
|
U32 index = indexFromUpdateKey(key);
|
|
|
|
stream->writeFlag(mLightInfo[detail].mLights[index].active);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (stream->writeFlag(mask & SkinBaseMask))
|
|
stream->writeString(mSkinBase);
|
|
|
|
// audio update:
|
|
if(stream->writeFlag(mask & AudioMask))
|
|
{
|
|
// profile:
|
|
if(stream->writeFlag(mAudioProfile))
|
|
stream->writeRangedU32(mAudioProfile->getId(), DataBlockObjectIdFirst, DataBlockObjectIdLast);
|
|
|
|
// environment:
|
|
if(stream->writeFlag(mAudioEnvironment))
|
|
stream->writeRangedU32(mAudioEnvironment->getId(), DataBlockObjectIdFirst, DataBlockObjectIdLast);
|
|
}
|
|
}
|
|
|
|
return retMask;
|
|
}
|
|
|
|
|
|
//------------------------------------------------------------------------------
|
|
void InteriorInstance::unpackUpdate(NetConnection* c, BitStream* stream)
|
|
{
|
|
Parent::unpackUpdate(c, stream);
|
|
|
|
MatrixF temp;
|
|
Point3F tempScale;
|
|
|
|
if (stream->readFlag())
|
|
{
|
|
// Initial Update
|
|
// CRC
|
|
stream->read(&mCRC);
|
|
|
|
// File
|
|
mInteriorFileName = stream->readSTString();
|
|
|
|
// Terrain flag
|
|
mShowTerrainInside = stream->readFlag();
|
|
|
|
// Transform
|
|
mathRead(*stream, &temp);
|
|
mathRead(*stream, &tempScale);
|
|
setScale(tempScale);
|
|
setTransform(temp);
|
|
|
|
// Alarm state: Note that we handle this ourselves on the initial update
|
|
// so that the state is always full on or full off...
|
|
mAlarmState = stream->readFlag();
|
|
|
|
mSkinBase = stream->readSTString();
|
|
|
|
// audio profile:
|
|
if(stream->readFlag())
|
|
{
|
|
U32 profileId = stream->readRangedU32(DataBlockObjectIdFirst, DataBlockObjectIdLast);
|
|
mAudioProfile = dynamic_cast<AudioProfile*>(Sim::findObject(profileId));
|
|
}
|
|
else
|
|
mAudioProfile = 0;
|
|
|
|
// audio environment:
|
|
if(stream->readFlag())
|
|
{
|
|
U32 profileId = stream->readRangedU32(DataBlockObjectIdFirst, DataBlockObjectIdLast);
|
|
mAudioEnvironment = dynamic_cast<AudioEnvironment*>(Sim::findObject(profileId));
|
|
}
|
|
else
|
|
mAudioEnvironment = 0;
|
|
|
|
// Lighting behavior.
|
|
mDoSimpleDynamicRender = mUseGLLighting = stream->readFlag();
|
|
}
|
|
else
|
|
{
|
|
// Normal update
|
|
if (stream->readFlag())
|
|
{
|
|
mathRead(*stream, &temp);
|
|
mathRead(*stream, &tempScale);
|
|
setScale(tempScale);
|
|
setTransform(temp);
|
|
}
|
|
|
|
setAlarmMode(stream->readFlag());
|
|
|
|
LightUpdateGrouper::BitIterator itr;
|
|
for (itr = mUpdateGrouper->begin(); itr.valid() && itr.getNumKeys(); itr++)
|
|
{
|
|
if (stream->readFlag())
|
|
{
|
|
LightUpdateGrouper::BitIterator::iterator kItr;
|
|
for (kItr = itr.begin(); kItr != itr.end(); kItr++)
|
|
{
|
|
U32 key = *kItr;
|
|
U32 detail = detailFromUpdateKey(key);
|
|
U32 index = indexFromUpdateKey(key);
|
|
|
|
if (stream->readFlag())
|
|
activateLight(detail, index);
|
|
else
|
|
deactivateLight(detail, index);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (stream->readFlag())
|
|
{
|
|
mSkinBase = stream->readSTString();
|
|
renewOverlays();
|
|
}
|
|
|
|
// audio update:
|
|
if(stream->readFlag())
|
|
{
|
|
// profile:
|
|
if(stream->readFlag())
|
|
{
|
|
U32 profileId = stream->readRangedU32(DataBlockObjectIdFirst, DataBlockObjectIdLast);
|
|
mAudioProfile = dynamic_cast<AudioProfile*>(Sim::findObject(profileId));
|
|
}
|
|
else
|
|
mAudioProfile = 0;
|
|
|
|
// environment:
|
|
if(stream->readFlag())
|
|
{
|
|
U32 profileId = stream->readRangedU32(DataBlockObjectIdFirst, DataBlockObjectIdLast);
|
|
mAudioEnvironment = dynamic_cast<AudioEnvironment*>(Sim::findObject(profileId));
|
|
}
|
|
else
|
|
mAudioEnvironment = 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
//------------------------------------------------------------------------------
|
|
Interior* InteriorInstance::getDetailLevel(const U32 level)
|
|
{
|
|
return mInteriorRes->getDetailLevel(level);
|
|
}
|
|
|
|
U32 InteriorInstance::getNumDetailLevels()
|
|
{
|
|
return mInteriorRes->getNumDetailLevels();
|
|
}
|
|
|
|
//--------------------------------------------------------------------------
|
|
//-------------------------------------- Alarm functionality
|
|
//
|
|
void InteriorInstance::setAlarmMode(const bool alarm)
|
|
{
|
|
if (mInteriorRes->getDetailLevel(0)->mHasAlarmState == false)
|
|
return;
|
|
|
|
if (mAlarmState == alarm)
|
|
return;
|
|
|
|
mAlarmState = alarm;
|
|
if (isServerObject())
|
|
{
|
|
setMaskBits(AlarmMask);
|
|
}
|
|
else
|
|
{
|
|
// DMMTODO: Invalidate current light state
|
|
}
|
|
}
|
|
|
|
|
|
//--------------------------------------------------------------------------
|
|
void InteriorInstance::rebuildVertexColors()
|
|
{
|
|
U32 i;
|
|
for (i = 0; i < mVertexColorsNormal.size(); i++)
|
|
{
|
|
delete mVertexColorsNormal[i];
|
|
mVertexColorsNormal[i] = NULL;
|
|
}
|
|
for (i = 0; i < mVertexColorsAlarm.size(); i++)
|
|
{
|
|
delete mVertexColorsAlarm[i];
|
|
mVertexColorsAlarm[i] = NULL;
|
|
}
|
|
|
|
if (bool(mInteriorRes) == false)
|
|
return;
|
|
|
|
mVertexColorsNormal.setSize(mInteriorRes->getNumDetailLevels());
|
|
mVertexColorsAlarm.setSize(mInteriorRes->getNumDetailLevels());
|
|
|
|
for (i = 0; i < mInteriorRes->getNumDetailLevels(); i++)
|
|
{
|
|
mVertexColorsNormal[i] = new Vector<ColorI>;
|
|
mVertexColorsAlarm[i] = new Vector<ColorI>;
|
|
VECTOR_SET_ASSOCIATION((*mVertexColorsNormal[i]));
|
|
VECTOR_SET_ASSOCIATION((*mVertexColorsAlarm[i]));
|
|
}
|
|
|
|
for (i = 0; i < mInteriorRes->getNumDetailLevels(); i++)
|
|
{
|
|
Interior* pInterior = mInteriorRes->getDetailLevel(i);
|
|
pInterior->rebuildVertexColors(mLMHandle,
|
|
mVertexColorsNormal[i],
|
|
mVertexColorsAlarm[i]);
|
|
}
|
|
}
|
|
|
|
|
|
//--------------------------------------------------------------------------
|
|
void InteriorInstance::updateLightMap(Interior* pInterior, LightInfo& rLightInfo, const U32 surfaceIndex)
|
|
{
|
|
AssertFatal(surfaceIndex < pInterior->mSurfaces.size(), "Error, out of range surface index");
|
|
static U8 _newLightMapBuffer[256*256*3];
|
|
|
|
const Interior::Surface& rSurface = pInterior->mSurfaces[surfaceIndex];
|
|
if (rSurface.lightCount == 0)
|
|
return;
|
|
|
|
// Get the surface's original bitmap
|
|
TextureHandle* originalLMapHandle = ((mAlarmState == false) ?
|
|
gInteriorLMManager.getHandle(pInterior->getLMHandle(), mLMHandle,
|
|
pInterior->mNormalLMapIndices[surfaceIndex]) :
|
|
gInteriorLMManager.getHandle(pInterior->getLMHandle(), mLMHandle,
|
|
pInterior->mAlarmLMapIndices[surfaceIndex]));
|
|
|
|
const GBitmap* pOriginalLMap = originalLMapHandle->getBitmap();
|
|
AssertFatal(pOriginalLMap != NULL, "error, no lightmap on the handle!");
|
|
AssertFatal(pOriginalLMap->getFormat() == GBitmap::RGB, "error, bad lightmap format!");
|
|
|
|
// First, we need to create a buffer that will receive the new lightmap
|
|
U32 dimX = rSurface.mapSizeX;
|
|
U32 dimY = rSurface.mapSizeY;
|
|
U8* pNewLightmap = _newLightMapBuffer;
|
|
|
|
// copy the original lightmap
|
|
const U8 * src = pOriginalLMap->getAddress(rSurface.mapOffsetX, rSurface.mapOffsetY);
|
|
U8 * dest = pNewLightmap;
|
|
|
|
U32 runSize = rSurface.mapSizeX * 3;
|
|
U32 srcStep = pOriginalLMap->getWidth() * 3;
|
|
|
|
for(U32 y = 0; y < rSurface.mapSizeY; y++)
|
|
{
|
|
dMemcpy(dest, src, runSize);
|
|
dest += runSize;
|
|
src += srcStep;
|
|
}
|
|
|
|
// ...now we have the original lightmap, add in the animateds...
|
|
for (U32 i = 0; i < rSurface.lightCount; i++)
|
|
{
|
|
const LightInfo::StateDataInfo& rInfo = rLightInfo.mStateDataInfo[rSurface.lightStateInfoStart + i];
|
|
|
|
// Only add in states that affect this surface...duh.
|
|
if (rInfo.curMap != NULL && rInfo.alarm == (mAlarmState != Normal))
|
|
{
|
|
intensityMapMerge(pNewLightmap, dimX, dimY,
|
|
rInfo.curMap, rInfo.curColor);
|
|
}
|
|
}
|
|
|
|
// OK, now we have the final, current lightmap. subimage it in...
|
|
glBindTexture(GL_TEXTURE_2D, originalLMapHandle->getGLName());
|
|
|
|
if (Con::getBoolVariable("$pref::OpenGL::disableSubImage", false))
|
|
{
|
|
const U8 *src = pNewLightmap;
|
|
U8 *dest = (U8 *) pOriginalLMap->getAddress(rSurface.mapOffsetX, rSurface.mapOffsetY);
|
|
U32 destStep = pOriginalLMap->getWidth() * 3;
|
|
|
|
// copy back into the original lightmap
|
|
for (U32 y = 0; y < rSurface.mapSizeY; y++)
|
|
{
|
|
dMemcpy(dest, src, runSize);
|
|
src += runSize;
|
|
dest += destStep;
|
|
}
|
|
|
|
glTexImage2D(GL_TEXTURE_2D,
|
|
0,
|
|
GL_RGB,
|
|
pOriginalLMap->getWidth(), pOriginalLMap->getHeight(),
|
|
0,
|
|
GL_RGB, GL_UNSIGNED_BYTE,
|
|
pOriginalLMap->getBits(0));
|
|
}
|
|
else
|
|
{
|
|
glTexSubImage2D(GL_TEXTURE_2D,
|
|
0,
|
|
rSurface.mapOffsetX, rSurface.mapOffsetY,
|
|
rSurface.mapSizeX, rSurface.mapSizeY,
|
|
GL_RGB, GL_UNSIGNED_BYTE,
|
|
pNewLightmap);
|
|
}
|
|
}
|
|
|
|
|
|
//--------------------------------------------------------------------------
|
|
void InteriorInstance::downloadLightmaps(SceneState* /*state*/,
|
|
Interior* pInterior,
|
|
LightInfo& rLightInfo)
|
|
{
|
|
extern U16* sgActivePolyList;
|
|
extern U32 sgActivePolyListSize;
|
|
|
|
for (U32 i = 0; i < sgActivePolyListSize; i++)
|
|
{
|
|
if (rLightInfo.mSurfaceInvalid.test(sgActivePolyList[i]) == true)
|
|
{
|
|
updateLightMap(pInterior, rLightInfo, sgActivePolyList[i]);
|
|
rLightInfo.mSurfaceInvalid.clear(sgActivePolyList[i]);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
//--------------------------------------------------------------------------
|
|
void InteriorInstance::addChildren()
|
|
{
|
|
if (bool(mInteriorRes) == false)
|
|
return;
|
|
|
|
char nameBuffer[256];
|
|
U32 i;
|
|
|
|
// First thing to do, add a group with our name
|
|
SimGroup* myGroup = getGroup();
|
|
|
|
// Load all the interior game objects...
|
|
for(i = 0; i < mInteriorRes->getNumGameEntities(); i++)
|
|
{
|
|
ItrGameEntity *ent = mInteriorRes->getGameEntity(i);
|
|
ConsoleObject *obj = ConsoleObject::create(ent->mGameClass);
|
|
GameBase *gb = dynamic_cast<GameBase*>(obj);
|
|
if(!gb)
|
|
{
|
|
Con::errorf("Invalid game class for entity: %s", ent->mGameClass);
|
|
delete obj;
|
|
continue;
|
|
}
|
|
gb->setField("dataBlock", ent->mDataBlock);
|
|
gb->setModStaticFields(true);
|
|
for(U32 j = 0; j < ent->mDictionary.size(); j++)
|
|
gb->setDataField(StringTable->insert(ent->mDictionary[j].name), NULL, ent->mDictionary[j].value);
|
|
gb->setModStaticFields(false);
|
|
Point3F origin = ent->mPos;
|
|
origin.convolve(mObjScale);
|
|
getTransform().mulP(origin);
|
|
MatrixF xform(true);
|
|
xform.setColumn(3, origin);
|
|
gb->setTransform(xform);
|
|
if(!gb->registerObject())
|
|
{
|
|
Con::errorf("Failed to register entity: %s: %s", ent->mGameClass, ent->mDataBlock);
|
|
delete gb;
|
|
continue;
|
|
}
|
|
myGroup->addObject(gb);
|
|
}
|
|
|
|
// Next, for each door in our resource, we'll be creating a group
|
|
for (i = 0; i < mInteriorRes->getNumInteriorPathFollowers(); i++)
|
|
{
|
|
InteriorPathFollower* pSource = mInteriorRes->getInteriorPathFollower(i);
|
|
|
|
StringTableEntry name = StringTable->insert(pSource->mName);
|
|
PathedInterior* child = new PathedInterior;
|
|
child->mName = name;
|
|
child->mInteriorResIndex = pSource->mInteriorResIndex;
|
|
child->mPathIndex = pSource->mPathIndex;
|
|
child->mOffset = pSource->mOffset;
|
|
child->mInteriorResName = mInteriorFileName;
|
|
child->setField("dataBlock", pSource->mDataBlock);
|
|
|
|
for(U32 i = 0; i < pSource->mDictionary.size(); i++)
|
|
child->setDataField(pSource->mDictionary[i].name, NULL, pSource->mDictionary[i].value);
|
|
|
|
// Create a group for the door
|
|
SimGroup* doorGroup = new SimGroup;
|
|
dSprintf(nameBuffer, 255, "%s_g", child->mName);
|
|
doorGroup->registerObject();
|
|
myGroup->addObject(doorGroup, nameBuffer);
|
|
|
|
// Ok, now we need to add the path and any triggers that affect the door here...
|
|
Path* pSimPath = new Path;
|
|
pSimPath->registerObject();
|
|
doorGroup->addObject(pSimPath);
|
|
|
|
for (U32 j = 0; j < pSource->mWayPoints.size(); j++)
|
|
{
|
|
Marker* pMarker = new Marker;
|
|
pMarker->mSeqNum = j;
|
|
pMarker->mMSToNext = pSource->mWayPoints[j].msToNext;
|
|
pMarker->mSmoothingType = pSource->mWayPoints[j].smoothingType;
|
|
|
|
pMarker->registerObject();
|
|
|
|
pSimPath->addObject(pMarker);
|
|
|
|
Point3F markerPos = pSource->mWayPoints[j].pos;
|
|
markerPos.convolve(mObjScale);
|
|
getTransform().mulP(markerPos);
|
|
MatrixF xform(true);
|
|
xform.setColumn(3, markerPos);
|
|
pMarker->setTransform(xform);
|
|
}
|
|
//pSimPath->finishPath();
|
|
|
|
// Now we need to add any triggers relevant to this door...
|
|
//
|
|
for (U32 k = 0; k < pSource->mTriggerIds.size(); k++)
|
|
{
|
|
InteriorResTrigger *pITrigger = mInteriorRes->getTrigger(pSource->mTriggerIds[k]);
|
|
// Add the object...
|
|
Trigger* pTrigger = new Trigger;
|
|
pTrigger->setField("dataBlock", pITrigger->mDataBlock);
|
|
for(U32 i = 0; i < pITrigger->mDictionary.size(); i++)
|
|
pTrigger->setDataField(StringTable->insert(pITrigger->mDictionary[i].name), NULL, pITrigger->mDictionary[i].value);
|
|
|
|
MatrixF newXForm;
|
|
createTriggerTransform(pITrigger, &newXForm);
|
|
pTrigger->setTriggerPolyhedron(pITrigger->mPolyhedron);
|
|
pTrigger->setScale(mObjScale);
|
|
pTrigger->setTransform(newXForm);
|
|
|
|
pTrigger->registerObject();
|
|
doorGroup->addObject(pTrigger, pITrigger->mName);
|
|
}
|
|
|
|
// And finally, add the door, taking care to get the transform right...
|
|
MatrixF childTransform(true);
|
|
Point3F childOffset = child->mOffset;
|
|
childOffset.convolve(mObjScale);
|
|
getTransform().mulP(childOffset);
|
|
childOffset.neg();
|
|
childTransform.setColumn(3, childOffset);
|
|
childTransform.mul(getTransform());
|
|
child->mBaseTransform = childTransform;
|
|
child->mBaseScale = mObjScale;
|
|
doorGroup->addObject(child, child->mName);
|
|
if (!child->registerObject())
|
|
{
|
|
Con::warnf(ConsoleLogEntry::General, "Warning, could not register door. Door skipped!");
|
|
delete child;
|
|
continue;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
void InteriorInstance::createTriggerTransform(const InteriorResTrigger* trigger, MatrixF* transform)
|
|
{
|
|
Point3F offset;
|
|
MatrixF xform = getTransform();
|
|
xform.getColumn(3, &offset);
|
|
|
|
Point3F triggerOffset = trigger->mOffset;
|
|
triggerOffset.convolve(mObjScale);
|
|
getTransform().mulV(triggerOffset);
|
|
offset += triggerOffset;
|
|
xform.setColumn(3, offset);
|
|
|
|
*transform = xform;
|
|
}
|
|
|
|
bool InteriorInstance::readLightmaps(GBitmap**** lightmaps)
|
|
{
|
|
AssertFatal(mInteriorRes, "Error, no interior loaded!");
|
|
AssertFatal(lightmaps, "Error, no lightmaps or numdetails result pointers");
|
|
AssertFatal(*lightmaps == NULL, "Error, already have a pointer in the lightmaps result field!");
|
|
|
|
// Load resource
|
|
Stream* pStream = ResourceManager->openStream(mInteriorFileName);
|
|
if (pStream == NULL) {
|
|
Con::errorf(ConsoleLogEntry::General, "Unable to load interior: %s", mInteriorFileName);
|
|
return false;
|
|
}
|
|
|
|
InteriorResource* pResource = new InteriorResource;
|
|
bool success = pResource->read(*pStream);
|
|
ResourceManager->closeStream(pStream);
|
|
|
|
if (success == false)
|
|
{
|
|
delete pResource;
|
|
return false;
|
|
}
|
|
AssertFatal(pResource->getNumDetailLevels() == mInteriorRes->getNumDetailLevels(),
|
|
"Mismatched detail levels!");
|
|
|
|
*lightmaps = new GBitmap**[mInteriorRes->getNumDetailLevels()];
|
|
|
|
for (U32 i = 0; i < pResource->getNumDetailLevels(); i++)
|
|
{
|
|
Interior* pInterior = pResource->getDetailLevel(i);
|
|
(*lightmaps)[i] = new GBitmap*[pInterior->mLightmaps.size()];
|
|
for (U32 j = 0; j < pInterior->mLightmaps.size(); j++)
|
|
{
|
|
((*lightmaps)[i])[j] = pInterior->mLightmaps[j];
|
|
pInterior->mLightmaps[j] = NULL;
|
|
}
|
|
pInterior->mLightmaps.clear();
|
|
}
|
|
|
|
delete pResource;
|
|
return true;
|
|
}
|
|
|
|
|