TorqueGameEngines/Torque3D
1
0
Fork 0
mirror of https://github.com/TorqueGameEngines/Torque3D.git synced 2026-02-18 06:03:48 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

working vhacd

Browse source 
renamed ThreadPool to TorqueThreadPool to avoid conflics
fixed data transmission between stages of convexDecome and trimesh creation
TODO: re-add our own functions for generating sphere/cylinder/box
This commit is contained in:
marauder2k7 2024-05-12 14:43:56 +01:00
parent 679f0ff065
commit eb33fe04af
15 changed files with 116 additions and 75 deletions
Download patch file Download diff file Expand all files Collapse all files

10
Engine/source/platform/async/asyncBufferedStream.h
View file

@ -107,7 +107,7 @@ class AsyncBufferedInputStream : public IInputStreamFilter< T, Stream >,
ElementList mBufferedElements;
/// The thread pool to which read items are queued.
ThreadPool* mThreadPool;
TorqueThreadPool* mThreadPool;
/// The thread context used for prioritizing read items in the pool.
ThreadContext* mThreadContext;
@ -132,7 +132,7 @@ class AsyncBufferedInputStream : public IInputStreamFilter< T, Stream >,
U32 numSourceElementsToRead = 0,
U32 numReadAhead = DEFAULT_STREAM_LOOKAHEAD,
bool isLooping = false,
ThreadPool* pool = &ThreadPool::GLOBAL(),
TorqueThreadPool* pool = &TorqueThreadPool::GLOBAL(),
ThreadContext* context = ThreadContext::ROOT_CONTEXT() );
virtual ~AsyncBufferedInputStream();
@ -162,7 +162,7 @@ AsyncBufferedInputStream< T, Stream >::AsyncBufferedInputStream
U32 numSourceElementsToRead,
U32 numReadAhead,
bool isLooping,
ThreadPool* threadPool,
TorqueThreadPool* threadPool,
ThreadContext* threadContext )
: Parent( stream ),
mIsLooping( isLooping ),
@ -321,7 +321,7 @@ class AsyncBufferedReadItem : public ThreadWorkItem
///
AsyncBufferedReadItem(
const AsyncStreamRef& asyncStream,
ThreadPool::Context* context = NULL
TorqueThreadPool::Context* context = NULL
)
: Parent( context ),
mAsyncStream( asyncStream ),
@ -376,7 +376,7 @@ class AsyncSingleBufferedInputStream : public AsyncBufferedInputStream< T, Strea
U32 numSourceElementsToRead = 0,
U32 numReadAhead = Parent::DEFAULT_STREAM_LOOKAHEAD,
bool isLooping = false,
ThreadPool* pool = &ThreadPool::GLOBAL(),
TorqueThreadPool* pool = &TorqueThreadPool::GLOBAL(),
ThreadContext* context = ThreadContext::ROOT_CONTEXT() )
: Parent( stream,
numSourceElementsToRead,

6
Engine/source/platform/async/asyncPacketStream.h
View file

@ -113,7 +113,7 @@ class AsyncPacketBufferedInputStream : public AsyncBufferedInputStream< Packet*,
PacketReadItem( const ThreadSafeRef< AsyncPacketBufferedInputStream< Stream, Packet > >& asyncStream,
PacketType* packet,
U32 numElements,
ThreadPool::Context* context = NULL )
TorqueThreadPool::Context* context = NULL )
: Parent( asyncStream->getSourceStream(), numElements, 0, *packet, false, 0, context ),
mAsyncStream( asyncStream ),
mPacket( packet ) {}
@ -227,7 +227,7 @@ class AsyncPacketBufferedInputStream : public AsyncBufferedInputStream< Packet*,
U32 numSourceElementsToRead = 0,
U32 numReadAhead = Parent::DEFAULT_STREAM_LOOKAHEAD,
bool isLooping = false,
ThreadPool* pool = &ThreadPool::GLOBAL(),
TorqueThreadPool* pool = &TorqueThreadPool::GLOBAL(),
ThreadContext* context = ThreadContext::ROOT_CONTEXT() );
/// @return the size of stream packets returned by this stream in number of elements.
@ -241,7 +241,7 @@ AsyncPacketBufferedInputStream< Stream, Packet >::AsyncPacketBufferedInputStream
U32 numSourceElementsToRead,
U32 numReadAhead,
bool isLooping,
ThreadPool* threadPool,
TorqueThreadPool* threadPool,
ThreadContext* threadContext )
: Parent( stream, numSourceElementsToRead, numReadAhead, isLooping, threadPool, threadContext ),
mPacketSize( packetSize ),

