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.

309 lines
8.5 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/>.
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 plVolumeIsect_inc
#define plVolumeIsect_inc
#include "hsGeometry3.h"
#include "hsMatrix44.h"
#include "hsTemplates.h"
#include "hsBounds.h"
#include "pnFactory/plCreatable.h"
class hsBounds3Ext;
enum plVolumeCullResult
{
kVolumeClear = 0x0,
kVolumeCulled = 0x1,
kVolumeSplit = 0x2
};
class plVolumeIsect : public plCreatable
{
public:
CLASSNAME_REGISTER( plVolumeIsect );
GETINTERFACE_ANY( plVolumeIsect, plCreatable );
virtual void SetTransform(const hsMatrix44& l2w, const hsMatrix44& w2l) = 0;
virtual plVolumeCullResult Test(const hsBounds3Ext& bnd) const = 0;
virtual hsScalar Test(const hsPoint3& pos) const = 0;
virtual void Read(hsStream* s, hsResMgr* mgr) = 0;
virtual void Write(hsStream* s, hsResMgr* mgr) = 0;
};
class plSphereIsect : public plVolumeIsect
{
protected:
hsPoint3 fCenter;
hsPoint3 fWorldCenter;
hsScalar fRadius;
hsPoint3 fMins;
hsPoint3 fMaxs;
public:
plSphereIsect();
virtual ~plSphereIsect();
CLASSNAME_REGISTER( plSphereIsect );
GETINTERFACE_ANY( plSphereIsect, plVolumeIsect );
void SetCenter(const hsPoint3& c);
void SetRadius(hsScalar r);
hsScalar GetRadius() const { return fRadius; }
virtual void SetTransform(const hsMatrix44& l2w, const hsMatrix44& w2l);
virtual plVolumeCullResult Test(const hsBounds3Ext& bnd) const;
virtual hsScalar Test(const hsPoint3& pos) const; // return 0 if point inside, else "distance" from pos to volume
virtual void Read(hsStream* s, hsResMgr* mgr);
virtual void Write(hsStream* s, hsResMgr* mgr);
};
class plConeIsect : public plVolumeIsect
{
protected:
hsBool fCapped;
hsScalar fRadAngle;
hsScalar fLength;
hsPoint3 fWorldTip;
hsVector3 fWorldNorm;
hsMatrix44 fWorldToNDC;
hsMatrix44 fLightToNDC;
hsVector3 fNorms[5];
hsScalar fDists[5];
void ISetup();
public:
plConeIsect();
virtual ~plConeIsect();
CLASSNAME_REGISTER( plConeIsect );
GETINTERFACE_ANY( plConeIsect, plVolumeIsect );
void SetAngle(hsScalar rads);
void SetLength(hsScalar d);
hsScalar GetLength() const { return fCapped ? fLength : 0; }
hsScalar GetAngle() const { return fRadAngle; }
virtual void SetTransform(const hsMatrix44& l2w, const hsMatrix44& w2l);
virtual plVolumeCullResult Test(const hsBounds3Ext& bnd) const;
virtual hsScalar Test(const hsPoint3& pos) const;
virtual void Read(hsStream* s, hsResMgr* mgr);
virtual void Write(hsStream* s, hsResMgr* mgr);
};
class plCylinderIsect : public plVolumeIsect
{
protected:
hsPoint3 fTop;
hsPoint3 fBot;
hsScalar fRadius;
hsPoint3 fWorldBot;
hsVector3 fWorldNorm;
hsScalar fLength;
hsScalar fMin;
hsScalar fMax;
void ISetupCyl(const hsPoint3& wTop, const hsPoint3& wBot, hsScalar radius);
public:
plCylinderIsect();
virtual ~plCylinderIsect();
CLASSNAME_REGISTER( plCylinderIsect );
GETINTERFACE_ANY( plCylinderIsect, plVolumeIsect );
void SetCylinder(const hsPoint3& lTop, const hsPoint3& lBot, hsScalar radius);
void SetCylinder(const hsPoint3& lBot, const hsVector3& axis, hsScalar radius);
virtual void SetTransform(const hsMatrix44& l2w, const hsMatrix44& w2l);
virtual plVolumeCullResult Test(const hsBounds3Ext& bnd) const;
virtual hsScalar Test(const hsPoint3& pos) const;
virtual void Read(hsStream* s, hsResMgr* mgr);
virtual void Write(hsStream* s, hsResMgr* mgr);
};
class plParallelIsect : public plVolumeIsect
{
protected:
class ParPlane
{
public:
hsVector3 fNorm;
hsScalar fMin;
hsScalar fMax;
hsPoint3 fPosOne;
hsPoint3 fPosTwo;
};
hsTArray<ParPlane> fPlanes;
public:
plParallelIsect();
virtual ~plParallelIsect();
CLASSNAME_REGISTER( plParallelIsect );
GETINTERFACE_ANY( plParallelIsect, plVolumeIsect );
void SetNumPlanes(int n); // each plane is really two parallel planes
UInt16 GetNumPlanes() const { return fPlanes.GetCount(); }
void SetPlane(int which, const hsPoint3& locPosOne, const hsPoint3& locPosTwo);
virtual void SetTransform(const hsMatrix44& l2w, const hsMatrix44& w2l);
virtual plVolumeCullResult Test(const hsBounds3Ext& bnd) const;
virtual hsScalar Test(const hsPoint3& pos) const;
virtual void Read(hsStream* s, hsResMgr* mgr);
virtual void Write(hsStream* s, hsResMgr* mgr);
};
class plConvexIsect : public plVolumeIsect
{
protected:
class SinglePlane
{
public:
hsVector3 fNorm;
hsScalar fDist;
hsPoint3 fPos;
hsVector3 fWorldNorm;
hsScalar fWorldDist;
};
hsTArray<SinglePlane> fPlanes;
public:
plConvexIsect();
virtual ~plConvexIsect();
CLASSNAME_REGISTER( plConvexIsect );
GETINTERFACE_ANY( plConvexIsect, plVolumeIsect );
void ClearPlanes() { fPlanes.SetCount(0); }
void AddPlaneUnchecked(const hsVector3& n, hsScalar dist); // no validation here
void AddPlane(const hsVector3& n, const hsPoint3& p);
UInt16 GetNumPlanes() const { return fPlanes.GetCount(); }
virtual void SetTransform(const hsMatrix44& l2w, const hsMatrix44& w2l);
virtual plVolumeCullResult Test(const hsBounds3Ext& bnd) const;
virtual hsScalar Test(const hsPoint3& pos) const;
virtual void Read(hsStream* s, hsResMgr* mgr);
virtual void Write(hsStream* s, hsResMgr* mgr);
};
class plBoundsIsect : public plVolumeIsect
{
protected:
hsBounds3Ext fLocalBounds;
hsBounds3Ext fWorldBounds;
public:
plBoundsIsect();
virtual ~plBoundsIsect();
CLASSNAME_REGISTER( plBoundsIsect );
GETINTERFACE_ANY( plBoundsIsect, plVolumeIsect );
void SetBounds(const hsBounds3Ext& bnd);
virtual void SetTransform(const hsMatrix44& l2w, const hsMatrix44& w2l);
virtual plVolumeCullResult Test(const hsBounds3Ext& bnd) const;
virtual hsScalar Test(const hsPoint3& pos) const;
virtual void Read(hsStream* s, hsResMgr* mgr);
virtual void Write(hsStream* s, hsResMgr* mgr);
};
class plComplexIsect : public plVolumeIsect
{
protected:
hsTArray<plVolumeIsect*> fVolumes;
public:
plComplexIsect();
virtual ~plComplexIsect();
CLASSNAME_REGISTER( plComplexIsect );
GETINTERFACE_ANY( plComplexIsect, plVolumeIsect );
void AddVolume(plVolumeIsect* v); // Will capture pointer
UInt16 GetNumVolumes() const { return fVolumes.GetCount(); }
virtual void SetTransform(const hsMatrix44& l2w, const hsMatrix44& w2l);
virtual void Read(hsStream* s, hsResMgr* mgr);
virtual void Write(hsStream* s, hsResMgr* mgr);
};
class plUnionIsect : public plComplexIsect
{
public:
plUnionIsect();
~plUnionIsect();
CLASSNAME_REGISTER( plUnionIsect );
GETINTERFACE_ANY( plUnionIsect, plComplexIsect );
virtual plVolumeCullResult Test(const hsBounds3Ext& bnd) const;
virtual hsScalar Test(const hsPoint3& pos) const;
};
class plIntersectionIsect : public plComplexIsect
{
public:
plIntersectionIsect();
~plIntersectionIsect();
CLASSNAME_REGISTER( plIntersectionIsect );
GETINTERFACE_ANY( plIntersectionIsect, plComplexIsect );
virtual plVolumeCullResult Test(const hsBounds3Ext& bnd) const;
virtual hsScalar Test(const hsPoint3& pos) const;
};
#endif // plVolumeIsect_inc