CWE-ou-minkata/Sources/Plasma/PubUtilLib/plDrawable/plWaveSet7.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/>.

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 plWaveSet7_inc
#define plWaveSet7_inc


#include "hsGeometry3.h"
#include "hsTemplates.h"
#include "plMath/plRandom.h"
#include "hsBounds.h"

#include "plFixedWaterState7.h"

#include "plWaveSetBase.h"

class hsStream;
class hsResMgr;
class plAccessVtxSpan;
class plMessage;
class hsGMaterial;
class plDrawableSpans;
class plRenderMsg;
class plArmatureUpdateMsg;
class plGenRefMsg;
class plAuxSpan;
class plDynaDecalMgr;
class plGBufferGroup;
class plBitmap;
class plMipmap;
class plLayer;
class plRenderRequest;
class plRenderRequestMsg;
class plRenderTarget;
class plShader;
class plPipeline;
class plRipVSConsts;
class plStatusLog;
class plGraphPlate;

class plWorldWaveData7
{
public:
    hsPoint3        fDir;
    hsScalar        fLength;

    hsScalar        fFreq;
    hsScalar        fPhase;
    hsScalar        fAmplitude;
};

class plWorldWave7 : public plWorldWaveData7
{
public:

    inline void Accumulate(hsPoint3& accumPos, hsVector3& accumNorm) const;
};


class plWaveSet7 : public plWaveSetBase
{
public:
    // Props inc by 1 (bit shift in bitvector).
    enum plDrawProperties {
        kDisable                = 0,

        kNumProps               // last in the list
    };
    // Flags, also in a bitvector, so far unused in the multimodifier
    enum {
        kHasRefObject           = 16
    };
    enum {
        kNumWaves       = 4
    };
    enum {
        kRefDynaDecalMgr,
        kRefBuoy,
        kRefBumpMat,
        kRefBumpDraw,
        kRefBumpVShader,
        kRefBumpPShader,
        kRefBiasVShader,
        kRefBiasPShader,
        kRefRipVShader,
        kRefRipPShader,
        kRefShoreVShader,
        kRefShorePShader,
        kRefFixedVShader,
        kRefFixedPShader,
        kRefGraphShoreTex,
        kRefBubbleShoreTex,
        kRefEdgeShoreTex,
        kRefGraphShoreMat,
        kRefGraphShoreDraw,
        kRefGraphVShader,
        kRefGraphPShader,
        kRefGraphShoreRT,
        kRefShore,
        kRefDecal,
        kRefDecVShader,
        kRefDecPShader,
        kRefEnvMap,
        kRefCosineLUT,
        kRefRefObj
    };

    enum {
        kGraphShorePasses = 3
    };

    enum {
        kNumWindDep = 5
    };
    enum {
        kNumTexWaves = 16
    };
    enum {
        kBumpPerPass = 4
    };
    enum {
        kNumBumpShaders = kNumTexWaves / kBumpPerPass
    };
    enum {
        kCompositeSize = 256
    };

    enum {
        kUpdateWaveKs       = 0x1,
        kRemakeBubble       = 0x2,
        kRemakeEdge         = 0x4,
        kReRenderEnvMap     = 0x8,
        kReInitWaves        = 0x10
    };

protected:

    double fCurrTime;
    double fLastTime;

    plStatusLog*    fStatusLog;
    plGraphPlate*   fStatusGraph;

    UInt32          fTrialUpdate;

    plFixedWaterState7      fState;

    hsScalar        fScrunchLen;
    hsScalar        fScrunchScale;

    hsVector3       fWindDir;

    hsScalar        fMinLen;
    hsScalar        fMaxLen;
    hsScalar        fFreqScale;

    hsScalar        fTransCountDown;
    int             fTransistor;
    hsScalar        fTransDel;
    
    hsScalar        fTexTransCountDown;
    int             fTexTrans;
    hsScalar        fTexTransDel;
    hsScalar        fTexWaveFade[kNumTexWaves];

    plWorldWave7    fWorldWaves[kNumWaves];
    hsScalar        fFreqMod[kNumWaves];

    plRandom        fRand;

    plKey               fSceneNode;

