nel/src/pacs/move_primitive.cpp

   1 // NeL - MMORPG Framework <http://dev.ryzom.com/projects/nel/>
   2 // Copyright (C) 2010  Winch Gate Property Limited
   3 //
   4 // This program is free software: you can redistribute it and/or modify
   5 // it under the terms of the GNU Affero General Public License as
   6 // published by the Free Software Foundation, either version 3 of the
   7 // License, or (at your option) any later version.
   8 //
   9 // This program is distributed in the hope that it will be useful,
  10 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12 // GNU Affero General Public License for more details.
  13 //
  14 // You should have received a copy of the GNU Affero General Public License
  15 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
  16
  17 #include "stdpacs.h"
  18
  19 #include "nel/pacs/move_primitive.h"
  20 #include "nel/pacs/collision_desc.h"
  21 #include "nel/pacs/move_element.h"
  22 #include "nel/misc/hierarchical_timer.h"
  23
  24 using namespace NLMISC;
  25
  26 H_AUTO_DECL ( NLPACS_Get_Global_Position )
  27 H_AUTO_DECL ( NLPACS_Set_Global_Position )
  28 H_AUTO_DECL ( NLPACS_Set_UGlobal_Position )
  29 H_AUTO_DECL ( NLPACS_Move )
  30 #define NLPACS_HAUTO_GET_GLOBAL_POSITION        H_AUTO_USE ( NLPACS_Get_Global_Position )
  31 #define NLPACS_HAUTO_SET_GLOBAL_POSITION        H_AUTO_USE ( NLPACS_Set_Global_Position )
  32 #define NLPACS_HAUTO_SET_UGLOBAL_POSITION       H_AUTO_USE ( NLPACS_Set_UGlobal_Position )
  33 #define NLPACS_HAUTO_MOVE                                       H_AUTO_USE ( NLPACS_Move )
  34
  35 namespace NLPACS
  36 {
  37
  38 // ***************************************************************************
  39
  40 CMovePrimitive::CMovePrimitive (CMoveContainer* container, uint8 firstWorldImage, uint8 numWorldImage)
  41 {
  42         _FirstWorldImage=firstWorldImage;
  43         _NumWorldImage=numWorldImage;
  44
  45         _CollisionMask=0xffffffff;
  46         _OcclusionMask=0xffffffff;
  47         _Attenuation=1;
  48         _Container=container;
  49         _StaticFlags=0;
  50         _RootOTInfo=NULL;
  51         _LastTestTime=0xffffffff;
  52
  53         // Ptr table alloc
  54         _WorldImages=_Container->allocateWorldImagesPtrs (numWorldImage);
  55
  56         // Alloc world images
  57         for (uint j=0; j<numWorldImage; j++)
  58                 _WorldImages[j]=_Container->allocateWorldImage ();
  59 }
  60
  61 // ***************************************************************************
  62
  63 CMovePrimitive::~CMovePrimitive ()
  64 {
  65         // Alloc world images
  66         for (uint j=0; j<(uint)_NumWorldImage; j++)
  67         {
  68                 _WorldImages[j]->deleteIt (*_Container, (uint8)(_FirstWorldImage+j));
  69                 _Container->freeWorldImage (_WorldImages[j]);
  70         }
  71
  72         // Ptr table alloc
  73         _Container->freeWorldImagesPtrs (_WorldImages);
  74 }
  75
  76 // ***************************************************************************
  77
  78 void CMovePrimitive::removeCollisionOTInfo (CCollisionOTInfo *toRemove)
  79 {
  80         // Should be ok
  81         CCollisionOTInfo        *previousElement=NULL;
  82         CCollisionOTInfo        *element=_RootOTInfo;
  83         nlassert (element);
  84
  85         // Look for it
  86         while (element)
  87         {
  88                 // Good one ?
  89                 if (element==toRemove)
  90                 {
  91                         // If previous element, just link
  92                         if (previousElement)
  93                                 previousElement->primitiveLink (this, element->getNext (this));
  94                         else
  95                                 _RootOTInfo=element->getNext (this);
  96
  97                         // End
  98                         break;
  99                 }
 100
 101                 // Look for next
 102                 previousElement=element;
 103                 element=element->getNext (this);
 104         }
 105
 106         // Should be found
 107         nlassert (element);
 108 }
 109
 110 // ***************************************************************************
 111
 112 void CMovePrimitive::removeCollisionOTInfo ()
 113 {
 114         // For each element in the list
 115         CCollisionOTInfo        *element=_RootOTInfo;
 116         while (element)
 117         {
 118                 // Unlink from ot
 119                 element->unlink ();
 120
 121                 // Remove collision ot info from other primitive
 122                 CMovePrimitive *other=element->getOtherPrimitive (this);
 123                 if (other)
 124                 {
 125                         // Remove it in the other element
 126                         other->removeCollisionOTInfo (element);
 127                 }
 128
 129                 // Next element
 130                 element=element->getNext (this);
 131         }
 132
 133         // Relink element because we keep it
 134         _RootOTInfo=NULL;
 135 }
 136
 137 // ***************************************************************************
 138
 139 void CMovePrimitive::checkSortedList ()
 140 {
 141         // Check sorted list for ecah world image
 142         for (uint i=0; i<(uint)_NumWorldImage; i++)
 143                 _WorldImages[i]->checkSortedList (uint8(i+_FirstWorldImage));
 144 }
 145
 146 // ***************************************************************************
 147
 148 bool CMovePrimitive::isTriggered (CMovePrimitive& second, bool enter, bool exit)
 149 {
 150         // Generate a trigger ?
 151
 152         // Is the two are not triggers ?
 153         if ( ( (_StaticFlags&TriggerMask) == NotATrigger ) && ( (second._StaticFlags&TriggerMask) == NotATrigger ) )
 154                 return false;
 155
 156         // Is one of them is an enter trigger ?
 157         if ( enter && ( (_StaticFlags&EnterTrigger) || (second._StaticFlags&EnterTrigger) ) )
 158                 return true;
 159
 160         // Is one of them is an exit trigger ?
 161         if ( exit && ( (_StaticFlags&ExitTrigger) || (second._StaticFlags&ExitTrigger) ) )
 162                 return true;
 163
 164         // Is one of them is a trigger ?
 165         if ( (_StaticFlags&OverlapTrigger) || (second._StaticFlags&OverlapTrigger) )
 166                 return true;
 167
 168         return false;
 169 }
 170
 171 // ***************************************************************************
 172
 173 void CMovePrimitive::insertInWorldImage (uint8 worldImage)
 174 {
 175         // Check it is a collisionable primitive
 176         nlassert (!isNonCollisionable());
 177
 178         // Check ad get the primitive world image
 179         CPrimitiveWorldImage *wI=getWorldImage (worldImage);
 180
 181         // Set as inserted
 182         wI->setInWorldImageFlag (true);
 183
 184         // Flag to update this wI
 185         _Container->changed (this, worldImage);
 186 }
 187
 188 // ***************************************************************************
 189
 190 void CMovePrimitive::removeFromWorldImage (uint8 worldImage)
 191 {
 192         // Check it is a collisionable primitive
 193         nlassert (!isNonCollisionable());
 194
 195         // Check ad get the primitive world image
 196         CPrimitiveWorldImage *wI=getWorldImage (worldImage);
 197
 198         // Remove from cells
 199         wI->deleteIt (*_Container, worldImage);
 200
 201         // Set as non inserted
 202         wI->setInWorldImageFlag (false);
 203 }
 204
 205 // ***************************************************************************
 206
 207 void CMovePrimitive::setAbsorbtion (float attenuation)
 208 {
 209         _Attenuation=attenuation;
 210 }
 211
 212 // ***************************************************************************
 213
 214 void CMovePrimitive::setOrientation (double rot, uint8 worldImage)
 215 {
 216         if (isNonCollisionable())
 217                 getWorldImage (0)->setOrientation (rot, _Container, this, worldImage);
 218         else
 219                 getWorldImage (worldImage)->setOrientation (rot, _Container, this, worldImage);
 220 }
 221
 222 // ***************************************************************************
 223
 224 void CMovePrimitive::setGlobalPosition (const UGlobalPosition& pos, uint8 worldImage)
 225 {
 226         NLPACS_HAUTO_SET_GLOBAL_POSITION
 227
 228         if (isNonCollisionable())
 229                 getWorldImage (0)->setGlobalPosition (pos, *_Container, *this, worldImage);
 230         else
 231                 getWorldImage (worldImage)->setGlobalPosition (pos, *_Container, *this, worldImage);
 232 }
 233
 234 // ***************************************************************************
 235
 236 void CMovePrimitive::setGlobalPosition (const NLMISC::CVectorD& pos, uint8 worldImage, UGlobalPosition::TType /* type */)
 237 {
 238         NLPACS_HAUTO_SET_UGLOBAL_POSITION
 239
 240         if (isNonCollisionable())
 241                 getWorldImage (0)->setGlobalPosition (pos, *_Container, *this, worldImage, (_StaticFlags & DontSnapToGroundFlag) != 0);
 242         else
 243                 getWorldImage (worldImage)->setGlobalPosition (pos, *_Container, *this, worldImage, (_StaticFlags & DontSnapToGroundFlag) != 0);
 244 }
 245
 246 // ***************************************************************************
 247
 248 void CMovePrimitive::move (const NLMISC::CVectorD& speed, uint8 worldImage)
 249 {
 250         NLPACS_HAUTO_MOVE
 251
 252         if (isNonCollisionable())
 253                 getWorldImage (0)->move (speed, *_Container, *this, worldImage);
 254         else
 255                 getWorldImage (worldImage)->move (speed, *_Container, *this, worldImage);
 256 }
 257
 258 // ***************************************************************************
 259
 260 NLMISC::CVectorD CMovePrimitive::getFinalPosition (uint8 worldImage)  const
 261 {
 262         if (isNonCollisionable())
 263                 return getWorldImage (0)->getFinalPosition ();
 264         else
 265                 return getWorldImage (worldImage)->getFinalPosition ();
 266 }
 267
 268 // ***************************************************************************
 269
 270 const NLMISC::CVectorD& CMovePrimitive::getSpeed (uint8 worldImage) const
 271 {
 272         if (isNonCollisionable())
 273                 return getWorldImage (0)->getSpeed ();
 274         else
 275                 return getWorldImage (worldImage)->getSpeed ();
 276 }
 277
 278 // ***************************************************************************
 279
 280 CMovePrimitive::TType CMovePrimitive::getPrimitiveType () const
 281 {
 282         return getPrimitiveTypeInternal ();
 283 }
 284
 285 // ***************************************************************************
 286
 287 CMovePrimitive::TReaction CMovePrimitive::getReactionType () const
 288 {
 289         return getReactionTypeInternal ();
 290 }
 291
 292 // ***************************************************************************
 293
 294 CMovePrimitive::TTrigger CMovePrimitive::getTriggerType () const
 295 {
 296         return getTriggerTypeInternal ();
 297 }
 298
 299 // ***************************************************************************
 300
 301 CMovePrimitive::TCollisionMask CMovePrimitive::getCollisionMask () const
 302 {
 303         return getCollisionMaskInternal ();
 304 }
 305
 306 // ***************************************************************************
 307
 308 CMovePrimitive::TCollisionMask CMovePrimitive::getOcclusionMask () const
 309 {
 310         return getOcclusionMaskInternal ();
 311 }
 312
 313 // ***************************************************************************
 314
 315 bool CMovePrimitive::getObstacle () const
 316 {
 317         return isObstacle ();
 318 }
 319
 320 // ***************************************************************************
 321
 322 float CMovePrimitive::getAbsorbtion () const
 323 {
 324         return _Attenuation;
 325 }
 326
 327 // ***************************************************************************
 328
 329 void CMovePrimitive::getSize (float& width, float& depth) const
 330 {
 331         width=getLength(0);
 332         depth=getLength(1);
 333 }
 334
 335 // ***************************************************************************
 336
 337 float CMovePrimitive::getHeight () const
 338 {
 339         return getHeightInternal ();
 340 }
 341
 342 // ***************************************************************************
 343
 344 float CMovePrimitive::getRadius () const
 345 {
 346         return getRadiusInternal ();
 347 }
 348
 349 // ***************************************************************************
 350
 351 double CMovePrimitive::getOrientation (uint8 worldImage) const
 352 {
 353         if (isNonCollisionable())
 354                 return getWorldImage (0)->getOrientation ();
 355         else
 356                 return getWorldImage (worldImage)->getOrientation ();
 357 }
 358
 359 // ***************************************************************************
 360
 361 void CMovePrimitive::getGlobalPosition (UGlobalPosition& pos, uint8 worldImage) const
 362 {
 363         NLPACS_HAUTO_GET_GLOBAL_POSITION
 364
 365         if (isNonCollisionable())
 366                 pos=getWorldImage (0)->getGlobalPosition();
 367         else
 368                 pos=getWorldImage (worldImage)->getGlobalPosition();
 369 }
 370
 371 // ***************************************************************************
 372
 373 uint8 CMovePrimitive::getFirstWorldImageV () const
 374 {
 375         return getFirstWorldImage ();
 376 }
 377
 378 // ***************************************************************************
 379
 380 uint8 CMovePrimitive::getNumWorldImageV () const
 381 {
 382         return getNumWorldImage ();
 383 }
 384
 385 // ***************************************************************************
 386
 387 bool CMovePrimitive::isInCollision (CMovePrimitive *primitive)
 388 {
 389         // Should be ok
 390         CCollisionOTInfo        *element=_RootOTInfo;
 391
 392         // Look for it
 393         while (element)
 394         {
 395                 // Dynamic collision ?
 396                 if (!element->isCollisionAgainstStatic())
 397                 {
 398                         // Cast
 399                         const CCollisionOTDynamicInfo *dynInfo=static_cast<const CCollisionOTDynamicInfo*> (element);
 400
 401                         // Check if the primitive is used
 402                         if ((dynInfo->getFirstPrimitive()== primitive)||(dynInfo->getSecondPrimitive()== primitive))
 403                                 return true;
 404                 }
 405
 406                 // Look for next
 407                 element=element->getNext (this);
 408         }
 409
 410         return false;
 411 }
 412
 413 } // NLPACS