8
Engine/source/platform/platformNetAsync.cpp
View file

@ -65,11 +65,11 @@ struct NetAsync::NameLookupRequest
/// Work item issued to the thread pool for each lookup request.
struct NetAsync::NameLookupWorkItem : public ThreadPool::WorkItem
struct NetAsync::NameLookupWorkItem : public TorqueThreadPool::WorkItem
{
typedef ThreadPool::WorkItem Parent;
typedef TorqueThreadPool::WorkItem Parent;
NameLookupWorkItem( NameLookupRequest& request, ThreadPool::Context* context = 0 )
NameLookupWorkItem( NameLookupRequest& request, TorqueThreadPool::Context* context = 0 )
: Parent( context ),
mRequest( request )
{
@ -133,7 +133,7 @@ void NetAsync::queueLookup(const char* remoteAddr, NetSocket socket)
dStrncpy(lookupRequest.remoteAddr, remoteAddr, sizeof(lookupRequest.remoteAddr));
ThreadSafeRef< NameLookupWorkItem > workItem( new NameLookupWorkItem( lookupRequest ) );
ThreadPool::GLOBAL().queueWorkItem( workItem );
TorqueThreadPool::GLOBAL().queueWorkItem( workItem );
}
bool NetAsync::checkLookup(NetSocket socket, void* out_h_addr,

62
Engine/source/platform/threads/threadPool.cpp
View file

@ -34,11 +34,11 @@
// ThreadPool::Context.
//=============================================================================
ThreadPool::Context ThreadPool::Context::smRootContext( "ROOT", NULL, 1.0 );
TorqueThreadPool::Context TorqueThreadPool::Context::smRootContext( "ROOT", NULL, 1.0 );
//--------------------------------------------------------------------------
ThreadPool::Context::Context( const char* name, ThreadPool::Context* parent, F32 priorityBias )
TorqueThreadPool::Context::Context( const char* name, TorqueThreadPool::Context* parent, F32 priorityBias )
: mParent( parent ),
mName( name ),
mChildren( 0 ),
@ -55,7 +55,7 @@ ThreadPool::Context::Context( const char* name, ThreadPool::Context* parent, F32
//--------------------------------------------------------------------------
ThreadPool::Context::~Context()
TorqueThreadPool::Context::~Context()
{
if( mParent )
for( Context* context = mParent->mChildren, *prev = 0; context != 0; prev = context, context = context->mSibling )
@ -70,7 +70,7 @@ ThreadPool::Context::~Context()
//--------------------------------------------------------------------------
ThreadPool::Context* ThreadPool::Context::getChild( const char* name )
TorqueThreadPool::Context* TorqueThreadPool::Context::getChild( const char* name )
{
for( Context* child = getChildren(); child != 0; child = child->getSibling() )
if( dStricmp( child->getName(), name ) == 0 )
@ -80,7 +80,7 @@ ThreadPool::Context* ThreadPool::Context::getChild( const char* name )
//--------------------------------------------------------------------------
F32 ThreadPool::Context::getAccumulatedPriorityBias()
F32 TorqueThreadPool::Context::getAccumulatedPriorityBias()
{
if( !mAccumulatedPriorityBias )
updateAccumulatedPriorityBiases();
@ -89,7 +89,7 @@ F32 ThreadPool::Context::getAccumulatedPriorityBias()
//--------------------------------------------------------------------------
void ThreadPool::Context::setPriorityBias( F32 value )
void TorqueThreadPool::Context::setPriorityBias( F32 value )
{
mPriorityBias = value;
mAccumulatedPriorityBias = 0.0;
@ -97,7 +97,7 @@ void ThreadPool::Context::setPriorityBias( F32 value )
//--------------------------------------------------------------------------
void ThreadPool::Context::updateAccumulatedPriorityBiases()
void TorqueThreadPool::Context::updateAccumulatedPriorityBiases()
{
// Update our own priority bias.
@ -117,7 +117,7 @@ void ThreadPool::Context::updateAccumulatedPriorityBiases()
//--------------------------------------------------------------------------
void ThreadPool::WorkItem::process()
void TorqueThreadPool::WorkItem::process()
{
execute();
mExecuted = true;
@ -125,14 +125,14 @@ void ThreadPool::WorkItem::process()
//--------------------------------------------------------------------------
bool ThreadPool::WorkItem::isCancellationRequested()
bool TorqueThreadPool::WorkItem::isCancellationRequested()
{
return false;
}
//--------------------------------------------------------------------------
bool ThreadPool::WorkItem::cancellationPoint()
bool TorqueThreadPool::WorkItem::cancellationPoint()
{
if( isCancellationRequested() )
{
@ -145,7 +145,7 @@ bool ThreadPool::WorkItem::cancellationPoint()
//--------------------------------------------------------------------------
F32 ThreadPool::WorkItem::getPriority()
F32 TorqueThreadPool::WorkItem::getPriority()
{
return 1.0;
}
@ -160,7 +160,7 @@ F32 ThreadPool::WorkItem::getPriority()
/// @see ThreadSafePriorityQueueWithUpdate
/// @see ThreadPool::WorkItem
///
struct ThreadPool::WorkItemWrapper : public ThreadSafeRef< WorkItem >
struct TorqueThreadPool::WorkItemWrapper : public ThreadSafeRef< WorkItem >
{
typedef ThreadSafeRef< WorkItem > Parent;
@ -172,7 +172,7 @@ struct ThreadPool::WorkItemWrapper : public ThreadSafeRef< WorkItem >
F32 getPriority();
};
inline bool ThreadPool::WorkItemWrapper::isAlive()
inline bool TorqueThreadPool::WorkItemWrapper::isAlive()
{
WorkItem* item = ptr();
if( !item )
@ -186,7 +186,7 @@ inline bool ThreadPool::WorkItemWrapper::isAlive()
return true;
}
inline F32 ThreadPool::WorkItemWrapper::getPriority()
inline F32 TorqueThreadPool::WorkItemWrapper::getPriority()
{
WorkItem* item = ptr();
AssertFatal( item != 0, "ThreadPool::WorkItemWrapper::getPriority - called on dead item" );
@ -201,20 +201,20 @@ inline F32 ThreadPool::WorkItemWrapper::getPriority()
///
///
struct ThreadPool::WorkerThread : public Thread
struct TorqueThreadPool::WorkerThread : public Thread
{
WorkerThread( ThreadPool* pool, U32 index );
WorkerThread( TorqueThreadPool* pool, U32 index );
WorkerThread* getNext();
void run( void* arg = 0 ) override;
private:
U32 mIndex;
ThreadPool* mPool;
TorqueThreadPool* mPool;
WorkerThread* mNext;
};
ThreadPool::WorkerThread::WorkerThread( ThreadPool* pool, U32 index )
TorqueThreadPool::WorkerThread::WorkerThread( TorqueThreadPool* pool, U32 index )
: mIndex( index ),
mPool( pool )
{
@ -224,12 +224,12 @@ ThreadPool::WorkerThread::WorkerThread( ThreadPool* pool, U32 index )
pool->mThreads = this;
}
inline ThreadPool::WorkerThread* ThreadPool::WorkerThread::getNext()
inline TorqueThreadPool::WorkerThread* TorqueThreadPool::WorkerThread::getNext()
{
return mNext;
}
void ThreadPool::WorkerThread::run( void* arg )
void TorqueThreadPool::WorkerThread::run( void* arg )
{
#ifdef TORQUE_DEBUG
{
@ -300,13 +300,13 @@ void ThreadPool::WorkerThread::run( void* arg )
// ThreadPool.
//=============================================================================
bool ThreadPool::smForceAllMainThread;
U32 ThreadPool::smMainThreadTimeMS;
ThreadPool::QueueType ThreadPool::smMainThreadQueue;
bool TorqueThreadPool::smForceAllMainThread;
U32 TorqueThreadPool::smMainThreadTimeMS;
TorqueThreadPool::QueueType TorqueThreadPool::smMainThreadQueue;
//--------------------------------------------------------------------------
ThreadPool::ThreadPool( const char* name, U32 numThreads )
TorqueThreadPool::TorqueThreadPool( const char* name, U32 numThreads )
: mName( name ),
mNumThreads( numThreads ),
mNumThreadsAwake( 0 ),
@ -347,14 +347,14 @@ ThreadPool::ThreadPool( const char* name, U32 numThreads )
//--------------------------------------------------------------------------
ThreadPool::~ThreadPool()
TorqueThreadPool::~TorqueThreadPool()
{
shutdown();
}
//--------------------------------------------------------------------------
void ThreadPool::shutdown()
void TorqueThreadPool::shutdown()
{
const U32 numThreads = mNumThreads;
@ -387,7 +387,7 @@ void ThreadPool::shutdown()
//--------------------------------------------------------------------------
void ThreadPool::queueWorkItem( WorkItem* item )
void TorqueThreadPool::queueWorkItem( WorkItem* item )
{
bool executeRightAway = ( getForceAllMainThread() );
#ifdef DEBUG_SPEW
@ -410,7 +410,7 @@ void ThreadPool::queueWorkItem( WorkItem* item )
//--------------------------------------------------------------------------
void ThreadPool::flushWorkItems( S32 timeOut )
void TorqueThreadPool::flushWorkItems( S32 timeOut )
{
AssertFatal( mNumThreads, "ThreadPool::flushWorkItems() - no worker threads in pool" );
@ -432,7 +432,7 @@ void ThreadPool::flushWorkItems( S32 timeOut )
}
}
void ThreadPool::waitForAllItems( S32 timeOut )
void TorqueThreadPool::waitForAllItems( S32 timeOut )
{
U32 endTime = 0;
if( timeOut != -1 )
@ -454,14 +454,14 @@ void ThreadPool::waitForAllItems( S32 timeOut )
//--------------------------------------------------------------------------
void ThreadPool::queueWorkItemOnMainThread( WorkItem* item )
void TorqueThreadPool::queueWorkItemOnMainThread( WorkItem* item )
{
smMainThreadQueue.insert( item->getPriority(), item );
}
//--------------------------------------------------------------------------
void ThreadPool::processMainThreadWorkItems()
void TorqueThreadPool::processMainThreadWorkItems()
{
AssertFatal( ThreadManager::isMainThread(),
"ThreadPool::processMainThreadWorkItems - this function must only be called on the main thread" );

18
Engine/source/platform/threads/threadPool.h
View file

@ -70,7 +70,7 @@
/// automatically being released once the last concurrent work item has been
/// processed or discarded.
///
class ThreadPool
class TorqueThreadPool
{
public:
@ -298,9 +298,9 @@ class ThreadPool
/// will be based on the number of CPU cores available.
///
/// @param numThreads Number of threads to create or zero for default.
ThreadPool( const char* name, U32 numThreads = 0 );
TorqueThreadPool( const char* name, U32 numThreads = 0 );
~ThreadPool();
~TorqueThreadPool();
/// Manually shutdown threads outside of static destructors.
void shutdown();
@ -397,16 +397,16 @@ class ThreadPool
}
/// Return the global thread pool singleton.
static ThreadPool& GLOBAL();
static TorqueThreadPool& GLOBAL();
};
typedef ThreadPool::Context ThreadContext;
typedef ThreadPool::WorkItem ThreadWorkItem;
typedef TorqueThreadPool::Context ThreadContext;
typedef TorqueThreadPool::WorkItem ThreadWorkItem;
struct ThreadPool::GlobalThreadPool : public ThreadPool, public ManagedSingleton< GlobalThreadPool >
struct TorqueThreadPool::GlobalThreadPool : public TorqueThreadPool, public ManagedSingleton< GlobalThreadPool >
{
typedef ThreadPool Parent;
typedef TorqueThreadPool Parent;
GlobalThreadPool()
: Parent( "GLOBAL" ) {}
@ -415,7 +415,7 @@ struct ThreadPool::GlobalThreadPool : public ThreadPool, public ManagedSingleton
static const char* getSingletonName() { return "GlobalThreadPool"; }
};
inline ThreadPool& ThreadPool::GLOBAL()
inline TorqueThreadPool& TorqueThreadPool::GLOBAL()
{
return *( GlobalThreadPool::instance() );
}

2
Engine/source/platform/threads/threadPoolAsyncIO.h
View file

@ -54,7 +54,7 @@
///
/// @param T Type of elements being streamed.
template< typename T, class Stream >
class AsyncIOItem : public ThreadPool::WorkItem
class AsyncIOItem : public TorqueThreadPool::WorkItem
{
public: