PxSceneDesc.h

Go to the documentation of this file.

//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions
// are met:
//  * Redistributions of source code must retain the above copyright
//    notice, this list of conditions and the following disclaimer.
//  * Redistributions in binary form must reproduce the above copyright
//    notice, this list of conditions and the following disclaimer in the
//    documentation and/or other materials provided with the distribution.
//  * Neither the name of NVIDIA CORPORATION nor the names of its
//    contributors may be used to endorse or promote products derived
//    from this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``AS IS'' AND ANY
// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
// PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR
// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
// OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
// Copyright (c) 2008-2018 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 PxSceneQueryUpdateMode
{
    enum Enum
    {
        eBUILD_ENABLED_COMMIT_ENABLED,      
        eBUILD_ENABLED_COMMIT_DISABLED,     
        eBUILD_DISABLED_COMMIT_DISABLED     
    };
};


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


struct PxSolverType
{
    enum Enum
    {
        ePGS,           
        eTGS            
    };
};


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

        eENABLE_CCD = (1<<1),

        eDISABLE_CCD_RESWEEP    = (1<<2),

        eADAPTIVE_FORCE         = (1<<3),

        eENABLE_KINEMATIC_STATIC_PAIRS  PX_DEPRECATED = (1<<4),

        eENABLE_KINEMATIC_PAIRS PX_DEPRECATED = (1<<5),

        eENABLE_PCM = (1 << 6),

        eDISABLE_CONTACT_REPORT_BUFFER_RESIZE   = (1 << 7),

        eDISABLE_CONTACT_CACHE  = (1 << 8),

        eREQUIRE_RW_LOCK = (1 << 9),

        eENABLE_STABILIZATION = (1 << 10),

        eENABLE_AVERAGE_POINT = (1 << 11),

        eEXCLUDE_KINEMATICS_FROM_ACTIVE_ACTORS = (1 << 12),

        /*\brief Enables the GPU dynamics pipeline

        When set to true, a CUDA ARCH 3.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 << 13),

        eENABLE_ENHANCED_DETERMINISM = (1<<14),

        eENABLE_FRICTION_EVERY_ITERATION = (1 << 15),

        eMUTABLE_FLAGS = eENABLE_ACTIVE_ACTORS|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_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)
{
}

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;

    PxPairFilteringMode::Enum       kineKineFilteringMode;

    PxPairFilteringMode::Enum       staticKineFilteringMode;

    PxBroadPhaseType::Enum      broadPhaseType;

    PxBroadPhaseCallback*       broadPhaseCallback;

    PxSceneLimits               limits;

    PxFrictionType::Enum frictionType;

    PxSolverType::Enum          solverType;

    PxReal bounceThresholdVelocity; 

    PxReal frictionOffsetThreshold;

    PxReal ccdMaxSeparation;

    PxReal solverOffsetSlop;

    PxSceneFlags            flags;

    PxCpuDispatcher*        cpuDispatcher;

    PxGpuDispatcher*        gpuDispatcher;

    PxPruningStructureType::Enum    staticStructure;

    PxPruningStructureType::Enum    dynamicStructure;

    PxU32                   dynamicTreeRebuildRateHint;

    PxSceneQueryUpdateMode::Enum sceneQueryUpdateMode;

    void*                   userData;

    PxU32                   solverBatchSize;

    PxU32                   nbContactDataBlocks;

    PxU32                   maxNbContactDataBlocks;

    PxReal                  maxBiasCoefficient;

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

    kineKineFilteringMode               (PxPairFilteringMode::eDEFAULT),
    staticKineFilteringMode             (PxPairFilteringMode::eDEFAULT),

    broadPhaseType                      (PxBroadPhaseType::eABP),
    broadPhaseCallback                  (NULL),

    frictionType                        (PxFrictionType::ePATCH),
    solverType                          (PxSolverType::ePGS),
    bounceThresholdVelocity             (0.2f * scale.speed),
    frictionOffsetThreshold             (0.04f * scale.length),
    ccdMaxSeparation                    (0.04f * scale.length),
    solverOffsetSlop                    (0.0f),

    flags                               (PxSceneFlag::eENABLE_PCM),

    cpuDispatcher                       (NULL),
    gpuDispatcher                       (NULL),

    staticStructure                     (PxPruningStructureType::eDYNAMIC_AABB_TREE),
    dynamicStructure                    (PxPruningStructureType::eDYNAMIC_AABB_TREE),
    dynamicTreeRebuildRateHint          (100),
    sceneQueryUpdateMode                (PxSceneQueryUpdateMode::eBUILD_ENABLED_COMMIT_ENABLED),

    userData                            (NULL),

    solverBatchSize                     (128),

    nbContactDataBlocks                 (0),
    maxNbContactDataBlocks              (1<<16),
    maxBiasCoefficient                  (PX_MAX_F32),
    contactReportStreamBufferSize       (8192),
    ccdMaxPasses                        (1),
    wakeCounterResetValue               (20.0f*0.02f),
    sanityBounds                        (PxBounds3(PxVec3(-PX_MAX_BOUNDS_EXTENTS), PxVec3(PX_MAX_BOUNDS_EXTENTS))),
    gpuMaxNumPartitions                 (8),
    gpuComputeVersion                   (0),
    tolerancesScale                     (scale)
{
}

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

PX_INLINE bool PxSceneDesc::isValid() const
{
    if(!filterShader)
        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.0f)
        return false;
    if(ccdMaxSeparation < 0.0f)
        return false;
    if (solverOffsetSlop < 0.f)
        return false;

    if(!cpuDispatcher)
        return false;

    if(!contactReportStreamBufferSize)
        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;
    if (gpuMaxNumPartitions > 32)
        return false;
#endif

    return true;
}


#if !PX_DOXYGEN
} // namespace physx
#endif

#endif