update to bullet 2.87

Engine/lib/bullet/src/LinearMath/btThreads.h

@@ -19,6 +19,23 @@ subject to the following restrictions:
 
 #include "btScalar.h" // has definitions like SIMD_FORCE_INLINE
 
+#if defined (_MSC_VER) && _MSC_VER >= 1600
+// give us a compile error if any signatures of overriden methods is changed
+#define BT_OVERRIDE override
+#endif
+
+#ifndef BT_OVERRIDE
+#define BT_OVERRIDE
+#endif
+
+const unsigned int BT_MAX_THREAD_COUNT = 64;  // only if BT_THREADSAFE is 1
+
+// for internal use only
+bool btIsMainThread();
+bool btThreadsAreRunning();
+unsigned int btGetCurrentThreadIndex();
+void btResetThreadIndexCounter(); // notify that all worker threads have been destroyed
+
 ///
 /// btSpinMutex -- lightweight spin-mutex implemented with atomic ops, never puts
 ///               a thread to sleep because it is designed to be used with a task scheduler
@@ -39,38 +56,100 @@ public:
     bool tryLock();
 };
 
-#if BT_THREADSAFE
 
-// for internal Bullet use only
+//
+// NOTE: btMutex* is for internal Bullet use only
+//
+// If BT_THREADSAFE is undefined or 0, should optimize away to nothing.
+// This is good because for the single-threaded build of Bullet, any calls
+// to these functions will be optimized out.
+//
+// However, for users of the multi-threaded build of Bullet this is kind
+// of bad because if you call any of these functions from external code
+// (where BT_THREADSAFE is undefined) you will get unexpected race conditions.
+//
 SIMD_FORCE_INLINE void btMutexLock( btSpinMutex* mutex )
 {
+#if BT_THREADSAFE
     mutex->lock();
+#endif // #if BT_THREADSAFE
 }
 
 SIMD_FORCE_INLINE void btMutexUnlock( btSpinMutex* mutex )
 {
+#if BT_THREADSAFE
     mutex->unlock();
+#endif // #if BT_THREADSAFE
 }
 
 SIMD_FORCE_INLINE bool btMutexTryLock( btSpinMutex* mutex )
 {
+#if BT_THREADSAFE
     return mutex->tryLock();
+#else
+    return true;
+#endif // #if BT_THREADSAFE
 }
 
-// for internal use only
-bool btIsMainThread();
-unsigned int btGetCurrentThreadIndex();
-const unsigned int BT_MAX_THREAD_COUNT = 64;
 
-#else
+//
+// btIParallelForBody -- subclass this to express work that can be done in parallel
+//
+class btIParallelForBody
+{
+public:
+    virtual ~btIParallelForBody() {}
+    virtual void forLoop( int iBegin, int iEnd ) const = 0;
+};
+
+//
+// btITaskScheduler -- subclass this to implement a task scheduler that can dispatch work to
+//                     worker threads
+//
+class btITaskScheduler
+{
+public:
+    btITaskScheduler( const char* name );
+    virtual ~btITaskScheduler() {}
+    const char* getName() const { return m_name; }
+
+    virtual int getMaxNumThreads() const = 0;
+    virtual int getNumThreads() const = 0;
+    virtual void setNumThreads( int numThreads ) = 0;
+    virtual void parallelFor( int iBegin, int iEnd, int grainSize, const btIParallelForBody& body ) = 0;
+
+    // internal use only
+    virtual void activate();
+    virtual void deactivate();
+
+protected:
+    const char* m_name;
+    unsigned int m_savedThreadCounter;
+    bool m_isActive;
+};
+
+// set the task scheduler to use for all calls to btParallelFor()
+// NOTE: you must set this prior to using any of the multi-threaded "Mt" classes
+void btSetTaskScheduler( btITaskScheduler* ts );
+
+// get the current task scheduler
+btITaskScheduler* btGetTaskScheduler();
+
+// get non-threaded task scheduler (always available)
+btITaskScheduler* btGetSequentialTaskScheduler();
+
+// get OpenMP task scheduler (if available, otherwise returns null)
+btITaskScheduler* btGetOpenMPTaskScheduler();
+
+// get Intel TBB task scheduler (if available, otherwise returns null)
+btITaskScheduler* btGetTBBTaskScheduler();
+
+// get PPL task scheduler (if available, otherwise returns null)
+btITaskScheduler* btGetPPLTaskScheduler();
+
+// btParallelFor -- call this to dispatch work like a for-loop
+//                 (iterations may be done out of order, so no dependencies are allowed)
+void btParallelFor( int iBegin, int iEnd, int grainSize, const btIParallelForBody& body );
 
-// for internal Bullet use only
-// if BT_THREADSAFE is undefined or 0, should optimize away to nothing
-SIMD_FORCE_INLINE void btMutexLock( btSpinMutex* ) {}
-SIMD_FORCE_INLINE void btMutexUnlock( btSpinMutex* ) {}
-SIMD_FORCE_INLINE bool btMutexTryLock( btSpinMutex* ) {return true;}
 
 #endif
-
-
-#endif //BT_THREADS_H