    hsTArray<plDynaDecalMgr*>       fDecalMgrs;

    hsTArray<plSceneObject*>        fBuoys; 
    hsTArray<plSceneObject*>        fShores;
    hsTArray<plSceneObject*>        fDecals;
    plSceneObject*                  fRefObj;

    hsTArray<hsBounds3Ext>          fTargBnds;

    plLayer*                        fBiasLayer[2];
    plLayer*                        fBumpLayers[kNumTexWaves];
    hsGMaterial*                    fBumpMat;
    plDrawableSpans*                fBumpDraw;
    plRenderRequest*                fBumpReq;
    plRenderRequestMsg*             fBumpReqMsg;
    plMipmap*                       fCosineLUT;

    plShader*                       fBumpVShader[kNumBumpShaders];
    plShader*                       fBumpPShader[kNumBumpShaders];

    plShader*                       fBiasVShader;
    plShader*                       fBiasPShader;

    plBitmap*                       fEnvMap;
    UInt32                          fEnvSize;
    hsScalar                        fEnvRefresh;

    plLayer*                        fFixedLayers[4];

    plShader*                       fRipVShader;
    plShader*                       fRipPShader;

    plShader*                       fShoreVShader;
    plShader*                       fShorePShader;

    plShader*                       fFixedVShader;
    plShader*                       fFixedPShader;

    enum DecalVType {
        kDecalV1Lay,
        kDecalV2Lay11,
        kDecalV2Lay12,
        kDecalVEnv,
        
        kNumDecalVShaders
    };
    enum DecalPType {
        kDecalPBB,
        kDecalPaB,
        kDecalPaM,
        kDecalPaA,
        kDecalPAB,
        kDecalPAM,
        kDecalPAA,
        kDecalPMB,
        kDecalPMM,
        kDecalPMA,
        kDecalPEnv,

        kNumDecalPShaders
    };
    plShader*                       fDecalVShaders[kNumDecalVShaders];
    plShader*                       fDecalPShaders[kNumDecalPShaders];

    // Graph shore stuff
    plMipmap*                       fGraphShoreTex;
    plMipmap*                       fBubbleShoreTex;
    plMipmap*                       fEdgeShoreTex;

    hsGMaterial*                    fGraphShoreMat[kGraphShorePasses];
    plDrawableSpans*                fGraphShoreDraw[kGraphShorePasses];
    plRenderTarget*                 fGraphShoreRT[kGraphShorePasses];

    plRenderRequest*                fGraphReq[kGraphShorePasses];
    plRenderRequestMsg*             fGraphReqMsg[kGraphShorePasses];

    plShader*                       fGraphVShader[kGraphShorePasses];
    plShader*                       fGraphPShader[kGraphShorePasses];

    class GraphState
    {
    public:
        float       fAge;
        float       fInvLife;
        float       fUOff;

        float       fFreq[4];
        float       fPhase[4];
        float       fAmp[4];
    };

    GraphState                      fGraphState[kGraphShorePasses];

    class WaveK
    {
    public:
        // fK is the number of times the sine wave repeats across the texture. Must be an integer
        // fS/fK is the base X component of the direction of the wave, with Y = 1.f - X. Note that X^2 + Y^2 != 1.
        // fD allows the wave to get more off the Y direction 
        // So the X component will be Int(fS + fD*dispersion) / fK, because it must be an integer ratio to
        // preserve tiling. Also, (fS + fD) must be <= fK (for the Y normalization).
        // See the notes.
        float   fS;
        float   fK;
        float   fD;
    };

    WaveK           fWaveKs[kNumTexWaves];

    class TexWaveDesc
    {
    public:
        hsScalar    fPhase;
        hsScalar    fAmp;
        hsScalar    fLen;
        hsScalar    fFreq;
        hsScalar    fDirX;
        hsScalar    fDirY;
        hsScalar    fRotScale00;
        hsScalar    fRotScale01;
    };
    TexWaveDesc     fTexWaves[kNumTexWaves];

    class TexWaveWindDep
    {
    public:
        hsScalar        fWindSpeed;

        hsScalar        fHeight;
        hsScalar        fSpecular;
    };

