khanat-opennel-code/code/nel/src/pacs/collision_ot.h
2010-05-06 02:08:41 +02:00

469 lines
9.3 KiB
C++

// NeL - MMORPG Framework <http://dev.ryzom.com/projects/nel/>
// Copyright (C) 2010 Winch Gate Property Limited
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU Affero 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 Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
#ifndef NL_COLLISION_OT_H
#define NL_COLLISION_OT_H
#include "nel/misc/types_nl.h"
#include "collision_desc.h"
#include "global_retriever.h"
namespace NLPACS
{
class CMovePrimitive;
class CCollisionOTInfo;
/**
* Odered table element
*
* \author Cyril 'Hulud' Corvazier
* \author Nevrax France
* \date 2001
*/
class CCollisionOT
{
public:
CCollisionOT ()
{
_Info=false;
clear ();
}
virtual ~CCollisionOT () { }
/// Clear the element
void clear ()
{
_Next=NULL;
_Previous=NULL;
}
/// Link in the ot
void link (CCollisionOT* newElement)
{
if (newElement)
{
newElement->_Previous=this;
newElement->_Next=_Next;
}
if (_Next)
_Next->_Previous=newElement;
_Next=newElement;
}
/// Remove from OT
void unlink ()
{
if (_Previous)
_Previous->_Next=_Next;
if (_Next)
_Next->_Previous=_Previous;
_Next=NULL;
_Previous=NULL;
}
/// Return true if it an info collision else false;
bool isInfo () const
{
return _Info;
}
/// Get next element in the ot
CCollisionOT *getPrevious () const
{
return _Previous;
}
/// Get next element in the ot
CCollisionOT *getNext () const
{
return _Next;
}
/// Get next element in the ot
CCollisionOTInfo *getNextInfo () const;
private:
// The next cell
CCollisionOT *_Next;
// The previous cell
CCollisionOT *_Previous;
protected:
// Is a CCollisionOTInfo
bool _Info;
};
/**
* Collision descriptor for time odered table
*
* \author Cyril 'Hulud' Corvazier
* \author Nevrax France
* \date 2001
*/
class CCollisionOTInfo : public CCollisionOT
{
public:
CCollisionOTInfo ()
{
_Info=true;
}
// Link in the primitive
virtual void primitiveLink (CMovePrimitive *primitive, CCollisionOTInfo *other) =0;
// Link in the primitive
virtual CCollisionOTInfo *getNext (CMovePrimitive *primitive) const =0;
// Return false for dynamic collision, true for static collision
virtual bool isCollisionAgainstStatic () const=0;
// Return collision time
virtual double getCollisionTime () const=0;
// Remove the collision from the primitives
virtual void removeFromPrimitives ()=0;
// Get second primitive
virtual CMovePrimitive *getOtherPrimitive (CMovePrimitive *primitive) const=0;
};
/**
* Dynamic collisions descriptor for time odered table
*
* \author Cyril 'Hulud' Corvazier
* \author Nevrax France
* \date 2001
*/
class CCollisionOTDynamicInfo : public CCollisionOTInfo
{
public:
CCollisionOTDynamicInfo ()
{
_Info=true;
}
// Get the first primitive in the collision
CMovePrimitive *getFirstPrimitive () const
{
return _FirstPrimitive;
}
// Get the second primitive in the collision
CMovePrimitive *getSecondPrimitive () const
{
return _SecondPrimitive;
}
// Get the collision descriptor
const CCollisionDesc &getCollisionDesc () const
{
return _Desc;
}
// Is a collision
bool isCollision() const
{
return _Collision;
}
// Is enter
bool isEnter() const
{
return _Enter;
}
// Is exit
bool isExit() const
{
return _Exit;
}
// Is exit
bool isInside() const
{
return _Inside;
}
// Is second primitive is static ?
bool isSecondStatic () const
{
return _SecondStatic;
}
// Get the world image
uint8 getFirstWorldImage () const
{
return _FirstWorldImage;
}
// Get the world image
uint8 getSecondWorldImage () const
{
return _SecondWorldImage;
}
// Init the info
void init (CMovePrimitive *firstPrimitive, CMovePrimitive *secondPrimitive, const CCollisionDesc& desc, bool collision,
bool enter, bool exit, bool inside, uint8 firstWorldImage, uint8 secondWorldImage, bool secondStatic)
{
_FirstPrimitive=firstPrimitive;
_SecondPrimitive=secondPrimitive;
_Desc=desc;
_Collision=collision;
_Enter=enter;
_Exit=exit;
_Inside=inside;
_FirstWorldImage=firstWorldImage;
_SecondWorldImage=secondWorldImage;
_SecondStatic=secondStatic;
}
// Link in the primitive
void primitiveLink (CMovePrimitive *primitive, CCollisionOTInfo *other)
{
// First primitive ?
if (primitive==_FirstPrimitive)
{
// Check
nlassert (primitive!=_SecondPrimitive);
// Link
_FirstNext=other;
}
else // second
{
// Check
nlassert (primitive==_SecondPrimitive);
// Link
_SecondNext=other;
}
}
// Link in the primitive
CCollisionOTInfo *getNext (CMovePrimitive *primitive) const
{
// First primitive ?
if (primitive==_FirstPrimitive)
{
// Check
nlassert (primitive!=_SecondPrimitive);
// return next
return _FirstNext;
}
else // second
{
// Check
nlassert (primitive==_SecondPrimitive);
// Link
return _SecondNext;
}
}
// Return false for dynamic collision, true for static collision
bool isCollisionAgainstStatic () const
{
return false;
}
// Return collision time
double getCollisionTime () const
{
return _Desc.ContactTime;
}
// Remove the collision from the primitives
void removeFromPrimitives ();
// Get second primitive
CMovePrimitive *getOtherPrimitive (CMovePrimitive *primitive) const
{
if (_FirstPrimitive==primitive)
return _SecondPrimitive;
else
{
nlassert (_SecondPrimitive==primitive);
return _FirstPrimitive;
}
}
private:
// The first primitive
CMovePrimitive *_FirstPrimitive;
// The second primitive
CMovePrimitive *_SecondPrimitive;
// Descriptor
CCollisionDesc _Desc;
// Collision or only trigger ?
bool _Collision;
bool _Enter;
bool _Exit;
bool _Inside;
bool _SecondStatic;
// World images
uint8 _FirstWorldImage;
uint8 _SecondWorldImage;
// First primitive linked list
CCollisionOTInfo *_FirstNext;
// Second primitive linked list
CCollisionOTInfo *_SecondNext;
};
/**
* Static collisions descriptor for time odered table
*
* \author Cyril 'Hulud' Corvazier
* \author Nevrax France
* \date 2001
*/
class CCollisionOTStaticInfo : public CCollisionOTInfo
{
public:
CCollisionOTStaticInfo ()
{
_Info=true;
}
// Get the first primitive in the collision
CMovePrimitive *getPrimitive () const
{
return _Primitive;
}
// Get the collision descriptor
const CCollisionSurfaceDesc &getCollisionDesc () const
{
return _StaticDesc;
}
// Get the collision descriptor
const UGlobalPosition &getGlobalPosition () const
{
return _GlobalPosition;
}
// Get delta time
double getDeltaTime () const
{
return _DeltaTime;
}
// Get the world image
uint8 getWorldImage () const
{
return _WorldImage;
}
// Init the info
void init (CMovePrimitive *primitive, const CCollisionSurfaceDesc& desc,
const UGlobalPosition& nextGlobalPosition, double delta, uint8 worldImage)
{
_Primitive=primitive;
_StaticDesc=desc;
_GlobalPosition=nextGlobalPosition;
_DeltaTime=delta;
_WorldImage=worldImage;
}
// Link in the primitive
void primitiveLink (CMovePrimitive * /* primitive */, CCollisionOTInfo *other)
{
// Link
_Next=other;
}
// Link in the primitive
CCollisionOTInfo *getNext (CMovePrimitive * /* primitive */) const
{
// return next
return _Next;
}
// Return false for dynamic collision, true for static collision
bool isCollisionAgainstStatic () const
{
return true;
}
// Return collision time
double getCollisionTime () const
{
return _StaticDesc.ContactTime;
}
// Remove the collision from the primitives
void removeFromPrimitives ();
CMovePrimitive *getOtherPrimitive (CMovePrimitive * /* primitive */) const
{
return NULL;
}
private:
// The first primitive
CMovePrimitive *_Primitive;
// The static descriptor
CCollisionSurfaceDesc _StaticDesc;
// The next global position
UGlobalPosition _GlobalPosition;
// Delta time for this collid
double _DeltaTime;
// World image
uint8 _WorldImage;
// Next primitive in the linked list
CCollisionOTInfo *_Next;
};
// ***************************************************************************
inline CCollisionOTInfo *CCollisionOT::getNextInfo () const
{
// Get next
CCollisionOT *next=_Next;
// Is an info ?
while ( next && (!next->isInfo ()) )
next=next->getNextInfo ();
// Return an info
return (CCollisionOTInfo*)next;
}
} // NLPACS
#endif // NL_COLLISION_OT_H
/* End of collision_ot.h */