nevrax.org : docs

00001 
+00007 /* Copyright, 2001 Nevrax Ltd.
+00008  *
+00009  * This file is part of NEVRAX NEL.
+00010  * NEVRAX NEL is free software; you can redistribute it and/or modify
+00011  * it under the terms of the GNU General Public License as published by
+00012  * the Free Software Foundation; either version 2, or (at your option)
+00013  * any later version.
+00014 
+00015  * NEVRAX NEL is distributed in the hope that it will be useful, but
+00016  * WITHOUT ANY WARRANTY; without even the implied warranty of
+00017  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+00018  * General Public License for more details.
+00019 
+00020  * You should have received a copy of the GNU General Public License
+00021  * along with NEVRAX NEL; see the file COPYING. If not, write to the
+00022  * Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
+00023  * MA 02111-1307, USA.
+00024  */
+00025 
+00026 #ifndef NL_MOVE_PRIMITIVE_H
+00027 #define NL_MOVE_PRIMITIVE_H
+00028 
+00029 #include "nel/misc/types_nl.h"
+00030 #include "nel/misc/vector.h"
+00031 
+00032 #include "nel/pacs/u_move_primitive.h"
+00033 
+00034 #include "pacs/move_container.h"
+00035 #include "pacs/primitive_world_image.h"
+00036 #include "pacs/global_retriever.h"
+00037 
+00038 #define NELPACS_DIST_BACK 0.01
+00039 
+00040 namespace NLPACS 
+00041 {
+00042 
+00052 class CMovePrimitive: public UMovePrimitive
+00053 {
+00054 private:
+00055         friend class CMoveContainer;
+00056 
+00057         // Some flags
+00058         enum TStaticFlags
+00059         {
+00060                 // Mask for the primitive type
+00061                 PrimitiveMask   =0x000f,
+00062 
+00063                 // Mask for the primitive type
+00064                 ReactionMask    =0x00f0,
+00065 
+00066                 // Mask for the trigger type
+00067                 TriggerMask             =0x0f00,
+00068 
+00069                 // Obstacle flag. This flag tells that this object is an obstacle for others objects.
+00070                 ObstacleFlag    =0x1000,
+00071 
+00072                 // Ghost flag. This flag tells that this object is a ghost object or not.
+00073                 NonCollisionableFlag    =0x2000,
+00074                 
+00076                 DontSnapToGroundFlag = 0x4000,
+00077 
+00078                 // Force the size to uint16.
+00079                 ForceSize               =0xffff
+00080         };
+00081 
+00082 public:
+00083 
+00085         CMovePrimitive (CMoveContainer* container, uint8 firstWorldImage, uint8 numWorldImage);
+00086 
+00088         virtual ~CMovePrimitive ();
+00089         //
+00090         virtual void    setDontSnapToGround(bool dont)
+00091         {
+00092                 if (dont) _StaticFlags |= DontSnapToGroundFlag;
+00093                 else _StaticFlags &= ~DontSnapToGroundFlag;
+00094         }
+00095         //
+00096         bool    getDontSnapToGround() const 
+00097         {
+00098                 return (_StaticFlags & DontSnapToGroundFlag) != 0;
+00099         }
+00100         // Return true if this primitive is noncollisionable
+00101         bool isNonCollisionable () const
+00102         {
+00103                 return (_StaticFlags&NonCollisionableFlag)!=0;
+00104         }
+00105 
+00106         // Set noncollisionable
+00107         void setNonCollisionable (bool nonCollisionable)
+00108         {
+00109                 if (nonCollisionable)
+00110                         _StaticFlags|=NonCollisionableFlag;
+00111                 else
+00112                         _StaticFlags&=~NonCollisionableFlag;
+00113         }
+00114 
+00115         // Get the nieme world image
+00116         CPrimitiveWorldImage            *getWorldImage (uint i) const
+00117         {
+00118                 // Checks this primitive belong of the requested world image.
+00119                 nlassert ((i>=(uint)_FirstWorldImage)&&(i<(uint)_FirstWorldImage+(uint)_NumWorldImage));
+00120 
+00121                 // Return the good one
+00122                 return _WorldImages[i-_FirstWorldImage];
+00123         }
+00124 
+00125         // is the primitive inserted in the world image
+00126         bool isInserted (uint i) const
+00127         {
+00128                 // Checks
+00129                 if ((i>=(uint)_FirstWorldImage)&&(i<(uint)_FirstWorldImage+(uint)_NumWorldImage))
+00130                 {
+00131                         // Get world image
+00132                         return getWorldImage (i)->isInWorldImageFlag ();
+00133                 }
+00134                 else
+00135                         return false;
+00136         }
+00137 
+00138         virtual uint8                           getFirstWorldImageV () const;
+00139         virtual uint8                           getNumWorldImageV () const;
+00140 
+00141         // Get first world image used
+00142         uint8   getFirstWorldImage () const
+00143         {
+00144                 return _FirstWorldImage;
+00145         }
+00146 
+00147         // Get count of world image used
+00148         uint8   getNumWorldImage () const
+00149         {
+00150                 return _NumWorldImage;
+00151         }
+00152 
+00153         // Dirt positions of the primitive in all the world images
+00154         void    dirtAllPos ()
+00155         {
+00156                 for (uint i=0; i<_NumWorldImage; i++)
+00157                 {
+00158                         // Get world image and check if it exist
+00159                         CPrimitiveWorldImage    *worldImage=_WorldImages[i];
+00160 
+00161                         // Dirt its pos
+00162                         worldImage->dirtPos (_Container, this, i+_FirstWorldImage);
+00163                 }
+00164         }
+00165 
+00171         void    setPrimitiveType (TType type)
+00172         {
+00173                 // New position
+00174                 _StaticFlags&=~(uint32)PrimitiveMask;
+00175                 _StaticFlags|=type;
+00176         }
+00177 
+00183         void    setReactionType (TReaction type)
+00184         {
+00185                 // New position
+00186                 _StaticFlags&=~(uint32)ReactionMask;
+00187                 _StaticFlags|=type;
+00188         }
+00189 
+00195         void    setTriggerType (TTrigger type)
+00196         {
+00197                 // New position
+00198                 _StaticFlags&=~(uint32)TriggerMask;
+00199                 _StaticFlags|=type;
+00200         }
+00201 
+00207         void    setCollisionMask (TCollisionMask mask)
+00208         {
+00209                 _CollisionMask=mask;
+00210         }
+00211 
+00217         void    setOcclusionMask (TCollisionMask mask)
+00218         {
+00219                 _OcclusionMask=mask;
+00220         }
+00221 
+00227         void    setObstacle (bool obstacle)
+00228         {
+00229                 // New flag
+00230                 if (obstacle)
+00231                         _StaticFlags|=ObstacleFlag;
+00232                 else
+00233                         _StaticFlags&=~(uint32)ObstacleFlag;
+00234         }
+00235 
+00242         void    setSize (float width, float depth)
+00243         {
+00244                 // Checks
+00245                 nlassert ((((uint32)_StaticFlags)&PrimitiveMask)==_2DOrientedBox);
+00246 
+00247                 // New position
+00248                 _Length[0]=width;
+00249                 _Length[1]=depth;
+00250         }
+00251 
+00257         void    setHeight (float height)
+00258         {
+00259                 // New size
+00260                 _Height=height;
+00261         }
+00262 
+00268         void    setRadius (float radius)
+00269         {
+00270                 // Checks
+00271                 nlassert ((((uint32)_StaticFlags)&PrimitiveMask)==_2DOrientedCylinder);
+00272 
+00273                 // New position
+00274                 _Length[0]=radius;
+00275         }
+00276 
+00278         TType   getPrimitiveTypeInternal () const
+00279         {
+00280                 // New position
+00281                 return (TType)(_StaticFlags&(uint32)PrimitiveMask);
+00282         }
+00283 
+00285         TReaction       getReactionTypeInternal () const
+00286         {
+00287                 // New position
+00288                 return (TReaction)(_StaticFlags&(uint32)ReactionMask);
+00289         }
+00290 
+00292         TTrigger        getTriggerTypeInternal () const
+00293         {
+00294                 // New position
+00295                 return (TTrigger)(_StaticFlags&(uint32)TriggerMask);
+00296         }
+00297 
+00299         TCollisionMask  getCollisionMaskInternal () const
+00300         {
+00301                 // New position
+00302                 return _CollisionMask;
+00303         }
+00304 
+00306         TCollisionMask  getOcclusionMaskInternal () const
+00307         {
+00308                 // New position
+00309                 return _OcclusionMask;
+00310         }
+00311 
+00313         float getAttenuation() const
+00314         {
+00315                 return _Attenuation;
+00316         }
+00317 
+00319         float getLength (uint where) const
+00320         {
+00321                 return _Length[where];
+00322         }
+00323 
+00325         float getHeightInternal () const
+00326         {
+00327                 return _Height;
+00328         }
+00329 
+00331         float getRadiusInternal () const
+00332         {
+00333                 return _Length[0];
+00334         }
+00335 
+00337         bool isObstacle () const
+00338         {
+00339                 return (_StaticFlags&ObstacleFlag)!=0;
+00340         }
+00341 
+00343         bool    isCollisionable() const
+00344         {
+00345                 return !isNonCollisionable();
+00346         }
+00347 
+00349         void addCollisionOTInfo (CCollisionOTInfo *info)
+00350         {
+00351                 // Link to the list
+00352                 info->primitiveLink (this, _RootOTInfo);
+00353                 _RootOTInfo=info;
+00354         }
+00355 
+00357         void removeCollisionOTInfo (CCollisionOTInfo *toRemove);
+00358 
+00360         void removeCollisionOTInfo ();
+00361 
+00363         void checkSortedList ();
+00364 
+00366         bool isTriggered (CMovePrimitive& second, bool enter, bool exit);
+00367 
+00369 
+00370         void                                    setAbsorbtion (float attenuation);
+00371         void                                    setOrientation (double rot, uint8 worldImage);
+00372         void                                    setGlobalPosition (const NLMISC::CVectorD& pos, uint8 worldImage);
+00373         void                                    setGlobalPosition (const UGlobalPosition& pos, uint8 worldImage);
+00374         void                                    move (const NLMISC::CVectorD& speed, uint8 worldImage);
+00375         NLMISC::CVectorD                getFinalPosition (uint8 worldImage)  const;
+00376         const NLMISC::CVectorD& getSpeed (uint8 worldImage) const;
+00377         void                                    insertInWorldImage (uint8 worldImage);
+00378         void                                    removeFromWorldImage (uint8 worldImage);
+00379         TType                                   getPrimitiveType () const;
+00380         TReaction                               getReactionType () const;
+00381         TTrigger                                getTriggerType () const;
+00382         TCollisionMask                  getCollisionMask () const;
+00383         TCollisionMask                  getOcclusionMask () const;
+00384         bool                                    getObstacle () const;
+00385         float                                   getAbsorbtion () const;
+00386         void                                    getSize (float& width, float& depth) const;
+00387         float                                   getHeight () const;
+00388         float                                   getRadius () const;
+00389         double                                  getOrientation (uint8 worldImage) const;
+00390         void                                    getGlobalPosition (UGlobalPosition& pos, uint8 worldImage) const;
+00391 
+00392         // Test time. Return true if tetst can be perform, false if too many test have been computed for this primitive
+00393         bool checkTestTime (uint32 testTime, uint32 maxTestIteration)
+00394         {
+00395                 // Already checked for this test time ?
+00396                 if (testTime!=_LastTestTime)
+00397                 {
+00398                         // First time this primitive is visited at this test
+00399                         _LastTestTime=testTime;
+00400 
+00401                         // Test counter
+00402                         _IterationCount=maxTestIteration;
+00403                 }
+00404                 else
+00405                 {
+00406                         // Too many test this primitive ?
+00407                         if (_IterationCount<=0)
+00408                         {
+00409 //                              nlwarning("in checkTestTime(): Get to the max iteration count");
+00410                                 return false;
+00411                         }
+00412                         else
+00413                                 _IterationCount--;
+00414                 }
+00415                 // Ok, test can be performed
+00416                 return true;
+00417         }
+00418 
+00419         // *** Get mass
+00420         
+00421         float getMass () const
+00422         {
+00423                 // Box ?
+00424                 if ( (_StaticFlags&PrimitiveMask) == _2DOrientedBox )
+00425                         return _Length[0]*_Length[1]*_Height;
+00426                 // Cylinder ?
+00427                 else
+00428                 {
+00429                         nlassert ( (_StaticFlags&PrimitiveMask) == _2DOrientedCylinder );
+00430                         return _Length[0]*(float)NLMISC::Pi*_Height;
+00431                 }
+00432         }
+00433 
+00434         // *** Primitive over primitive
+00435 
+00436 private:
+00437         // The length of the 4 edges. The first is the width, the second is the depth
+00438         // For cylinder, the first is the radius
+00439         float                           _Length[2];
+00440 
+00441         // This is the height of the box or of the cylinder.
+00442         float                           _Height;
+00443 
+00444         // Attenuation 
+00445         float                           _Attenuation;
+00446 
+00447         // Flags
+00448         uint16                          _StaticFlags;
+00449 
+00450         // Num world images
+00451         uint8                           _NumWorldImage;
+00452 
+00453         // First world images
+00454         uint8                           _FirstWorldImage;
+00455 
+00456         // Occlusion mask
+00457         TCollisionMask          _OcclusionMask;
+00458 
+00459         // Collision mask
+00460         TCollisionMask          _CollisionMask;
+00461 
+00462         // Container of this primitive
+00463         CMoveContainer          *_Container;
+00464 
+00465         // List of time ordered table element using this primitive
+00466         CCollisionOTInfo        *_RootOTInfo;
+00467 
+00468         // Pointer table of world images for this primitive
+00469         CPrimitiveWorldImage    **_WorldImages;
+00470 
+00471         // Last primitive test time
+00472         uint32                          _LastTestTime;
+00473 
+00474         // Iteration count
+00475         sint32                          _IterationCount;
+00476 };
+00477 
+00478 } // NLPACS
+00479 
+00480 #include "pacs/move_container_inline.h"
+00481 
+00482 #endif // NL_MOVE_PRIMITIVE_H
+00483 
+00484 /* End of move_primitive.h */
+