//----------------------------------------------------------------------------
// like C-style
void StoreObject(int i, int maxCntObject, std::string nameClass, void* pThis)
{
static TMapStrInt mMapClassCnt;// для нахождения по имени класса макс. кол-ва объектов
static TMapPtrStr mMapPtrName; // по указателю на объект имя класса
int cntMake = 0;
bool res = false;
LockThread(nsLockThread::eLock);// блокировка
switch(i)
{
case nsStoreObject::ePush:
{
//-------------------------------
TMapStrInt::iterator fit = mMapClassCnt.find(nameClass);
if(fit==mMapClassCnt.end())
{
// не нашли - добавить
mMapClassCnt.insert(TMapStrInt::value_type(nameClass,1));
fit = mMapClassCnt.find(nameClass);
// что бы потом найти в деструкторе
mMapPtrName.insert(TMapPtrStr::value_type(pThis,nameClass));
}
else
fit->second++;
cntMake = fit->second;
}
break;
case nsStoreObject::ePop:
{
//-------------------------------
TMapPtrStr::iterator fit_name = mMapPtrName.find(pThis);
if(fit_name!=mMapPtrName.end())
{
TMapStrInt::iterator fit = mMapClassCnt.find(fit_name->second);
if(fit!=mMapClassCnt.end())
{
fit->second--;
cntMake = fit->second;
res = true;
}
}
}
break;
}
LockThread(nsLockThread::eUnlock);// разблокировать
// проверка результатов
switch(i)
{
case nsStoreObject::ePush:
BL_ASSERT(cntMake <= maxCntObject);
break;
case nsStoreObject::ePop:
BL_ASSERT(cntMake >= 0 && res);
break;
}
}
trap_retval ReqRunThread_get_name( void )
{
run_thread_get_name_req *acc;
char *name;
struct TDebug *obj;
struct TDebugThread *t = 0;
acc = GetInPtr( 0 );
name = GetOutPtr( 0 );
strcpy( name, "" );
if( acc->thread == 0 )
strcpy( name, "Name" );
else {
obj = GetCurrentDebug();
if (obj) {
t = LockThread( obj, acc->thread );
if( t )
sprintf( name, "%04hX %s", t->ThreadID, t->ThreadName );
UnlockThread( obj );
}
}
return( strlen( name ) + 1 );
}
void PhysicsWorld::PurgeColPairs()
{
LockThread();
m_Pairs.Empty();
RSKMAP_ITERATE( m_Entities )
iter->second->Purge();
}
/** \brief Funkce starajici se o predani tokenu nejakeho ze sdilenych zdroju
*
* Pokud se nikdo neuchazi o token, nastavi se dalsi applicant na THREAD_MAX, cili nejake makro neplatneho uchazece, a pote se pri vyzadani ihned prideli
*/
void SpinLock::PassToken(LockType target, LockThread holder)
{
// Kdyz token nemame, nemuzeme ho ani predat
if (!HasToken(target, holder))
return;
LockThread next = THREAD_MAX;
// projdeme zadatele od holdera dal
for (uint32 i = holder+1; i < THREAD_MAX; i++)
{
if (ApplicantMap[target][i])
{
next = LockThread(i);
break;
}
}
// pokud jsme nenalezli...
if (next == THREAD_MAX)
{
// ... projdeme jeste zadatele od nuly k holderovi
for (uint32 i = 0; i <= holder; i++)
{
if (ApplicantMap[target][i])
{
next = LockThread(i);
break;
}
}
}
// Neni nutne, aby token melo nejake z vlaken, kdyz ho nepotrebuje
// Pokud nastane takova situace, holder tokenu se nastavi na hodnotu makra THREAD_MAX
// pote se pri vyzadani tokenu take token automaticky prideli
HolderMap[target] = next;
}
void PhysicsWorld::ExecFrame()
{
LockThread();
//
// [disabled] Lock timestep to improve collision prediction
//m_QueuedTime += (GFloat)rsk::gClock->GetFrameTimeSeconds();
//
// [enabled] Try to normalize the timestep to improve collision prediction
m_FrameTime += (GFloat)rsk::gClock->GetFrameTimeSeconds();
m_FrameTime *= 0.5f;
// if( m_QueuedTime >= m_FrameTime )
{
CheckCollisions();
HandleCollisions();
ApplyGravity();
RSKMAP_ITERATE( m_Entities )
iter->second->ExecFrame( m_FrameTime );
// m_QueuedTime = 0.f;
}
}
static void SignalDebugData( struct TDebug *obj )
{
int thread;
char debtype;
struct TCreateProcessEvent cpe;
struct TCreateThreadEvent cte;
struct TLoadDllEvent lde;
struct TExceptionEvent ee;
int ExitCode;
int handle;
struct TDebugThread *newt;
RdosWaitMilli( 5 );
debtype = RdosGetDebugEvent( obj->FHandle, &thread );
switch (debtype) {
case EVENT_EXCEPTION:
RdosGetDebugEventData( obj->FHandle, &ee );
HandleException( obj, &ee, thread );
break;
case EVENT_CREATE_THREAD:
RdosGetDebugEventData( obj->FHandle, &cte );
HandleCreateThread( obj, &cte );
obj->FThreadChanged = TRUE;
break;
case EVENT_CREATE_PROCESS:
RdosGetDebugEventData( obj->FHandle, &cpe );
HandleCreateProcess( obj, &cpe );
break;
case EVENT_TERMINATE_THREAD:
HandleTerminateThread( obj, thread );
obj->FThreadChanged = TRUE;
if( !obj->CurrentThread ) {
obj->CurrentThread = obj->ThreadList;
while( obj->CurrentThread && !IsDebug( obj->CurrentThread ) )
obj->CurrentThread = obj->CurrentThread->Next;
if (!obj->CurrentThread)
obj->CurrentThread = obj->ThreadList;
}
break;
case EVENT_TERMINATE_PROCESS:
RdosGetDebugEventData( obj->FHandle, &ExitCode );
HandleTerminateProcess( obj, ExitCode);
obj->FInstalled = FALSE;
RdosSetSignal( obj->UserSignal );
break;
case EVENT_LOAD_DLL:
RdosGetDebugEventData( obj->FHandle, &lde );
HandleLoadDll( obj, &lde );
obj->FModuleChanged = TRUE;
break;
case EVENT_FREE_DLL:
RdosGetDebugEventData( obj->FHandle, &handle );
HandleFreeDll( obj, handle );
obj->FModuleChanged = TRUE;
break;
}
RdosClearDebugEvent( obj->FHandle );
if( debtype == EVENT_EXCEPTION ) {
if( obj->CurrentThread ) {
DeactivateBreaks( obj->CurrentThread, obj->BreakList);
if( thread != obj->CurrentThread->ThreadID ) {
newt = LockThread( obj, thread );
if( newt ) {
obj->CurrentThread = newt;
obj->FThreadChanged = TRUE;
}
UnlockThread( obj );
}
}
RdosSetSignal( obj->UserSignal );
}
else
RdosContinueDebugEvent( obj->FHandle, thread );
}
void PhysicsWorld::SetGravity( GFloat accel )
{
LockThread();
m_Gravity = accel;
}
void PhysicsWorld::RemoveBody( DetectorID id )
{
LockThread();
m_Bodies.Remove( id );
}
void PhysicsWorld::AddBody( Detector* det )
{
LockThread();
m_Bodies[det->GetID()] = det;
}
void PhysicsWorld::RemoveEntity( rsk::SystemID id )
{
LockThread();
m_Entities.Remove( id );
}
void PhysicsWorld::AddEntity( rsk::SystemID id, PhysicsEntity* entity )
{
LockThread();
m_Entities.Add( id, entity );
}
