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.

293 lines
11 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 plDynaDecalMgr_inc
#define plDynaDecalMgr_inc
#include "pnNetCommon/plSynchedObject.h"
#include "hsTemplates.h"
#include "hsGeometry3.h"
#include "hsMatrix44.h"
#include "hsStlUtils.h"
class plParticleSystem;
class plPrintShape;
class plDynaDecalEnableMsg;
class plDynaDecal;
class plDrawableSpans;
class plGBufferGroup;
class plIcicle;
class hsGMaterial;
class plBitmap;
class plMipmap;
class plSceneObject;
class plArmatureMod;
class hsStream;
class hsResMgr;
class plMessage;
class plCutter;
class plCutoutPoly;
class plFlatGridMesh;
class plDrawVisList;
class plRenderLevel;
class plAccessSpan;
class plAuxSpan;
class plDecalVtxFormat;
class plPipeline;
// plDynaDecalInfo - information we store specific to what we've
// done about a specific avatar part or scene object.
class plDynaDecalInfo
{
public:
enum
{
kNone = 0x0,
kImmersed = 0x1,
kActive = 0x2
};
plKey fKey;
double fLastTime;
hsPoint3 fLastPos;
double fWetTime;
hsScalar fWetLength;
UInt32 fFlags;
plDynaDecalInfo& Init(const plKey& key);
};
typedef std::map< UInt32, plDynaDecalInfo, std::less<UInt32> > plDynaDecalMap;
// plDynaDecalMgr
// Primary responsibilities:
// Allocation of adequate buffer space in plGBufferGroup
// Setup of decal materials
// Allocation of auxSpans
// Receive lists of polys, translate into drawable tris
// Create DynaDecals and destroy them when they expire.
// Assign vertex and index subsets to DynaDecals
// Call Update on DynaDecals
class plDynaDecalMgr : public plSynchedObject
{
public:
enum DynaRefType
{
kRefMatPreShade,
kRefMatRTShade,
kRefTarget,
kRefAvatar,
kRefPartyObject,
kRefParticles,
kRefNextAvailable = 10
};
protected:
static hsBool fDisableAccumulate;
static hsBool fDisableUpdate;
plDynaDecalMap fDecalMap;
hsTArray<plDynaDecal*> fDecals;
hsTArray<plGBufferGroup*> fGroups;
plCutter* fCutter;
hsTArray<plAuxSpan*> fAuxSpans;
hsGMaterial* fMatPreShade;
hsGMaterial* fMatRTShade;
hsTArray<plSceneObject*> fTargets;
hsTArray<plSceneObject*> fPartyObjects;
hsTArray<plParticleSystem*> fParticles;
hsScalar fPartyTime;
UInt16 fMaxNumVerts;
UInt16 fMaxNumIdx;
UInt32 fWaitOnEnable;
hsScalar fWetLength;
hsScalar fRampEnd;
hsScalar fDecayStart;
hsScalar fLifeSpan;
hsScalar fIntensity;
hsScalar fGridSizeU;
hsScalar fGridSizeV;
hsVector3 fScale;
// some temp calculated stuff
hsScalar fInitAtten;
// These 4 are in normalized units [0..1], not feet.
hsScalar fMinDepth;
hsScalar fMinDepthRange;
hsScalar fMaxDepth;
hsScalar fMaxDepthRange;
hsTArray<UInt32> fPartIDs;
hsTArray<plKey> fNotifies;
const plPrintShape* IGetPrintShape(const plKey& objKey) const;
const plPrintShape* IGetPrintShape(plArmatureMod* avMod, UInt32 id) const;
virtual hsBool IHandleEnableMsg(const plDynaDecalEnableMsg* enaMsg);
void INotifyActive(plDynaDecalInfo& info, const plKey& armKey, UInt32 id) const;
void INotifyInactive(plDynaDecalInfo& info, const plKey& armKey, UInt32 id) const;
hsBool IWetParts(const plDynaDecalEnableMsg* enaMsg);
hsBool IWetPart(UInt32 id, const plDynaDecalEnableMsg* enaMsg);
void IWetInfo(plDynaDecalInfo& info, const plDynaDecalEnableMsg* enaMsg) const;
hsScalar IHowWet(plDynaDecalInfo& info, double t) const;
plDynaDecalInfo& IGetDecalInfo(UInt32 id, const plKey& key);
void IRemoveDecalInfo(UInt32 id);
void IRemoveDecalInfos(const plKey& key);
hsGMaterial* ISetAuxMaterial(plAuxSpan* aux, hsGMaterial* mat, hsBool rtLit);
void IAllocAuxSpan(plAuxSpan* aux, UInt32 maxNumVerts, UInt32 maxNumIdx);
plAuxSpan* IGetAuxSpan(plDrawableSpans* targ, int iSpan, hsGMaterial* mat, UInt16 numVerts, UInt16 numIdx);
hsBool IMakeAuxRefs(plPipeline* pipe);
UInt16* IGetBaseIdxPtr(const plAuxSpan* auxSpan) const;
plDecalVtxFormat* IGetBaseVtxPtr(const plAuxSpan* auxSpan) const;
virtual int INewDecal() = 0;
plDynaDecal* IInitDecal(plAuxSpan* aux, double t, UInt16 numVerts, UInt16 numIdx);
void IKillDecal(int i);
void IUpdateDecals(double t);
void ICountIncoming(hsTArray<plCutoutPoly>& src, UInt16& numVerts, UInt16& numIdx) const;
hsBool IConvertPolysColor(plAuxSpan* auxSpan, plDynaDecal* decal, hsTArray<plCutoutPoly>& src);
hsBool IConvertPolysAlpha(plAuxSpan* auxSpan, plDynaDecal* decal, hsTArray<plCutoutPoly>& src);
hsBool IConvertPolysVS(plAuxSpan* auxSpan, plDynaDecal* decal, hsTArray<plCutoutPoly>& src);
hsBool IConvertPolys(plAuxSpan* auxSpan, plDynaDecal* decal, hsTArray<plCutoutPoly>& src);
hsBool IProcessPolys(plDrawableSpans* targ, int iSpan, double t, hsTArray<plCutoutPoly>& src);
hsBool IHitTestPolys(hsTArray<plCutoutPoly>& src) const;
hsBool IProcessGrid(plDrawableSpans* targ, int iSpan, hsGMaterial* mat, double t, const plFlatGridMesh& grid);
hsBool IConvertFlatGrid(plAuxSpan* auxSpan, plDynaDecal* decal, const plFlatGridMesh& grid) const;
hsBool ICutoutGrid(plDrawableSpans* drawable, int iSpan, hsGMaterial* mat, double secs);
hsBool IHitTestFlatGrid(const plFlatGridMesh& grid) const;
hsBool ICutoutList(hsTArray<plDrawVisList>& drawVis, double secs);
hsBool ICutoutObject(plSceneObject* so, double secs);
hsBool ICutoutTargets(double secs);
void ISetDepthFalloff(); // Sets from current cutter settings.
virtual void ICutoutCallback(const hsTArray<plCutoutPoly>& cutouts, hsBool hasWaterHeight=false, hsScalar waterHeight=0.f);
hsGMaterial* IConvertToEnvMap(hsGMaterial* mat, plBitmap* envMap);
virtual void SetKey(plKey k);
hsVector3 IReflectDir(hsVector3 dir) const;
hsMatrix44 IL2WFromHit(hsPoint3 pos, hsVector3 dir) const;
hsVector3 IRandomUp(hsVector3 dir) const;
void IGetParticles();
public:
plDynaDecalMgr();
virtual ~plDynaDecalMgr();
CLASSNAME_REGISTER( plDynaDecalMgr );
GETINTERFACE_ANY( plDynaDecalMgr, plSynchedObject );
virtual void Read(hsStream* stream, hsResMgr* mgr);
virtual void Write(hsStream* stream, hsResMgr* mgr);
virtual hsBool MsgReceive(plMessage* msg);
// This is public, because you need to call it after creating
// a DynaDecalMgr on the fly. It's normally called on Read().
void InitAuxSpans();
void SetScale(const hsVector3& v) { fScale = v; }
const hsVector3& GetScale() const { return fScale; }
void SetWaitOnEnable(hsBool on) { fWaitOnEnable = on; }
hsBool GetWaitOnEnable() const { return fWaitOnEnable; }
void SetWetLength(hsScalar f) { fWetLength = f; }
void SetRampEnd(hsScalar f) { fRampEnd = f; }
void SetDecayStart(hsScalar f) { fDecayStart = f; }
void SetLifeSpan(hsScalar f) { fLifeSpan = f; }
void SetIntensity(hsScalar f) { fIntensity = f; }
hsScalar GetWetLength() const { return fWetLength; }
hsScalar GetRampEnd() const { return fRampEnd; }
hsScalar GetDecayStart() const { return fDecayStart; }
hsScalar GetLifeSpan() const { return fLifeSpan; }
hsScalar GetIntensity() const { return fIntensity; }
void SetPartyTime(hsScalar secs) { fPartyTime = secs; } // Duration of particle spewage
hsScalar GetPartyTime() const { return fPartyTime; }
void ConvertToEnvMap(plBitmap* envMap);
const plMipmap* GetMipmap() const;
void AddNotify(const plKey& k) { fNotifies.Append(k); }
UInt32 GetNumNotifies() const { return fNotifies.GetCount(); }
const plKey& GetNotify(int i) const { return fNotifies[i]; }
static void SetDisableAccumulate(hsBool on) { fDisableAccumulate = on; }
static void ToggleDisableAccumulate() { fDisableAccumulate = !fDisableAccumulate; }
static hsBool GetDisableAccumulate() { return fDisableAccumulate; }
static void SetDisableUpdate(hsBool on) { fDisableUpdate = on; }
static void ToggleDisableUpdate() { fDisableUpdate = !fDisableUpdate; }
static hsBool GetDisableUpdate() { return fDisableUpdate; }
};
#endif // plDynaDecalMgr_inc