DyContext.h

// 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-2022 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 DY_CONTEXT_H
#define DY_CONTEXT_H
 
#include "PxSceneDesc.h"
#include "DyThresholdTable.h"
#include "PxcNpThreadContext.h"
#include "PxsSimulationController.h"
#include "DyConstraintWriteBack.h"
#include "foundation/PxAllocator.h"
 
#define DY_MAX_VELOCITY_COUNT 4
 
namespace physx
{
 
class PxsIslandManager;
class PxcNpMemBlockPool;
 
namespace Cm
{
    class EventProfiler;
    class FlushPool;
}
 
namespace IG
{
    class SimpleIslandManager;
    class IslandSim;
}
 
template<typename T, typename P> class PxcThreadCoherentCache;
class PxcScratchAllocator;
struct PxvSimStats;
class PxTaskManager;
class PxsContactManagerOutputIterator;
struct PxsContactManagerOutput;
class PxsContactManager;
struct PxsContactManagerOutputCounts;
 
class PxvNphaseImplementationContext;
 
 
namespace Dy
{
 
 
class Context
{
    PX_NOCOPY(Context)
public:
 
    // PT: TODO: consider making all of these public at this point
    PX_FORCE_INLINE PxReal              getMaxBiasCoefficient()         const   { return mMaxBiasCoefficient;   }
    PX_FORCE_INLINE void                setMaxBiasCoefficient(PxReal coeff)     { mMaxBiasCoefficient = coeff;  }
 
    PX_FORCE_INLINE PxReal              getBounceThreshold()            const   { return mBounceThreshold;  }
    PX_FORCE_INLINE PxReal              getFrictionOffsetThreshold()    const   { return mFrictionOffsetThreshold;  }
    PX_FORCE_INLINE PxReal              getCorrelationDistance()        const   { return mCorrelationDistance;  }
 
    PX_FORCE_INLINE PxReal              getCCDSeparationThreshold()     const   { return mCCDSeparationThreshold; }
 
    PX_FORCE_INLINE PxReal              getLengthScale()                const   { return mLengthScale; }
 
    PX_FORCE_INLINE void                setBounceThreshold(PxReal f)            { mBounceThreshold = f;     }
    PX_FORCE_INLINE void                setCorrelationDistance(PxReal f)            { mCorrelationDistance = f;     }
    PX_FORCE_INLINE void                setFrictionOffsetThreshold(PxReal offset)       { mFrictionOffsetThreshold = offset;                }
 
    PX_FORCE_INLINE void                setCCDSeparationThreshold(PxReal offset)        { mCCDSeparationThreshold = offset; }
 
    PX_FORCE_INLINE PxU32               getSolverBatchSize()                const   { return mSolverBatchSize;  }
    PX_FORCE_INLINE void                setSolverBatchSize(PxU32 f)             { mSolverBatchSize = f;     }
 
    PX_FORCE_INLINE PxU32               getSolverArticBatchSize()               const { return mSolverArticBatchSize; }
    PX_FORCE_INLINE void                setSolverArticBatchSize(PxU32 f) { mSolverArticBatchSize = f; }
 
    PX_FORCE_INLINE PxU32               getMaxSolverConstraintSize()    const   { return mMaxSolverConstraintSize; }
 
    PX_FORCE_INLINE PxFrictionType::Enum getFrictionType() const                { return mFrictionType; }
 
    PX_FORCE_INLINE ThresholdStream&    getThresholdStream()                    { return *mThresholdStream; }
 
    PX_FORCE_INLINE ThresholdStream&    getForceChangedThresholdStream()        { return *mForceChangedThresholdStream; }
 
    PX_FORCE_INLINE ThresholdTable&     getThresholdTable()                     { return mThresholdTable; }
 
    PX_FORCE_INLINE void                setFrictionType(PxFrictionType::Enum f)     { mFrictionType = f; }
 
    virtual void                        destroy() = 0;
 
    PX_FORCE_INLINE PxcDataStreamPool&              getContactStreamPool()                      { return mContactStreamPool;    }
 
    PX_FORCE_INLINE PxcDataStreamPool&              getPatchStreamPool()                        { return mPatchStreamPool;  }
 
    PX_FORCE_INLINE PxcDataStreamPool&              getForceStreamPool()                        { return mForceStreamPool;  }
 
    PX_FORCE_INLINE PxPinnedArray<Dy::ConstraintWriteback>&     getConstraintWriteBackPool()            { return mConstraintWriteBackPool;  }
 
    PX_FORCE_INLINE PxReal                  getDt()                         const   { return mDt;               }
    PX_FORCE_INLINE PxReal                  getInvDt()                      const   { return mInvDt;            }
 
    PX_FORCE_INLINE PxVec3                  getGravity()                    const   { return mGravity;          }
 
    virtual void                        update(IG::SimpleIslandManager& simpleIslandManager, PxBaseTask* continuation, PxBaseTask* processLostTouchTask,
        PxvNphaseImplementationContext* nPhaseContext, const PxU32 maxPatchesPerCM, const PxU32 maxArticulationLinks, const PxReal dt, const PxVec3& gravity, PxBitMapPinned& changedHandleMap) = 0;
 
