PxSceneDesc.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_PHYSICS_NX_SCENEDESC
#define PX_PHYSICS_NX_SCENEDESC

#include "PxPhysXConfig.h"
#include "foundation/PxFlags.h"
#include "foundation/PxBounds3.h"
#include "PxFiltering.h"
#include "PxBroadPhase.h"
#include "common/PxTolerancesScale.h"

#ifndef PX_DOXYGEN
namespace physx
{
#endif

class PxCpuDispatcher;
class PxGpuDispatcher;
class PxSpuDispatcher;

struct PxPruningStructure
{
    enum Enum
    {
        eNONE,                  
        eDYNAMIC_AABB_TREE,     
        eSTATIC_AABB_TREE,      

        eLAST
    };
};


struct PxSimulationOrder
{
    enum Enum
    {
        eCOLLIDE_SOLVE,     
        eSOLVE_COLLIDE      
    };
};



    struct PxFrictionType
    {
        enum Enum
        {
            ePATCH,             
            eONE_DIRECTIONAL,   
            eTWO_DIRECTIONAL    
        };
    };

struct PxSceneFlag
{
    enum Enum
    {
        eENABLE_ACTIVETRANSFORMS    =(1<<1),

        eENABLE_CCD =(1<<2),

        eDISABLE_CCD_RESWEEP    =(1<<3),


        eADAPTIVE_FORCE             =(1<<4),


        eENABLE_KINEMATIC_STATIC_PAIRS =(1<<5),


        eENABLE_KINEMATIC_PAIRS =(1<<6),


        eENABLE_PCM = (1 << 9),

        eDISABLE_CONTACT_REPORT_BUFFER_RESIZE   = (1 << 10),

        eDISABLE_CONTACT_CACHE  = (1 << 11),


        eREQUIRE_RW_LOCK = (1 << 12),

        eENABLE_STABILIZATION = (1 << 14),

        eENABLE_AVERAGE_POINT = (1 << 15)

    };
};

typedef PxFlags<PxSceneFlag::Enum,PxU16> PxSceneFlags;
PX_FLAGS_OPERATORS(PxSceneFlag::Enum,PxU16)


class PxSimulationEventCallback;
class PxContactModifyCallback;
class PxCCDContactModifyCallback;
class PxSimulationFilterCallback;

class PxSceneLimits
{
public:
    PxU32                   maxNbActors;            
    PxU32                   maxNbBodies;            
    PxU32                   maxNbStaticShapes;      
    PxU32                   maxNbDynamicShapes;     
    PxU32                   maxNbAggregates;        
    PxU32                   maxNbConstraints;       
    PxU32                   maxNbRegions;           
    PxU32                   maxNbObjectsPerRegion;  

    PX_INLINE PxSceneLimits();

    PX_INLINE void setToDefault();

    PX_INLINE bool isValid() const;
};

PX_INLINE PxSceneLimits::PxSceneLimits()    //constructor sets to default
{
    maxNbActors         = 0;
    maxNbBodies         = 0;
    maxNbStaticShapes   = 0;
    maxNbDynamicShapes  = 0;
    maxNbAggregates     = 0;
    maxNbConstraints    = 0;
    maxNbRegions        = 0;
    maxNbObjectsPerRegion = 0;
}

PX_INLINE void PxSceneLimits::setToDefault()
{
    *this = PxSceneLimits();
}

PX_INLINE bool PxSceneLimits::isValid() const   
{
    if(maxNbRegions>256)    // max number of regions is currently limited
        return false;

    return true;
}

class PxSceneDesc
{
public:

    PxVec3                  gravity;

    PxSimulationEventCallback*  simulationEventCallback;

    PxContactModifyCallback*    contactModifyCallback;

    PxCCDContactModifyCallback* ccdContactModifyCallback;

    const void*             filterShaderData;

    PxU32                   filterShaderDataSize;

    PxSimulationFilterShader    filterShader;

    PxSimulationFilterCallback* filterCallback;

    PxBroadPhaseType::Enum      broadPhaseType;

    PxBroadPhaseCallback*       broadPhaseCallback;

    PxSceneLimits               limits;

    PX_DEPRECATED PxReal        meshContactMargin;


    PxFrictionType::Enum frictionType;

    PX_DEPRECATED  PxReal   contactCorrelationDistance;

    PxReal bounceThresholdVelocity; 

    PxReal frictionOffsetThreshold;

    PxSceneFlags            flags;

    PxCpuDispatcher*    cpuDispatcher;

    PxGpuDispatcher*    gpuDispatcher;

    PxSpuDispatcher*    spuDispatcher;

    PxPruningStructure::Enum    staticStructure;

    PxPruningStructure::Enum    dynamicStructure;

    PxU32                   dynamicTreeRebuildRateHint;

    void*                   userData;

    PxU32                   solverBatchSize;