    TexWaveWindDep  fWindDeps[kNumWindDep];

    void            IInitWaveConsts();
    void            IInitState();

    inline void     IScrunch(hsPoint3& pos, hsVector3& norm) const;

    void            ICalcWindow(hsScalar dt);
    void            ICalcScale();
    void            IUpdateWaves(hsScalar dt);
    void            IUpdateWave(hsScalar dt, int i);
    hsBool          IAnyBoundsVisible(plPipeline* pipe) const;

    void            IInitWave(int i);
    void            IReInitWaves();

    void            IUpdateRefObject();
    void            IUpdateWindDir(hsScalar dt);

    void            IShiftCenter(plSceneObject* so) const;
    void            IFloatBuoys(hsScalar dt);
    void            IFloatBuoy(hsScalar dt, plSceneObject* so);

    // Bookkeeping
    void    IAddTarget(const plKey& key);
    void    IRemoveTarget(const plKey& key);

    void    ISetWindSpeed(hsScalar s);

    hsBool      IOnReceive(plGenRefMsg* refMsg);
    hsBool      IOnRemove(plGenRefMsg* refMsg);

    hsBool              ITransContinue(hsScalar dt);
    void                IStartTransition(hsScalar dt);
    hsScalar            ITransitionDelay() const;
    void                ITransition(hsScalar dt);

    hsBool              ITransTexContinue(hsScalar dt);
    void                IStartTexTransition(hsScalar dt);
    void                ITransTex(hsScalar dt);

    void                IInitTexWave(int i);
    void                ISetupTextureWaves();

    void                IUpdateLayers(hsScalar dt);
    void                IUpdateBumpLayers(hsScalar dt);
    
    plRenderRequest*    ICreateRenderRequest(plRenderTarget* rt, plDrawableSpans* draw, hsScalar pri);
    void                ISubmitRenderRequests();

    plRenderTarget*     ICreateTransferRenderTarget(const char* name, int size);
    plDrawableSpans*    ICreateClearDrawable(plDrawableSpans* drawable, hsGMaterial* mat);
    
    void                IAddBumpBiasShaders(plLayer* layer);
    plMipmap*           ICreateBiasNoiseMap();
    void                IAddBumpBiasLayer(hsGMaterial* mat);

    plMipmap*           ICreateBumpBitmapFFP(hsScalar amp, hsScalar dx, hsScalar dy) const;
    hsGMaterial*        ICreateBumpLayersFFP();
    plMipmap*           ICreateBumpMipmapPS();
    plLayer*            ICreateBumpLayerPS(plMipmap* mipMap, hsGMaterial* bumpMat, int which);
    hsGMaterial*        ICreateBumpLayersPS();
    plDrawableSpans*    ICreateBumpDrawable();

    plLayer*            ICreateTotalEnvLayer(plBitmap* envMap, hsGMaterial* mat, int which, const char* pref);
    plLayer*            ICreateTotalLayer(plBitmap* bm, hsGMaterial* mat, int which, const char* suff);

    hsGMaterial*        ICreateFixedMatPS(hsGMaterial* mat, const int numUVWs);
    void                ICreateFixedMat(hsGMaterial* mat, const int numUVWs);
    void                ICheckTargetMaterials();

