---

       

---

PxSceneDesc.h

Go to the documentation of this file.

// This code contains NVIDIA Confidential Information and is disclosed to you
// under a form of NVIDIA software license agreement provided separately to you.
//
// Notice
// NVIDIA Corporation and its licensors retain all intellectual property and
// proprietary rights in and to this software and 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.
//
// ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
// NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
// THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
// MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
//
// Information and code furnished is believed to be accurate and reliable.
// However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
// information or for any infringement of patents or other rights of third parties that may
// result from its use. No license is granted by implication or otherwise under any patent
// or patent rights of NVIDIA Corporation. Details are subject to change without notice.
// This code supersedes and replaces all information previously supplied.
// NVIDIA Corporation products are not authorized for use as critical
// components in life support devices or systems without express written approval of
// NVIDIA Corporation.
//
// Copyright (c) 2008-2016 NVIDIA Corporation. All rights reserved.
// 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"
#include "task/PxTask.h"

#if !PX_DOXYGEN
namespace physx
{
#endif

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

        eLAST
    };
};


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

struct PxSceneFlag
{
    enum Enum
    {
        eENABLE_ACTIVE_ACTORS   = (1<<0),

        eENABLE_ACTIVETRANSFORMS    PX_DEPRECATED = (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),

        eDEPRECATED_TRIGGER_TRIGGER_REPORTS = (1 << 16),

        eEXCLUDE_KINEMATICS_FROM_ACTIVE_ACTORS = (1 << 17),

        eSUPPRESS_EAGER_SCENE_QUERY_REFIT = (1 << 18),

        /*\brief Enables the GPU dynamics pipeline

        When set to true, a CUDA 2.0 or above-enabled NVIDIA GPU is present and the GPU dispatcher has been configured, this will run the GPU dynamics pipelin instead of the CPU dynamics pipeline.

        Note that this flag is not mutable and must be set in PxSceneDesc at scene creation.

        */

        eENABLE_GPU_DYNAMICS = (1 << 19),

        eENABLE_ENHANCED_DETERMINISM = (1<<20),

        eMUTABLE_FLAGS = eENABLE_ACTIVE_ACTORS|eENABLE_ACTIVETRANSFORMS|eEXCLUDE_KINEMATICS_FROM_ACTIVE_ACTORS
    };
};


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


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       maxNbBroadPhaseOverlaps;    
    PX_DEPRECATED   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),
    maxNbBroadPhaseOverlaps (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;
}

//#if PX_SUPPORT_GPU_PHYSX
struct PxgDynamicsMemoryConfig
{
    PxU32 constraintBufferCapacity; 
    PxU32 contactBufferCapacity;    
    PxU32 tempBufferCapacity;       
    PxU32 contactStreamSize;        
    PxU32 patchStreamSize;          
    PxU32 forceStreamCapacity;      
    PxU32 heapCapacity;             
    PxU32 foundLostPairsCapacity;   


    PxgDynamicsMemoryConfig() :
        constraintBufferCapacity(32 * 1024 * 1024),
        contactBufferCapacity(24 * 1024 * 1024),
        tempBufferCapacity(16 * 1024 * 1024),
        contactStreamSize(1024 * 512),
        patchStreamSize(1024 * 80),
        forceStreamCapacity(1 * 1024 * 1024),
        heapCapacity(64 * 1024 * 1024),
        foundLostPairsCapacity(256 * 1024)
    {
    }
};

//#endif

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;


    PxFrictionType::Enum frictionType;

    PxReal bounceThresholdVelocity; 

    PxReal frictionOffsetThreshold;

    PxReal ccdMaxSeparation;

    PxSceneFlags            flags;

    PxCpuDispatcher*        cpuDispatcher;

    PxGpuDispatcher*        gpuDispatcher;

    PxPruningStructureType::Enum    staticStructure;

    PxPruningStructureType::Enum    dynamicStructure;

    PxU32                   dynamicTreeRebuildRateHint;

    void*                   userData;

    PxU32                   solverBatchSize;

    PxU32                   nbContactDataBlocks;

    PxU32                   maxNbContactDataBlocks;

    PxU32                   contactReportStreamBufferSize;

    PxU32                   ccdMaxPasses;


    PxReal                  wakeCounterResetValue;


    PxBounds3               sanityBounds;


    PxgDynamicsMemoryConfig gpuDynamicsConfig;

    PxU32                   gpuMaxNumPartitions;

    PxU32                   gpuComputeVersion;



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),

    frictionType                        (PxFrictionType::ePATCH),
    bounceThresholdVelocity             (0.2f * scale.speed),
    frictionOffsetThreshold             (0.04f * scale.length),
    ccdMaxSeparation                    (0.04f * scale.length),

    flags                               (PxSceneFlag::eENABLE_PCM),

    cpuDispatcher                       (NULL),
    gpuDispatcher                       (NULL),

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

    userData                            (NULL),

    solverBatchSize                     (128),

    nbContactDataBlocks                 (0),
    maxNbContactDataBlocks              (1<<16),
    contactReportStreamBufferSize       (8192),
    ccdMaxPasses                        (1),
    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))),
#if PX_SUPPORT_GPU_PHYSX
    gpuMaxNumPartitions                 (8),
    gpuComputeVersion                   (0),
#endif
    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!=PxPruningStructureType::eSTATIC_AABB_TREE && staticStructure!=PxPruningStructureType::eDYNAMIC_AABB_TREE)
        return false;

    if(dynamicTreeRebuildRateHint < 4)
        return false;

    if(bounceThresholdVelocity < 0.0f)
        return false;
    if(frictionOffsetThreshold < 0.f)
        return false;
    if (ccdMaxSeparation < 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;

    //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;

#if PX_SUPPORT_GPU_PHYSX
    //gpuMaxNumPartitions must be power of 2
    if ((gpuMaxNumPartitions&(gpuMaxNumPartitions - 1)) != 0)
        return false;
#endif

    return true;
}


#if !PX_DOXYGEN
} // namespace physx
#endif

#endif

---

Copyright © 2008-2016 NVIDIA Corporation, 2701 San Tomas Expressway, Santa Clara, CA 95050 U.S.A. All rights reserved. www.nvidia.com