NLPACS::CPrimitiveWorldImage Class Reference

#include <primitive_world_image.h>

---

Detailed Description

Data for the primitive duplicated for each world image it is linked

Author:

Cyril 'Hulud' Corvazier

Nevrax France

Date:

2001

Definition at line 43 of file primitive_world_image.h.

Public Member Functions
void	addMoveElement (CMoveCell &cell, uint16 x, uint16 y, double centerX, double centerY, CMovePrimitive *primitive, CMoveContainer &container, uint8 worldImage)
	Add the primitive in the cell and resort the list.
void	checkSortedList (uint8 worldImage)
	Check sorted lists.
void	copy (const CPrimitiveWorldImage &source)
	CPrimitiveWorldImage ()
void	CPrimitiveWorldImage::addMoveElementendOfList (CMoveCell &cell, uint16 x, uint16 y, CMovePrimitive *primitive, CMoveContainer &container)
	Add the primitive in the cell at the end of the list and don't sort.
void	deleteIt (CMoveContainer &container, uint8 worldImage)
void	dirtBB (CMoveContainer *container, CMovePrimitive *primitive, uint8 worldImage)
void	dirtPos (CMoveContainer *container, CMovePrimitive *primitive, uint8 worldImage)
void	doMove (double timeMax)
void	doMove (CGlobalRetriever &retriever, CCollisionSurfaceTemp &surfaceTemp, double originalMax, double finalMax, bool keepZ=false)
const TCollisionSurfaceDescVector *	evalCollision (CGlobalRetriever &retriever, CCollisionSurfaceTemp &surfaceTemp, uint32 testTime, uint32 maxTestIteration, CMovePrimitive &primitive)
bool	evalCollision (CPrimitiveWorldImage &other, class CCollisionDesc &desc, double timeMin, double timeMax, uint32 testTime, uint32 maxTestIteration, double &firstContactTime, double &lastContactTime, CMovePrimitive &primitive, CMovePrimitive &otherPrimitive)
bool	evalCollisionOBoverOB (CPrimitiveWorldImage &other, CCollisionDesc &desc, double timeMin, double timeMax, double &firstContactTime, double &lastContactTime, CMovePrimitive &primitive, CMovePrimitive &otherPrimitive)
bool	evalCollisionOBoverOC (CPrimitiveWorldImage &other, CCollisionDesc &desc, double timeMin, double timeMax, double &firstContactTime, double &lastContactTime, CMovePrimitive &primitive, CMovePrimitive &otherPrimitive)
bool	evalCollisionOCoverOC (CPrimitiveWorldImage &other, CCollisionDesc &desc, double timeMin, double timeMax, double &firstContactTime, double &lastContactTime, CMovePrimitive &primitive, CMovePrimitive &otherPrimitive)
bool	evalCollisionPoverOC (CPrimitiveWorldImage &other, CCollisionDesc &desc, uint numPoint, double &firstContactTime, double &lastContactTime, CMovePrimitive &primitive, CMovePrimitive &otherPrimitive)
bool	evalCollisionPoverS (CPrimitiveWorldImage &other, CCollisionDesc &desc, uint numPoint, uint numSeg, CMovePrimitive &primitive, CMovePrimitive &otherPrimitive)
bool	evalCollisionSoverOC (CPrimitiveWorldImage &other, CCollisionDesc &desc, uint numPoint, CMovePrimitive &primitive, CMovePrimitive &otherPrimitive)
double	getBBXMax () const
double	getBBXMin () const
double	getBBYMax () const
double	getBBYMin () const
const NLMISC::CVectorD &	getDeltaPosition () const
NLMISC::CVectorD	getFinalPosition () const
const UGlobalPosition &	getGlobalPosition ()
double	getInitTime () const
CMoveElement *	getMoveElement (uint i)
	Return the nieme MoveElement. The primitive can have 4 move elements. Can be NULL if the ineme elment is not in a list.
CMovePrimitive *	getNextModified () const
	Get next modified primitive.
double	getOrientation () const
const NLMISC::CVectorD &	getSpeed () const
bool	isInModifiedListFlag ()
	Is in modified list ?
bool	isInWorldImageFlag ()
	Is in modified list ?
void	linkInModifiedList (CMovePrimitive *next)
void	move (const NLMISC::CVectorD &speed, CMoveContainer &container, CMovePrimitive &primitive, uint8 worldImage)
void	precalcBB (double beginTime, double endTime, CMovePrimitive &primitive)
void	precalcPos (CMovePrimitive &primitive)
void	precalcSpeed ()
void	reaction (const CCollisionSurfaceDesc &surfaceDesc, const UGlobalPosition &globalPosition, CGlobalRetriever &retriever, double ratio, double dt, CMovePrimitive &primitive, CMoveContainer &container, uint8 worldImage)
void	reaction (CPrimitiveWorldImage &second, const CCollisionDesc &desc, CGlobalRetriever *retriver, CCollisionSurfaceTemp &surfaceTemp, bool collision, CMovePrimitive &primitive, CMovePrimitive &otherPrimitive, CMoveContainer *container, uint8 worldImage, uint8 secondWorldImage, bool secondConst)
void	removeMoveElement (uint i, CMoveContainer &container, uint8 worldImage)
	Remove the nieme MoveElement.
void	setGlobalPosition (const NLMISC::CVectorD &pos, CMoveContainer &container, CMovePrimitive &primitive, uint8 worldImage, bool keepZ=false, UGlobalPosition::TType type=UGlobalPosition::Unspecified)
void	setGlobalPosition (const UGlobalPosition &pos, CMoveContainer &container, CMovePrimitive &primitive, uint8 worldImage)
void	setInModifiedListFlag (bool itis)
	Clear the inModifiedList flag.
void	setInWorldImageFlag (bool itis)
	Clear the inModifiedList flag.
void	setOrientation (double rot, CMoveContainer *container, CMovePrimitive *primitive, uint8 worldImage)
void	setSpeed (const NLMISC::CVectorD &speed, CMoveContainer *container, CMovePrimitive *primitive, uint8 worldImage)
void	update (double beginTime, double endTime, CMovePrimitive &primitive)
	Update precalculated data.
Private Types
enum	TDynamicFlags {   DirtPosFlag = 0x0001, DirtBBFlag = 0x0002, InModifiedListFlag = 0x0004, InWorldImageFlag = 0x0008,   ForceSize = 0xffff }
Private Attributes
NLMISC::CVectorD	_3dInitPosition
double	_BBXMax
double	_BBXMin
double	_BBYMax
double	_BBYMin
NLMISC::CVectorD	_DeltaPosition
uint16	_DynamicFlags
double	_InitTime
CMoveElement *	_MoveElement [4]
CMovePrimitive *	_NextModified
CPosition	_Position
NLMISC::CVectorD	_Speed

---

Member Enumeration Documentation

enum NLPACS::CPrimitiveWorldImage::TDynamicFlags [private]

