//*************************************************************************************************************
void UninitScene()
{
streamer.Destroy();
WaitForSingleObject(worker.GetHandle(), 3000);
worker.Close();
if( masteringvoice )
masteringvoice->DestroyVoice();
if( xaudio2 )
xaudio2->Release();
// don't do this, ever!!!
system1.~ParticleSystem();
for( int i = 0; i < NUM_DWARFS; ++i )
dwarfs[i].~AnimatedMesh();
SAFE_RELEASE(skyeffect);
SAFE_RELEASE(skymesh);
SAFE_RELEASE(skytex);
SAFE_RELEASE(text);
SAFE_RELEASE(mesh);
SAFE_RELEASE(effect);
SAFE_RELEASE(texture1);
SAFE_RELEASE(texture2);
DXKillAnyRogueObject();
//CoUninitialize();
}
void EventCallbackBase::PrintCallstacksX64( IProcess* process )
{
Enumerator<Thread*>* threads = NULL;
process->EnumThreads( threads );
while ( threads->MoveNext() )
{
Thread* t = threads->GetCurrent();
std::list<FrameX64> stack;
ReadCallstackX64( process->GetHandle(), t->GetHandle(), stack );
printf( " TID=%d\n", t->GetId() );
for ( std::list<FrameX64>::iterator it = stack.begin();
it != stack.end();
it++ )
{
printf( " RIP=%016x, RBP=%016x\n", it->Rip, it->Rbp );
}
}
threads->Release();
}
/// Reschedules to the next available thread (call after current thread is suspended)
void Reschedule() {
Thread* prev = GetCurrentThread();
Thread* next = NextThread();
HLE::g_reschedule = false;
if (next > 0) {
INFO_LOG(KERNEL, "context switch 0x%08X -> 0x%08X", prev->GetHandle(), next->GetHandle());
SwitchContext(next);
// Hack - There is no mechanism yet to waken the primary thread if it has been put to sleep
// by a simulated VBLANK thread switch. So, we'll just immediately set it to "ready" again.
// This results in the current thread yielding on a VBLANK once, and then it will be
// immediately placed back in the queue for execution.
if (prev->wait_type == WAITTYPE_VBLANK) {
ResumeThreadFromWait(prev->GetHandle());
}
}
}
inline void SetThreadContext(Thread const& thread, CONTEXT const& context)
{
if (!::SetThreadContext(thread.GetHandle(), &context))
{
DWORD const last_error = ::GetLastError();
HADESMEM_DETAIL_THROW_EXCEPTION(Error()
<< ErrorString("SetThreadContext failed.")
<< ErrorCodeWinLast(last_error));
}
}
inline DWORD ResumeThread(Thread const& thread)
{
HADESMEM_DETAIL_TRACE_FORMAT_A("Resuming thread with ID 0n%lu.",
thread.GetId());
DWORD const suspend_count = ::ResumeThread(thread.GetHandle());
if (suspend_count == static_cast<DWORD>(-1))
{
DWORD const last_error = ::GetLastError();
HADESMEM_DETAIL_THROW_EXCEPTION(Error()
<< ErrorString("ResumeThread failed.")
<< ErrorCodeWinLast(last_error));
}
return suspend_count;
}
inline CONTEXT GetThreadContext(Thread const& thread, DWORD context_flags)
{
if (::GetCurrentThreadId() == thread.GetId() &&
context_flags != CONTEXT_DEBUG_REGISTERS)
{
HADESMEM_DETAIL_THROW_EXCEPTION(
Error() << ErrorString("GetThreadContext called for current thread."));
}
CONTEXT context{};
context.ContextFlags = context_flags;
if (!::GetThreadContext(thread.GetHandle(), &context))
{
DWORD const last_error = ::GetLastError();
HADESMEM_DETAIL_THROW_EXCEPTION(Error()
<< ErrorString("GetThreadContext failed.")
<< ErrorCodeWinLast(last_error));
}
return context;
}
