/*==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/>.
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==*/
#ifndef hsGEnviron_inc
#define hsGEnviron_inc
#include "hsGeometry3.h" // hsPoint3
#include "../plInterp/hsTimedValue.h"
#include "../plResMgr/hsKeyedObject.h"
#include "hsColorRGBA.h"
#include "hsTemplates.h"
//
//-----------------------------------
// Environment
//-----------------------------------
//
class hsGMaterial;
class hsGDevEnvCache;
class hsFogControl;
class hsSceneNode;
class hsScene;
class hsGRenderProcs;
class hsG3DDevice;
class plKey;
class hsResMgr;
class hsGEnvironment : public hsKeyedObject {
private:
static const UInt16 kSaveMagicNumber;
static const UInt16 kSaveVersion;
public:
struct FogState {
private:
static const UInt16 kSaveMagicNumber;
static const UInt16 kSaveVersion;
public:
FogState() : fFlags(0) {};
enum {
kColorSet = 0x1,
kDistanceSet = 0x2,
kDepthSet = 0x4,
kDensitySet = 0x8,
kYonSet = 0x10,
kClearSet = 0x20,
kLinear = 0x10000000,
kExp = 0x20000000,
kExp2 = 0x40000000,
kTypeMask = kLinear | kExp | kExp2
};
UInt32 fFlags;
hsTimedValue<hsColorRGBA> fColor;
hsTimedValue<hsColorRGBA> fClear;
hsTimedValue<hsScalar> fDistance;
hsTimedValue<hsScalar> fDensity;
hsTimedValue<hsScalar> fDepth;
hsTimedValue<hsScalar> fYon;
void ValidateEnv(class hsGEnvironment* env);
void SetFromEnv(class hsGEnvironment* env);
void SetToEnv(class hsGEnvironment* env);
void Save(hsStream *stream, hsResMgr* mgr);
void Load(hsStream *stream, hsResMgr* mgr);
};
enum {
kMapSet = 0x1,
kCenterSet = 0x2,
kRadiusSet = 0x4,
kEnvironMapSet = kMapSet | kCenterSet | kRadiusSet,
kFogDepthSet = 0x8,
kFogColorSet = 0x10,
kFogDensitySet = 0x20,
kYonSet = 0x40,
kOverride = 0x80,
kFarOut = 0x100,
kFogDistanceSet = 0x200,
kCacheInvalid = 0x400,
kClearColorSet = 0x800,
kCurrentDepthSet = 0x1000,
kFogControl = 0x2000,
kSortObjects = 0x4000,
kHasRenderProcs = 0x8000,
kFogLinear = 0x10000,
kFogExp = 0x20000,
kFogExp2 = 0x40000,
kFogTypeMask = kFogLinear | kFogExp | kFogExp2,
kClearColorAmbient = 0x80000,
kFogColorAmbient = 0x100000,
kFogColorDiffuse = 0x200000
};
protected:
static hsScalar fYonScale;
UInt32 fFlags;
hsGMaterial* fMap;
char fMapName[256];
hsPoint3 fPos;
hsScalar fRadius;
hsScalar fValidScale;
hsTArray<FogState*> fFogStateStack;
hsTimedValue<hsScalar> fFogDistance;
hsTimedValue<hsScalar> fFogDepth; // value 0..1, as fraction of yon, 0 is no fog
hsTimedValue<hsScalar> fFogDensity;
hsTimedValue<hsColorRGBA> fFogColor;
hsTimedValue<hsColorRGBA> fClearColor;
hsTimedValue<hsScalar> fYon;
hsScalar fCurrentDepth; // function of Depth and Distance
FogState fResetState;
hsGDevEnvCache* fDevCache;
hsDynamicArray<hsGRenderProcs*> fRenderProcs;
hsTArray<plKey*> fNodeKeys;
hsFogControl* fFogControl;
void IReadFogControl(hsStream* s, hsResMgr* mgr);
void IWriteFogControl(hsStream* s, hsResMgr* mgr);
public:
hsGEnvironment();
virtual ~hsGEnvironment();
hsBool32 AddNode(hsSceneNode *node);
hsBool32 AddNodeKey(plKey *key);
Int32 GetNumNodes() { return fNodeKeys.GetCount(); }
hsSceneNode* GetNode(Int32 i);
plKey* GetNodeKey(Int32 i) { return fNodeKeys[i]; }
char* GetMapName() { return fMapName; }
hsGMaterial* GetMap() const { return fMap; }
hsPoint3 GetCenter() const { return fPos; }
hsScalar GetRadius() const { return fRadius; }
hsScalar GetFogDistance() const { return fFogDistance.GetValue(); }
hsScalar GetFogDepth() const { return fFogDepth.GetValue(); }
hsScalar GetCurrentDepth() const { return fCurrentDepth; }
hsScalar GetFogDensity() const { return fFogDensity.GetValue(); }
hsColorRGBA GetFogColor() const { return fFogColor.GetValue(); }
hsColorRGBA GetClearColor() const { return fClearColor.GetValue(); }
hsScalar GetYon() const { return fYonScale * fYon.GetValue(); }
hsScalar GetUnscaledYon() const { return fYon.GetValue(); }
hsBool32 GetOverride() const { return 0 != (fFlags & kOverride); }
UInt32 GetFlags() const { return fFlags; }
hsScalar GoalFogDistance() const { return fFogDistance.GetGoal(); }
hsScalar GoalFogDepth() const { return fFogDepth.GetGoal(); }
hsScalar GoalFogDensity() const { return fFogDensity.GetGoal(); }
hsColorRGBA GoalFogColor() const { return fFogColor.GetGoal(); }
hsColorRGBA GoalClearColor() const { return fClearColor.GetGoal(); }
hsScalar GoalYon() const { return fYon.GetGoal(); }
const hsTimedValue<hsScalar>& FogDistanceState() const { return fFogDistance; }
const hsTimedValue<hsScalar>& FogDepthState() const { return fFogDepth; }
const hsTimedValue<hsScalar>& FogDensityState() const { return fFogDensity; }
const hsTimedValue<hsColorRGBA>& FogColorState() const { return fFogColor; }
const hsTimedValue<hsColorRGBA>& ClearColorState() const { return fClearColor; }
const hsTimedValue<hsScalar>& YonState() const { return fYon; }
void SetFogDistance(const hsTimedValue<hsScalar>& v);
void SetFogDepth(const hsTimedValue<hsScalar>& v);
void SetFogDensity(const hsTimedValue<hsScalar>& v);
void SetFogColor(const hsTimedValue<hsColorRGBA>& v);
void SetClearColor(const hsTimedValue<hsColorRGBA>& v);
void SetYon(const hsTimedValue<hsScalar>& v);
void SetMapName(const char *name);
void SetMap(hsGMaterial *m); // refs
void SetCenter(const hsPoint3 &p);
void SetRadius(hsScalar r);
void SetFogDistance(hsScalar d);
void SetFogDepth(hsScalar f);
void SetCurrentDepth(hsScalar f);
void SetFogDensity(hsScalar f);
void SetFogColor(const hsColorRGBA &c);
void SetClearColor(const hsColorRGBA &c);
void SetYon(hsScalar f);
void SetOverride(hsBool32 on);
void SetIsFar(hsBool32 on=true);
void SetHasFogControl(hsBool32 on=true);
void SetSortObjects(hsBool32 on=true);
void SetFogType(UInt32 t);
void SetFogColorAmbient(hsBool32 on=true);
void SetFogColorDiffuse(hsBool32 on=true);
void SetClearColorAmbient(hsBool32 on=true);
void SetTimedFogDistance(const hsScalar g, const hsScalar s);
void SetTimedFogDepth(const hsScalar g, const hsScalar s);
void SetTimedFogDensity(const hsScalar g, const hsScalar s);
void SetTimedFogColor(const hsColorRGBA& g, const hsScalar s);
void SetTimedClearColor(const hsColorRGBA& g, const hsScalar s);
void SetTimedYon(const hsScalar g, const hsScalar s);
void UnSetMapName() { *fMapName = 0; }
void UnSetEnvironMap() { fFlags &= ~kEnvironMapSet; }
void UnSetFogDistance() { fFlags &= ~kFogDistanceSet; }
void UnSetFogDepth() { fFlags &= ~kFogDepthSet; }
void UnSetFogDensity() { fFlags &= ~kFogDensitySet; }
void UnSetFogColor() { fFlags &= ~kFogColorSet; }
void UnSetClearColor() { fFlags &= ~kClearColorSet; }
void UnSetYon() { fFlags &= ~kYonSet; }
hsGEnvironment* Copy(hsGEnvironment* env); // returns this
void MixEnvirons(hsGEnvironment* env, hsGEnvironment* def);
void Push(hsG3DDevice* d);
void Pop(hsG3DDevice* d);
void Blend();
void Restore();
void Init(hsSceneNode* node);
void SetDeviceCache(hsGDevEnvCache* p);
hsGDevEnvCache* GetDeviceCache(){ return fDevCache; }
void SetFogControl(hsFogControl* fc);
hsFogControl* GetFogControl() { return fFogControl; }
void SaveFogState(); // push
hsGEnvironment::FogState* PopFogState() { return fFogStateStack.GetCount() ? fFogStateStack.Pop() : nil; } // doesn't restore
void RestoreFogState(); // pop and restore
void AddRenderProc(hsGRenderProcs* rp); // refs
hsGRenderProcs* GetRenderProc(int i); // no ref
UInt32 GetNumRenderProcs();
virtual void SetResetState();
virtual void Reset();
virtual void ValidateInResetState();
virtual void Save(hsStream *stream, hsResMgr* mgr);
virtual void Load(hsStream *stream, hsResMgr* mgr);
virtual void Update(hsScalar secs, const hsPoint3& vPos);
virtual void Read(hsStream* s);
virtual void Write(hsStream* s);
virtual void Write(hsStream *stream, hsResMgr *group);
virtual void Read(hsStream *stream, hsResMgr *group);
static hsScalar GetYonScale() { return fYonScale; }
static hsScalar SetYonScale(hsScalar s);
virtual hsBool MsgReceive(plMessage* msg);
};
#endif // hsGEnviron_inc