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.
289 lines
9.8 KiB
289 lines
9.8 KiB
/*==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==*/ |
|
#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
|
|
|