Enumeration values: DirtPosFlag  DirtBBFlag  InModifiedListFlag  InWorldImageFlag  ForceSize  Definition at line 385 of file primitive_world_image.h. { // The dirt flag. Precalculated data for the position must be recomputed. DirtPosFlag =0x0001, // The dirt bounding box. Precalculated data for the bounding box must be recomputed. DirtBBFlag =0x0002, // In modified list. InModifiedListFlag =0x0004, // Inserted in the world image. InWorldImageFlag =0x0008, // Force the size to uint16. ForceSize =0xffff };

---

Constructor & Destructor Documentation

NLPACS::CPrimitiveWorldImage::CPrimitiveWorldImage (   )

Definition at line 42 of file primitive_world_image.cpp. References _BBXMax, _BBXMin, _BBYMax, _BBYMin, _DynamicFlags, _MoveElement, and uint. { // Set to NULL for (uint i=0; i<4; i++) _MoveElement[i]=NULL; _DynamicFlags=0; _BBXMin=-FLT_MAX; _BBXMax=-FLT_MAX; _BBYMin=-FLT_MAX; _BBYMax=-FLT_MAX; }

---

Member Function Documentation

void NLPACS::CPrimitiveWorldImage::addMoveElement (  CMoveCell &  cell, uint16  x, uint16  y, double  centerX, double  centerY, CMovePrimitive *  primitive, CMoveContainer &  container, uint8  worldImage )

Add the primitive in the cell and resort the list. Definition at line 1058 of file primitive_world_image.cpp. References _BBXMax, _BBXMin, _MoveElement, NLPACS::CMoveContainer::allocateMoveElement(), NLPACS::CMoveCell::linkFirstX(), NLPACS::CMoveCell::linkLastX(), NLPACS::CMoveElement::Primitive, uint, uint16, uint8, NLPACS::CMoveCell::updateSortedLists(), NLPACS::CMoveElement::X, x, NLPACS::CMoveElement::Y, and y. { // Find a free place uint slot; for (slot=0; slot<4; slot++) { // Empty ? if (_MoveElement[slot]==NULL) { // Primitive center double cx=(_BBXMin+_BBXMax)/2.f; // Allocate move element _MoveElement[slot]=container.allocateMoveElement (); _MoveElement[slot]->Primitive=primitive; _MoveElement[slot]->X=x; _MoveElement[slot]->Y=y; // Insert in left or right ? if (cx<centerX) // In the left cell.linkFirstX (_MoveElement[slot]); else // In the right cell.linkLastX (_MoveElement[slot]); /*// Insert in left or right ? if (cy<centerY) // In the left cell.linkFirstY (_MoveElement[slot]); else // In the right cell.linkLastY (_MoveElement[slot]);*/ // Move it cell.updateSortedLists (_MoveElement[slot], worldImage); // End break; } } }

void NLPACS::CPrimitiveWorldImage::checkSortedList (  uint8  worldImage  )

Check sorted lists. Definition at line 1149 of file primitive_world_image.cpp. References _BBXMin, _MoveElement, NLPACS::CMovePrimitive::getWorldImage(), NLPACS::CMoveElement::NextX, nlassertonce, NLPACS::CMoveElement::PreviousX, NLPACS::CMoveElement::Primitive, uint, and uint8. { // For the 4 elements for (uint i=0; i<4; i++) { // element here ? if (_MoveElement[i]) { if (_MoveElement[i]->PreviousX) nlassertonce (_MoveElement[i]->PreviousX->Primitive->getWorldImage(worldImage)->_BBXMin <= _BBXMin); if (_MoveElement[i]->NextX) nlassertonce (_BBXMin <= _MoveElement[i]->NextX->Primitive->getWorldImage(worldImage)->_BBXMin); } } }

void NLPACS::CPrimitiveWorldImage::copy (  const CPrimitiveWorldImage &  source  )

Definition at line 66 of file primitive_world_image.cpp. References _DynamicFlags, _MoveElement, InModifiedListFlag, and uint. { // Copy this->operator=(source); // Reset some flags _DynamicFlags&=~InModifiedListFlag; // Pointer into the 4 possibles sorted lists of movable primitives. Must be NULL for (uint i=0; i<4; i++) _MoveElement[i]=NULL; }

void NLPACS::CPrimitiveWorldImage::CPrimitiveWorldImage::addMoveElementendOfList (  CMoveCell &  cell, uint16  x, uint16  y, CMovePrimitive *  primitive, CMoveContainer &  container )

Add the primitive in the cell at the end of the list and don't sort.

void NLPACS::CPrimitiveWorldImage::deleteIt (  CMoveContainer &  container, uint8  worldImage )

Definition at line 57 of file primitive_world_image.cpp. References _MoveElement, removeMoveElement(), uint, and uint8. { // Free the move elements for (uint i=0; i<4; i++) if (_MoveElement[i]) removeMoveElement (i, container, worldImage); }

void NLPACS::CPrimitiveWorldImage::dirtBB (  CMoveContainer *  container, CMovePrimitive *  primitive, uint8  worldImage )  [inline]

Definition at line 277 of file primitive_world_image.h. References _DynamicFlags, NLPACS::CMoveContainer::changed(), DirtBBFlag, and uint8. Referenced by dirtPos(). { // Warn container that BB has changed container->changed (primitive, worldImage); _DynamicFlags|=DirtBBFlag; }

void NLPACS::CPrimitiveWorldImage::dirtPos (  CMoveContainer *  container, CMovePrimitive *  primitive, uint8  worldImage )  [inline]

Definition at line 270 of file primitive_world_image.h. References _DynamicFlags, dirtBB(), DirtPosFlag, and uint8. Referenced by NLPACS::CMovePrimitive::dirtAllPos(), move(), reaction(), setGlobalPosition(), setOrientation(), and setSpeed(). { _DynamicFlags|=DirtPosFlag; dirtBB (container, primitive, worldImage); }

void NLPACS::CPrimitiveWorldImage::doMove (  double  timeMax  )

Definition at line 230 of file primitive_world_image.cpp. References NLPACS::CPrimitiveWorldImage::CPosition::getPos(), and NLPACS::CPrimitiveWorldImage::CPosition::setPos(). { // H_AUTO(PACS_PWI_doMove_short); // Make the move _Position.setPos (_Position.getPos ()+_Speed*(timeMax-_InitTime)); // Final position _InitTime=timeMax; }

void NLPACS::CPrimitiveWorldImage::doMove (  CGlobalRetriever &  retriever, CCollisionSurfaceTemp &  surfaceTemp, double  originalMax, double  finalMax, bool  keepZ = false )

Definition at line 201 of file primitive_world_image.cpp. References _DeltaPosition, NLPACS::CGlobalRetriever::doMove(), NLPACS::CPrimitiveWorldImage::CPosition::getGlobalPos(), H_AUTO, NLPACS::CPrimitiveWorldImage::CPosition::setGlobalPos(), and NLPACS::CPrimitiveWorldImage::CPosition::setGlobalPosKeepZ(). { H_AUTO(NLPACS_PWI_Do_Move); // Time to avance double ratio; if (finalMax!=originalMax) ratio=(finalMax-_InitTime)/(originalMax-_InitTime); else ratio=1; // Make the move if (!keepZ) { _Position.setGlobalPos (retriever.doMove(_Position.getGlobalPos(), _DeltaPosition, (float)ratio, surfaceTemp, false), retriever); } else { _Position.setGlobalPosKeepZ(retriever.doMove(_Position.getGlobalPos(), _DeltaPosition, (float)ratio, surfaceTemp, false), retriever); } // Final position _InitTime=finalMax; }

const TCollisionSurfaceDescVector * NLPACS::CPrimitiveWorldImage::evalCollision (  CGlobalRetriever &  retriever, CCollisionSurfaceTemp &  surfaceTemp, uint32  testTime, uint32  maxTestIteration, CMovePrimitive &  primitive )

Eval collisions with the global retriever. Parameters: retriever  is the global retriever used to test collision timeMin  is the time you want to clip collision result in the past. timeMax  is the time you want to clip collision result in the futur. Returns: true if a collision has been detected in the time range, else false. Definition at line 166 of file primitive_world_image.cpp. References _DeltaPosition, _OBData, NLPACS::CMovePrimitive::checkTestTime(), NLPACS::CPrimitiveWorldImage::CPosition::getGlobalPos(), NLPACS::CMovePrimitive::getLength(), NLPACS::CMovePrimitive::getPrimitiveTypeInternal(), NLPACS::CMovePrimitive::getRadiusInternal(), nlassert, NLPACS::TCollisionSurfaceDescVector, NLPACS::CGlobalRetriever::testBBoxMove(), NLPACS::CGlobalRetriever::testCylinderMove(), and uint32. { // H_AUTO(PACS_PWI_evalCollision_short); // Test time if (!primitive.checkTestTime (testTime, maxTestIteration)) return NULL; // Switch the good test if (primitive.getPrimitiveTypeInternal()==UMovePrimitive::_2DOrientedBox) { // Local I CVector locI ((float)(_OBData.EdgeDirectionX[0]*primitive.getLength(0)/2.0), (float)(_OBData.EdgeDirectionY[0]*primitive.getLength(1)/2.0), 0); // Local J CVector locJ ((float)(_OBData.EdgeDirectionX[1]*primitive.getLength(0)/2.0), (float)(_OBData.EdgeDirectionY[1]*primitive.getLength(1)/2.0), 0); // Test return retriever.testBBoxMove (_Position.getGlobalPos (), _DeltaPosition, locI, locJ, surfaceTemp); } else { // Check nlassert (primitive.getPrimitiveTypeInternal()==UMovePrimitive::_2DOrientedCylinder); // Test //nlinfo ("1) %f %f %f\n", _DeltaPosition.x, _DeltaPosition.y, _DeltaPosition.z); return retriever.testCylinderMove (_Position.getGlobalPos (), _DeltaPosition, primitive.getRadiusInternal(), surfaceTemp); } }

bool NLPACS::CPrimitiveWorldImage::evalCollision (  CPrimitiveWorldImage &  other, class CCollisionDesc &  desc, double  timeMin, double  timeMax, uint32  testTime, uint32  maxTestIteration, double &  firstContactTime, double &  lastContactTime, CMovePrimitive &  primitive, CMovePrimitive &  otherPrimitive )

Eval collisions with the other primitive. Parameters: other  is another move primitive to test collisions with. desc  is a collision descriptor filled with information about the collision context if the method return true. timeMin  is the time you want to clip collision result in the past. timeMax  is the time you want to clip collision result in the futur. Returns: true if a collision has been detected in the time range, else false. Definition at line 81 of file primitive_world_image.cpp. References NLPACS::CMovePrimitive::checkTestTime(), evalCollisionOBoverOB(), evalCollisionOBoverOC(), evalCollisionOCoverOC(), NLPACS::CMovePrimitive::getCollisionMaskInternal(), NLPACS::CMovePrimitive::getOcclusionMaskInternal(), NLPACS::CMovePrimitive::getPrimitiveTypeInternal(), nlstop, uint32, and NLPACS::CCollisionDesc::XChgContactNormals(). { // H_AUTO(PACS_PWI_evalCollision_long); // Mask test if (( (primitive.getCollisionMaskInternal() & otherPrimitive.getOcclusionMaskInternal()) == 0) && ( (primitive.getOcclusionMaskInternal() & otherPrimitive.getCollisionMaskInternal()) == 0)) return false; // Test time if ( (!primitive.checkTestTime (testTime, maxTestIteration)) || (!otherPrimitive.checkTestTime (testTime, maxTestIteration)) ) return false; // Clear time min time max firstContactTime=FLT_MAX; lastContactTime=-FLT_MAX; // Switch the good test switch (primitive.getPrimitiveTypeInternal()) { // Static box over... case UMovePrimitive::_2DOrientedBox: { // Switch second type switch (otherPrimitive.getPrimitiveTypeInternal()) { // Static box over movable box case UMovePrimitive::_2DOrientedBox: // Make the test return evalCollisionOBoverOB (other, desc, timeMin, timeMax, firstContactTime, lastContactTime, primitive, otherPrimitive); // Static box over movable cylinder case UMovePrimitive::_2DOrientedCylinder: // Make the test return evalCollisionOBoverOC (other, desc, timeMin, timeMax, firstContactTime, lastContactTime, primitive, otherPrimitive); default: // Should not go here nlstop; } } // Static box over... case UMovePrimitive::_2DOrientedCylinder: { // Switch second type switch (otherPrimitive.getPrimitiveTypeInternal()) { // Static box over movable box case UMovePrimitive::_2DOrientedBox: { // Make the test bool collid=other.evalCollisionOBoverOC (*this, desc, timeMin, timeMax, firstContactTime, lastContactTime, otherPrimitive, primitive); if (collid) desc.XChgContactNormals (); return collid; } // Static box over movable cylinder case UMovePrimitive::_2DOrientedCylinder: // Make the test return evalCollisionOCoverOC (other, desc, timeMin, timeMax, firstContactTime, lastContactTime, primitive, otherPrimitive); default: // Should not go here nlstop; } } default: // Should not go here nlstop; } return false; }

bool NLPACS::CPrimitiveWorldImage::evalCollisionOBoverOB (  CPrimitiveWorldImage &  other, CCollisionDesc &  desc, double  timeMin, double  timeMax, double &  firstContactTime, double &  lastContactTime, CMovePrimitive &  primitive, CMovePrimitive &  otherPrimitive )

Definition at line 243 of file primitive_world_image.cpp. References NLPACS::UCollisionDesc::ContactTime, evalCollisionPoverS(), NLPACS::CMovePrimitive::getPrimitiveTypeInternal(), nlassert, and uint. Referenced by evalCollision(). { // Checks nlassert (primitive.getPrimitiveTypeInternal()==UMovePrimitive::_2DOrientedBox); nlassert (otherPrimitive.getPrimitiveTypeInternal()==UMovePrimitive::_2DOrientedBox); // Find a collision bool find=false; // Best time desc.ContactTime=FLT_MAX; // Timemin double _timeMax=-FLT_MAX; // Check movable points over the edge uint pt; uint seg; for (pt=0; pt<4; pt++) for (seg=0; seg<4; seg++) { // Get collision time of the point over the segment CCollisionDesc d; if ( evalCollisionPoverS (other, d, pt, seg, primitive, otherPrimitive) ) { // Find find=true; // Best time ? if (d.ContactTime<desc.ContactTime) { // This is the new descriptor desc=d; } // Best max time ? if (d.ContactTime>_timeMax) { // This is the new max time _timeMax=d.ContactTime; } } } // Check static points over the movable box for (pt=0; pt<4; pt++) for (seg=0; seg<4; seg++) { // Get collision time of the point over the segment CCollisionDesc d; if (other.evalCollisionPoverS (*this, d, pt, seg, primitive, otherPrimitive)) { // Find find=true; // Best time ? if (d.ContactTime<desc.ContactTime) { // This is the new descriptor desc=d; } // Best max time ? if (d.ContactTime>_timeMax) { // This is the new max time _timeMax=d.ContactTime; } } } if (find) { // First last contact time firstContactTime=desc.ContactTime; lastContactTime=_timeMax; // Half time //double halfTime = (_timeMax+desc.ContactTime)/2.0; // Collision in the past ? //if (timeMin > halfTime) if (timeMin > _timeMax) // yes, abort return false; // Collision not in the future ? if (timeMax>desc.ContactTime) { // Clamp time if (desc.ContactTime<timeMin) desc.ContactTime=timeMin; // yes, found it return true; } } // No collision found return false; }

bool NLPACS::CPrimitiveWorldImage::evalCollisionOBoverOC (  CPrimitiveWorldImage &  other, CCollisionDesc &  desc, double  timeMin, double  timeMax, double &  firstContactTime, double &  lastContactTime, CMovePrimitive &  primitive, CMovePrimitive &  otherPrimitive )

Definition at line 349 of file primitive_world_image.cpp. References NLPACS::UCollisionDesc::ContactTime, evalCollisionPoverOC(), evalCollisionSoverOC(), NLPACS::CMovePrimitive::getPrimitiveTypeInternal(), nlassert, and uint. Referenced by evalCollision(). { // Checks nlassert (primitive.getPrimitiveTypeInternal()==UMovePrimitive::_2DOrientedBox); nlassert (otherPrimitive.getPrimitiveTypeInternal()==UMovePrimitive::_2DOrientedCylinder); // Find a collision bool find=false; // Best time desc.ContactTime=FLT_MAX; // time min clip double _timeMax = -FLT_MAX; // Check movable points over the cylinder uint pt; for (pt=0; pt<4; pt++) { // Get collision time of the point over the segment CCollisionDesc d; double firstContactTime; double lastContactTime; if (evalCollisionPoverOC (other, d, pt, firstContactTime, lastContactTime, primitive, otherPrimitive)) { // Found find=true; // Best time ? if (firstContactTime<desc.ContactTime) { // This is the new descriptor desc=d; } // Best max time ? if (lastContactTime>_timeMax) { // New max time _timeMax=lastContactTime; } } } // Check static points over the movable box uint seg; for (seg=0; seg<4; seg++) { // Get collision time of the point over the segment CCollisionDesc d; if (evalCollisionSoverOC (other, d, seg, primitive, otherPrimitive)) { // Found find=true; // Best time ? if (d.ContactTime<desc.ContactTime) { // This is the new descriptor desc=d; } // Best max time ? if (d.ContactTime>_timeMax) { // New max time _timeMax=d.ContactTime; } } } if (find) { // First last contact time firstContactTime=desc.ContactTime; lastContactTime=_timeMax; // Half time //double halfTime = (_timeMax+desc.ContactTime)/2.0; // Collision in the past ? //if (timeMin > halfTime) if (timeMin > _timeMax) // yes, abort return false; // Collision not in the future ? if (timeMax>desc.ContactTime) { // Clamp time if (desc.ContactTime<timeMin) desc.ContactTime=timeMin; // yes, found it return true; } } // No collision found return false; }

bool NLPACS::CPrimitiveWorldImage::evalCollisionOCoverOC (  CPrimitiveWorldImage &  other, CCollisionDesc &  desc, double  timeMin, double  timeMax, double &  firstContactTime, double &  lastContactTime, CMovePrimitive &  primitive, CMovePrimitive &  otherPrimitive )

Definition at line 780 of file primitive_world_image.cpp. References _3dInitPosition, _Speed, NLPACS::UCollisionDesc::ContactNormal0, NLPACS::UCollisionDesc::ContactNormal1, NLPACS::UCollisionDesc::ContactPosition, NLPACS::UCollisionDesc::ContactTime, NLPACS::CMovePrimitive::getHeightInternal(), NLPACS::CMovePrimitive::getPrimitiveTypeInternal(), NLPACS::CMovePrimitive::getRadiusInternal(), nlassert, NLMISC::CVectorD::normalize(), NLPACS::secondDegree(), uint, NLMISC::CVectorD::x, NLMISC::CVectorD::y, and NLMISC::CVectorD::z. Referenced by evalCollision(). { // Checks nlassert (primitive.getPrimitiveTypeInternal()==UMovePrimitive::_2DOrientedCylinder); nlassert (otherPrimitive.getPrimitiveTypeInternal()==UMovePrimitive::_2DOrientedCylinder); /* Cylinder0 center equ: * p(t) = p0 + v0*(t - t0) * * Cylinder1 center equ: * p'(t) = p'0 + v'0*(t - t'0) * * Find t for this equation: * (R + R')² = Norm² (p(t) - p'(t)) * (R + R')² = Norm² ( p0 + v0 ( t - t0 ) - p'0 - v'0 ( t - t'0 ) ) * * A = p0 - v0*t0 - p'0 + v'0*t'0 * B = (v0 - v'0) * * Norm² (B)*t² + 2*(A.B)*t + Norm² (A) - (R + R')² = 0 * * a = Norm² (B) * b = 2*(A.B) * c = Norm² (A) - (R + R')² * * a*t² + b*t + c = 0 */ // Let's go const double _Ax = _3dInitPosition.x - other._3dInitPosition.x; const double _Ay = _3dInitPosition.y - other._3dInitPosition.y; const double _Bx = _Speed.x - other._Speed.x; const double _By = _Speed.y - other._Speed.y; // Eval system double s0, s1; double radiusSquare=primitive.getRadiusInternal()+otherPrimitive.getRadiusInternal(); radiusSquare*=radiusSquare; uint numSolution=secondDegree (_Bx*_Bx+_By*_By, 2.f*(_Ax*_Bx+_Ay*_By), _Ax*_Ax+_Ay*_Ay-radiusSquare, s0, s1); if (numSolution!=0) { // time double _timeMin, _timeMax; // Collision time if (numSolution==1) { _timeMin=s0; _timeMax=s0; } else { // Time min and max if (s0>s1) { _timeMin=s1; _timeMax=s0; } else { _timeMin=s0; _timeMax=s1; } } // half time //const double halfTime=(_timeMin+_timeMax)/2.0; // Conatct time firstContactTime=_timeMin; lastContactTime=_timeMax; // Clip time if ((timeMin<_timeMax)&&(_timeMin<timeMax)) { // Some constants const double cyl0Time= _timeMin; const double pointCyl0Z=_3dInitPosition.z; const double cyl0PosZ= pointCyl0Z + _Speed.z*cyl0Time; // Pos Z const double cyl1Time= _timeMin; const double pointCyl1Z=other._3dInitPosition.z; const double cyl1PosZ= pointCyl1Z + other._Speed.z * cyl1Time; // Z Included ? if ( (cyl0PosZ <= cyl1PosZ + otherPrimitive.getHeightInternal() ) && (cyl0PosZ + primitive.getHeightInternal() >= cyl1PosZ) ) { // Ok Collision, fill the result // Time desc.ContactTime=std::max (_timeMin, timeMin); // Cylinder 0 position const double cyl0PosX= _3dInitPosition.x + _Speed.x*cyl0Time; const double cyl0PosY= _3dInitPosition.y + _Speed.y*cyl0Time; // Cylinder 1 position const double cyl1PosX= other._3dInitPosition.x + other._Speed.x*cyl1Time; const double cyl1PosY= other._3dInitPosition.y + other._Speed.y*cyl1Time; // First cylinder normal desc.ContactNormal0.x= cyl1PosX - cyl0PosX; desc.ContactNormal0.y= cyl1PosY - cyl0PosY; desc.ContactNormal0.z= 0; desc.ContactNormal0.normalize (); // Contact position desc.ContactPosition.x= desc.ContactNormal0.x*primitive.getRadiusInternal() + cyl0PosX; desc.ContactPosition.y= desc.ContactNormal0.y*primitive.getRadiusInternal() + cyl0PosY; desc.ContactPosition.z= std::max (cyl0PosZ, cyl1PosZ); // Second cylinder normal desc.ContactNormal1.x= -desc.ContactNormal0.x; desc.ContactNormal1.y= -desc.ContactNormal0.y; desc.ContactNormal1.z= 0; // End return true; } } } // No collision return false; }

bool NLPACS::CPrimitiveWorldImage::evalCollisionPoverOC (  CPrimitiveWorldImage &  other, CCollisionDesc &  desc, uint  numPoint, double &  firstContactTime, double &  lastContactTime, CMovePrimitive &  primitive, CMovePrimitive &  otherPrimitive )

Definition at line 573 of file primitive_world_image.cpp. References _3dInitPosition, _OBData, _Speed, NLPACS::UCollisionDesc::ContactNormal0, NLPACS::UCollisionDesc::ContactNormal1, NLPACS::UCollisionDesc::ContactPosition, NLPACS::UCollisionDesc::ContactTime, NLPACS::CMovePrimitive::getHeightInternal(), NLPACS::CMovePrimitive::getPrimitiveTypeInternal(), NLPACS::CMovePrimitive::getRadiusInternal(), nlassert, NLMISC::CVectorD::normalize(), NLPACS::secondDegree(), uint, NLMISC::CVectorD::x, NLMISC::CVectorD::y, and NLMISC::CVectorD::z. Referenced by evalCollisionOBoverOC(). { // Checks nlassert (primitive.getPrimitiveTypeInternal()==UMovePrimitive::_2DOrientedBox); nlassert (otherPrimitive.getPrimitiveTypeInternal()==UMovePrimitive::_2DOrientedCylinder); /* Point Equ: * p(t) = p0 + v0*(t - t0) * * Cylinder center Equ: * p'(t) = p'0 + v'0*(t - t'0) * * Find t for this equation: * R² = Norm² (p(t) - p'(t)) * R² = Norm² ( p0 + v0 ( t - t0 ) - p'0 - v'0 ( t - t'0 ) ) * * A = p0 - v0*t0 - p'0 + v'0*t'0 * B = (v0 - v'0) * * Norm² (B)*t² + 2*(A.B)*t + Norm² (A) - R² = 0 * * a = Norm² (B) * b = 2*(A.B) * c = Norm² (A) - R² * * a*t² + b*t + c = 0 */ // Let's go const double _Ax = _OBData.PointPosX[numPoint] - other._3dInitPosition.x; const double _Ay = _OBData.PointPosY[numPoint] - other._3dInitPosition.y; const double _Bx = _Speed.x - other._Speed.x; const double _By = _Speed.y - other._Speed.y; // Eval system double s0, s1; double squareRadius=otherPrimitive.getRadiusInternal()*otherPrimitive.getRadiusInternal(); uint numSolution=secondDegree (_Bx*_Bx+_By*_By, 2.f*(_Ax*_Bx+_Ay*_By), _Ax*_Ax+_Ay*_Ay-squareRadius, s0, s1); if (numSolution!=0) { // time double time; // Collision time if (numSolution==1) { firstContactTime=s0; lastContactTime=s0; } else { // First and last time if (s0<s1) { firstContactTime=s0; lastContactTime=s1; } else { firstContactTime=s1; lastContactTime=s0; } } time=firstContactTime; // Pos Z const double pointCylZ=other._3dInitPosition.z; const double cylPosZ= pointCylZ + other._Speed.z*time; // Some constants const double pointZ=_3dInitPosition.z; const double ptPosZ= pointZ + _Speed.z*time; // Z Included ? if ( (ptPosZ <= cylPosZ + otherPrimitive.getHeightInternal()) && (ptPosZ + primitive.getHeightInternal() >= cylPosZ) ) { // Ok Collision, fill the result // Time desc.ContactTime=time; // Point position const double ptPosX= _OBData.PointPosX[numPoint] + _Speed.x*time; const double ptPosY= _OBData.PointPosY[numPoint] + _Speed.y*time; // Cylinder position const double cylPosX= other._3dInitPosition.x + other._Speed.x*time; const double cylPosY= other._3dInitPosition.y + other._Speed.y*time; // Position desc.ContactPosition.x=ptPosX; desc.ContactPosition.y=ptPosY; desc.ContactPosition.z=std::max (cylPosZ, ptPosZ); // Cylinder normal desc.ContactNormal1.x=ptPosX-cylPosX; desc.ContactNormal1.y=ptPosY-cylPosY; desc.ContactNormal1.z=0; desc.ContactNormal1.normalize (); desc.ContactNormal0.x=-desc.ContactNormal1.x; desc.ContactNormal0.y=-desc.ContactNormal1.y; desc.ContactNormal0.z=0; // End return true; } } // No collision return false; }

bool NLPACS::CPrimitiveWorldImage::evalCollisionPoverS (  CPrimitiveWorldImage &  other, CCollisionDesc &  desc, uint  numPoint, uint  numSeg, CMovePrimitive &  primitive, CMovePrimitive &  otherPrimitive )

Definition at line 455 of file primitive_world_image.cpp. References _3dInitPosition, _OBData, _Speed, NLPACS::UCollisionDesc::ContactNormal0, NLPACS::UCollisionDesc::ContactNormal1, NLPACS::UCollisionDesc::ContactPosition, NLPACS::UCollisionDesc::ContactTime, NLPACS::CMovePrimitive::getHeightInternal(), NLPACS::CMovePrimitive::getLength(), NLPACS::CMovePrimitive::getPrimitiveTypeInternal(), nlassert, uint, NLMISC::CVectorD::x, NLMISC::CVectorD::y, and NLMISC::CVectorD::z. Referenced by evalCollisionOBoverOB(). { // Checks nlassert (primitive.getPrimitiveTypeInternal()==UMovePrimitive::_2DOrientedBox); nlassert (otherPrimitive.getPrimitiveTypeInternal()==UMovePrimitive::_2DOrientedBox); // Some constants const double normalSegX=other._OBData.EdgeDirectionY[numSeg]; const double normalSegY=-other._OBData.EdgeDirectionX[numSeg]; // Relative speed const double speedX=other._Speed.x-_Speed.x; const double speedY=other._Speed.y-_Speed.y; // Dot product with the plan tangeante double dotProd= speedX*normalSegX + speedY*normalSegY; //if ( dotProd > 0 ) if ( dotProd != 0 ) { // Time of the collision double time= (normalSegX*(_OBData.PointPosX[numPoint] - other._OBData.PointPosX[numSeg]) + normalSegY*(_OBData.PointPosY[numPoint] - other._OBData.PointPosY[numSeg])) / dotProd; // Position of segment point at collision time const double segPosX= other._OBData.PointPosX[numSeg] + other._Speed.x*time; const double segPosY= other._OBData.PointPosY[numSeg] + other._Speed.y*time; // Position of the point at collision time const double ptPosX= _OBData.PointPosX[numPoint] + _Speed.x*time; const double ptPosY= _OBData.PointPosY[numPoint] + _Speed.y*time; // Direction of the collision on the segment const double dirX= ptPosX - segPosX; const double dirY= ptPosY - segPosY; // Length of this vector const double length= dirY*normalSegX - dirX*normalSegY; // Included ? if ( ( length >= 0 ) && ( length <= otherPrimitive.getLength(numSeg&1) ) ) { // 2d Collid checked... Now check height // Pos Z const double pointSegZ=other._3dInitPosition.z; const double segPosZ= pointSegZ + other._Speed.z*time; // Some constants const double pointZ=_3dInitPosition.z; const double ptPosZ= pointZ + _Speed.z*time; // Included ? if ( (ptPosZ <= segPosZ + otherPrimitive.getHeightInternal()) && (ptPosZ + primitive.getHeightInternal() >= segPosZ) ) { // Ok Collision, fill the result // Time desc.ContactTime=time; // Position desc.ContactPosition.x=ptPosX; desc.ContactPosition.y=ptPosY; desc.ContactPosition.z=std::max (segPosZ, ptPosZ); // Seg box normal desc.ContactNormal1.x=normalSegX; desc.ContactNormal1.y=normalSegY; desc.ContactNormal1.z=0; desc.ContactNormal0.x=-desc.ContactNormal1.x; desc.ContactNormal0.y=-desc.ContactNormal1.y; desc.ContactNormal0.z=0; // End return true; } } } // No collision return false; }

bool NLPACS::CPrimitiveWorldImage::evalCollisionSoverOC (  CPrimitiveWorldImage &  other, CCollisionDesc &  desc, uint  numPoint, CMovePrimitive &  primitive, CMovePrimitive &  otherPrimitive )

Definition at line 689 of file primitive_world_image.cpp. References _3dInitPosition, _OBData, _Speed, NLPACS::UCollisionDesc::ContactNormal0, NLPACS::UCollisionDesc::ContactNormal1, NLPACS::UCollisionDesc::ContactPosition, NLPACS::UCollisionDesc::ContactTime, NLPACS::CMovePrimitive::getHeightInternal(), NLPACS::CMovePrimitive::getLength(), NLPACS::CMovePrimitive::getPrimitiveTypeInternal(), NLPACS::CMovePrimitive::getRadiusInternal(), nlassert, NLMISC::CVectorD::normalize(), uint, NLMISC::CVectorD::x, NLMISC::CVectorD::y, and NLMISC::CVectorD::z. Referenced by evalCollisionOBoverOC(). { // Checks nlassert (primitive.getPrimitiveTypeInternal()==UMovePrimitive::_2DOrientedBox); nlassert (otherPrimitive.getPrimitiveTypeInternal()==UMovePrimitive::_2DOrientedCylinder); // Some constants const double normalSegX=_OBData.EdgeDirectionY[numSeg]; const double normalSegY=-_OBData.EdgeDirectionX[numSeg]; // Relative speed const double speedX=other._Speed.x-_Speed.x; const double speedY=other._Speed.y-_Speed.y; // Dot product with the plan tangeante double dotProd= speedX*normalSegX + speedY*normalSegY; //if ( dotProd < 0 ) if ( dotProd !=0 ) { // Time of the collision double time= (otherPrimitive.getRadiusInternal() + normalSegX*(_OBData.PointPosX[numSeg] - other._3dInitPosition.x ) + normalSegY*(_OBData.PointPosY[numSeg] - other._3dInitPosition.y ) ) / dotProd; // Position of segment point at collision time const double segPosX= _OBData.PointPosX[numSeg] + _Speed.x*time; const double segPosY= _OBData.PointPosY[numSeg] + _Speed.y*time; // Position of the cylinder at collision time const double cylPosX= other._3dInitPosition.x + _Speed.x*time; const double cylPosY= other._3dInitPosition.y + _Speed.y*time; // Position de contact const double contactX= cylPosX - normalSegX*otherPrimitive.getRadiusInternal(); const double contactY= cylPosY - normalSegY*otherPrimitive.getRadiusInternal(); // Direction of the collision on the segment const double dirX= contactX - segPosX; const double dirY= contactY - segPosY; // Length of this vector const double length= dirY*normalSegX - dirX*normalSegY; // Included ? if ( ( length >= 0 ) && ( length <= primitive.getLength (numSeg&1) ) ) { // 2d Collid checked... Now check height // Pos Z const double segPosZ= _3dInitPosition.z + _Speed.z*time; // Some constants const double cylPosZ= other._3dInitPosition.z + other._Speed.z*time; // Included ? if ( (cylPosZ <= segPosZ + primitive.getHeightInternal() ) && (cylPosZ + otherPrimitive.getHeightInternal() >= segPosZ) ) { // Ok Collision, fill the result // Time desc.ContactTime=time; // Position desc.ContactPosition.x=contactX; desc.ContactPosition.y=contactY; desc.ContactPosition.z=std::max (segPosZ, cylPosZ); // Segment normal desc.ContactNormal0.x=normalSegX; desc.ContactNormal0.y=normalSegY; desc.ContactNormal0.z=0; // Seg box normal desc.ContactNormal1.x=contactX-cylPosX; desc.ContactNormal1.y=contactY-cylPosY; desc.ContactNormal1.z=0; desc.ContactNormal1.normalize (); // End return true; } } } // No collision return false; }

double NLPACS::CPrimitiveWorldImage::getBBXMax (   )  const [inline]

Return max of the bounding box in X. Definition at line 192 of file primitive_world_image.h. References _BBXMax. { return _BBXMax; }

double NLPACS::CPrimitiveWorldImage::getBBXMin (   )  const [inline]

Return min of the bounding box in X. Definition at line 176 of file primitive_world_image.h. References _BBXMin. Referenced by NLPACS::CMoveCell::updateSortedLists(). { return _BBXMin; }

double NLPACS::CPrimitiveWorldImage::getBBYMax (   )  const [inline]

Return max of the bounding box in Y. Definition at line 200 of file primitive_world_image.h. References _BBYMax. { return _BBYMax; }

double NLPACS::CPrimitiveWorldImage::getBBYMin (   )  const [inline]

Return min of the bounding box in Y. Definition at line 184 of file primitive_world_image.h. References _BBYMin. { return _BBYMin; }

const NLMISC::CVectorD& NLPACS::CPrimitiveWorldImage::getDeltaPosition (   )  const [inline]

Return the delta position Definition at line 208 of file primitive_world_image.h. References _DeltaPosition. { return _DeltaPosition; }

NLMISC::CVectorD NLPACS::CPrimitiveWorldImage::getFinalPosition (   )  const [inline]

Get the position of the move primitive at the end of the movement. Returns: the new position of the primitive. Definition at line 78 of file primitive_world_image.h. References NLPACS::CPrimitiveWorldImage::CPosition::getPos(). { // Get the position return _Position.getPos(); }

const UGlobalPosition& NLPACS::CPrimitiveWorldImage::getGlobalPosition (   )  [inline]

Definition at line 258 of file primitive_world_image.h. References NLPACS::CPrimitiveWorldImage::CPosition::getGlobalPos(). { return _Position.getGlobalPos(); }

double NLPACS::CPrimitiveWorldImage::getInitTime (   )  const [inline]

Definition at line 286 of file primitive_world_image.h. { return _InitTime; }

CMoveElement* NLPACS::CPrimitiveWorldImage::getMoveElement (  uint  i  )  [inline]

Return the nieme MoveElement. The primitive can have 4 move elements. Can be NULL if the ineme elment is not in a list. Definition at line 214 of file primitive_world_image.h. References _MoveElement, and uint. { return _MoveElement[i]; }

CMovePrimitive* NLPACS::CPrimitiveWorldImage::getNextModified (   )  const [inline]

Get next modified primitive. Definition at line 168 of file primitive_world_image.h. References _NextModified. { return _NextModified; }

double NLPACS::CPrimitiveWorldImage::getOrientation (   )  const [inline]

Definition at line 264 of file primitive_world_image.h. References _OBData. { return _OBData.Orientation; }

const NLMISC::CVectorD& NLPACS::CPrimitiveWorldImage::getSpeed (  void   )  const [inline]

Get the speed vector for this primitive. the new speed vector. Definition at line 125 of file primitive_world_image.h. { // New time return _Speed; }

bool NLPACS::CPrimitiveWorldImage::isInModifiedListFlag (   )  [inline]

Is in modified list ? Definition at line 132 of file primitive_world_image.h. References _DynamicFlags, and InModifiedListFlag. Referenced by NLPACS::CMoveContainer::changed(). { return (_DynamicFlags&InModifiedListFlag) != 0; }

bool NLPACS::CPrimitiveWorldImage::isInWorldImageFlag (   )  [inline]

Is in modified list ? Definition at line 153 of file primitive_world_image.h. References _DynamicFlags, and InWorldImageFlag. Referenced by NLPACS::CMovePrimitive::isInserted(). { return (_DynamicFlags&InWorldImageFlag) != 0; }

void NLPACS::CPrimitiveWorldImage::linkInModifiedList (  CMovePrimitive *  next  )  [inline]

Definition at line 147 of file primitive_world_image.h. References _NextModified. Referenced by NLPACS::CMoveContainer::changed(). { _NextModified=next; }

void NLPACS::CPrimitiveWorldImage::move (  const NLMISC::CVectorD &  speed, CMoveContainer &  container, CMovePrimitive &  primitive, uint8  worldImage )

Set the speed vector for this primitive. Only for movable primitives. Parameters: speed  is the speed of the primitive. Definition at line 1480 of file primitive_world_image.cpp. References _3dInitPosition, dirtPos(), NLPACS::CPrimitiveWorldImage::CPosition::getPos(), setSpeed(), and uint8. { // New speed setSpeed (speed, &container, &primitive, worldImage); // Set initial position _3dInitPosition = _Position.getPos (); // Set initial time _InitTime = 0; // Dirt BB dirtPos (&container, &primitive, worldImage); }

void NLPACS::CPrimitiveWorldImage::precalcBB (  double  beginTime, double  endTime, CMovePrimitive &  primitive )

Definition at line 971 of file primitive_world_image.cpp. References _3dInitPosition, _BBXMax, _BBXMin, _BBYMax, _BBYMin, _DeltaPosition, _OBData, NLPACS::CMovePrimitive::getPrimitiveTypeInternal(), NLPACS::CMovePrimitive::getRadiusInternal(), min, nlassert, sint, type, uint, NLMISC::CVectorD::x, and NLMISC::CVectorD::y. Referenced by update(). { // Type of the primitive uint type=primitive.getPrimitiveTypeInternal(); // Box ? if (type==UMovePrimitive::_2DOrientedBox) { // Orientation index sint orient= (sint)(256.f*_OBData.Orientation/(2.f*NLMISC::Pi)); orient&=0xff; orient>>=6; nlassert (orient>=0); nlassert (orient<4); // Compute coordinates _BBXMin=FLT_MAX; _BBYMin=FLT_MAX; _BBXMax=-FLT_MAX; _BBYMax=-FLT_MAX; for (uint i=0; i<4; i++) { if (_OBData.PointPosX[i]<_BBXMin) _BBXMin=_OBData.PointPosX[i]; if (_OBData.PointPosX[i]>_BBXMax) _BBXMax=_OBData.PointPosX[i]; if (_OBData.PointPosY[i]<_BBYMin) _BBYMin=_OBData.PointPosY[i]; if (_OBData.PointPosY[i]>_BBYMax) _BBYMax=_OBData.PointPosY[i]; } _BBXMin=std::min (std::min (_BBXMin, _BBXMin+endTime*_Speed.x), _BBXMin+beginTime*_Speed.x); _BBXMax=std::max (std::max (_BBXMax, _BBXMax+endTime*_Speed.x), _BBXMax+beginTime*_Speed.x); _BBYMin=std::min (std::min (_BBYMin, _BBYMin+endTime*_Speed.y), _BBYMin+beginTime*_Speed.y); _BBYMax=std::max (std::max (_BBYMax, _BBYMax+endTime*_Speed.y), _BBYMax+beginTime*_Speed.y); /* // This code is faster but buggy.. _BBXMin= _OBData.PointPosX[minX[orient]] + _Speed.x*beginTime; _BBXMin= std::min (_BBXMin, _OBData.PointPosX[minX[orient]] + _Speed.x*endTime); _BBYMin= _OBData.PointPosY[minY[orient]] + _Speed.y*beginTime; _BBYMin= std::min (_BBYMin, _OBData.PointPosY[minY[orient]] + _Speed.y*endTime); _BBXMax= _OBData.PointPosX[maxX[orient]] + _Speed.x*beginTime; _BBXMax= std::max (_BBXMax, _OBData.PointPosX[maxX[orient]] + _Speed.x*endTime); _BBYMax= _OBData.PointPosY[maxY[orient]] + _Speed.y*beginTime; _BBYMax= std::max (_BBYMax, _OBData.PointPosY[maxY[orient]] + _Speed.y*endTime);*/ } else { // Should be a cylinder nlassert (type==UMovePrimitive::_2DOrientedCylinder); // Compute X coordinates _BBXMin= _3dInitPosition.x + _Speed.x*beginTime; _BBXMax= _3dInitPosition.x + _Speed.x*endTime; if (_BBXMin>_BBXMax) { double tmp=_BBXMin; _BBXMin=_BBXMax; _BBXMax=tmp; } _BBXMin-=primitive.getRadiusInternal(); _BBXMax+=primitive.getRadiusInternal(); // Compute Y coordinates _BBYMin= _3dInitPosition.y + _Speed.y*beginTime; _BBYMax= _3dInitPosition.y + _Speed.y*endTime; if (_BBYMin>_BBYMax) { double tmp=_BBYMin; _BBYMin=_BBYMax; _BBYMax=tmp; } _BBYMin-=primitive.getRadiusInternal(); _BBYMax+=primitive.getRadiusInternal(); } // Delta position _DeltaPosition=_Speed*(endTime-beginTime); }

void NLPACS::CPrimitiveWorldImage::precalcPos (  CMovePrimitive &  primitive  )

Definition at line 912 of file primitive_world_image.cpp. References _3dInitPosition, _OBData, NLPACS::CMovePrimitive::getLength(), NLPACS::CMovePrimitive::getPrimitiveTypeInternal(), nlassert, type, uint, NLMISC::CVectorD::x, and NLMISC::CVectorD::y. Referenced by update(). { // Type of the primitive uint type=primitive.getPrimitiveTypeInternal(); // Box ? if (type==UMovePrimitive::_2DOrientedBox) { // Calc cosinus and sinus double cosinus=(double)cos(_OBData.Orientation); double sinus=(double)sin(_OBData.Orientation); // Size double halfWidth=primitive.getLength (0)/2; double halfDepth=primitive.getLength (1)/2; // First point _OBData.PointPosX[0]=cosinus*(-halfWidth)-sinus*(-halfDepth)+_3dInitPosition.x; _OBData.PointPosY[0]=sinus*(-halfWidth)+cosinus*(-halfDepth)+_3dInitPosition.y; // Second point _OBData.PointPosX[1]=cosinus*halfWidth-sinus*(-halfDepth)+_3dInitPosition.x; _OBData.PointPosY[1]=sinus*halfWidth+cosinus*(-halfDepth)+_3dInitPosition.y; // Third point _OBData.PointPosX[2]=cosinus*halfWidth-sinus*halfDepth+_3dInitPosition.x; _OBData.PointPosY[2]=sinus*halfWidth+cosinus*halfDepth+_3dInitPosition.y; // Fourth point _OBData.PointPosX[3]=cosinus*(-halfWidth)-sinus*halfDepth+_3dInitPosition.x; _OBData.PointPosY[3]=sinus*(-halfWidth)+cosinus*halfDepth+_3dInitPosition.y; // Direction double length0 = (primitive.getLength(0)==0)? 0.001 : primitive.getLength(0); double length1 = (primitive.getLength(1)==0)? 0.001 : primitive.getLength(1); double oneOverLength[2]= { 1 / length0, 1 / length1 }; // Direction uint i; for (i=0; i<4; i++) { // Next index uint next=(i+1)&3; double oneOver=oneOverLength[i&1]; // New direction _OBData.EdgeDirectionX[i]=(_OBData.PointPosX[next] - _OBData.PointPosX[i])*oneOver; _OBData.EdgeDirectionY[i]=(_OBData.PointPosY[next] - _OBData.PointPosY[i])*oneOver; } } else { // Should be a cylinder nlassert (type==UMovePrimitive::_2DOrientedCylinder); } }

void NLPACS::CPrimitiveWorldImage::precalcSpeed (   )

void NLPACS::CPrimitiveWorldImage::reaction (  const CCollisionSurfaceDesc &  surfaceDesc, const UGlobalPosition &  globalPosition, CGlobalRetriever &  retriever, double  ratio, double  dt, CMovePrimitive &  primitive, CMoveContainer &  container, uint8  worldImage )

Definition at line 1350 of file primitive_world_image.cpp. References _3dInitPosition, NLPACS::CCollisionSurfaceDesc::ContactNormal, NLPACS::CCollisionSurfaceDesc::ContactTime, dirtPos(), NLPACS::CMovePrimitive::getAttenuation(), NLPACS::CPrimitiveWorldImage::CPosition::getPos(), NLPACS::CMovePrimitive::getReactionTypeInternal(), NELPACS_DIST_BACK, NLMISC::CVectorD::set(), NLPACS::CPrimitiveWorldImage::CPosition::setGlobalPos(), type, uint32, and uint8. { // H_AUTO(PACS_PWI_reaction_short); // Reaction type uint32 type=primitive.getReactionTypeInternal(); // Reaction to the collision: copy the CGlobalRetriever::CGlobalPosition _Position.setGlobalPos (globalPosition, retriever); // Relfexion or slide ? if ((type==UMovePrimitive::Reflexion)||(type==UMovePrimitive::Slide)) { // Slide ? if (type==UMovePrimitive::Slide) { // Project last delta on plane of collision. _Speed-= surfaceDesc.ContactNormal*(surfaceDesc.ContactNormal*_Speed-NELPACS_DIST_BACK/(dt-surfaceDesc.ContactTime)); } // Reflexion ? if (type==UMovePrimitive::Reflexion) { // Project last delta on plane of collision. double speedProj=surfaceDesc.ContactNormal*_Speed; _Speed-=surfaceDesc.ContactNormal*(speedProj+speedProj*primitive.getAttenuation()-NELPACS_DIST_BACK/(dt-surfaceDesc.ContactTime)); } } else { // Stop ? if (type==UMovePrimitive::Stop) { _Speed.set (0,0,0); } } // Contact time double contactTime=surfaceDesc.ContactTime; // Init position _3dInitPosition = _Position.getPos() - _Speed * contactTime; // Set contactTime _InitTime=contactTime; // Dirt pos dirtPos (&container, &primitive, worldImage); }

void NLPACS::CPrimitiveWorldImage::reaction (  CPrimitiveWorldImage &  second, const CCollisionDesc &  desc, CGlobalRetriever *  retriver, CCollisionSurfaceTemp &  surfaceTemp, bool  collision, CMovePrimitive &  primitive, CMovePrimitive &  otherPrimitive, CMoveContainer *  container, uint8  worldImage, uint8  secondWorldImage, bool  secondConst )

Definition at line 1167 of file primitive_world_image.cpp. References _3dInitPosition, _DeltaPosition, _InitTime, _Position, _Speed, NLMISC::clamp(), NLPACS::UCollisionDesc::ContactNormal0, NLPACS::UCollisionDesc::ContactNormal1, NLPACS::UCollisionDesc::ContactTime, dirtPos(), NLPACS::CGlobalRetriever::doMove(), NLPACS::CMovePrimitive::getAttenuation(), NLPACS::CPrimitiveWorldImage::CPosition::getGlobalPos(), NLPACS::CMovePrimitive::getMass(), NLPACS::CPrimitiveWorldImage::CPosition::getPos(), NLPACS::CMovePrimitive::getReactionTypeInternal(), NLPACS::CMovePrimitive::isObstacle(), nlassert, NLMISC::CVectorD::norm(), NLMISC::CVectorD::set(), NLPACS::CPrimitiveWorldImage::CPosition::setGlobalPos(), NLPACS::CPrimitiveWorldImage::CPosition::setPos(), setSpeed(), and uint8. { // H_AUTO(PACS_PWI_reaction_long); // Get the two reaction codes UMovePrimitive::TReaction firstReaction=primitive.getReactionTypeInternal(); UMovePrimitive::TReaction secondReaction=otherPrimitive.getReactionTypeInternal(); // Overide collsion collision = collision && (primitive.isObstacle ()) && (otherPrimitive.isObstacle ()); // Get the two mass float mass0 = primitive.getMass (); float mass1 = otherPrimitive.getMass (); // Energy sum double projSpeed0 = desc.ContactNormal1 * _Speed; double projSpeed1 = desc.ContactNormal0 * second._Speed; double energySum = (- mass0 * projSpeed0 - mass1 * projSpeed1 ) / 2.0; // Old position CVectorD collisionPosition=_3dInitPosition; collisionPosition+=_Speed*desc.ContactTime; // Calc new speed CVectorD newSpeed; // Obstacle ? if (collision) { switch (firstReaction) { case UMovePrimitive::Slide: // Remove projected speed newSpeed=_Speed - projSpeed0 * desc.ContactNormal1; // Reflexion speed newSpeed+=( primitive.getAttenuation()*energySum / mass0 ) * desc.ContactNormal1; break; case UMovePrimitive::Reflexion: // Remove projected speed newSpeed=_Speed - projSpeed0 * desc.ContactNormal1; // Reflexion speed newSpeed+=( primitive.getAttenuation()*energySum / mass0 ) * desc.ContactNormal1; break; case UMovePrimitive::Stop: newSpeed.set (0,0,0); break; case UMovePrimitive::DoNothing: newSpeed=_Speed; break; default: break; } // Set new speed setSpeed (newSpeed, container, &primitive, worldImage); // New position at t=0 if (retriever) { // Make a domove in the Ben data double deltaDist= _DeltaPosition.norm(); double deltaTime; if(deltaDist<0.000001) deltaTime= 0; else deltaTime=(collisionPosition-_Position.getPos ()).norm()/deltaDist; nlassert (deltaTime>=0); nlassert (deltaTime<=1); UGlobalPosition newPosition = retriever->doMove (_Position.getGlobalPos (), _DeltaPosition, (float)deltaTime, surfaceTemp, true); // Set the new position _Position.setGlobalPos (newPosition, *retriever); // Position at t=0 _3dInitPosition = _Position.getPos() - newSpeed * desc.ContactTime; // New init time _InitTime = desc.ContactTime; } else { // No retriever used _Position.setPos (collisionPosition); // Position at t=0 _3dInitPosition = collisionPosition - newSpeed * desc.ContactTime; // New init time _InitTime = desc.ContactTime; } // Dirt pos dirtPos (container, &primitive, worldImage); // ****** Second object // Is second object in a static world ? if (!secondConst) { // Old position collisionPosition=second._3dInitPosition; collisionPosition+=second._Speed * desc.ContactTime; // Obstacle ? switch (secondReaction) { case UMovePrimitive::Slide: // Remove projected speed newSpeed=second._Speed - projSpeed1 * desc.ContactNormal0; // Reflexion speed newSpeed+=( otherPrimitive.getAttenuation()*energySum / mass1 ) * desc.ContactNormal1; break; case UMovePrimitive::Reflexion: // Remove projected speed newSpeed=second._Speed - projSpeed1 * desc.ContactNormal0; // Reflexion speed newSpeed+=( otherPrimitive.getAttenuation()*energySum / mass1 ) * desc.ContactNormal0; break; case UMovePrimitive::Stop: newSpeed.set (0,0,0); break; case UMovePrimitive::DoNothing: newSpeed=second._Speed; break; default: break; } // Set new speed second.setSpeed (newSpeed, container, &otherPrimitive, secondWorldImage); // New position at t=0 if (retriever) { // Make a domove in the Ben data double deltaDist= second._DeltaPosition.norm(); double deltaTime; if(deltaDist==0) deltaTime= 0; else deltaTime=(collisionPosition-second._Position.getPos ()).norm()/deltaDist; clamp (deltaTime, 0.0, 1.0); UGlobalPosition newPosition = retriever->doMove (second._Position.getGlobalPos (), second._DeltaPosition, (float)deltaTime, surfaceTemp, true); // Set the new position second._Position.setGlobalPos (newPosition, *retriever); // Position at t=0 second._3dInitPosition = second._Position.getPos() - newSpeed * desc.ContactTime; // New init time second._InitTime = desc.ContactTime; } else { // No retriever used second._Position.setPos (collisionPosition); // Position at t=0 second._3dInitPosition = collisionPosition - newSpeed * desc.ContactTime; // New init time second._InitTime = desc.ContactTime; } // Dirt pos second.dirtPos (container, &otherPrimitive, secondWorldImage); } } }

void NLPACS::CPrimitiveWorldImage::removeMoveElement (  uint  i, CMoveContainer &  container, uint8  worldImage )

Remove the nieme MoveElement. Definition at line 1131 of file primitive_world_image.cpp. References _MoveElement, NLPACS::CMoveContainer::freeMoveElement(), nlassert, uint, uint8, and NLPACS::CMoveContainer::unlinkMoveElement(). Referenced by deleteIt(). { // Check nlassert ((i>=0)||(i<4)); nlassert (_MoveElement[i]!=NULL); // Unlink the element container.unlinkMoveElement (_MoveElement[i], worldImage); // Free the move element container.freeMoveElement (_MoveElement[i]); // Set to NULL _MoveElement[i]=NULL; }

void NLPACS::CPrimitiveWorldImage::setGlobalPosition (  const NLMISC::CVectorD &  pos, CMoveContainer &  container, CMovePrimitive &  primitive, uint8  worldImage, bool  keepZ = false, UGlobalPosition::TType  type = UGlobalPosition::Unspecified )

Set the global position of the move primitive. Setting the global position can take a long time if you use a UGlobalRetriever. Set the position with this method only the first time or for teleporting. Parameters: pos  is the new global position of the primitive. Definition at line 1429 of file primitive_world_image.cpp. References _3dInitPosition, dirtPos(), NLPACS::CMoveContainer::getGlobalRetriever(), NLPACS::CPrimitiveWorldImage::CPosition::getPos(), nlassert, NLPACS::CGlobalRetriever::retrievePosition(), NLPACS::CPrimitiveWorldImage::CPosition::setGlobalPos(), NLPACS::CPrimitiveWorldImage::CPosition::setGlobalPosKeepZ(), NLPACS::CPrimitiveWorldImage::CPosition::setPos(), type, and uint8. { // Cast type nlassert (dynamic_cast<const CMoveContainer*>(&container)); const CMoveContainer *cont=(const CMoveContainer*)&container; // Get the retriever CGlobalRetriever *retriever=cont->getGlobalRetriever(); // Use a global retriever if (retriever) { // Get a cvector // CVector vect=pos; // better with CVectorD // Get global position UGlobalPosition globalPosition=retriever->retrievePosition (pos, 1.0e10, type); if (keepZ) { // Set the position _Position.setPos (pos); // Set global position _Position.setGlobalPosKeepZ (globalPosition, *retriever); } else { // Set global position _Position.setGlobalPos (globalPosition, *retriever); } } else { // Set the position _Position.setPos (pos); } // Precalc some values _3dInitPosition = _Position.getPos (); _InitTime = 0; // Speed NULL _Speed=CVector::Null; // Dirt BB dirtPos (&container, &primitive, worldImage); }

void NLPACS::CPrimitiveWorldImage::setGlobalPosition (  const UGlobalPosition &  pos, CMoveContainer &  container, CMovePrimitive &  primitive, uint8  worldImage )

Set the global position of the move primitive. Parameters: pos  is the new global position of the primitive. Definition at line 1404 of file primitive_world_image.cpp. References _3dInitPosition, dirtPos(), NLPACS::CMoveContainer::getGlobalRetriever(), NLPACS::CPrimitiveWorldImage::CPosition::getPos(), nlassert, NLPACS::CPrimitiveWorldImage::CPosition::setGlobalPos(), and uint8. { // Cast type nlassert (dynamic_cast<const CMoveContainer*>(&container)); const CMoveContainer *cont=(const CMoveContainer*)&container; // Use the global retriever ? nlassert (cont->getGlobalRetriever()); // Get the pos _Position.setGlobalPos (pos, *cont->getGlobalRetriever()); // Precalc some values _3dInitPosition = _Position.getPos (); _InitTime = 0; // Speed NULL _Speed=CVector::Null; // Dirt BB dirtPos (&container, &primitive, worldImage); }

void NLPACS::CPrimitiveWorldImage::setInModifiedListFlag (  bool  itis  )  [inline]

Clear the inModifiedList flag. Definition at line 138 of file primitive_world_image.h. References _DynamicFlags, and InModifiedListFlag. Referenced by NLPACS::CMoveContainer::changed(). { if (itis) _DynamicFlags|=InModifiedListFlag; else _DynamicFlags&=~InModifiedListFlag; }

void NLPACS::CPrimitiveWorldImage::setInWorldImageFlag (  bool  itis  )  [inline]

Clear the inModifiedList flag. Definition at line 159 of file primitive_world_image.h. References _DynamicFlags, and InWorldImageFlag. { if (itis) _DynamicFlags|=InWorldImageFlag; else _DynamicFlags&=~InWorldImageFlag; }

void NLPACS::CPrimitiveWorldImage::setOrientation (  double  rot, CMoveContainer *  container, CMovePrimitive *  primitive, uint8  worldImage )  [inline]

Set the new orientation of the move primitive. Only for the box primitives. Parameters: rot  is the new OZ rotation in radian. Definition at line 89 of file primitive_world_image.h. References _OBData, dirtPos(), and uint8. { // New position _OBData.Orientation=rot; // Position has changed dirtPos (container, primitive, worldImage); }

void NLPACS::CPrimitiveWorldImage::setSpeed (  const NLMISC::CVectorD &  speed, CMoveContainer *  container, CMovePrimitive *  primitive, uint8  worldImage )  [inline]

Set the speed vector for this primitive. Parameters: speed  is the new speed vector. Definition at line 111 of file primitive_world_image.h. References dirtPos(), and uint8. Referenced by move(), and reaction(). { // New time _Speed=speed; // Speed has changed dirtPos (container, primitive, worldImage); }

void NLPACS::CPrimitiveWorldImage::update (  double  beginTime, double  endTime, CMovePrimitive &  primitive )  [inline]

Update precalculated data. Definition at line 231 of file primitive_world_image.h. References _DynamicFlags, DirtBBFlag, DirtPosFlag, precalcBB(), and precalcPos(). { // Pos dirt ? if (_DynamicFlags&DirtPosFlag) { // Compute precalculated data precalcPos (primitive); // Clean _DynamicFlags&=~DirtPosFlag; } // Bounding box dirt ? if (_DynamicFlags&DirtBBFlag) { // Compute precalculated data precalcBB (beginTime, endTime, primitive); // Clean _DynamicFlags&=~DirtBBFlag; } }

---

Field Documentation

NLMISC::CVectorD NLPACS::CPrimitiveWorldImage::_3dInitPosition [private]

Definition at line 463 of file primitive_world_image.h. Referenced by evalCollisionOCoverOC(), evalCollisionPoverOC(), evalCollisionPoverS(), evalCollisionSoverOC(), move(), precalcBB(), precalcPos(), reaction(), and setGlobalPosition().

double NLPACS::CPrimitiveWorldImage::_BBXMax [private]

Definition at line 474 of file primitive_world_image.h. Referenced by addMoveElement(), CPrimitiveWorldImage(), getBBXMax(), and precalcBB().

double NLPACS::CPrimitiveWorldImage::_BBXMin [private]

Definition at line 472 of file primitive_world_image.h. Referenced by addMoveElement(), checkSortedList(), CPrimitiveWorldImage(), getBBXMin(), and precalcBB().

double NLPACS::CPrimitiveWorldImage::_BBYMax [private]

Definition at line 475 of file primitive_world_image.h. Referenced by CPrimitiveWorldImage(), getBBYMax(), and precalcBB().

double NLPACS::CPrimitiveWorldImage::_BBYMin [private]

Definition at line 473 of file primitive_world_image.h. Referenced by CPrimitiveWorldImage(), getBBYMin(), and precalcBB().

NLMISC::CVectorD NLPACS::CPrimitiveWorldImage::_DeltaPosition [private]

Definition at line 466 of file primitive_world_image.h. Referenced by doMove(), evalCollision(), getDeltaPosition(), precalcBB(), and reaction().

uint16 NLPACS::CPrimitiveWorldImage::_DynamicFlags [private]

Definition at line 404 of file primitive_world_image.h. Referenced by copy(), CPrimitiveWorldImage(), dirtBB(), dirtPos(), isInModifiedListFlag(), isInWorldImageFlag(), setInModifiedListFlag(), setInWorldImageFlag(), and update().

double NLPACS::CPrimitiveWorldImage::_InitTime [private]

Definition at line 460 of file primitive_world_image.h. Referenced by reaction().

CMoveElement* NLPACS::CPrimitiveWorldImage::_MoveElement[4] [private]

Definition at line 500 of file primitive_world_image.h. Referenced by addMoveElement(), checkSortedList(), copy(), CPrimitiveWorldImage(), deleteIt(), getMoveElement(), and removeMoveElement().

CMovePrimitive* NLPACS::CPrimitiveWorldImage::_NextModified [private]

Definition at line 497 of file primitive_world_image.h. Referenced by getNextModified(), and linkInModifiedList().

struct { ... } NLPACS::CPrimitiveWorldImage::_OBData [private]

Referenced by evalCollision(), evalCollisionPoverOC(), evalCollisionPoverS(), evalCollisionSoverOC(), getOrientation(), precalcBB(), precalcPos(), and setOrientation().

CPosition NLPACS::CPrimitiveWorldImage::_Position [private]

Definition at line 457 of file primitive_world_image.h. Referenced by reaction().

NLMISC::CVectorD NLPACS::CPrimitiveWorldImage::_Speed [private]

Definition at line 469 of file primitive_world_image.h. Referenced by evalCollisionOCoverOC(), evalCollisionPoverOC(), evalCollisionPoverS(), evalCollisionSoverOC(), and reaction().

double NLPACS::CPrimitiveWorldImage::EdgeDirectionX[4] [private]

Definition at line 488 of file primitive_world_image.h.

double NLPACS::CPrimitiveWorldImage::EdgeDirectionY[4] [private]

Definition at line 489 of file primitive_world_image.h.

double NLPACS::CPrimitiveWorldImage::Orientation [private]

Definition at line 492 of file primitive_world_image.h.

double NLPACS::CPrimitiveWorldImage::PointPosX[4] [private]

Definition at line 484 of file primitive_world_image.h.

double NLPACS::CPrimitiveWorldImage::PointPosY[4] [private]

Definition at line 485 of file primitive_world_image.h.

---

The documentation for this class was generated from the following files:

• primitive_world_image.h
• primitive_world_image.cpp

---