CWE-ou-minkata/Sources/Plasma/PubUtilLib/plPipeline/hsGEnviron.h

/*==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