    plDrawableSpans*    ICreateGraphDrawable(plDrawableSpans* drawable, hsGMaterial* mat, int nWid);
    plDrawableSpans*    ICreateEmptyGraphDrawable(const char* name, UInt32 ref, int wich);
    hsGMaterial*        ICreateEmptyMaterial(const char* name, UInt32 ref, int which);
    plLayer*            ICreateBlankLayer(const char* name, int suff);
    plMipmap*           ICreateBlankTex(const char* name, int width, int height, UInt32 ref);
    plMipmap*           ICreateGraphShoreTex(int width, int height);
    plMipmap*           ICreateBubbleShoreTex(int width, int height);
    void                IRefillBubbleShoreTex();
    plMipmap*           ICreateEdgeShoreTex(int width, int height);
    void                IRefillEdgeShoreTex();
    void                ISetAsTexture(plLayer* lay, plBitmap* tex);
    void                ICreateGraphShoreLayer(hsGMaterial* mat, int iPass);
    void                ICreateGraphBubbleLayer(hsGMaterial* mat, int iPass);
    void                ICreateGraphEdgeLayer(hsGMaterial* mat, int iPass);
    void                ICreateGraphShoreMaterials();
    plRenderTarget*     ISetupGraphShoreRenderReq(int which);
    void                IMakeShoreLayer(hsGMaterial* mat, int which);
    void                ISetupShoreLayers(hsGMaterial* mat);
    void                ISetupGraphShore(hsGMaterial* mat);
    void                ICheckShoreMaterial(plSceneObject* so);
    void                ICheckShoreMaterials();
    void                ICheckDecalMaterial(plSceneObject* so);
    void                ICheckDecalMaterials();
    void                ISetupDecal(hsGMaterial* mat);
    void                ICheckDecalEnvLayers(hsGMaterial* mat);

    void                IAddGraphPShader(hsGMaterial* mat, int iPass);
    void                IAddGraphVShader(hsGMaterial* mat, int iPass);
    void                IUpdateGraphShader(hsScalar dt, int iPass);
    void                IInitGraph(int iPass);
    void                IShuffleDownGraphs(int iPass);

    // type is either plLayRefMsg::kVertexShader or plLayRefMsg::kPixelShader.
    void                IAddShaderToLayers(hsGMaterial* mat, int iFirst, int iLast, UInt8 type, plShader* shader);

    void                IAddBumpPixelShader(hsGMaterial* mat, int iShader, int iFirst, int iLast);
    void                IAddBumpVertexShader(hsGMaterial* mat, int iShader, int iFirst, int iLast);

    void                IAddRipVertexShader(hsGMaterial* mat, const plRipVSConsts& ripConsts);
    void                IAddRipPixelShader(hsGMaterial* mat, const plRipVSConsts& ripConsts);

    void                IAddShoreVertexShader(hsGMaterial* mat);
    void                IAddShorePixelShader(hsGMaterial* mat);

    void                IAddFixedVertexShader(hsGMaterial* mat, const int numUVWs);
    void                IAddFixedPixelShader(hsGMaterial* mat);

    plShader*           IGetDecalPShader(hsGMaterial* mat);
    plShader*           ICreateDecalPShader(DecalPType t);
    plShader*           IGetDecalVShader(hsGMaterial* mat);
    plShader*           ICreateDecalVShader(DecalVType t);

    void                IUpdateShaders(plPipeline* pipe, const hsMatrix44& l2w, const hsMatrix44& w2l);

    void                IUpdateBiasVShader();
    void                IUpdateBumpPShader(plPipeline* pipe, const hsMatrix44& l2w, const hsMatrix44& w2l);
    void                IUpdateBumpVShader(plPipeline* pipe, const hsMatrix44& l2w, const hsMatrix44& w2l);
    void                IUpdateRipPShader(plPipeline* pipe, const hsMatrix44& l2w, const hsMatrix44& w2l);
    void                IUpdateRipVShader(plPipeline* pipe, const hsMatrix44& l2w, const hsMatrix44& w2l);
    void                IUpdateShoreVShader(plPipeline* pipe, const hsMatrix44& l2w, const hsMatrix44& w2l);
    void                IUpdateFixedVShader(plPipeline* pipe, const hsMatrix44& l2w, const hsMatrix44& w2l);
    void                IUpdateFixedPShader(plPipeline* pipe, const hsMatrix44& l2w, const hsMatrix44& w2l);
    void                IUpdateGraphShaders(plPipeline* pipe, hsScalar dt);
    void                IUpdateDecVShader(int t, plPipeline* pipe);
    void                IUpdateDecVShaders(plPipeline* pipe, const hsMatrix44& l2w, const hsMatrix44& w2l);

    virtual int IShoreRef() const { return kRefShore; }
    virtual int IDecalRef() const { return kRefDecal; }

    inline void LogF(const char *format, ...) const;
    inline void LogF(UInt32 color, const char *format, ...) const;
    inline void IRestartLog() const;
    inline void GraphLen(hsScalar len) const;
    inline void IRestartGraph() const;

public:
    plWaveSet7();
    virtual ~plWaveSet7();

