PxContact.h

Go to the documentation of this file.

/*
 * Copyright (c) 2008-2015, NVIDIA CORPORATION.  All rights reserved.
 *
 * NVIDIA CORPORATION and its licensors retain all intellectual property
 * and proprietary rights in and to this software, related documentation
 * and any modifications thereto.  Any use, reproduction, disclosure or
 * distribution of this software and related documentation without an express
 * license agreement from NVIDIA CORPORATION is strictly prohibited.
 */
// Copyright (c) 2004-2008 AGEIA Technologies, Inc. All rights reserved.
// Copyright (c) 2001-2004 NovodeX AG. All rights reserved.  


#ifndef PX_CONTACT_H
#define PX_CONTACT_H

#include "foundation/PxVec3.h"

#ifndef PX_DOXYGEN
namespace physx
{
#endif

#ifdef PX_VC
#pragma warning(push)
#pragma warning(disable: 4324)  // Padding was added at the end of a structure because of a __declspec(align) value.
#endif

#define PXC_CONTACT_NO_FACE_INDEX 0xffffffff


struct PxContactHeader
{
    enum PxContactHeaderFlags
    {
        eHAS_FACE_INDICES = 1,              
        eMODIFIABLE = 2,                    
        eFORCE_NO_RESPONSE = 4,             
        eHAS_MODIFIED_MASS_RATIOS = 8,      
        eHAS_TARGET_VELOCITY = 16,          
        eHAS_MAX_IMPULSE = 32               
    };
    PxU16 totalContactCount;        //2
    PxU16 flags;                    //4
};

struct PxModifyContactHeader : public PxContactHeader
{
    PxReal invMassScale0;           //8
    PxReal invMassScale1;           //12
    PxReal invInertiaScale0;        //16
    PxReal invInertiaScale1;        //20
};

struct PxContactPatchBase
{
    PxU16   nbContacts;             //2
    PxU16   flags;                  //4
};

struct PxContactPatch : public PxContactPatchBase
{
    PxVec3  normal;                 //16
    PxReal  staticFriction;         //20
    PxReal  dynamicFriction;        //24
    PxReal  restitution;            //28
    PxU16   materialIndex0;         //30
    PxU16   materialIndex1;         //32
};

struct PxSimpleContact
{
    PxVec3  contact;                //12
    PxReal  separation;             //16
};

struct PxFeatureContact : public PxSimpleContact
{   
    PxU32   internalFaceIndex0;     //20
    PxU32   internalFaceIndex1;     //24
};

struct PxModifiableContact : public PxFeatureContact
{
    PxVec3  normal;                 //36
    PxVec3  targetVel;              //48
    PxReal  maxImpulse;             //52
    PxReal  staticFriction;         //56
    PxReal  dynamicFriction;        //60
    PxReal  restitution;            //64
    PxU16   materialIndex0;         //66
    PxU16   materialIndex1;         //68
    PxU32   flags;                  //72
};

struct PxContactStreamIterator
{
    PxVec3 zero;
    const PxContactHeader* header;
    const PxU8* currPtr;
    const PxU8* endPtr;
    const PxU8* patchStart;
    const PxU8* patchEnd;
    const PxSimpleContact* contactStart;
    PxU32 streamSize;
    PxU32 nbContactsInPatch;
    PxU32 currentContact;
    PxU32 contactPatchHeaderSize;
    PxU32 contactPointSize;
    PxU32 hasFaceIndices;
    PxU32 contactsWereModifiable;
    PxU32 forceNoResponse;

    PX_FORCE_INLINE PxContactStreamIterator(const PxU8* stream, PxU32 size) 
        : zero(0.f), streamSize(size), nbContactsInPatch(0), currentContact(0)
    {       
        const PxContactHeader* h = reinterpret_cast<const PxContactHeader*>(stream);
        header = h;     

        bool modify = false;
        bool faceIndices = false;
        bool response = false;

        PxU32 pointSize = 0;
        PxU32 patchHeaderSize = 0;
        const PxU8* start = NULL;

        if(size > 0)
        {
            modify = (h->flags & PxContactHeader::eMODIFIABLE) != 0;
            faceIndices = (h->flags & PxContactHeader::eHAS_FACE_INDICES) != 0;

            start = stream + (modify ? sizeof(PxModifyContactHeader) : sizeof(PxContactHeader));


            PX_ASSERT(((PxU32)(start - stream)) < size);
            //if(((PxU32)(start - stream)) < size)
            {
                patchHeaderSize = modify ? sizeof(PxContactPatchBase) : sizeof(PxContactPatch);
                pointSize = modify ?  sizeof(PxModifiableContact) : faceIndices ? sizeof(PxFeatureContact) : sizeof(PxSimpleContact);

                response = (header->flags & PxContactHeader::eFORCE_NO_RESPONSE) == 0;
            }
        }

        contactsWereModifiable = (PxU32)modify;
        hasFaceIndices = (PxU32)faceIndices;
        forceNoResponse = (PxU32)!response;

        contactPatchHeaderSize = patchHeaderSize;
        contactPointSize = pointSize;

        patchStart = start;
        patchEnd = start;
        currPtr = start;
    }

    PX_FORCE_INLINE bool hasNextPatch() const
    {
        return ((PxU32)(patchEnd - reinterpret_cast<const PxU8*>(header))) < streamSize;
    }

    PX_FORCE_INLINE PxU32 getTotalContactCount() const
    {
        return header->totalContactCount;
    }

