You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1270 lines
28 KiB
1270 lines
28 KiB
4 years ago
|
/*==LICENSE==*
|
||
|
|
|
||
|
|
CyanWorlds.com Engine - MMOG client, server and tools
|
||
|
|
Copyright (C) 2011 Cyan Worlds, Inc.
|
||
|
|
|
||
|
|
This program is free software: you can redistribute it and/or modify
|
||
|
|
it under the terms of the GNU General Public License as published by
|
||
|
|
the Free Software Foundation, either version 3 of the License, or
|
||
|
|
(at your option) any later version.
|
||
|
|
|
||
|
|
This program is distributed in the hope that it will be useful,
|
||
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||
|
|
GNU General Public License for more details.
|
||
|
|
|
||
|
|
You should have received a copy of the GNU General Public License
|
||
|
|
along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||
|
|
|
||
|
|
Additional permissions under GNU GPL version 3 section 7
|
||
|
|
|
||
|
|
If you modify this Program, or any covered work, by linking or
|
||
|
|
combining it with any of RAD Game Tools Bink SDK, Autodesk 3ds Max SDK,
|
||
|
|
NVIDIA PhysX SDK, Microsoft DirectX SDK, OpenSSL library, Independent
|
||
|
|
JPEG Group JPEG library, Microsoft Windows Media SDK, or Apple QuickTime SDK
|
||
|
|
(or a modified version of those libraries),
|
||
|
|
containing parts covered by the terms of the Bink SDK EULA, 3ds Max EULA,
|
||
|
|
PhysX SDK EULA, DirectX SDK EULA, OpenSSL and SSLeay licenses, IJG
|
||
|
|
JPEG Library README, Windows Media SDK EULA, or QuickTime SDK EULA, the
|
||
|
|
licensors of this Program grant you additional
|
||
|
|
permission to convey the resulting work. Corresponding Source for a
|
||
|
|
non-source form of such a combination shall include the source code for
|
||
|
|
the parts of OpenSSL and IJG JPEG Library used as well as that of the covered
|
||
|
|
work.
|
||
|
|
|
||
|
|
You can contact Cyan Worlds, Inc. by email legal@cyan.com
|
||
|
|
or by snail mail at:
|
||
|
|
Cyan Worlds, Inc.
|
||
|
|
14617 N Newport Hwy
|
||
|
|
Mead, WA 99021
|
||
|
|
|
||
|
|
*==LICENSE==*/
|
||
|
|
|
||
|
|
#include "hsTypes.h"
|
||
|
|
#include "hsGEnviron.h"
|
||
|
|
#include "../plSurface/hsGLayer.h"
|
||
|
|
#include "../plSurface/hsGMaterial.h"
|
||
|
|
//#include "hsG3DDevice.h"
|
||
|
|
//#include "plCamera.h"
|
||
|
|
#include "hsFogControl.h"
|
||
|
|
#include "../plGRenderProcs/hsGRenderProcs.h"
|
||
|
|
#if 0 // SCENENODE_DEFER
|
||
|
|
#include "hsScene.h"
|
||
|
|
#endif // SCENENODE_DEFER
|
||
|
|
#include "../plResMgr/hsResMgr.h"
|
||
|
|
#include "hsGStatGather3.h"
|
||
|
|
#include "../plResMgr/plKey.h"
|
||
|
|
#include "hsTimer.h"
|
||
|
|
#include "../plResMgr/plRefMsg.h"
|
||
|
|
|
||
|
|
const UInt16 hsGEnvironment::kSaveMagicNumber = 0x1f7a;
|
||
|
|
const UInt16 hsGEnvironment::kSaveVersion = 2;
|
||
|
|
|
||
|
|
hsScalar hsGEnvironment::fYonScale = 1.f;
|
||
|
|
|
||
|
|
hsGEnvironment::hsGEnvironment()
|
||
|
|
: fFlags(0),
|
||
|
|
fValidScale(1.f),
|
||
|
|
fMap(nil),
|
||
|
|
fPos(0,0,0),
|
||
|
|
fRadius(0),
|
||
|
|
fFogDistance(0),
|
||
|
|
fFogDepth(0),
|
||
|
|
fCurrentDepth(0),
|
||
|
|
fFogDensity(0),
|
||
|
|
fDevCache(nil),
|
||
|
|
fYon(0),
|
||
|
|
fFogControl(nil)
|
||
|
|
{
|
||
|
|
fFogColor.SetValue(hsColorRGBA().Set(0, 0, 0, hsScalar1));
|
||
|
|
SetFogColor(fFogColor.GetValue());
|
||
|
|
*fMapName = 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
hsGEnvironment::~hsGEnvironment()
|
||
|
|
{
|
||
|
|
hsRefCnt_SafeUnRef(fMap);
|
||
|
|
hsRefCnt_SafeUnRef(fDevCache);
|
||
|
|
|
||
|
|
hsRefCnt_SafeUnRef(fFogControl);
|
||
|
|
|
||
|
|
Int32 i;
|
||
|
|
for (i=0; i<fFogStateStack.GetCount(); i++)
|
||
|
|
delete fFogStateStack[i];
|
||
|
|
|
||
|
|
for( i = 0; i < GetNumRenderProcs(); i++ )
|
||
|
|
hsRefCnt_SafeUnRef(GetRenderProc(i));
|
||
|
|
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
#if 0 // SCENENODE_DEFER
|
||
|
|
hsBool32 hsGEnvironment::AddNode(hsSceneNode *node)
|
||
|
|
{
|
||
|
|
return AddNodeKey(node->GetKey());
|
||
|
|
}
|
||
|
|
#endif // SCENENODE_DEFER
|
||
|
|
|
||
|
|
hsBool32 hsGEnvironment::AddNodeKey(plKey *key)
|
||
|
|
{
|
||
|
|
Int32 i;
|
||
|
|
for (i = 0; i < GetNumNodes(); i++)
|
||
|
|
{
|
||
|
|
if (GetNodeKey(i) == key) // nothing to do
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
fNodeKeys.Append(key);
|
||
|
|
|
||
|
|
hsSceneNode *node = (hsSceneNode *)(key->GetObjectPtr());
|
||
|
|
#if 0 // SCENENODE_DEFER
|
||
|
|
if (node)
|
||
|
|
{
|
||
|
|
if (!(GetFlags() & hsGEnvironment::kFarOut))
|
||
|
|
{
|
||
|
|
node->SetEnvironment(this);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
node->SetFarEnvironment(this);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
#endif // SCENENODE_DEFER
|
||
|
|
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
hsSceneNode* hsGEnvironment::GetNode(Int32 i)
|
||
|
|
{
|
||
|
|
return (hsSceneNode*)(fNodeKeys[i]->GetObjectPtr());
|
||
|
|
}
|
||
|
|
|
||
|
|
void hsGEnvironment::FogState::ValidateEnv(hsGEnvironment* env)
|
||
|
|
{
|
||
|
|
char* msg = "hsGEnvironment not in reset state.";
|
||
|
|
if( fFlags & kYonSet )
|
||
|
|
{
|
||
|
|
hsAssert(env->GetFlags() & hsGEnvironment::kYonSet, msg);
|
||
|
|
hsAssert(fYon == env->YonState(), msg);
|
||
|
|
}
|
||
|
|
|
||
|
|
if( fFlags & kDistanceSet )
|
||
|
|
{
|
||
|
|
hsAssert(env->GetFlags() & hsGEnvironment::kFogDistanceSet, msg);
|
||
|
|
hsAssert(fDistance == env->FogDistanceState(), msg);
|
||
|
|
}
|
||
|
|
|
||
|
|
if( fFlags & kDepthSet )
|
||
|
|
{
|
||
|
|
hsAssert(env->GetFlags() & hsGEnvironment::kFogDepthSet, msg);
|
||
|
|
hsAssert(fDepth == env->FogDepthState(), msg);
|
||
|
|
}
|
||
|
|
|
||
|
|
if( fFlags & kDensitySet )
|
||
|
|
{
|
||
|
|
hsAssert(env->GetFlags() & hsGEnvironment::kFogDensitySet, msg);
|
||
|
|
hsAssert(fDensity == env->FogDensityState(), msg);
|
||
|
|
}
|
||
|
|
|
||
|
|
if( fFlags & kColorSet )
|
||
|
|
{
|
||
|
|
hsAssert(env->GetFlags() & hsGEnvironment::kFogColorSet, msg);
|
||
|
|
hsAssert(fColor == env->FogColorState(), msg);
|
||
|
|
}
|
||
|
|
|
||
|
|
if( fFlags & kClearSet )
|
||
|
|
{
|
||
|
|
hsAssert(env->GetFlags() & hsGEnvironment::kClearColorSet, msg);
|
||
|
|
hsAssert(fClear == env->ClearColorState(), msg);
|
||
|
|
}
|
||
|
|
|
||
|
|
UInt32 envFogType = env->GetFlags() & hsGEnvironment::kFogTypeMask;
|
||
|
|
switch( fFlags & kTypeMask )
|
||
|
|
{
|
||
|
|
case kLinear:
|
||
|
|
hsAssert(envFogType == hsGEnvironment::kFogLinear, msg);
|
||
|
|
break;
|
||
|
|
case kExp:
|
||
|
|
hsAssert(envFogType == hsGEnvironment::kFogExp, msg);
|
||
|
|
break;
|
||
|
|
case kExp2:
|
||
|
|
hsAssert(envFogType == hsGEnvironment::kFogExp2, msg);
|
||
|
|
break;
|
||
|
|
default:
|
||
|
|
hsAssert(false, msg);
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
void hsGEnvironment::FogState::SetFromEnv(hsGEnvironment* env)
|
||
|
|
{
|
||
|
|
if( env->GetFlags() & hsGEnvironment::kYonSet )
|
||
|
|
{
|
||
|
|
fYon = env->YonState();
|
||
|
|
fFlags |= kYonSet;
|
||
|
|
}
|
||
|
|
if( env->GetFlags() & hsGEnvironment::kFogDistanceSet )
|
||
|
|
{
|
||
|
|
fDistance = env->FogDistanceState();
|
||
|
|
fFlags |= kDistanceSet;
|
||
|
|
}
|
||
|
|
if( env->GetFlags() & hsGEnvironment::kFogDepthSet )
|
||
|
|
{
|
||
|
|
fDepth = env->FogDepthState();
|
||
|
|
fFlags |= kDepthSet;
|
||
|
|
}
|
||
|
|
if( env->GetFlags() & hsGEnvironment::kFogDensitySet )
|
||
|
|
{
|
||
|
|
fDensity = env->FogDensityState();
|
||
|
|
fFlags |= kDensitySet;
|
||
|
|
}
|
||
|
|
if( env->GetFlags() & hsGEnvironment::kFogColorSet )
|
||
|
|
{
|
||
|
|
fColor = env->FogColorState();
|
||
|
|
fFlags |= kColorSet;
|
||
|
|
}
|
||
|
|
if( env->GetFlags() & hsGEnvironment::kClearColorSet )
|
||
|
|
{
|
||
|
|
fClear = env->ClearColorState();
|
||
|
|
fFlags |= kClearSet;
|
||
|
|
}
|
||
|
|
|
||
|
|
fFlags &= ~kTypeMask;
|
||
|
|
switch( env->GetFlags() & hsGEnvironment::kFogTypeMask )
|
||
|
|
{
|
||
|
|
case hsGEnvironment::kFogLinear:
|
||
|
|
fFlags |= kLinear;
|
||
|
|
break;
|
||
|
|
case hsGEnvironment::kFogExp:
|
||
|
|
fFlags |= kExp;
|
||
|
|
break;
|
||
|
|
case hsGEnvironment::kFogExp2:
|
||
|
|
fFlags |= kExp2;
|
||
|
|
break;
|
||
|
|
default:
|
||
|
|
hsAssert(false, "Fog type should at least default at load");
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
void hsGEnvironment::FogState::SetToEnv(hsGEnvironment* env)
|
||
|
|
{
|
||
|
|
if( fFlags & kYonSet )
|
||
|
|
env->SetYon(fYon);
|
||
|
|
else
|
||
|
|
env->UnSetYon();
|
||
|
|
|
||
|
|
if( fFlags & kDistanceSet )
|
||
|
|
env->SetFogDistance(fDistance);
|
||
|
|
else
|
||
|
|
env->UnSetFogDistance();
|
||
|
|
|
||
|
|
if( fFlags & kDepthSet )
|
||
|
|
{
|
||
|
|
env->SetFogDepth(fDepth);
|
||
|
|
env->SetCurrentDepth(fDepth.GetValue());
|
||
|
|
}
|
||
|
|
else
|
||
|
|
env->UnSetFogDepth();
|
||
|
|
|
||
|
|
if( fFlags & kDensitySet )
|
||
|
|
env->SetFogDensity(fDensity);
|
||
|
|
else
|
||
|
|
env->UnSetFogDensity();
|
||
|
|
|
||
|
|
if( fFlags & kColorSet )
|
||
|
|
env->SetFogColor(fColor);
|
||
|
|
else
|
||
|
|
env->UnSetFogColor();
|
||
|
|
|
||
|
|
if( fFlags & kClearSet )
|
||
|
|
env->SetClearColor(fClear);
|
||
|
|
else
|
||
|
|
env->UnSetClearColor();
|
||
|
|
|
||
|
|
switch( fFlags & kTypeMask )
|
||
|
|
{
|
||
|
|
case kLinear:
|
||
|
|
env->SetFogType(hsGEnvironment::kFogLinear);
|
||
|
|
break;
|
||
|
|
case kExp:
|
||
|
|
env->SetFogType(hsGEnvironment::kFogExp);
|
||
|
|
break;
|
||
|
|
case kExp2:
|
||
|
|
env->SetFogType(hsGEnvironment::kFogExp2);
|
||
|
|
break;
|
||
|
|
default:
|
||
|
|
hsAssert(false, "Setting lack of fog type");
|
||
|
|
env->SetFogType(0);
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
const UInt16 hsGEnvironment::FogState::kSaveMagicNumber = 0x7385;
|
||
|
|
const UInt16 hsGEnvironment::FogState::kSaveVersion = 1;
|
||
|
|
|
||
|
|
void hsGEnvironment::FogState::Save(hsStream *stream, hsResMgr* mgr)
|
||
|
|
{
|
||
|
|
stream->WriteSwap16(kSaveMagicNumber);
|
||
|
|
stream->WriteSwap16(kSaveVersion);
|
||
|
|
|
||
|
|
hsScalar currSecs = hsTimer::GetSysSeconds();
|
||
|
|
stream->WriteSwap32(fFlags);
|
||
|
|
fColor.Write(stream, currSecs);
|
||
|
|
fClear.Write(stream, currSecs);
|
||
|
|
fDistance.WriteScalar(stream, currSecs);
|
||
|
|
fDensity.WriteScalar(stream, currSecs);
|
||
|
|
fDepth.WriteScalar(stream, currSecs);
|
||
|
|
fYon.WriteScalar(stream, currSecs);
|
||
|
|
}
|
||
|
|
|
||
|
|
void hsGEnvironment::FogState::Load(hsStream *stream, hsResMgr* mgr)
|
||
|
|
{
|
||
|
|
UInt16 magic = stream->ReadSwap16();
|
||
|
|
hsAssert(magic == kSaveMagicNumber, "Bad magic number in hsGEnvironment::FogState on load.");
|
||
|
|
|
||
|
|
UInt16 version = stream->ReadSwap16();
|
||
|
|
hsAssert(version == kSaveVersion, "Bad version in hsGEnvironment::FogState on load.");
|
||
|
|
|
||
|
|
hsScalar currSecs = hsTimer::GetSysSeconds();
|
||
|
|
fFlags = stream->ReadSwap32();
|
||
|
|
fColor.Read(stream, currSecs);
|
||
|
|
fClear.Read(stream, currSecs);
|
||
|
|
fDistance.ReadScalar(stream, currSecs);
|
||
|
|
fDensity.ReadScalar(stream, currSecs);
|
||
|
|
fDepth.ReadScalar(stream, currSecs);
|
||
|
|
fYon.ReadScalar(stream, currSecs);
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
void hsGEnvironment::SetResetState()
|
||
|
|
{
|
||
|
|
fResetState.SetFromEnv(this);
|
||
|
|
}
|
||
|
|
|
||
|
|
void hsGEnvironment::Reset()
|
||
|
|
{
|
||
|
|
fResetState.SetToEnv(this);
|
||
|
|
|
||
|
|
Int32 i;
|
||
|
|
for (i=0; i<fFogStateStack.GetCount(); i++)
|
||
|
|
delete fFogStateStack[i];
|
||
|
|
fFogStateStack.Reset();
|
||
|
|
}
|
||
|
|
|
||
|
|
void hsGEnvironment::ValidateInResetState()
|
||
|
|
{
|
||
|
|
fResetState.ValidateEnv(this);
|
||
|
|
|
||
|
|
hsAssert(fFogStateStack.GetCount() == 0, "Bad fog state stack.");
|
||
|
|
}
|
||
|
|
|
||
|
|
void hsGEnvironment::Save(hsStream *stream, hsResMgr* mgr)
|
||
|
|
{
|
||
|
|
hsKeyedObject::Save(stream, mgr);
|
||
|
|
|
||
|
|
stream->WriteSwap16(kSaveMagicNumber);
|
||
|
|
stream->WriteSwap16(kSaveVersion);
|
||
|
|
|
||
|
|
stream->WriteSwap32(fFlags);
|
||
|
|
|
||
|
|
if( fFlags & hsGEnvironment::kCenterSet )
|
||
|
|
fPos.Write(stream);
|
||
|
|
|
||
|
|
if( fFlags & hsGEnvironment::kRadiusSet )
|
||
|
|
stream->WriteSwapScalar(fRadius);
|
||
|
|
|
||
|
|
FogState tempState;
|
||
|
|
tempState.SetFromEnv(this);
|
||
|
|
|
||
|
|
tempState.Save(stream, mgr);
|
||
|
|
fResetState.Save(stream, mgr);
|
||
|
|
|
||
|
|
UInt32 numFogStates = fFogStateStack.GetCount();
|
||
|
|
stream->WriteSwap32(numFogStates);
|
||
|
|
for (UInt32 i = 0; i < numFogStates; i++)
|
||
|
|
{
|
||
|
|
fFogStateStack[i]->Save(stream, mgr);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
void hsGEnvironment::Load(hsStream *stream, hsResMgr* mgr)
|
||
|
|
{
|
||
|
|
// Clear old data
|
||
|
|
UInt32 i;
|
||
|
|
for (i=0; i<fFogStateStack.GetCount(); i++)
|
||
|
|
delete fFogStateStack[i];
|
||
|
|
fFogStateStack.Reset();
|
||
|
|
|
||
|
|
// Load
|
||
|
|
hsKeyedObject::Load(stream, mgr);
|
||
|
|
|
||
|
|
UInt16 magic = stream->ReadSwap16();
|
||
|
|
hsAssert(magic == kSaveMagicNumber, "Bad magic number in hsGEnvironment on load.");
|
||
|
|
|
||
|
|
UInt16 version = stream->ReadSwap16();
|
||
|
|
hsAssert(version == kSaveVersion, "Bad version in hsGEnvironment on load.");
|
||
|
|
|
||
|
|
fFlags = stream->ReadSwap32();
|
||
|
|
|
||
|
|
if( fFlags & hsGEnvironment::kCenterSet )
|
||
|
|
fPos.Read(stream);
|
||
|
|
|
||
|
|
if( fFlags & hsGEnvironment::kRadiusSet )
|
||
|
|
fRadius = stream->ReadSwapScalar();
|
||
|
|
|
||
|
|
FogState tempState;
|
||
|
|
tempState.Load(stream, mgr);
|
||
|
|
tempState.SetToEnv(this);
|
||
|
|
fResetState.Load(stream, mgr);
|
||
|
|
|
||
|
|
UInt32 numFogStates = stream->ReadSwap32();
|
||
|
|
for (i = 0; i < numFogStates; i++)
|
||
|
|
{
|
||
|
|
FogState *newFogState = new FogState;
|
||
|
|
newFogState->Load(stream, mgr);
|
||
|
|
fFogStateStack.Append(newFogState);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
void hsGEnvironment::Update(hsScalar s, const hsPoint3& vPos)
|
||
|
|
{
|
||
|
|
if( fFlags & kFogDepthSet )
|
||
|
|
fFogDepth.Update(s);
|
||
|
|
if( fFlags & kFogDensitySet )
|
||
|
|
fFogDensity.Update(s);
|
||
|
|
if( fFlags & kFogColorSet )
|
||
|
|
fFogColor.Update(s);
|
||
|
|
if( fFlags & kClearColorSet )
|
||
|
|
fClearColor.Update(s);
|
||
|
|
if( fFlags & kYonSet )
|
||
|
|
fYon.Update(s);
|
||
|
|
if( fFlags & kMapSet )
|
||
|
|
{
|
||
|
|
hsGStatGather3::UpdateMaterialBegin();
|
||
|
|
fMap->Update(s);
|
||
|
|
hsGStatGather3::UpdateMaterialEnd();
|
||
|
|
|
||
|
|
if( fFlags & kClearColorAmbient )
|
||
|
|
SetClearColor(fMap->GetLayer(0)->GetAmbientColor());
|
||
|
|
|
||
|
|
if( fFlags & kFogColorAmbient )
|
||
|
|
SetFogColor(fMap->GetLayer(0)->GetAmbientColor());
|
||
|
|
else
|
||
|
|
if( fFlags & kFogColorDiffuse )
|
||
|
|
SetFogColor(fMap->GetLayer(0)->GetColor());
|
||
|
|
}
|
||
|
|
|
||
|
|
if( fFlags & kFogDistanceSet )
|
||
|
|
{
|
||
|
|
fFogDistance.Update(s);
|
||
|
|
|
||
|
|
|
||
|
|
hsVector3 del(&vPos, &fPos);
|
||
|
|
hsScalar dist = del.Magnitude();
|
||
|
|
|
||
|
|
hsScalar yon = hsMaximum(dist, fFogDistance.GetValue());
|
||
|
|
|
||
|
|
SetYon(yon);
|
||
|
|
|
||
|
|
hsScalar depth = fFogDistance.GetValue();
|
||
|
|
if( fFlags & kFogDepthSet )
|
||
|
|
depth *= fFogDepth.GetValue();
|
||
|
|
|
||
|
|
depth += yon - dist;
|
||
|
|
depth /= yon;
|
||
|
|
|
||
|
|
if( depth > hsScalar1 )
|
||
|
|
depth = hsScalar1;
|
||
|
|
|
||
|
|
fCurrentDepth = depth;
|
||
|
|
fFlags |= kCurrentDepthSet;
|
||
|
|
}
|
||
|
|
else if( fFlags & kFogDepthSet )
|
||
|
|
{
|
||
|
|
fCurrentDepth = fFogDepth.GetValue();
|
||
|
|
fFlags |= kCurrentDepthSet;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
fFlags &= ~kCurrentDepthSet;
|
||
|
|
|
||
|
|
if( fValidScale != fYonScale )
|
||
|
|
{
|
||
|
|
if( fDevCache )
|
||
|
|
fDevCache->Validate(false);
|
||
|
|
fValidScale = fYonScale;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
void hsGEnvironment::SetTimedFogDistance(const hsScalar g, const hsScalar s)
|
||
|
|
{
|
||
|
|
if( fFlags & kFogDistanceSet )
|
||
|
|
{
|
||
|
|
fFogDistance.Update(hsTimer::GetSysSeconds());
|
||
|
|
fFogDistance.SetGoal(g);
|
||
|
|
fFogDistance.SetDuration(s);
|
||
|
|
fFogDistance.StartClock(hsTimer::GetSysSeconds());
|
||
|
|
}
|
||
|
|
else
|
||
|
|
SetFogDistance(g);
|
||
|
|
}
|
||
|
|
|
||
|
|
void hsGEnvironment::SetTimedFogDepth(const hsScalar g, const hsScalar s)
|
||
|
|
{
|
||
|
|
if( fFlags & kFogDepthSet )
|
||
|
|
{
|
||
|
|
fFogDepth.Update(hsTimer::GetSysSeconds());
|
||
|
|
fFogDepth.SetGoal(g);
|
||
|
|
fFogDepth.SetDuration(s);
|
||
|
|
fFogDepth.StartClock(hsTimer::GetSysSeconds());
|
||
|
|
}
|
||
|
|
else
|
||
|
|
SetFogDepth(g);
|
||
|
|
}
|
||
|
|
|
||
|
|
void hsGEnvironment::SetTimedFogDensity(const hsScalar g, const hsScalar s)
|
||
|
|
{
|
||
|
|
if( fFlags & kFogDensitySet )
|
||
|
|
{
|
||
|
|
fFogDensity.Update(hsTimer::GetSysSeconds());
|
||
|
|
fFogDensity.SetGoal(g);
|
||
|
|
fFogDensity.SetDuration(s);
|
||
|
|
fFogDensity.StartClock(hsTimer::GetSysSeconds());
|
||
|
|
}
|
||
|
|
else
|
||
|
|
SetFogDensity(g);
|
||
|
|
}
|
||
|
|
|
||
|
|
void hsGEnvironment::SetTimedFogColor(const hsColorRGBA& g, const hsScalar s)
|
||
|
|
{
|
||
|
|
if( fFlags & kFogColorSet )
|
||
|
|
{
|
||
|
|
fFogColor.Update(hsTimer::GetSysSeconds());
|
||
|
|
fFogColor.SetGoal(g);
|
||
|
|
fFogColor.SetDuration(s);
|
||
|
|
fFogColor.StartClock(hsTimer::GetSysSeconds());
|
||
|
|
}
|
||
|
|
else
|
||
|
|
SetFogColor(g);
|
||
|
|
}
|
||
|
|
|
||
|
|
void hsGEnvironment::SetTimedClearColor(const hsColorRGBA& g, const hsScalar s)
|
||
|
|
{
|
||
|
|
if( fFlags & kClearColorSet )
|
||
|
|
{
|
||
|
|
fClearColor.Update(hsTimer::GetSysSeconds());
|
||
|
|
fClearColor.SetGoal(g);
|
||
|
|
fClearColor.SetDuration(s);
|
||
|
|
fClearColor.StartClock(hsTimer::GetSysSeconds());
|
||
|
|
}
|
||
|
|
else
|
||
|
|
SetClearColor(g);
|
||
|
|
}
|
||
|
|
|
||
|
|
void hsGEnvironment::SetTimedYon(const hsScalar g, const hsScalar s)
|
||
|
|
{
|
||
|
|
if( fFlags & kYonSet )
|
||
|
|
{
|
||
|
|
fYon.Update(hsTimer::GetSysSeconds());
|
||
|
|
fYon.SetGoal(g);
|
||
|
|
fYon.SetDuration(s);
|
||
|
|
fYon.StartClock(hsTimer::GetSysSeconds());
|
||
|
|
}
|
||
|
|
else
|
||
|
|
SetYon(g);
|
||
|
|
}
|
||
|
|
|
||
|
|
void hsGEnvironment::SetMapName(const char *n)
|
||
|
|
{
|
||
|
|
if( n )
|
||
|
|
{
|
||
|
|
hsAssert(strlen(n) < 255, "Environment name overflow");
|
||
|
|
fFlags |= kMapSet;
|
||
|
|
strcpy(fMapName, n);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
fFlags &= ~kMapSet;
|
||
|
|
*fMapName = 0;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
void hsGEnvironment::SetMap(hsGMaterial *m)
|
||
|
|
{
|
||
|
|
fFlags |= kMapSet;
|
||
|
|
hsRefCnt_SafeAssign(fMap, m);
|
||
|
|
}
|
||
|
|
|
||
|
|
void hsGEnvironment::SetCenter(const hsPoint3 &p)
|
||
|
|
{
|
||
|
|
fFlags |= kCenterSet; fPos = p;
|
||
|
|
}
|
||
|
|
|
||
|
|
void hsGEnvironment::SetRadius(hsScalar r)
|
||
|
|
{
|
||
|
|
fFlags |= kRadiusSet;
|
||
|
|
fRadius = r;
|
||
|
|
}
|
||
|
|
|
||
|
|
void hsGEnvironment::SetFogDistance(hsScalar f)
|
||
|
|
{
|
||
|
|
if( fDevCache &&( f != fFogDistance.GetValue()) )
|
||
|
|
fDevCache->Validate(false);
|
||
|
|
fFlags |= kFogDistanceSet;
|
||
|
|
fFogDistance.SetValue(f);
|
||
|
|
}
|
||
|
|
|
||
|
|
void hsGEnvironment::SetCurrentDepth(hsScalar f)
|
||
|
|
{
|
||
|
|
if( fDevCache && (f != fCurrentDepth) )
|
||
|
|
fDevCache->Validate(false);
|
||
|
|
fFlags |= kCurrentDepthSet;
|
||
|
|
fCurrentDepth = f;
|
||
|
|
}
|
||
|
|
|
||
|
|
void hsGEnvironment::SetFogDepth(hsScalar f)
|
||
|
|
{
|
||
|
|
if( fDevCache && (f != fFogDepth.GetValue()) )
|
||
|
|
fDevCache->Validate(false);
|
||
|
|
fFlags |= kFogDepthSet;
|
||
|
|
fFogDepth.SetValue(f);
|
||
|
|
}
|
||
|
|
|
||
|
|
void hsGEnvironment::SetFogDensity(hsScalar f)
|
||
|
|
{
|
||
|
|
if( fDevCache && (f != fFogDensity.GetValue()) )
|
||
|
|
fDevCache->Validate(false);
|
||
|
|
fFlags |= kFogDensitySet;
|
||
|
|
fFogDensity.SetValue(f);
|
||
|
|
}
|
||
|
|
|
||
|
|
void hsGEnvironment::SetFogColor(const hsColorRGBA &c)
|
||
|
|
{
|
||
|
|
if( fDevCache
|
||
|
|
&& (
|
||
|
|
(c.r != fFogColor.GetValue().r)
|
||
|
|
|| (c.g != fFogColor.GetValue().g)
|
||
|
|
|| (c.b != fFogColor.GetValue().b)
|
||
|
|
) )
|
||
|
|
fDevCache->Validate(false);
|
||
|
|
fFlags |= kFogColorSet;
|
||
|
|
fFogColor.SetValue(c);
|
||
|
|
}
|
||
|
|
|
||
|
|
void hsGEnvironment::SetClearColor(const hsColorRGBA &c)
|
||
|
|
{
|
||
|
|
fFlags |= kClearColorSet;
|
||
|
|
fClearColor.SetValue(c);
|
||
|
|
}
|
||
|
|
|
||
|
|
void hsGEnvironment::SetYon(hsScalar f)
|
||
|
|
{
|
||
|
|
if( fDevCache && (f != fYon.GetValue()) )
|
||
|
|
fDevCache->Validate(false);
|
||
|
|
fFlags |= kYonSet;
|
||
|
|
fYon.SetValue(f);
|
||
|
|
}
|
||
|
|
|
||
|
|
void hsGEnvironment::SetFogDistance(const hsTimedValue<hsScalar>& f)
|
||
|
|
{
|
||
|
|
if( fDevCache )
|
||
|
|
fDevCache->Validate(false);
|
||
|
|
fFlags |= kFogDistanceSet;
|
||
|
|
fFogDistance = f;
|
||
|
|
}
|
||
|
|
|
||
|
|
void hsGEnvironment::SetFogDepth(const hsTimedValue<hsScalar>& f)
|
||
|
|
{
|
||
|
|
if( fDevCache )
|
||
|
|
fDevCache->Validate(false);
|
||
|
|
fFlags |= kFogDepthSet;
|
||
|
|
fFogDepth = f;
|
||
|
|
}
|
||
|
|
|
||
|
|
void hsGEnvironment::SetFogDensity(const hsTimedValue<hsScalar>& f)
|
||
|
|
{
|
||
|
|
if( fDevCache )
|
||
|
|
fDevCache->Validate(false);
|
||
|
|
fFlags |= kFogDensitySet;
|
||
|
|
fFogDensity = f;
|
||
|
|
}
|
||
|
|
|
||
|
|
void hsGEnvironment::SetFogColor(const hsTimedValue<hsColorRGBA>& c)
|
||
|
|
{
|
||
|
|
if( fDevCache )
|
||
|
|
fDevCache->Validate(false);
|
||
|
|
fFlags |= kFogColorSet;
|
||
|
|
fFogColor = c;
|
||
|
|
}
|
||
|
|
|
||
|
|
void hsGEnvironment::SetClearColor(const hsTimedValue<hsColorRGBA>& c)
|
||
|
|
{
|
||
|
|
fFlags |= kClearColorSet;
|
||
|
|
fClearColor = c;
|
||
|
|
}
|
||
|
|
|
||
|
|
void hsGEnvironment::SetYon(const hsTimedValue<hsScalar>& f)
|
||
|
|
{
|
||
|
|
if( fDevCache )
|
||
|
|
fDevCache->Validate(false);
|
||
|
|
fFlags |= kYonSet;
|
||
|
|
fYon = f;
|
||
|
|
}
|
||
|
|
|
||
|
|
void hsGEnvironment::SetFogType(UInt32 t)
|
||
|
|
{
|
||
|
|
fFlags &= ~kFogTypeMask;
|
||
|
|
fFlags |= (t & kFogTypeMask);
|
||
|
|
}
|
||
|
|
|
||
|
|
void hsGEnvironment::SetFogColorAmbient(hsBool32 on)
|
||
|
|
{
|
||
|
|
if( on )
|
||
|
|
{
|
||
|
|
fFlags &= ~kFogColorDiffuse;
|
||
|
|
fFlags |= kFogColorAmbient;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
fFlags &= ~kFogColorAmbient;
|
||
|
|
}
|
||
|
|
|
||
|
|
void hsGEnvironment::SetFogColorDiffuse(hsBool32 on)
|
||
|
|
{
|
||
|
|
if( on )
|
||
|
|
{
|
||
|
|
fFlags &= ~kFogColorAmbient;
|
||
|
|
fFlags |= kFogColorDiffuse;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
fFlags &= ~kFogColorDiffuse;
|
||
|
|
}
|
||
|
|
|
||
|
|
void hsGEnvironment::SetClearColorAmbient(hsBool32 on)
|
||
|
|
{
|
||
|
|
if( on )
|
||
|
|
fFlags |= kClearColorAmbient;
|
||
|
|
else
|
||
|
|
fFlags &= ~kClearColorAmbient;
|
||
|
|
}
|
||
|
|
|
||
|
|
void hsGEnvironment::SetOverride(hsBool32 on)
|
||
|
|
{
|
||
|
|
if( on )
|
||
|
|
fFlags |= kOverride;
|
||
|
|
else
|
||
|
|
fFlags &= ~kOverride;
|
||
|
|
}
|
||
|
|
|
||
|
|
void hsGEnvironment::SetIsFar(hsBool32 on)
|
||
|
|
{
|
||
|
|
if( on )
|
||
|
|
fFlags |= kFarOut;
|
||
|
|
else
|
||
|
|
fFlags &= ~kFarOut;
|
||
|
|
}
|
||
|
|
|
||
|
|
void hsGEnvironment::SetSortObjects(hsBool32 on)
|
||
|
|
{
|
||
|
|
if( on )
|
||
|
|
fFlags |= kSortObjects;
|
||
|
|
else
|
||
|
|
fFlags &= ~kSortObjects;
|
||
|
|
}
|
||
|
|
|
||
|
|
void hsGEnvironment::SetHasFogControl(hsBool32 on)
|
||
|
|
{
|
||
|
|
if( on )
|
||
|
|
fFlags |= kFogControl;
|
||
|
|
else
|
||
|
|
fFlags &= ~kFogControl;
|
||
|
|
}
|
||
|
|
|
||
|
|
void hsGEnvironment::SetFogControl(hsFogControl* fc)
|
||
|
|
{
|
||
|
|
hsRefCnt_SafeAssign(fFogControl, fc);
|
||
|
|
}
|
||
|
|
|
||
|
|
void hsGEnvironment::SetDeviceCache(hsGDevEnvCache *p)
|
||
|
|
{
|
||
|
|
hsRefCnt_SafeAssign(fDevCache, p);
|
||
|
|
}
|
||
|
|
|
||
|
|
hsGEnvironment *hsGEnvironment::Copy(hsGEnvironment *env)
|
||
|
|
{
|
||
|
|
if( env->GetFlags() & kMapSet )
|
||
|
|
SetMap(env->GetMap());
|
||
|
|
else
|
||
|
|
fFlags &= ~kMapSet;
|
||
|
|
if( env->GetFlags() & kCenterSet )
|
||
|
|
SetCenter(env->GetCenter());
|
||
|
|
else
|
||
|
|
fFlags &= ~kCenterSet;
|
||
|
|
if( env->GetFlags() & kRadiusSet )
|
||
|
|
SetRadius(env->GetRadius());
|
||
|
|
else
|
||
|
|
fFlags &= ~kRadiusSet;
|
||
|
|
if( env->GetFlags() & kFogDepthSet )
|
||
|
|
SetFogDepth(env->GetFogDepth());
|
||
|
|
else
|
||
|
|
fFlags &= ~kFogDepthSet;
|
||
|
|
if( env->GetFlags() & kFogDensitySet )
|
||
|
|
SetFogDensity(env->GetFogDensity());
|
||
|
|
else
|
||
|
|
fFlags &= ~kFogDensitySet;
|
||
|
|
if( env->GetFlags() & kFogColorSet )
|
||
|
|
SetFogColor(env->GetFogColor());
|
||
|
|
else
|
||
|
|
fFlags &= ~kFogColorSet;
|
||
|
|
if( env->GetFlags() & kClearColorSet )
|
||
|
|
SetClearColor(env->GetClearColor());
|
||
|
|
else
|
||
|
|
fFlags &= ~kClearColorSet;
|
||
|
|
if( env->GetFlags() & kYonSet )
|
||
|
|
SetYon(env->GetUnscaledYon());
|
||
|
|
else
|
||
|
|
fFlags &= ~kYonSet;
|
||
|
|
|
||
|
|
if( env->GetFlags() & kCurrentDepthSet )
|
||
|
|
{
|
||
|
|
fCurrentDepth = env->GetCurrentDepth();
|
||
|
|
fFlags |= kCurrentDepthSet;
|
||
|
|
}
|
||
|
|
|
||
|
|
fFlags &= ~hsGEnvironment::kFogTypeMask;
|
||
|
|
fFlags |= env->GetFlags() & hsGEnvironment::kFogTypeMask;
|
||
|
|
|
||
|
|
SetOverride(env->GetOverride());
|
||
|
|
|
||
|
|
SetDeviceCache(env->GetDeviceCache());
|
||
|
|
|
||
|
|
if( env->GetFlags() & kCacheInvalid )
|
||
|
|
fFlags |= kCacheInvalid;
|
||
|
|
else
|
||
|
|
fFlags &= ~kCacheInvalid;
|
||
|
|
|
||
|
|
int i;
|
||
|
|
for( i = 0; i < env->GetNumRenderProcs(); i++ )
|
||
|
|
AddRenderProc(env->GetRenderProc(i));
|
||
|
|
|
||
|
|
return this;
|
||
|
|
}
|
||
|
|
|
||
|
|
void hsGEnvironment::MixEnvirons(hsGEnvironment *env, hsGEnvironment *def)
|
||
|
|
{
|
||
|
|
if( env && (env->GetFlags() & kMapSet) )
|
||
|
|
{
|
||
|
|
SetMap(env->GetMap());
|
||
|
|
}
|
||
|
|
else if( def && (def->GetFlags() & kMapSet) )
|
||
|
|
{
|
||
|
|
hsGMaterial *map = def->GetMap();
|
||
|
|
if( map )
|
||
|
|
{
|
||
|
|
SetMap(def->GetMap());
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
def->SetMapName(nil);
|
||
|
|
hsRefCnt_SafeUnRef(fMap);
|
||
|
|
fMap = nil;
|
||
|
|
fFlags &= ~kMapSet;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
hsRefCnt_SafeUnRef(fMap);
|
||
|
|
fMap = nil;
|
||
|
|
fFlags &= ~kMapSet;
|
||
|
|
}
|
||
|
|
if( env && (env->GetFlags() & kCenterSet) )
|
||
|
|
SetCenter(env->GetCenter());
|
||
|
|
else if( def &&(def->GetFlags() & kCenterSet) )
|
||
|
|
SetCenter(def->GetCenter());
|
||
|
|
else
|
||
|
|
fFlags &= ~kCenterSet;
|
||
|
|
if( env && (env->GetFlags() & kRadiusSet) )
|
||
|
|
SetRadius(env->GetRadius());
|
||
|
|
else if( def &&(def->GetFlags() & kRadiusSet) )
|
||
|
|
SetRadius(def->GetRadius());
|
||
|
|
else
|
||
|
|
fFlags &= ~kRadiusSet;
|
||
|
|
|
||
|
|
if( env && (env->GetFlags() & kFogDepthSet) )
|
||
|
|
SetFogDepth(env->GetFogDepth());
|
||
|
|
else if( def &&(def->GetFlags() & kFogDepthSet) )
|
||
|
|
SetFogDepth(def->GetFogDepth());
|
||
|
|
else
|
||
|
|
fFlags &= ~kFogDepthSet;
|
||
|
|
|
||
|
|
if( env &&(env->GetFlags() & kCurrentDepthSet) )
|
||
|
|
{
|
||
|
|
fCurrentDepth = env->GetCurrentDepth();
|
||
|
|
fFlags |= kCurrentDepthSet;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
if( def &&(def->GetFlags() & kCurrentDepthSet) )
|
||
|
|
{
|
||
|
|
fCurrentDepth = def->GetCurrentDepth();
|
||
|
|
fFlags |= kCurrentDepthSet;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
fFlags &= ~kCurrentDepthSet;
|
||
|
|
|
||
|
|
fFlags &= ~kFogTypeMask;
|
||
|
|
if( env && (env->GetFlags() & kFogTypeMask) )
|
||
|
|
fFlags |= env->GetFlags() & kFogTypeMask;
|
||
|
|
else if( def && (def->GetFlags() & kFogTypeMask) )
|
||
|
|
fFlags |= def->GetFlags() & kFogTypeMask;
|
||
|
|
else
|
||
|
|
fFlags &= ~kFogTypeMask;
|
||
|
|
|
||
|
|
if( env && (env->GetFlags() & kFogDensitySet) )
|
||
|
|
SetFogDensity(env->GetFogDensity());
|
||
|
|
else if( def &&(def->GetFlags() & kFogDensitySet) )
|
||
|
|
SetFogDensity(def->GetFogDensity());
|
||
|
|
else
|
||
|
|
SetFogDensity(hsScalar1);
|
||
|
|
|
||
|
|
if( env &&(env->GetFlags() & kFogColorSet) )
|
||
|
|
SetFogColor(env->GetFogColor());
|
||
|
|
else if( def &&(def->GetFlags() & kFogColorSet) )
|
||
|
|
SetFogColor(def->GetFogColor());
|
||
|
|
else
|
||
|
|
{
|
||
|
|
hsColorRGBA col;
|
||
|
|
col.r = col.g = col.b = col.a = 0;
|
||
|
|
SetFogColor(col);
|
||
|
|
}
|
||
|
|
if( env &&(env->GetFlags() & kClearColorSet) )
|
||
|
|
SetClearColor(env->GetClearColor());
|
||
|
|
else if( def &&(def->GetFlags() & kClearColorSet) )
|
||
|
|
SetClearColor(def->GetClearColor());
|
||
|
|
else
|
||
|
|
fFlags &= ~kClearColorSet;
|
||
|
|
|
||
|
|
if( env && (env->GetFlags() & kYonSet) )
|
||
|
|
SetYon(env->GetUnscaledYon());
|
||
|
|
else if( def &&(def->GetFlags() & kYonSet) )
|
||
|
|
SetYon(def->GetUnscaledYon());
|
||
|
|
else
|
||
|
|
fFlags &= ~kYonSet;
|
||
|
|
|
||
|
|
if( env && (env->GetOverride()) )
|
||
|
|
SetOverride(true);
|
||
|
|
else if( def &&(def->GetOverride()) )
|
||
|
|
SetOverride(true);
|
||
|
|
else
|
||
|
|
SetOverride(false);
|
||
|
|
|
||
|
|
if( env && env->GetDeviceCache() )
|
||
|
|
SetDeviceCache(env->GetDeviceCache());
|
||
|
|
else if( def && def->GetDeviceCache() )
|
||
|
|
SetDeviceCache(def->GetDeviceCache());
|
||
|
|
else
|
||
|
|
SetDeviceCache(nil);
|
||
|
|
|
||
|
|
int i;
|
||
|
|
for( i = 0; i < GetNumRenderProcs(); i++ )
|
||
|
|
{
|
||
|
|
hsRefCnt_SafeUnRef(GetRenderProc(i));
|
||
|
|
}
|
||
|
|
fRenderProcs.Reset();
|
||
|
|
if( env )
|
||
|
|
{
|
||
|
|
for( i = 0; i < env->GetNumRenderProcs(); i++ )
|
||
|
|
AddRenderProc(env->GetRenderProc(i));
|
||
|
|
}
|
||
|
|
if( def )
|
||
|
|
{
|
||
|
|
for( i = 0; i < def->GetNumRenderProcs(); i++ )
|
||
|
|
AddRenderProc(def->GetRenderProc(i));
|
||
|
|
}
|
||
|
|
|
||
|
|
}
|
||
|
|
|
||
|
|
void hsGEnvironment::Blend()
|
||
|
|
{
|
||
|
|
if( fFogControl )
|
||
|
|
fFogControl->Blend();
|
||
|
|
}
|
||
|
|
|
||
|
|
void hsGEnvironment::Restore()
|
||
|
|
{
|
||
|
|
if( fFogControl )
|
||
|
|
fFogControl->Restore();
|
||
|
|
}
|
||
|
|
|
||
|
|
void hsGEnvironment::Init(hsSceneNode* node)
|
||
|
|
{
|
||
|
|
if (!node)
|
||
|
|
{
|
||
|
|
char str[256];
|
||
|
|
sprintf(str, "hsGEnvironment %s initted with nil room. Weirdness may result.",
|
||
|
|
GetKeyName());
|
||
|
|
HSDebugProc(str);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
if( fFogControl )
|
||
|
|
fFogControl->Init(node);
|
||
|
|
}
|
||
|
|
|
||
|
|
SetResetState();
|
||
|
|
}
|
||
|
|
|
||
|
|
void hsGEnvironment::SaveFogState()
|
||
|
|
{
|
||
|
|
FogState* curFogState = new FogState;
|
||
|
|
curFogState->SetFromEnv(this);
|
||
|
|
fFogStateStack.Push(curFogState);
|
||
|
|
}
|
||
|
|
|
||
|
|
void hsGEnvironment::RestoreFogState()
|
||
|
|
{
|
||
|
|
FogState* curFogState = fFogStateStack.GetCount() ? fFogStateStack.Pop() : nil;
|
||
|
|
if (curFogState)
|
||
|
|
{
|
||
|
|
curFogState->SetToEnv(this);
|
||
|
|
}
|
||
|
|
delete curFogState;
|
||
|
|
}
|
||
|
|
|
||
|
|
void hsGEnvironment::Read(hsStream *stream)
|
||
|
|
{
|
||
|
|
fFlags = stream->ReadSwap32();
|
||
|
|
|
||
|
|
if( fFlags & hsGEnvironment::kFogDistanceSet )
|
||
|
|
{
|
||
|
|
hsScalar d = stream->ReadSwapScalar();
|
||
|
|
SetFogDistance(d);
|
||
|
|
}
|
||
|
|
if( fFlags & hsGEnvironment::kFogDepthSet )
|
||
|
|
{
|
||
|
|
hsScalar d = stream->ReadSwapScalar();
|
||
|
|
SetFogDepth(d);
|
||
|
|
SetCurrentDepth(d);
|
||
|
|
}
|
||
|
|
if( fFlags & hsGEnvironment::kFogDensitySet )
|
||
|
|
{
|
||
|
|
hsScalar d = stream->ReadSwapScalar();
|
||
|
|
SetFogDensity(d);
|
||
|
|
}
|
||
|
|
if( fFlags & hsGEnvironment::kFogColorSet )
|
||
|
|
{
|
||
|
|
hsColorRGBA c;
|
||
|
|
c.r = stream->ReadSwapScalar();
|
||
|
|
c.g = stream->ReadSwapScalar();
|
||
|
|
c.b = stream->ReadSwapScalar();
|
||
|
|
c.a = stream->ReadSwapScalar();
|
||
|
|
SetFogColor(c);
|
||
|
|
}
|
||
|
|
if( fFlags & hsGEnvironment::kClearColorSet )
|
||
|
|
{
|
||
|
|
hsColorRGBA c;
|
||
|
|
c.r = stream->ReadSwapScalar();
|
||
|
|
c.g = stream->ReadSwapScalar();
|
||
|
|
c.b = stream->ReadSwapScalar();
|
||
|
|
c.a = stream->ReadSwapScalar();
|
||
|
|
SetClearColor(c);
|
||
|
|
}
|
||
|
|
if( fFlags & hsGEnvironment::kYonSet )
|
||
|
|
{
|
||
|
|
hsScalar d = stream->ReadSwapScalar();
|
||
|
|
SetYon(d);
|
||
|
|
}
|
||
|
|
|
||
|
|
if( fFlags & hsGEnvironment::kCenterSet )
|
||
|
|
fPos.Read(stream);
|
||
|
|
if( fFlags & hsGEnvironment::kRadiusSet )
|
||
|
|
fRadius = stream->ReadSwapScalar();
|
||
|
|
// still don't write the map out
|
||
|
|
|
||
|
|
if( !(fFlags & kFogTypeMask) )
|
||
|
|
{
|
||
|
|
if( GetFogDepth() <= 0.5f )
|
||
|
|
fFlags |= kFogLinear;
|
||
|
|
else
|
||
|
|
fFlags |= kFogExp;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
void hsGEnvironment::Write(hsStream *stream)
|
||
|
|
{
|
||
|
|
stream->WriteSwap32(fFlags);
|
||
|
|
|
||
|
|
if( fFlags & hsGEnvironment::kFogDistanceSet )
|
||
|
|
stream->WriteSwapScalar(GetFogDistance());
|
||
|
|
if( fFlags & hsGEnvironment::kFogDepthSet )
|
||
|
|
stream->WriteSwapScalar(GetFogDepth());
|
||
|
|
if( fFlags & hsGEnvironment::kFogDensitySet )
|
||
|
|
stream->WriteSwapScalar(GetFogDensity());
|
||
|
|
if( fFlags & hsGEnvironment::kFogColorSet )
|
||
|
|
{
|
||
|
|
hsColorRGBA c = GetFogColor();
|
||
|
|
stream->WriteSwapScalar(c.r);
|
||
|
|
stream->WriteSwapScalar(c.g);
|
||
|
|
stream->WriteSwapScalar(c.b);
|
||
|
|
stream->WriteSwapScalar(c.a);
|
||
|
|
}
|
||
|
|
if( fFlags & hsGEnvironment::kClearColorSet )
|
||
|
|
{
|
||
|
|
hsColorRGBA c = GetClearColor();
|
||
|
|
stream->WriteSwapScalar(c.r);
|
||
|
|
stream->WriteSwapScalar(c.g);
|
||
|
|
stream->WriteSwapScalar(c.b);
|
||
|
|
stream->WriteSwapScalar(c.a);
|
||
|
|
}
|
||
|
|
if( fFlags & hsGEnvironment::kYonSet )
|
||
|
|
stream->WriteSwapScalar(GetUnscaledYon());
|
||
|
|
|
||
|
|
if( fFlags & hsGEnvironment::kCenterSet )
|
||
|
|
fPos.Write(stream);
|
||
|
|
if( fFlags & hsGEnvironment::kRadiusSet )
|
||
|
|
stream->WriteSwapScalar(fRadius);
|
||
|
|
// still don't write the map out
|
||
|
|
|
||
|
|
}
|
||
|
|
|
||
|
|
void hsGEnvironment::Write(hsStream* stream, hsResMgr* group)
|
||
|
|
{
|
||
|
|
Write(stream);
|
||
|
|
|
||
|
|
if( fFlags & hsGEnvironment::kHasRenderProcs )
|
||
|
|
{
|
||
|
|
int n = GetNumRenderProcs();
|
||
|
|
stream->WriteSwap32(n);
|
||
|
|
int i;
|
||
|
|
for( i = 0; i < n; i++ )
|
||
|
|
{
|
||
|
|
hsAssert(0,"Its Pauls fault");
|
||
|
|
// plFactory::LabelAndWrite(stream, group, GetRenderProc(i));
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if ((GetFlags() & hsGEnvironment::kEnvironMapSet) == hsGEnvironment::kEnvironMapSet)
|
||
|
|
{
|
||
|
|
group->WriteKey(stream, GetMap());
|
||
|
|
}
|
||
|
|
|
||
|
|
stream->WriteSwap32(fNodeKeys.GetCount());
|
||
|
|
Int32 i;
|
||
|
|
for (i = 0; i < fNodeKeys.GetCount(); i++)
|
||
|
|
{
|
||
|
|
group->WriteKey(stream, fNodeKeys[i]);
|
||
|
|
}
|
||
|
|
|
||
|
|
if( fFlags & hsGEnvironment::kFogControl )
|
||
|
|
IWriteFogControl(stream, group);
|
||
|
|
}
|
||
|
|
|
||
|
|
void hsGEnvironment::Read(hsStream* stream, hsResMgr* group)
|
||
|
|
{
|
||
|
|
Read(stream);
|
||
|
|
|
||
|
|
if( fFlags & hsGEnvironment::kHasRenderProcs )
|
||
|
|
{
|
||
|
|
int n = stream->ReadSwap32();
|
||
|
|
int i;
|
||
|
|
for( i = 0; i < n; i++ )
|
||
|
|
{
|
||
|
|
hsAssert(0,"Its Pauls fault");
|
||
|
|
// hsGRenderProcs* rp = hsGRenderProcs::ConvertNoRef(plFactory::CreateAndRead(stream, group));
|
||
|
|
// AddRenderProc(rp);
|
||
|
|
// hsRefCnt_SafeUnRef(rp);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if ((GetFlags() & hsGEnvironment::kEnvironMapSet) == hsGEnvironment::kEnvironMapSet)
|
||
|
|
{
|
||
|
|
plRefMsg* refMsg = new plRefMsg(GetKey(), plRefMsg::kOnCreate);
|
||
|
|
group->ReadKeyNotifyMe(stream,refMsg);
|
||
|
|
}
|
||
|
|
|
||
|
|
hsAssert(fNodeKeys.GetCount() == 0, "fNodeKeys not empty in hsGEnvironment::Read.");
|
||
|
|
Int32 nodeCount = stream->ReadSwap32();
|
||
|
|
hsAssert(nodeCount > 0, "Environment node not in any rooms in hsGEnvironment::Read.");
|
||
|
|
Int32 i;
|
||
|
|
for (i = 0; i < nodeCount; i++)
|
||
|
|
{
|
||
|
|
plKey *key = group->ReadKey(stream);
|
||
|
|
AddNodeKey(key);
|
||
|
|
}
|
||
|
|
|
||
|
|
if( fFlags & hsGEnvironment::kFogControl )
|
||
|
|
IReadFogControl(stream, group);
|
||
|
|
}
|
||
|
|
|
||
|
|
void hsGEnvironment::IReadFogControl(hsStream* s, hsResMgr* mgr)
|
||
|
|
{
|
||
|
|
hsAssert(0,"Its Pauls fault");
|
||
|
|
// hsFogControl* fc = hsFogControl::ConvertNoRef(plFactory::CreateAndRead(s, mgr));
|
||
|
|
// SetFogControl(fc);
|
||
|
|
// hsRefCnt_SafeUnRef(fc);
|
||
|
|
|
||
|
|
}
|
||
|
|
|
||
|
|
void hsGEnvironment::IWriteFogControl(hsStream* s, hsResMgr* mgr)
|
||
|
|
{
|
||
|
|
hsAssert(0,"Its Pauls fault");
|
||
|
|
// plFactory::LabelAndWrite(s, mgr, fFogControl);
|
||
|
|
}
|
||
|
|
|
||
|
|
void hsGEnvironment::Push(hsG3DDevice* d)
|
||
|
|
{
|
||
|
|
#if 0 // Nuking old device - mf
|
||
|
|
int i;
|
||
|
|
|
||
|
|
for( i = 0; i < GetNumRenderProcs(); i++ )
|
||
|
|
d->AddRenderProc(GetRenderProc(i));
|
||
|
|
#endif // Nuking old device - mf
|
||
|
|
}
|
||
|
|
|
||
|
|
void hsGEnvironment::Pop(hsG3DDevice* d)
|
||
|
|
{
|
||
|
|
#if 0 // Nuking old device - mf
|
||
|
|
int i;
|
||
|
|
for( i = 0; i < GetNumRenderProcs(); i++ )
|
||
|
|
d->RemoveRenderProc(GetRenderProc(i));
|
||
|
|
#endif // Nuking old device - mf
|
||
|
|
}
|
||
|
|
|
||
|
|
void hsGEnvironment::AddRenderProc(hsGRenderProcs* rp)
|
||
|
|
{
|
||
|
|
hsRefCnt_SafeRef(rp);
|
||
|
|
fRenderProcs.Append(rp);
|
||
|
|
fFlags |= hsGEnvironment::kHasRenderProcs;
|
||
|
|
}
|
||
|
|
|
||
|
|
hsGRenderProcs* hsGEnvironment::GetRenderProc(int i)
|
||
|
|
{
|
||
|
|
return fRenderProcs[i];
|
||
|
|
}
|
||
|
|
|
||
|
|
UInt32 hsGEnvironment::GetNumRenderProcs()
|
||
|
|
{
|
||
|
|
return fRenderProcs.GetCount();
|
||
|
|
}
|
||
|
|
|
||
|
|
hsScalar hsGEnvironment::SetYonScale(hsScalar s)
|
||
|
|
{
|
||
|
|
const hsScalar kMinYonScale = 0.05f;
|
||
|
|
const hsScalar kMaxYonScale = 100.f;
|
||
|
|
|
||
|
|
if( s < kMinYonScale )
|
||
|
|
s = kMinYonScale;
|
||
|
|
else if( s > kMaxYonScale )
|
||
|
|
s = kMaxYonScale;
|
||
|
|
return fYonScale = s;
|
||
|
|
}
|
||
|
|
|
||
|
|
hsBool hsGEnvironment::MsgReceive(plMessage* msg)
|
||
|
|
{
|
||
|
|
plRefMsg* refMsg = plRefMsg::ConvertNoRef(msg);
|
||
|
|
|
||
|
|
if( refMsg )
|
||
|
|
{
|
||
|
|
|
||
|
|
hsGMaterial *mat = hsGMaterial::ConvertNoRef(refMsg->GetRef());
|
||
|
|
SetMap(mat);
|
||
|
|
}
|
||
|
|
return false;
|
||
14 years ago
|
}
|