    CLASSNAME_REGISTER( plWaveSet7 );
    GETINTERFACE_ANY( plWaveSet7, plWaveSetBase );

    virtual hsBool MsgReceive(plMessage* msg);

    virtual hsBool IEval(double secs, hsScalar del, UInt32 dirty) { return false; }

    Int32       GetNumProperties() const { return kNumProps; }

    virtual void Read(hsStream* stream, hsResMgr* mgr);
    virtual void Write(hsStream* stream, hsResMgr* mgr);

    hsScalar            EvalPoint(hsPoint3& pos, hsVector3& norm);

    // Getters and Setters for Python twiddling
    //
    // First a way to set new values. The secs parameter says how long to take
    // blending to the new value from the current value.
    //
    // Geometric wave parameters. These are all safe to twiddle at any time or speed.
    // The new settings take effect as new waves are spawned.
    void SetGeoMaxLength(hsScalar s, hsScalar secs=0) { fState.fGeoState.fMaxLength.Set(s, secs); }
    void SetGeoMinLength(hsScalar s, hsScalar secs=0) { fState.fGeoState.fMinLength.Set(s, secs); }
    void SetGeoAmpOverLen(hsScalar s, hsScalar secs=0) { fState.fGeoState.fAmpOverLen.Set(s, secs); }
    void SetGeoChop(hsScalar s, hsScalar secs=0) { fState.fGeoState.fChop.Set(s, secs); }
    void SetGeoAngleDev(hsScalar s, hsScalar secs=0) { fState.fGeoState.fAngleDev.Set(s, secs); }

    // Texture wave parameters. Safe to twiddle any time or speed.
    // The new settings take effect as new waves are spawned.
    void SetTexMaxLength(hsScalar s, hsScalar secs=0) { fState.fTexState.fMaxLength.Set(s, secs); }
    void SetTexMinLength(hsScalar s, hsScalar secs=0) { fState.fTexState.fMinLength.Set(s, secs); }
    void SetTexAmpOverLen(hsScalar s, hsScalar secs=0) { fState.fTexState.fAmpOverLen.Set(s, secs); }
    void SetTexChop(hsScalar s, hsScalar secs=0) { fState.fTexState.fChop.Set(s, secs); }
    void SetTexAngleDev(hsScalar s, hsScalar secs=0) { fState.fTexState.fAngleDev.Set(s, secs); }

    // The size in feet of one tile of the ripple texture. If you change this (I don't 
    // recommend it), you need to change it very slowly or it will look very stupid.
    void SetRippleScale(hsScalar s, hsScalar secs=0) { fState.fRippleScale.Set(s, secs); }

    // The direction the wind is blowing (waves will be more or less perpindicular to wind dir).
    // Change somewhat slowly, like over 30 seconds.
    void SetWindDir(const hsVector3& s, hsScalar secs=0) { fState.fWindDir.Set(s, secs); }

    // Change these gently, effect is immediate.
    void SetSpecularNoise(hsScalar s, hsScalar secs=0) { hsVector3 spec = fState.fSpecVec; spec[plFixedWaterState7::kNoise] = s; fState.fSpecVec.Set(spec, secs); }
    void SetSpecularStart(hsScalar s, hsScalar secs=0) { hsVector3 spec = fState.fSpecVec; spec[plFixedWaterState7::kSpecStart] = s; fState.fSpecVec.Set(spec, secs); }
    void SetSpecularEnd(hsScalar s, hsScalar secs=0) { hsVector3 spec = fState.fSpecVec; spec[plFixedWaterState7::kSpecEnd] = s; fState.fSpecVec.Set(spec, secs); }

    // Water Height is overriden if the ref object is animated.
    void SetWaterHeight(hsScalar s, hsScalar secs=0) { fState.fWaterHeight.Set(s, secs); }