    PxU32                   nbContactDataBlocks;

    PxU32                   maxNbContactDataBlocks;

    PxU32                   contactReportStreamBufferSize;

    PxU32                   ccdMaxPasses;

    PxSimulationOrder::Enum     simulationOrder;

    PxReal                  wakeCounterResetValue;


    PxBounds3               sanityBounds;

private:
    // For internal use only
    PxTolerancesScale       tolerancesScale;
public:
    PX_INLINE PxSceneDesc(const PxTolerancesScale& scale);

    PX_INLINE void setToDefault(const PxTolerancesScale& scale);

    PX_INLINE bool isValid() const;

    // For internal use only
    PX_INLINE const PxTolerancesScale& getTolerancesScale() const { return tolerancesScale; }
};

PX_INLINE PxSceneDesc::PxSceneDesc(const PxTolerancesScale& scale):
    gravity                             (PxVec3(0.0f)),
    simulationEventCallback             (NULL),
    contactModifyCallback               (NULL),
    ccdContactModifyCallback            (NULL),

    filterShaderData                    (NULL),
    filterShaderDataSize                (0),
    filterShader                        (NULL),
    filterCallback                      (NULL),
    broadPhaseType                      (PxBroadPhaseType::eSAP),
    broadPhaseCallback                  (NULL),

    meshContactMargin                   (0.01f * scale.length),
    frictionType                        (PxFrictionType::ePATCH),
    contactCorrelationDistance          (0.025f * scale.length),
    bounceThresholdVelocity             (0.2f * scale.speed),
    frictionOffsetThreshold             (0.04f * scale.length),

    flags                               (0),

    cpuDispatcher                       (NULL),
    gpuDispatcher                       (NULL),
    spuDispatcher                       (NULL),

    staticStructure                     (PxPruningStructure::eDYNAMIC_AABB_TREE),
    dynamicStructure                    (PxPruningStructure::eDYNAMIC_AABB_TREE),
    dynamicTreeRebuildRateHint          (100),

    userData                            (NULL),

    solverBatchSize                     (32),

#ifdef PX_PS3
    nbContactDataBlocks                 (256),
#else
    nbContactDataBlocks                 (0),
#endif

    maxNbContactDataBlocks              (1<<16),
    contactReportStreamBufferSize       (8192),
    ccdMaxPasses                        (1),
    simulationOrder                     (PxSimulationOrder::eCOLLIDE_SOLVE),
    wakeCounterResetValue               (20.0f*0.02f),
    sanityBounds                        (PxBounds3(PxVec3(-PX_MAX_BOUNDS_EXTENTS, -PX_MAX_BOUNDS_EXTENTS, -PX_MAX_BOUNDS_EXTENTS),
                                                   PxVec3(PX_MAX_BOUNDS_EXTENTS, PX_MAX_BOUNDS_EXTENTS, PX_MAX_BOUNDS_EXTENTS))),
    tolerancesScale                     (scale)
{
}

PX_INLINE void PxSceneDesc::setToDefault(const PxTolerancesScale& scale)
{
    *this = PxSceneDesc(scale);
}

PX_INLINE bool PxSceneDesc::isValid() const
{
    if(filterShader == NULL)
        return false;

    if( ((filterShaderDataSize == 0) && (filterShaderData != NULL)) ||
        ((filterShaderDataSize > 0) && (filterShaderData == NULL)) )
        return false;

    if(!limits.isValid())
        return false;

    if(staticStructure!=PxPruningStructure::eSTATIC_AABB_TREE && staticStructure!=PxPruningStructure::eDYNAMIC_AABB_TREE)
        return false;

    if(dynamicTreeRebuildRateHint < 4)
        return false;

    if(meshContactMargin < 0.0f)
        return false;
    if(contactCorrelationDistance < 0.0f)
        return false;
    if(bounceThresholdVelocity < 0.0f)
        return false;
    if(frictionOffsetThreshold < 0.f)
        return false;

    if(cpuDispatcher == NULL)
        return false;

    if(contactReportStreamBufferSize == 0)
        return false;

    if(maxNbContactDataBlocks < nbContactDataBlocks)
        return false;

    if (wakeCounterResetValue <= 0.0f)
        return false;

#if !PX_ENABLE_INVERTED_STEPPER_FEATURE
    if (simulationOrder == PxSimulationOrder::eSOLVE_COLLIDE)
        return false;
#endif

    //Adaptive force and stabilization are incompatible. You can only have one or the other
    if((flags & (PxSceneFlag::eADAPTIVE_FORCE | PxSceneFlag::eENABLE_STABILIZATION)) == (PxSceneFlag::eADAPTIVE_FORCE | PxSceneFlag::eENABLE_STABILIZATION))
        return false;

    if(!sanityBounds.isValid())
        return false;

    return true;
}


#ifndef PX_DOXYGEN
} // namespace physx
#endif

#endif