    PX_INLINE void nextPatch()
    {
        const PxU8* start = patchEnd;
        patchStart = start;

        if(((PxU32)(start - (reinterpret_cast<const PxU8*>(header)))) < streamSize)
        {
            const PxU32 numContactsInPatch = *(reinterpret_cast<const PxU16*>(patchStart));
            nbContactsInPatch = numContactsInPatch;

            patchEnd = start + contactPatchHeaderSize + numContactsInPatch * contactPointSize;
            currPtr = start + contactPatchHeaderSize;
            currentContact = 0;
        }
        else
        {
            patchEnd = start;
        }
    }

    PX_FORCE_INLINE bool hasNextContact() const
    {
        return currentContact < nbContactsInPatch;
    }

    PX_FORCE_INLINE void nextContact()
    {
        PX_ASSERT(currentContact < nbContactsInPatch);
        currentContact++;
        contactStart = reinterpret_cast<const PxSimpleContact*>(currPtr);
        currPtr += contactPointSize;
    }

    PX_FORCE_INLINE const PxVec3& getContactNormal() const
    {
        return contactsWereModifiable ? getModifiableContact().normal : getContactPatch().normal;
    }

    PX_FORCE_INLINE PxReal getInvMassScale0() const
    {
        return contactsWereModifiable ? getModifiableContactHeader().invMassScale0 : 1.f;
    }

    PX_FORCE_INLINE PxReal getInvMassScale1() const
    {
        return contactsWereModifiable ? getModifiableContactHeader().invMassScale1 : 1.f;
    }

    PX_FORCE_INLINE PxReal getInvInertiaScale0() const
    {
        return contactsWereModifiable ? getModifiableContactHeader().invInertiaScale0 : 1.f;
    }

    PX_FORCE_INLINE PxReal getInvInertiaScale1() const
    {
        return contactsWereModifiable ? getModifiableContactHeader().invInertiaScale1 : 1.f;
    }

    PX_FORCE_INLINE PxReal getMaxImpulse() const
    {
        return contactsWereModifiable ? getModifiableContact().maxImpulse : PX_MAX_REAL;
    }

    PX_FORCE_INLINE const PxVec3& getTargetVel() const
    {
        return contactsWereModifiable ? getModifiableContact().targetVel : zero;
    }

    PX_FORCE_INLINE const PxVec3& getContactPoint() const
    {
        return contactStart->contact;
    }

    PX_FORCE_INLINE PxReal getSeparation() const
    {
        return contactStart->separation;
    }

    PX_FORCE_INLINE PxU32 getFaceIndex0() const
    {
        return hasFaceIndices ? (static_cast<const PxFeatureContact*>(contactStart))->internalFaceIndex0 : PXC_CONTACT_NO_FACE_INDEX;
    }

    PX_FORCE_INLINE PxU32 getFaceIndex1() const
    {
        return hasFaceIndices ? (static_cast<const PxFeatureContact*>(contactStart))->internalFaceIndex1 : PXC_CONTACT_NO_FACE_INDEX;
    }

    PX_FORCE_INLINE PxReal getStaticFriction() const
    {
        return contactsWereModifiable ? getModifiableContact().staticFriction : getContactPatch().staticFriction;
    }

    PX_FORCE_INLINE PxReal getDynamicFriction() const
    {
        return contactsWereModifiable ? getModifiableContact().dynamicFriction : getContactPatch().dynamicFriction;
    }

    PX_FORCE_INLINE PxReal getRestitution() const
    {
        return contactsWereModifiable ? getModifiableContact().restitution : getContactPatch().restitution;
    }

    PX_FORCE_INLINE PxU32 getMaterialFlags() const
    {
        return contactsWereModifiable ? getModifiableContact().flags : getContactPatch().flags;
    }

    PX_FORCE_INLINE PxU16 getMaterialIndex0() const
    {
        return contactsWereModifiable ? getModifiableContact().materialIndex0 : getContactPatch().materialIndex0;
    }

    PX_FORCE_INLINE PxU16 getMaterialIndex1() const
    {
        return contactsWereModifiable ? getModifiableContact().materialIndex1 : getContactPatch().materialIndex1;
    }

    bool advanceToIndex(const PxU32 initialIndex)
    {
        PX_ASSERT(currPtr == (reinterpret_cast<const PxU8*>(header + 1)));
    
        PxU32 numToAdvance = initialIndex;

        if(numToAdvance == 0)
        {
            PX_ASSERT(hasNextPatch());
            nextPatch();
            return true;
        }
        
        while(numToAdvance)
        {
            while(hasNextPatch())
            {
                nextPatch();
                PxU32 patchSize = nbContactsInPatch;
                if(numToAdvance <= patchSize)
                {
                    while(hasNextContact())
                    {
                        --numToAdvance;
                        if(numToAdvance == 0)
                            return true;
                        nextContact();
                    }
                }
                else
                {
                    numToAdvance -= patchSize;
                }
            }
        }
        return false;
    }

private:

    PX_FORCE_INLINE const PxContactPatch& getContactPatch() const
    {
        PX_ASSERT(!contactsWereModifiable);
        return *reinterpret_cast<const PxContactPatch*>(patchStart);
    }

    PX_FORCE_INLINE const PxModifiableContact& getModifiableContact() const
    {
        PX_ASSERT(contactsWereModifiable);
        return *static_cast<const PxModifiableContact*>(contactStart);
    }

    PX_FORCE_INLINE const PxModifyContactHeader& getModifiableContactHeader() const
    {
        PX_ASSERT(contactsWereModifiable);
        return *static_cast<const PxModifyContactHeader*>(header);
    }

};


#ifdef PX_VC
#pragma warning(pop)
#endif

#ifndef PX_DOXYGEN
} // namespace physx
#endif

#endif