    // Water Offset and DepthFalloff are complicated, and not immediately interesting to animate.
    void SetWaterOffset(const hsVector3& s, hsScalar secs=0) { fState.fWaterOffset.Set(s, secs); }
        void SetOpacOffset(hsScalar s, hsScalar secs=0) { hsVector3 off = fState.fWaterOffset; off.fX = s; fState.fWaterOffset.Set(off, secs); }
        void SetReflOffset(hsScalar s, hsScalar secs=0) { hsVector3 off = fState.fWaterOffset; off.fY = s; fState.fWaterOffset.Set(off, secs); }
        void SetWaveOffset(hsScalar s, hsScalar secs=0) { hsVector3 off = fState.fWaterOffset; off.fZ = s; fState.fWaterOffset.Set(off, secs); }
    void SetDepthFalloff(const hsVector3& s, hsScalar secs=0) { fState.fDepthFalloff.Set(s, secs); }
        void SetOpacFalloff(hsScalar s, hsScalar secs=0) { hsVector3 off = fState.fDepthFalloff; off.fX = s; fState.fDepthFalloff.Set(off, secs); }
        void SetReflFalloff(hsScalar s, hsScalar secs=0) { hsVector3 off = fState.fDepthFalloff; off.fY = s; fState.fDepthFalloff.Set(off, secs); }
        void SetWaveFalloff(hsScalar s, hsScalar secs=0) { hsVector3 off = fState.fDepthFalloff; off.fZ = s; fState.fDepthFalloff.Set(off, secs); }

    // Max and Min Atten aren't very interesting, and will probably go away.
    void SetMaxAtten(const hsVector3& s, hsScalar secs=0) { fState.fMaxAtten.Set(s, secs); }
    void SetMinAtten(const hsVector3& s, hsScalar secs=0) { fState.fMinAtten.Set(s, secs); }

    // Skipping the shore parameters, because they are never used.

    // Water colors, adjust slowly, effect is immediate.
    void SetWaterTint(const hsColorRGBA& s, hsScalar secs=0) { fState.fWaterTint.Set(s, secs); }
        void SetWaterRGB(const hsVector3& col, hsScalar secs=0) { hsColorRGBA rgb; rgb.Set(col.fX, col.fY, col.fZ, GetWaterOpacity()); SetWaterTint(rgb, secs); }
        void SetWaterOpacity(hsScalar s, hsScalar secs=0) { hsColorRGBA col = GetWaterTint(); col.a = s; SetWaterTint(col, secs); }
    void SetSpecularTint(const hsColorRGBA& s, hsScalar secs=0) { fState.fSpecularTint.Set(s, secs); }
        void SetSpecularRGB(const hsVector3& col, hsScalar secs=0) { hsColorRGBA rgb; rgb.Set(col.fX, col.fY, col.fZ, GetSpecularMute()); SetSpecularTint(rgb, secs); }
        void SetSpecularMute(hsScalar s, hsScalar secs=0) { hsColorRGBA col = GetSpecularTint(); col.a = s; SetSpecularTint(col, secs); }

    // The environment map is essentially projected onto a sphere. Moving the center of
    // the sphere north will move the reflections north, changing the radius of the
    // sphere effects parallax in the obvious way.
    void SetEnvCenter(const hsPoint3& s, hsScalar secs=0) { fState.fEnvCenter.Set(s, secs); }
    void SetEnvRadius(hsScalar s, hsScalar secs=0) { fState.fEnvRadius.Set(s, secs); }

    // Now a way to get current values. See the accompanying Setter for notes on
    // what the parameter means.
    //
    hsScalar GetGeoMaxLength() const { return fState.fGeoState.fMaxLength; }
    hsScalar GetGeoMinLength() const { return fState.fGeoState.fMinLength; }
    hsScalar GetGeoAmpOverLen() const { return fState.fGeoState.fAmpOverLen; }
    hsScalar GetGeoChop() const { return fState.fGeoState.fChop; }
    hsScalar GetGeoAngleDev() const { return fState.fGeoState.fAngleDev; }

    hsScalar GetTexMaxLength() const { return fState.fTexState.fMaxLength; }
    hsScalar GetTexMinLength() const { return fState.fTexState.fMinLength; }
    hsScalar GetTexAmpOverLen() const { return fState.fTexState.fAmpOverLen; }
    hsScalar GetTexChop() const { return fState.fTexState.fChop; }
    hsScalar GetTexAngleDev() const { return fState.fTexState.fAngleDev; }

