NVIDIA(R) PhysX(R) SDK 3.4 API Reference: PxSimulationEventCallback.h Source File

00001 // This code contains NVIDIA Confidential Information and is disclosed to you
+00002 // under a form of NVIDIA software license agreement provided separately to you.
+00003 //
+00004 // Notice
+00005 // NVIDIA Corporation and its licensors retain all intellectual property and
+00006 // proprietary rights in and to this software and related documentation and
+00007 // any modifications thereto. Any use, reproduction, disclosure, or
+00008 // distribution of this software and related documentation without an express
+00009 // license agreement from NVIDIA Corporation is strictly prohibited.
+00010 //
+00011 // ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
+00012 // NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
+00013 // THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
+00014 // MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
+00015 //
+00016 // Information and code furnished is believed to be accurate and reliable.
+00017 // However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
+00018 // information or for any infringement of patents or other rights of third parties that may
+00019 // result from its use. No license is granted by implication or otherwise under any patent
+00020 // or patent rights of NVIDIA Corporation. Details are subject to change without notice.
+00021 // This code supersedes and replaces all information previously supplied.
+00022 // NVIDIA Corporation products are not authorized for use as critical
+00023 // components in life support devices or systems without express written approval of
+00024 // NVIDIA Corporation.
+00025 //
+00026 // Copyright (c) 2008-2016 NVIDIA Corporation. All rights reserved.
+00027 // Copyright (c) 2004-2008 AGEIA Technologies, Inc. All rights reserved.
+00028 // Copyright (c) 2001-2004 NovodeX AG. All rights reserved.  
+00029 
+00030 
+00031 #ifndef PX_SIMULATION_EVENT_CALLBACK
+00032 #define PX_SIMULATION_EVENT_CALLBACK
+00033 
+00037 #include "foundation/PxVec3.h"
+00038 #include "foundation/PxTransform.h"
+00039 #include "foundation/PxMemory.h"
+00040 #include "PxPhysXConfig.h"
+00041 #include "PxFiltering.h"
+00042 #include "PxContact.h"
+00043 
+00044 #if !PX_DOXYGEN
+00045 namespace physx
+00046 {
+00047 #endif
+00048 
+00049 class PxShape;
+00050 class PxActor;
+00051 class PxRigidActor;
+00052 class PxRigidBody;
+00053 class PxConstraint;
+00054 
+00055 
+00061 struct PxContactPairExtraDataType
+00062 {
+00063     enum Enum
+00064     {
+00065         ePRE_SOLVER_VELOCITY,   
+00066         ePOST_SOLVER_VELOCITY,  
+00067         eCONTACT_EVENT_POSE,    
+00068         eCONTACT_PAIR_INDEX     
+00069     };
+00070 };
+00071 
+00072 
+00078 struct PxContactPairExtraDataItem
+00079 {
+00080 public:
+00081     PX_FORCE_INLINE PxContactPairExtraDataItem() {}
+00082 
+00086     PxU8 type;
+00087 };
+00088 
+00089 
+00101 struct PxContactPairVelocity : public PxContactPairExtraDataItem
+00102 {
+00103 public:
+00104     PX_FORCE_INLINE PxContactPairVelocity() {}
+00105 
+00109     PxVec3 linearVelocity[2];
+00110     
+00114     PxVec3 angularVelocity[2];
+00115 };
+00116 
+00117 
+00123 struct PxContactPairPose : public PxContactPairExtraDataItem
+00124 {
+00125 public:
+00126     PX_FORCE_INLINE PxContactPairPose() {}
+00127 
+00131     PxTransform globalPose[2];
+00132 };
+00133 
+00134 
+00160 struct PxContactPairIndex : public PxContactPairExtraDataItem
+00161 {
+00162 public:
+00163     PX_FORCE_INLINE PxContactPairIndex() {}
+00164 
+00168     PxU16 index;
+00169 };
+00170 
+00171 
+00177 struct PxContactPairExtraDataIterator
+00178 {
+00184     PX_FORCE_INLINE PxContactPairExtraDataIterator(const PxU8* stream, PxU32 size) 
+00185         : currPtr(stream), endPtr(stream + size), contactPairIndex(0)
+00186     {
+00187         clearDataPtrs();
+00188     }
+00189 
+00208     PX_INLINE bool nextItemSet()
+00209     {
+00210         clearDataPtrs();
+00211         
+00212         bool foundEntry = false;
+00213         bool endOfItemSet = false;
+00214         while ((currPtr < endPtr) && (!endOfItemSet))
+00215         {
+00216             const PxContactPairExtraDataItem* edItem = reinterpret_cast<const PxContactPairExtraDataItem*>(currPtr);
+00217             PxU8 type = edItem->type;
+00218 
+00219             switch(type)
+00220             {
+00221                 case PxContactPairExtraDataType::ePRE_SOLVER_VELOCITY:
+00222                 {
+00223                     PX_ASSERT(!preSolverVelocity);
+00224                     preSolverVelocity = static_cast<const PxContactPairVelocity*>(edItem);
+00225                     currPtr += sizeof(PxContactPairVelocity);
+00226                     foundEntry = true;
+00227                 }
+00228                 break;
+00229                 
+00230                 case PxContactPairExtraDataType::ePOST_SOLVER_VELOCITY:
+00231                 {
+00232                     postSolverVelocity = static_cast<const PxContactPairVelocity*>(edItem);
+00233                     currPtr += sizeof(PxContactPairVelocity);
+00234                     foundEntry = true;
+00235                 }
+00236                 break;
+00237                 
+00238                 case PxContactPairExtraDataType::eCONTACT_EVENT_POSE:
+00239                 {
+00240                     eventPose = static_cast<const PxContactPairPose*>(edItem);
+00241                     currPtr += sizeof(PxContactPairPose);
+00242                     foundEntry = true;
+00243                 }
+00244                 break;
+00245                 
+00246                 case PxContactPairExtraDataType::eCONTACT_PAIR_INDEX:
+00247                 {
+00248                     if (!foundEntry)
+00249                     {
+00250                         contactPairIndex = static_cast<const PxContactPairIndex*>(edItem)->index;
+00251                         currPtr += sizeof(PxContactPairIndex);
+00252                         foundEntry = true;
+00253                     }
+00254                     else
+00255                         endOfItemSet = true;
+00256                 }
+00257                 break;
+00258                 
+00259                 default:
+00260                     return foundEntry;
+00261             }
+00262         }
+00263         
+00264         return foundEntry;
+00265     }
+00266 
+00267 private:
+00271     PX_FORCE_INLINE void clearDataPtrs()
+00272     {
+00273         preSolverVelocity = NULL;
+00274         postSolverVelocity = NULL;
+00275         eventPose = NULL;
+00276     }
+00277     
+00278 public:
+00282     const PxU8* currPtr;
+00283     
+00287     const PxU8* endPtr;
+00288     
+00294     const PxContactPairVelocity* preSolverVelocity;
+00295     
+00301     const PxContactPairVelocity* postSolverVelocity;
+00302     
+00308     const PxContactPairPose* eventPose;
+00309     
+00315     PxU32 contactPairIndex;
+00316 };
+00317 
+00318 
+00324 struct PxContactPairHeaderFlag
+00325 {
+00326     enum Enum
+00327     {
+00328         eREMOVED_ACTOR_0                = (1<<0),           
+00329         eREMOVED_ACTOR_1                = (1<<1)            
+00330     };
+00331 };
+00332 
+00338 typedef PxFlags<PxContactPairHeaderFlag::Enum, PxU16> PxContactPairHeaderFlags;
+00339 PX_FLAGS_OPERATORS(PxContactPairHeaderFlag::Enum, PxU16)
+00340 
+00341 
+00342 
+00347 struct PxContactPairHeader
+00348 {
+00349     public:
+00350         PX_INLINE   PxContactPairHeader() {}
+00351 
+00363     PxRigidActor*               actors[2];
+00364 
+00373     const PxU8*                 extraDataStream;
+00374     
+00378     PxU16                       extraDataStreamSize;
+00379 
+00385     PxContactPairHeaderFlags    flags;
+00386 
+00390     const struct PxContactPair* pairs;
+00391 
+00395     PxU32                       nbPairs;
+00396 };
+00397 
+00398 
+00404 struct PxContactPairFlag
+00405 {
+00406     enum Enum
+00407     {
+00411         eREMOVED_SHAPE_0                = (1<<0),
+00412 
+00416         eREMOVED_SHAPE_1                = (1<<1),
+00417 
+00425         eACTOR_PAIR_HAS_FIRST_TOUCH     = (1<<2),
+00426 
+00432         eACTOR_PAIR_LOST_TOUCH          = (1<<3),
+00433 
+00440         eINTERNAL_HAS_IMPULSES          = (1<<4),
+00441 
+00447         eINTERNAL_CONTACTS_ARE_FLIPPED  = (1<<5)
+00448     };
+00449 };
+00450 
+00456 typedef PxFlags<PxContactPairFlag::Enum, PxU16> PxContactPairFlags;
+00457 PX_FLAGS_OPERATORS(PxContactPairFlag::Enum, PxU16)
+00458 
+00459 
+00460 
+00463 struct PxContactPairPoint
+00464 {
+00468     PxVec3  position;
+00469 
+00473     PxReal  separation;
+00474 
+00478     PxVec3  normal;
+00479 
+00483     PxU32   internalFaceIndex0;
+00484 
+00488     PxVec3  impulse;
+00489 
+00493     PxU32   internalFaceIndex1;
+00494 };
+00495 
+00496 
+00505 struct PxContactPair
+00506 {
+00507     public:
+00508         PX_INLINE   PxContactPair() {}
+00509 
+00521     PxShape*                shapes[2];
+00522 
+00529     const PxU8* contactPatches;
+00530 
+00537     const PxU8* contactPoints;
+00538 
+00545     const PxReal*           contactImpulses;
+00546 
+00550     PxU32                   requiredBufferSize;
+00551 
+00555     PxU8                    contactCount;
+00556 
+00561     PxU8                    patchCount;
+00562 
+00567     PxU16                   contactStreamSize;
+00568 
+00574     PxContactPairFlags      flags;
+00575 
+00598     PxPairFlags             events;
+00599 
+00600     PxU32                   internalData[2];    // For internal use only
+00601 
+00611     PX_INLINE PxU32         extractContacts(PxContactPairPoint* userBuffer, PxU32 bufferSize) const;
+00612 
+00622     PX_INLINE void              bufferContacts(PxContactPair* newPair, PxU8* bufferMemory) const;
+00623 
+00624     PX_INLINE const PxU32*      getInternalFaceIndices() const;
+00625 };
+00626 
+00627 
+00628 PX_INLINE PxU32 PxContactPair::extractContacts(PxContactPairPoint* userBuffer, PxU32 bufferSize) const
+00629 {
+00630     PxU32 nbContacts = 0;
+00631 
+00632     if(contactCount && bufferSize)
+00633     {
+00634         PxContactStreamIterator iter(contactPatches, contactPoints, getInternalFaceIndices(), patchCount, contactCount);
+00635 
+00636         const PxReal* impulses = contactImpulses;
+00637 
+00638         const PxU32 flippedContacts = (flags & PxContactPairFlag::eINTERNAL_CONTACTS_ARE_FLIPPED);
+00639         const PxU32 hasImpulses = (flags & PxContactPairFlag::eINTERNAL_HAS_IMPULSES);
+00640 
+00641         while(iter.hasNextPatch())
+00642         {
+00643             iter.nextPatch();
+00644             while(iter.hasNextContact())
+00645             {
+00646                 iter.nextContact();
+00647                 PxContactPairPoint& dst = userBuffer[nbContacts];
+00648                 dst.position = iter.getContactPoint();
+00649                 dst.separation = iter.getSeparation();
+00650                 dst.normal = iter.getContactNormal();
+00651                 if(!flippedContacts)
+00652                 {
+00653                     dst.internalFaceIndex0 = iter.getFaceIndex0();
+00654                     dst.internalFaceIndex1 = iter.getFaceIndex1();
+00655                 }
+00656                 else
+00657                 {
+00658                     dst.internalFaceIndex0 = iter.getFaceIndex1();
+00659                     dst.internalFaceIndex1 = iter.getFaceIndex0();
+00660                 }
+00661 
+00662                 if(hasImpulses)
+00663                 {
+00664                     const PxReal impulse = impulses[nbContacts];
+00665                     dst.impulse = dst.normal * impulse;
+00666                 }
+00667                 else
+00668                     dst.impulse = PxVec3(0.0f);
+00669                 ++nbContacts;
+00670                 if(nbContacts == bufferSize)
+00671                     return nbContacts;
+00672             }
+00673         }
+00674     }
+00675 
+00676     return nbContacts;
+00677 }
+00678 
+00679 
+00680 PX_INLINE void PxContactPair::bufferContacts(PxContactPair* newPair, PxU8* bufferMemory) const
+00681 {
+00682     PxU8* patches = bufferMemory;
+00683     PxU8* contacts = NULL;
+00684     if(patches)
+00685     {
+00686         contacts = bufferMemory + patchCount * sizeof(PxContactPatch);
+00687         PxMemCopy(patches, contactPatches, sizeof(PxContactPatch)*patchCount);
+00688         PxMemCopy(contacts, contactPoints, contactStreamSize - (sizeof(PxContactPatch)*patchCount));
+00689     }
+00690 
+00691     if(contactImpulses)
+00692     {
+00693         PxMemCopy(bufferMemory + ((contactStreamSize + 15) & (~15)), contactImpulses, sizeof(PxReal) * contactCount);
+00694     }
+00695 
+00696     if (newPair)
+00697     {
+00698         *newPair = *this;
+00699         newPair->contactPatches = patches;
+00700         newPair->contactPoints = contacts;
+00701     }
+00702 }
+00703 
+00704 
+00705 PX_INLINE const PxU32* PxContactPair::getInternalFaceIndices() const
+00706 {
+00707     return reinterpret_cast<const PxU32*>(contactImpulses + contactCount);
+00708 }
+00709 
+00715 struct PxTriggerPairFlag
+00716 {
+00717     enum Enum
+00718     {
+00719         eREMOVED_SHAPE_TRIGGER                  = (1<<0),                   
+00720         eREMOVED_SHAPE_OTHER                    = (1<<1),                   
+00721         eNEXT_FREE                              = (1<<2)                    
+00722     };
+00723 };
+00724 
+00730 typedef PxFlags<PxTriggerPairFlag::Enum, PxU8> PxTriggerPairFlags;
+00731 PX_FLAGS_OPERATORS(PxTriggerPairFlag::Enum, PxU8)
+00732 
+00733 
+00734 
+00746 struct PxTriggerPair
+00747 {
+00748     PX_INLINE PxTriggerPair() {}
+00749 
+00750     PxShape*                triggerShape;   
+00751     PxRigidActor*           triggerActor;   
+00752     PxShape*                otherShape;     
+00753     PxRigidActor*           otherActor;     
+00754     PxPairFlag::Enum        status;         
+00755     PxTriggerPairFlags      flags;          
+00756 };
+00757 
+00758 
+00766 struct PxConstraintInfo
+00767 {
+00768     PX_INLINE PxConstraintInfo() {}
+00769     PX_INLINE PxConstraintInfo(PxConstraint* c, void* extRef, PxU32 t) : constraint(c), externalReference(extRef), type(t) {}
+00770 
+00771     PxConstraint*   constraint;             
+00772     void*           externalReference;      
+00773     PxU32           type;                   
+00774 };
+00775 
+00776 
+00793 class PxSimulationEventCallback
+00794     {
+00795     public:
+00808     virtual void onConstraintBreak(PxConstraintInfo* constraints, PxU32 count) = 0;
+00809 
+00826     virtual void onWake(PxActor** actors, PxU32 count) = 0;
+00827 
+00845     virtual void onSleep(PxActor** actors, PxU32 count) = 0;
+00846 
+00863     virtual void onContact(const PxContactPairHeader& pairHeader, const PxContactPair* pairs, PxU32 nbPairs) = 0;
+00864 
+00880     virtual void onTrigger(PxTriggerPair* pairs, PxU32 count) = 0;
+00881 
+00907     virtual void onAdvance(const PxRigidBody*const* bodyBuffer, const PxTransform* poseBuffer, const PxU32 count) = 0;
+00908 
+00909     virtual ~PxSimulationEventCallback() {}
+00910     };
+00911 
+00912 #if !PX_DOXYGEN
+00913 } // namespace physx
+00914 #endif
+00915 
+00917 #endif
+