    virtual void                        processLostPatches(IG::SimpleIslandManager& simpleIslandManager, PxsContactManager** lostPatchManagers, PxU32 nbLostPatchManagers, PxsContactManagerOutputCounts* outCounts) = 0;
    virtual void                        processFoundPatches(IG::SimpleIslandManager& simpleIslandManager, PxsContactManager** foundPatchManagers, PxU32 nbFoundPatchManagers, PxsContactManagerOutputCounts* outCounts) = 0;
 
 
    virtual void                        updateBodyCore(PxBaseTask* continuation) = 0;
 
    virtual void                        mergeResults() = 0;
 
    virtual void                        setSimulationController(PxsSimulationController* simulationController) = 0;
 
    virtual void                        getDataStreamBase(void*& contactStreamBase, void*& patchStreamBase, void*& forceAndIndiceStreamBase) = 0;
 
    virtual PxSolverType::Enum          getSolverType() const   = 0;
 
    void createThresholdStream(PxVirtualAllocatorCallback& callback)            { PX_ASSERT(!mThresholdStream); mThresholdStream = PX_NEW(ThresholdStream)(callback);   }
 
    void createForceChangeThresholdStream(PxVirtualAllocatorCallback& callback) { PX_ASSERT(!mForceChangedThresholdStream); mForceChangedThresholdStream = PX_NEW(ThresholdStream)(callback);   }
 
    //Forces any cached body state to be updated!
    void setStateDirty(bool dirty) { mBodyStateDirty = dirty; }
 
    bool isStateDirty() { return mBodyStateDirty;}
 
    void setSuppressReadback(bool suppressReadback) { mSuppressReadback = suppressReadback; }
 
    bool getSuppressReadback() { return mSuppressReadback; }
 
    void setDt(const PxReal dt) { mDt = dt; }
 
protected:
 
    Context(IG::SimpleIslandManager* islandManager, PxVirtualAllocatorCallback* allocatorCallback,
        PxvSimStats& simStats, bool enableStabilization, bool useEnhancedDeterminism,
        const PxReal maxBiasCoefficient, const PxReal lengthScale) :
        mThresholdStream            (NULL),
        mForceChangedThresholdStream(NULL),     
        mIslandManager              (islandManager),
        mDt                         (1.0f), 
        mInvDt                      (1.0f),
        mMaxBiasCoefficient         (maxBiasCoefficient),
        mEnableStabilization        (enableStabilization),
        mUseEnhancedDeterminism     (useEnhancedDeterminism),
        mBounceThreshold            (-2.0f),
        mLengthScale                (lengthScale),
        mSolverBatchSize            (32),
        mConstraintWriteBackPool    (PxVirtualAllocator(allocatorCallback)),
        mSimStats                   (simStats),
        mBodyStateDirty             (false),
        mSuppressReadback           (false)
        {
        }
 
    virtual ~Context() 
    { 
        PX_DELETE(mThresholdStream);
        PX_DELETE(mForceChangedThresholdStream);
    }
 
    ThresholdStream*                        mThresholdStream;
    ThresholdStream*                        mForceChangedThresholdStream;
    ThresholdTable                          mThresholdTable;
 
    IG::SimpleIslandManager*                mIslandManager;
    PxsSimulationController*                mSimulationController;
    PxReal                      mDt;
    PxReal                      mInvDt;
 
    PxReal                      mMaxBiasCoefficient;
 
    const bool                  mEnableStabilization;
 
    const bool                  mUseEnhancedDeterminism;
 
    PxVec3                      mGravity;
    PxU32                       mMaxSolverConstraintSize;
 
    PxReal                      mBounceThreshold;
    PxReal                      mFrictionOffsetThreshold;
 
    PxReal                      mCCDSeparationThreshold;
 
    PxReal                      mCorrelationDistance;
 
 
    PxReal                      mLengthScale;
 
    PxU32                       mSolverBatchSize;
 
    PxU32                       mSolverArticBatchSize;
 
 
    PxFrictionType::Enum        mFrictionType;
 
    PxcDataStreamPool       mContactStreamPool;
 
    PxcDataStreamPool       mPatchStreamPool;
 
    PxcDataStreamPool       mForceStreamPool;
    
    PxPinnedArray<Dy::ConstraintWriteback>  mConstraintWriteBackPool;
 
    PxvSimStats& mSimStats;
 
    bool mBodyStateDirty;
    bool mSuppressReadback;
};
 
Context* createDynamicsContext( PxcNpMemBlockPool* memBlockPool,
                                PxcScratchAllocator& scratchAllocator, Cm::FlushPool& taskPool,
                                PxvSimStats& simStats, PxTaskManager* taskManager, PxVirtualAllocatorCallback* allocatorCallback, PxsMaterialManager* materialManager,
                                IG::SimpleIslandManager* islandManager, PxU64 contextID,
                                const bool enableStabilization, const bool useEnhancedDeterminism, const PxReal maxBiasCoefficient,
                                const bool frictionEveryIteration, const PxReal lengthScale
                                );
 
Context* createTGSDynamicsContext(PxcNpMemBlockPool* memBlockPool,
    PxcScratchAllocator& scratchAllocator, Cm::FlushPool& taskPool,
    PxvSimStats& simStats, PxTaskManager* taskManager, PxVirtualAllocatorCallback* allocatorCallback, PxsMaterialManager* materialManager,
    IG::SimpleIslandManager* islandManager, PxU64 contextID,
    const bool enableStabilization, const bool useEnhancedDeterminism, const PxReal lengthScale
);
 
 
}
 
}
 
#endif