    hsScalar GetRippleScale() const { return fState.fRippleScale; }

    hsVector3 GetWindDir() const { return fState.fWindDir; }

    hsScalar GetSpecularNoise() const { hsVector3 spec = fState.fSpecVec; return spec[plFixedWaterState7::kNoise]; }
    hsScalar GetSpecularStart() const { hsVector3 spec = fState.fSpecVec; return spec[plFixedWaterState7::kSpecStart]; }
    hsScalar GetSpecularEnd() const { hsVector3 spec = fState.fSpecVec; return spec[plFixedWaterState7::kSpecEnd]; }

    hsScalar GetWaterHeight() const { return fState.fWaterHeight; }

    hsVector3 GetWaterOffset() const { return fState.fWaterOffset; }
        hsScalar GetOpacOffset() const { hsVector3 off = fState.fWaterOffset; return off.fX; }
        hsScalar GetReflOffset() const { hsVector3 off = fState.fWaterOffset; return off.fY; }
        hsScalar GetWaveOffset() const { hsVector3 off = fState.fWaterOffset; return off.fZ; }
    hsVector3 GetDepthFalloff() const { return fState.fDepthFalloff; }
        hsScalar GetOpacFalloff() const { hsVector3 off = fState.fDepthFalloff; return off.fX; }
        hsScalar GetReflFalloff() const { hsVector3 off = fState.fDepthFalloff; return off.fY; }
        hsScalar GetWaveFalloff() const { hsVector3 off = fState.fDepthFalloff; return off.fZ; }

    hsVector3 GetMaxAtten() const { return fState.fMaxAtten; }
    hsVector3 GetMinAtten() const { return fState.fMinAtten; }

    hsColorRGBA GetWaterTint() const { return fState.fWaterTint; }
        hsVector3 GetWaterRGB() const { hsColorRGBA col = GetWaterTint(); return hsVector3(col.r, col.g, col.b); }
        hsScalar GetWaterOpacity() const { return GetWaterTint().a; }
    hsColorRGBA GetSpecularTint() const { return fState.fSpecularTint; }
        hsVector3 GetSpecularRGB() const { hsColorRGBA col = GetSpecularTint(); return hsVector3(col.r, col.g, col.b); }
        hsScalar GetSpecularMute() const { return GetSpecularTint().a; }

    hsPoint3 GetEnvCenter() const { return fState.fEnvCenter; }
    hsScalar GetEnvRadius() const { return fState.fEnvRadius; }

    // Export/debugging functions. For runtime, use message interface (plGenRefMsg, plWaveMsg).
    void        AddTarget(const plKey& key);
    void        RemoveTarget(const plKey& key);
    void        AddShoreTest(plKey& key);

    void        SetRefObject(plSceneObject* refObj);

    void            SetSceneNode(const plKey& key);
    plKey           GetSceneNode() const { return fSceneNode; }

    void            AddDynaDecalMgr(plKey& key);
    void            RemoveDynaDecalMgr(plKey& key);

    void            AddBuoy(plKey soKey);
    void            RemoveBuoy(plKey soKey);

    virtual hsBool          SetupRippleMat(hsGMaterial* mat, const plRipVSConsts& ripConsts);

    virtual hsScalar        GetHeight() const { return State().fWaterHeight; }

    const plFixedWaterState7::WaveState& GeoState() const { return State().fGeoState; }
    const plFixedWaterState7::WaveState& TexState() const { return State().fTexState; }
    const plFixedWaterState7& State() const { return fState; }
    void            SetState(const plFixedWaterState7& state, hsScalar dur);

    void            SetEnvSize(UInt32 s) { fEnvSize = s; }
    UInt32          GetEnvSize() const { return fEnvSize; }

    void StopLog();
    void StartLog();
    hsBool Logging() const { return fStatusLog != nil; }
    void StartGraph();
    void StopGraph();
    hsBool Graphing() const { return fStatusGraph != nil; }
};

#endif // plWaveSet7_inc