PxSimulationStatistics.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_SIMULATION_STATISTICS
#define PX_SIMULATION_STATISTICS

#include "PxPhysXConfig.h"
#include "geometry/PxGeometry.h"

#ifndef PX_DOXYGEN
namespace physx
{
#endif

class PxSimulationStatistics
{
public:
    enum VolumeType
    {
        eRIGID_BODY,

        ePARTICLE_SYSTEM,

        eCLOTH,

        eVOLUME_COUNT
    };

    enum RbPairStatsType
    {
        eDISCRETE_CONTACT_PAIRS,

        eCCD_PAIRS,

        eMODIFIED_CONTACT_PAIRS,

        eTRIGGER_PAIRS
    };


//objects:
    PxU32   nbActiveConstraints;

    PxU32   nbActiveDynamicBodies;

    PxU32   nbActiveKinematicBodies;

    PxU32   nbStaticBodies;

    PxU32   nbDynamicBodies;

    PxU32   nbShapes[PxGeometryType::eGEOMETRY_COUNT];

//solver:
    PxU32   nbAxisSolverConstraints;

    PxU32   compressedContactSize;

    PxU32   requiredContactConstraintMemory;

    PxU32   peakConstraintMemory;

//broadphase:
    PxU32 getNbBroadPhaseAdds(VolumeType type) const
    {
        if (type != eVOLUME_COUNT)
            return nbBroadPhaseAdds[type];
        else
        {
            PX_ASSERT(false);
            return 0;
        }
    }

    PxU32 getNbBroadPhaseRemoves(VolumeType type) const
    {
        if (type != eVOLUME_COUNT)
            return nbBroadPhaseRemoves[type];
        else
        {
            PX_ASSERT(false);
            return 0;
        }
    }

//collisions:
    PxU32 getRbPairStats(RbPairStatsType pairType, PxGeometryType::Enum g0, PxGeometryType::Enum g1) const
    {
        if (g0 >= PxGeometryType::eGEOMETRY_COUNT || g1 >= PxGeometryType::eGEOMETRY_COUNT)
        {
            PX_ASSERT(false);
            return 0;
        }

        switch(pairType)
        {
            case eDISCRETE_CONTACT_PAIRS:
                return nbDiscreteContactPairs[g0][g1];

            case eCCD_PAIRS:
                return nbCCDPairs[g0][g1];

            case eMODIFIED_CONTACT_PAIRS:
                return nbModifiedContactPairs[g0][g1];

            case eTRIGGER_PAIRS:
                return nbTriggerPairs[g0][g1];

            default:
                PX_ASSERT(false);
                return 0;
        }
    }

    PxSimulationStatistics()
    {
        for(PxU32 i=0; i < eVOLUME_COUNT; i++)
        {
            nbBroadPhaseAdds[i] = 0;
            nbBroadPhaseRemoves[i] = 0;
        }

        for(PxU32 i=0; i < PxGeometryType::eGEOMETRY_COUNT; i++)
        {
            for(PxU32 j=0; j < PxGeometryType::eGEOMETRY_COUNT; j++)
            {
                nbDiscreteContactPairs[i][j] = 0;
                nbModifiedContactPairs[i][j] = 0;
                nbCCDPairs[i][j] = 0;
                nbTriggerPairs[i][j] = 0;
            }
        }

        for(PxU32 i=0; i < PxGeometryType::eGEOMETRY_COUNT; i++)
        {
            nbShapes[i] = 0;
        }

        totalDiscreteContactPairsAnyShape = 0;

        nbActiveConstraints = 0;
        nbActiveDynamicBodies = 0;
        nbActiveKinematicBodies = 0;
        nbStaticBodies = 0;
        nbDynamicBodies = 0;
        compressedContactSize = 0;
        requiredContactConstraintMemory = 0;
        peakConstraintMemory = 0;

        nbAxisSolverConstraints = 0;

        particlesGpuMeshCacheSize = 0;
        particlesGpuMeshCacheUsed = 0;
        particlesGpuMeshCacheHitrate = 0.0f;
    }


    //
    // We advise to not access these members directly. Use the provided accessor methods instead.
    //
//broadphase:
    PxU32   nbBroadPhaseAdds[eVOLUME_COUNT];
    PxU32   nbBroadPhaseRemoves[eVOLUME_COUNT];

//collisions:
    PxU32   nbDiscreteContactPairs[PxGeometryType::eGEOMETRY_COUNT][PxGeometryType::eGEOMETRY_COUNT];
    PxU32   nbCCDPairs[PxGeometryType::eGEOMETRY_COUNT][PxGeometryType::eGEOMETRY_COUNT];
    PxU32   nbModifiedContactPairs[PxGeometryType::eGEOMETRY_COUNT][PxGeometryType::eGEOMETRY_COUNT];
    PxU32   nbTriggerPairs[PxGeometryType::eGEOMETRY_COUNT][PxGeometryType::eGEOMETRY_COUNT];
    PxU32   totalDiscreteContactPairsAnyShape;

//triangle mesh cache statistics
    PxU32   particlesGpuMeshCacheSize;
    PxU32   particlesGpuMeshCacheUsed;
    PxReal  particlesGpuMeshCacheHitrate;
};

#ifndef PX_DOXYGEN
} // namespace physx
#endif

#endif