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.
658 lines
23 KiB
658 lines
23 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 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
|
|
|