Initial commit

1 files changed, 1100 insertions, 0 deletions

diff --git a/Minecraft.World/C4JThread.cpp b/Minecraft.World/C4JThread.cpp
new file mode 100644
index 00000000..4b9760c1
--- /dev/null
+++ b/Minecraft.World/C4JThread.cpp
@@ -0,0 +1,1100 @@
+#include "stdafx.h"
+
+
+#include "C4JThread.h"
+#ifdef __PSVITA__
+#include "..\Minecraft.Client\PSVita\PSVitaExtras\ShutdownManager.h"
+#include "..\Minecraft.Client\PSVita\PSVitaExtras\PSVitaTLSStorage.h"
+
+// AP - this comes from the low level user_malloc.c file used to overide the default memory functions. These must be called when a thread is started/stopped
+extern "C" {
+extern void user_registerthread();
+extern void user_removethread();
+}
+#else
+#include "..\Minecraft.Client\PS3\PS3Extras\ShutdownManager.h"
+
+#endif
+
+std::vector<C4JThread*> C4JThread::ms_threadList;
+CRITICAL_SECTION C4JThread::ms_threadListCS;
+
+#ifdef _XBOX_ONE
+	// 4J Stu - On XboxOne the main thread is not the one that does all the static init, so we have to set this up later
+C4JThread *C4JThread::m_mainThread = NULL;
+
+void C4JThread::StaticInit()
+{
+	m_mainThread = new C4JThread("Main thread");
+}
+#else
+C4JThread	C4JThread::m_mainThread("Main thread");
+#endif
+
+#ifdef __ORBIS__
+__thread SceKernelCpumask C4JThread::m_oldAffinityMask;
+#endif
+
+
+#if __PSVITA__
+static SceInt32 g_DefaultCPU;
+static SceInt32 g_DefaultPriority;
+#endif
+
+C4JThread::C4JThread( C4JThreadStartFunc* startFunc, void* param, const char* threadName, int stackSize/* = 0*/ )
+{
+	m_startFunc = startFunc;
+	m_threadParam = param;
+	m_stackSize = stackSize;
+
+	// to match XBox, if the stack size is zero, use the default 64k
+	if(m_stackSize == 0)
+		m_stackSize = 65536 * 2;
+	// make sure it's at least 16K
+	if(m_stackSize < 16384)
+		m_stackSize = 16384;
+
+#ifdef __PS3__
+	sprintf(m_threadName, "(4J) %s", threadName );
+#else
+	sprintf_s(m_threadName,64, "(4J) %s", threadName );
+#endif
+
+	m_isRunning = false;
+	m_hasStarted = false;
+
+	m_exitCode = STILL_ACTIVE;
+
+#ifdef __PS3__
+	m_completionFlag = new Event(Event::e_modeManualClear);
+	m_threadID = 0;
+	m_lastSleepTime = 0;
+	m_priority = 1002;	// main thread has priority 1001
+#elif defined __ORBIS__
+	m_completionFlag = new Event(Event::e_modeManualClear);
+	m_threadID = 0;
+	m_lastSleepTime = 0;
+	scePthreadAttrInit(&m_threadAttr);
+	int err = scePthreadAttrSetaffinity(&m_threadAttr, 63); // set the thread affinity to all cores to start with
+	assert(err == SCE_OK);
+	m_oldAffinityMask = 0;
+	m_priority = SCE_KERNEL_PRIO_FIFO_DEFAULT;
+#elif defined __PSVITA__
+	m_completionFlag = new Event(Event::e_modeManualClear);
+	m_threadID = 0;
+	m_lastSleepTime = 0;
+	m_priority = g_DefaultPriority;
+	//m_CPUMask = SCE_KERNEL_CPU_MASK_USER_ALL;
+
+	// AP - I had trouble getting the cpu to change once the thread was created so I've hard coded them here
+	// The main work division is...
+	// 0 - Main
+	// 1 - Chunk/Tile Update
+	// 2 - Server/Audio
+	// These three can sometimes consume ALL the CPU time so they are set to below average priority so as not to block other critical threads
+	int CPU = SCE_KERNEL_CPU_MASK_USER_ALL;
+	if( !strcmp(threadName, "Chunk update") )
+	{
+		CPU = SCE_KERNEL_CPU_MASK_USER_2;
+		m_priority = g_DefaultPriority + 1; 
+	}
+	if( !strcmp(threadName, "Server" ) )
+	{
+		CPU = SCE_KERNEL_CPU_MASK_USER_1;
+		m_priority = g_DefaultPriority + 1; 
+	}
+	// make sure Tile Update doesn't go on cpu 0 because it will hold up the main thread. And it can't go on cpu 1 because Chunk Update crashes.
+	if( !strcmp(threadName, "Tile update") )
+	{
+		CPU = SCE_KERNEL_CPU_MASK_USER_1;
+	}
+
+	m_threadID = sceKernelCreateThread(m_threadName, entryPoint, g_DefaultPriority, m_stackSize, 0, CPU, NULL);
+	app.DebugPrintf("***************************** start thread %s **************************\n", m_threadName);
+#else
+	m_threadID = 0;
+	m_threadHandle = 0;
+	m_threadHandle = CreateThread(NULL, m_stackSize, entryPoint, this, CREATE_SUSPENDED, &m_threadID);
+#endif
+	EnterCriticalSection(&ms_threadListCS);
+	ms_threadList.push_back(this);
+	LeaveCriticalSection(&ms_threadListCS);
+}
+
+// only used for the main thread
+C4JThread::C4JThread( const char* mainThreadName)
+{
+#ifdef __PSVITA__
+	user_registerthread();
+#endif
+
+	m_startFunc = NULL;
+	m_threadParam = NULL;
+	m_stackSize = 0;
+
+#ifdef __PS3__
+	sprintf(m_threadName, "(4J) %s", mainThreadName);
+#else
+	sprintf_s(m_threadName, 64, "(4J) %s", mainThreadName);
+#endif
+	m_isRunning = true;
+	m_hasStarted = true;
+	m_lastSleepTime = System::currentTimeMillis();
+
+	// should be the first thread to be created, so init the static critical section for the threadlist here
+	InitializeCriticalSection(&ms_threadListCS);
+
+
+#ifdef __PS3__
+	m_completionFlag = new Event(Event::e_modeManualClear);
+	sys_ppu_thread_get_id(&m_threadID);
+#elif defined __ORBIS__
+	m_completionFlag = new Event(Event::e_modeManualClear);
+	m_threadID = scePthreadSelf();
+	m_priority = SCE_KERNEL_PRIO_FIFO_DEFAULT;
+#elif defined __PSVITA__
+	m_completionFlag = new Event(Event::e_modeManualClear);
+	g_DefaultPriority = sceKernelGetThreadCurrentPriority();
+	m_threadID = sceKernelGetThreadId();
+	int err = sceKernelChangeThreadCpuAffinityMask(m_threadID, SCE_KERNEL_CPU_MASK_USER_0);
+//	sceKernelChangeThreadPriority(m_threadID, g_DefaultPriority + 1);
+	g_DefaultCPU = SCE_KERNEL_CPU_MASK_USER_ALL;//sceKernelGetThreadCpuAffinityMask(m_threadID);
+#else
+	m_threadID = GetCurrentThreadId();
+	m_threadHandle = GetCurrentThread();
+#endif
+#ifdef _XBOX_ONE
+	SetThreadName(-1, m_threadName);
+#endif
+	EnterCriticalSection(&ms_threadListCS);
+	ms_threadList.push_back(this);
+	LeaveCriticalSection(&ms_threadListCS);
+}
+
+C4JThread::~C4JThread()
+{
+#if defined __PS3__ || defined __ORBIS__ || defined __PSVITA__
+	delete m_completionFlag;
+#endif
+
+#if defined __ORBIS__
+	scePthreadJoin(m_threadID, NULL);
+#endif
+
+	EnterCriticalSection(&ms_threadListCS);
+
+	for( AUTO_VAR(it,ms_threadList.begin()); it != ms_threadList.end(); it++ )
+	{
+		if( (*it) == this )
+		{
+			ms_threadList.erase(it);			
+			LeaveCriticalSection(&ms_threadListCS);
+			return;
+		}
+	}
+
+	LeaveCriticalSection(&ms_threadListCS);
+}
+
+#ifdef __PS3__
+void C4JThread::entryPoint(uint64_t param)
+{
+	C4JThread* pThread = (C4JThread*)param;
+	pThread->m_exitCode = (*pThread->m_startFunc)(pThread->m_threadParam);
+	pThread->m_completionFlag->Set();
+	pThread->m_isRunning = false;
+	sys_ppu_thread_exit(0);
+}
+#elif defined __ORBIS__
+void * C4JThread::entryPoint(void *param)
+{
+	C4JThread* pThread = (C4JThread*)param;
+	pThread->m_exitCode = (*pThread->m_startFunc)(pThread->m_threadParam);
+	pThread->m_completionFlag->Set();
+	pThread->m_isRunning = false;
+	scePthreadExit(NULL);
+}
+#elif defined __PSVITA__
+struct StrArg {
+	C4JThread* Thread;
+};
+
+SceInt32 C4JThread::entryPoint(SceSize argSize, void *pArgBlock)
+{
+	StrArg *strArg = (StrArg*)pArgBlock;
+	C4JThread* pThread = strArg->Thread;
+	user_registerthread();
+	pThread->m_exitCode = (*pThread->m_startFunc)(pThread->m_threadParam);
+	app.DebugPrintf("***************************** thread exit %s **************************\n", pThread->m_threadName);
+	pThread->m_completionFlag->Set();
+	pThread->m_isRunning = false;
+
+	// AP - make sure we clean up this thread's storage and memory
+	PSVitaTLSStorage::RemoveThread(pThread->m_threadID);
+	user_removethread();
+
+	sceKernelExitDeleteThread(NULL);
+
+	return pThread->m_exitCode;
+}
+#else
+DWORD WINAPI	C4JThread::entryPoint(LPVOID lpParam)
+{
+	C4JThread* pThread = (C4JThread*)lpParam;
+	SetThreadName(-1, pThread->m_threadName);
+	pThread->m_exitCode = (*pThread->m_startFunc)(pThread->m_threadParam);
+	pThread->m_isRunning = false;
+	return pThread->m_exitCode;
+}
+#endif
+
+
+
+
+void C4JThread::Run()
+{
+#ifdef __PS3__
+	//		prio specifies the priority value of the PPU thread within the range from 0 to 3071 where 0 is the highest.
+	// One of the following values is set to flags:
+	// 0 - non-joinable non-interrupt thread 
+	// SYS_PPU_THREAD_CREATE_JOINABLE - Create a joinable thread 
+	// SYS_PPU_THREAD_CREATE_INTERRUPT - Create an interrupt thread 
+	uint64_t flags = 0;
+	int err = sys_ppu_thread_create(&m_threadID, entryPoint, (uint64_t)this, m_priority, m_stackSize, flags, m_threadName);
+#elif defined __ORBIS__
+	scePthreadAttrSetstacksize(&m_threadAttr, m_stackSize);
+	scePthreadAttrSetguardsize(&m_threadAttr, 1024);
+	int ret = scePthreadCreate(&m_threadID, &m_threadAttr, entryPoint, this, m_threadName);
+	assert( ret == SCE_OK );
+	scePthreadSetprio(m_threadID,m_priority);
+	scePthreadAttrDestroy(&m_threadAttr);
+#elif defined __PSVITA__
+	StrArg strArg = {this};
+//	m_threadID = sceKernelCreateThread(m_threadName, entryPoint, m_priority, m_stackSize, 0, m_CPUMask, NULL);
+	sceKernelStartThread( m_threadID, sizeof(strArg), &strArg);
+#else
+	ResumeThread(m_threadHandle);
+#endif
+	m_lastSleepTime = System::currentTimeMillis();
+	m_isRunning = true;
+	m_hasStarted = true;
+}
+
+void C4JThread::SetProcessor( int proc )
+{
+#ifdef __PS3__
+	// does nothing since we only have the 1 processor
+#elif defined __ORBIS__
+	scePthreadAttrSetaffinity(&m_threadAttr, 1 << proc);
+#elif defined __PSVITA__
+	int Proc = proc >> 1;			// convert from 360's 3 cores * 2 hardware threads to Vita's 3 cores
+	int Mask = SCE_KERNEL_CPU_MASK_USER_0 << Proc;
+	//m_CPUMask = Mask;
+//	int err = sceKernelChangeThreadCpuAffinityMask(m_threadID, Mask);
+	int Newmask = sceKernelGetThreadCpuAffinityMask(m_threadID);
+	app.DebugPrintf("***************************** set thread proc %s %d %d %d **************************\n", m_threadName, proc, Mask, Newmask);
+#elif defined _DURANGO
+	SetThreadAffinityMask(m_threadHandle, 1 << proc );
+#else
+	XSetThreadProcessor( m_threadHandle, proc);
+#endif
+}
+
+void C4JThread::SetPriority( int priority )
+{
+#ifdef __PS3__
+	switch(priority)
+	{
+	case THREAD_PRIORITY_LOWEST:			m_priority = 1003; break;  
+	case THREAD_PRIORITY_BELOW_NORMAL:		m_priority = 1002; break;  
+	case THREAD_PRIORITY_NORMAL:			m_priority = 1001; break;  // same as main thread
+	case THREAD_PRIORITY_ABOVE_NORMAL:		m_priority = 1000; break; 
+	case THREAD_PRIORITY_HIGHEST:			m_priority = 999; break; 
+	}
+	if(m_threadID != 0)
+		sys_ppu_thread_set_priority(m_threadID, m_priority);
+	//int erro = sys_ppu_thread_set_priority(m_threadID, priority);
+#elif defined __ORBIS__
+
+	switch(priority)
+	{
+		case THREAD_PRIORITY_LOWEST:			m_priority = SCE_KERNEL_PRIO_FIFO_LOWEST; break;  
+		case THREAD_PRIORITY_BELOW_NORMAL:		m_priority = SCE_KERNEL_PRIO_FIFO_LOWEST + ((SCE_KERNEL_PRIO_FIFO_DEFAULT-SCE_KERNEL_PRIO_FIFO_LOWEST)/2); break;  
+		case THREAD_PRIORITY_NORMAL:			m_priority = SCE_KERNEL_PRIO_FIFO_DEFAULT; break;  // same as main thread
+		case THREAD_PRIORITY_ABOVE_NORMAL:		m_priority = SCE_KERNEL_PRIO_FIFO_DEFAULT + ((SCE_KERNEL_PRIO_FIFO_HIGHEST-SCE_KERNEL_PRIO_FIFO_DEFAULT)/2); break; 
+		case THREAD_PRIORITY_HIGHEST:			m_priority = SCE_KERNEL_PRIO_FIFO_HIGHEST; break; 
+	}
+
+	if( m_threadID != 0 )
+	{
+		scePthreadSetprio(m_threadID,m_priority);
+	}
+#elif defined __PSVITA__
+	int Mid = g_DefaultPriority;//(SCE_KERNEL_LOWEST_PRIORITY_USER + SCE_KERNEL_HIGHEST_PRIORITY_USER) / 2;
+	switch(priority)
+	{
+		case THREAD_PRIORITY_LOWEST:			
+			m_priority = SCE_KERNEL_LOWEST_PRIORITY_USER; 
+			break;  
+		case THREAD_PRIORITY_BELOW_NORMAL:		
+			m_priority = Mid + 1; 
+			break;  
+		case THREAD_PRIORITY_NORMAL:			
+			m_priority = Mid; 
+			break;  // same as main thread
+		case THREAD_PRIORITY_ABOVE_NORMAL:		
+			m_priority = Mid - 1; 
+			break; 
+		case THREAD_PRIORITY_HIGHEST:			
+			m_priority = SCE_KERNEL_HIGHEST_PRIORITY_USER; 
+			break; 
+	}
+
+//	sceKernelChangeThreadPriority(m_threadID, m_priority);
+	app.DebugPrintf("***************************** set thread prio %s %d %d **************************\n", m_threadName, priority, m_priority);
+#else
+	SetThreadPriority(m_threadHandle, priority);
+#endif // __PS3__
+}
+
+DWORD C4JThread::WaitForCompletion( int timeoutMs )
+{
+#ifdef __PS3__
+	if(timeoutMs == INFINITE)
+		timeoutMs = SYS_NO_TIMEOUT ;
+	return m_completionFlag->WaitForSignal(timeoutMs);
+#elif defined __ORBIS__
+	return m_completionFlag->WaitForSignal( timeoutMs );
+#elif defined __PSVITA__
+	return m_completionFlag->WaitForSignal( timeoutMs );
+/*	SceUInt32 Timeout = timeoutMs * 1000;
+	SceInt32 err = sceKernelWaitThreadEnd(m_threadID, &m_exitCode, &Timeout);
+	if( err == 0 )
+	{
+		return m_exitCode;
+	}
+	else
+	{
+		if( err == SCE_KERNEL_ERROR_WAIT_TIMEOUT )
+		{
+			return WAIT_TIMEOUT;
+		}
+		else
+		{
+			// AP - not sure what to do here
+			return 0;
+		}
+	}*/
+
+//	return m_exitCode;
+#else
+	return WaitForSingleObject(m_threadHandle, timeoutMs);
+#endif // __PS3__
+}
+
+int C4JThread::GetExitCode()
+{
+#if defined  __PS3__ || defined __ORBIS__ || defined __PSVITA__
+	return m_exitCode;
+#else
+	DWORD exitcode = 0;
+	GetExitCodeThread(m_threadHandle, &exitcode);
+
+	return *((int *)&exitcode);
+#endif
+}
+
+void C4JThread::Sleep( int millisecs )
+{
+#ifdef __PS3__
+	if(millisecs == 0)
+	{
+		// https://ps3.scedev.net/forums/thread/116470/
+		// "sys_timer_usleep(0) does not yield the CPU."
+		sys_ppu_thread_yield();
+	}
+	else
+		sys_timer_usleep(millisecs * 1000);
+#elif defined __ORBIS__
+	sceKernelUsleep(((SceKernelUseconds)millisecs) * 1000);
+#elif defined __PSVITA__
+	// 4J Stu - 0 is an error, so add a tiny sleep when we just want to yield
+	sceKernelDelayThread(millisecs * 1000 + 1);
+#else
+	::Sleep(millisecs);
+#endif // __PS3__
+}
+
+C4JThread* C4JThread::getCurrentThread()
+{
+#ifdef __PS3__
+	sys_ppu_thread_t currThreadID;
+	sys_ppu_thread_get_id(&currThreadID);
+#elif defined __ORBIS__
+	ScePthread currThreadID = scePthreadSelf();
+#elif defined __PSVITA__
+	SceUID currThreadID = sceKernelGetThreadId();
+#else
+	DWORD currThreadID = GetCurrentThreadId();
+#endif //__PS3__
+	EnterCriticalSection(&ms_threadListCS);
+
+	for(int i=0;i<ms_threadList.size(); i++)
+	{
+		if(currThreadID == ms_threadList[i]->m_threadID)
+		{
+			LeaveCriticalSection(&ms_threadListCS);
+			return ms_threadList[i];
+		}
+	}
+
+	LeaveCriticalSection(&ms_threadListCS);
+
+	return NULL;
+}
+
+bool C4JThread::isMainThread()
+{
+#ifdef _XBOX_ONE
+	return getCurrentThread() == m_mainThread;
+#else
+	return getCurrentThread() == &m_mainThread;
+#endif
+}
+
+C4JThread::Event::Event(EMode mode/* = e_modeAutoClear*/)
+{
+	m_mode = mode;
+#ifdef __PS3__
+	sys_event_flag_attribute_t attr;
+	// default values taken from sys_event_flag_attribute_initialize
+	attr.attr_protocol = SYS_SYNC_PRIORITY;
+	attr.attr_pshared = SYS_SYNC_NOT_PROCESS_SHARED;
+	attr.key = 0;
+	attr.flags = 0;
+	attr.type = SYS_SYNC_WAITER_SINGLE; 
+	attr.name[0] = '\0';
+	sys_event_flag_attribute_initialize(attr);
+	
+	int err = sys_event_flag_create(&m_event, &attr, 0);
+
+#elif defined __ORBIS__
+	char name[1] = {0};
+	sceKernelCreateEventFlag( &m_event, name, SCE_KERNEL_EVF_ATTR_TH_FIFO | SCE_KERNEL_EVF_ATTR_MULTI, 0, NULL);
+#elif defined __PSVITA__
+	char name[1] = {0};
+	m_event = sceKernelCreateEventFlag( name, SCE_KERNEL_EVF_ATTR_TH_FIFO | SCE_KERNEL_EVF_ATTR_MULTI, 0, NULL);
+#else
+	m_event = CreateEvent( NULL, (m_mode == e_modeManualClear), FALSE, NULL );
+#endif //__PS3__
+}
+
+
+C4JThread::Event::~Event()
+{
+#ifdef __PS3__
+	sys_event_flag_destroy(m_event);
+#elif defined __ORBIS__
+	sceKernelDeleteEventFlag(m_event);
+#elif defined __PSVITA__
+	sceKernelDeleteEventFlag(m_event);
+#else
+	CloseHandle( m_event );
+#endif // __PS3__
+}
+
+
+void C4JThread::Event::Set()
+{
+#ifdef __PS3__
+	int err =sys_event_flag_set(m_event, 1);
+#elif defined __ORBIS__
+	sceKernelSetEventFlag(m_event, 1);
+#elif defined __PSVITA__
+	sceKernelSetEventFlag(m_event, 1);
+#else
+	SetEvent(m_event);
+#endif //__PS3__
+}
+
+void C4JThread::Event::Clear()
+{
+#ifdef __PS3__
+	int err =sys_event_flag_clear(m_event, ~(1));
+#elif defined __ORBIS__
+	sceKernelClearEventFlag(m_event, ~(1));
+#elif defined __PSVITA__
+	sceKernelClearEventFlag(m_event, ~1);
+#else
+	ResetEvent(m_event);
+#endif //__PS3__
+}
+
+DWORD C4JThread::Event::WaitForSignal( int timeoutMs )
+{
+#ifdef __PS3__
+	if(timeoutMs == INFINITE)
+		timeoutMs = SYS_NO_TIMEOUT ;
+	int timoutMicrosecs = timeoutMs * 1000;
+	uint32_t mode = SYS_EVENT_FLAG_WAIT_AND;
+	if(m_mode == e_modeAutoClear)
+		mode |= SYS_EVENT_FLAG_WAIT_CLEAR;
+	int err = sys_event_flag_wait(m_event, 1, mode, 0, timoutMicrosecs);
+
+	switch(err)
+	{
+	case CELL_OK: return WAIT_OBJECT_0;
+	case ETIMEDOUT: return WAIT_TIMEOUT;
+	case ECANCELED: return WAIT_ABANDONED;
+	default: return WAIT_FAILED;
+	}
+
+#elif defined __ORBIS__
+	SceKernelUseconds timeoutMicrosecs;
+	SceKernelUseconds *pTimeoutMicrosecs;
+	if( timeoutMs == INFINITE )
+	{
+		pTimeoutMicrosecs = NULL;
+	}
+	else
+	{
+		timeoutMicrosecs = ((SceKernelUseconds)timeoutMs) * 1000;
+		pTimeoutMicrosecs = &timeoutMicrosecs;
+	}
+	uint32_t waitMode = SCE_KERNEL_EVF_WAITMODE_AND;
+	if(m_mode == e_modeAutoClear)
+	{
+		waitMode |= SCE_KERNEL_EVF_WAITMODE_CLEAR_PAT;
+	}
+	int err = sceKernelWaitEventFlag(m_event, 1, waitMode, NULL, pTimeoutMicrosecs);
+	switch(err)
+	{
+		case SCE_OK: return WAIT_OBJECT_0;
+		case SCE_KERNEL_ERROR_ETIMEDOUT: return WAIT_TIMEOUT;
+		case SCE_KERNEL_ERROR_ECANCELED: return WAIT_ABANDONED;
+		default: return WAIT_FAILED;
+	}
+#elif defined __PSVITA__
+	SceUInt32 timeoutMicrosecs;
+	SceUInt32 *pTimeoutMicrosecs;
+	if( timeoutMs == INFINITE )
+	{
+		pTimeoutMicrosecs = NULL;
+	}
+	else
+	{
+		timeoutMicrosecs = ((SceInt32)timeoutMs) * 1000;
+		pTimeoutMicrosecs = &timeoutMicrosecs;
+	}
+	uint32_t waitMode = SCE_KERNEL_EVF_WAITMODE_AND;
+	if(m_mode == e_modeAutoClear)
+	{
+		waitMode |= SCE_KERNEL_EVF_WAITMODE_CLEAR_ALL;
+	}
+	int err = sceKernelWaitEventFlag(m_event, 1, waitMode, NULL, pTimeoutMicrosecs);
+	switch(err)
+	{
+		case SCE_OK: return WAIT_OBJECT_0;
+		case SCE_KERNEL_ERROR_WAIT_TIMEOUT: return WAIT_TIMEOUT;
+		case SCE_KERNEL_ERROR_WAIT_CANCEL: return WAIT_ABANDONED;
+		default: return WAIT_FAILED;
+	}
+#else
+	return WaitForSingleObject(m_event, timeoutMs);
+#endif // __PS3__
+}
+
+C4JThread::EventArray::EventArray( int size, EMode mode/* = e_modeAutoClear*/)
+{
+	assert(size<32);
+	m_size = size;
+	m_mode = mode;
+#ifdef __PS3__
+	sys_event_flag_attribute_t attr;
+	// default values taken from sys_event_flag_attribute_initialize
+	attr.attr_protocol = SYS_SYNC_PRIORITY;
+	attr.attr_pshared = SYS_SYNC_NOT_PROCESS_SHARED;
+	attr.key = 0;
+	attr.flags = 0;
+	attr.type = SYS_SYNC_WAITER_SINGLE; 
+	attr.name[0] = '\0';
+	sys_event_flag_attribute_initialize(attr);
+	int err = sys_event_flag_create(&m_events, &attr, 0);
+	assert(err == CELL_OK);
+#elif defined __ORBIS__
+	char name[1] = {0};
+	sceKernelCreateEventFlag( &m_events, name, SCE_KERNEL_EVF_ATTR_TH_FIFO | SCE_KERNEL_EVF_ATTR_MULTI, 0, NULL);
+#elif defined __PSVITA__
+	char name[1] = {0};
+	m_events = sceKernelCreateEventFlag( name, SCE_KERNEL_EVF_ATTR_TH_FIFO | SCE_KERNEL_EVF_ATTR_MULTI, 0, NULL);
+#else
+	m_events = new HANDLE[size];
+	for(int i=0;i<size;i++)
+	{
+		m_events[i]  = CreateEvent(NULL, (m_mode == e_modeManualClear), FALSE, NULL );
+	}
+#endif // __PS3__
+}
+
+
+void C4JThread::EventArray::Set(int index)
+{
+#ifdef __PS3__
+	int err =sys_event_flag_set(m_events, 1<<index);
+	assert(err == CELL_OK);
+#elif defined __ORBIS__
+	sceKernelSetEventFlag(m_events, 1<<index);
+#elif defined __PSVITA__
+	sceKernelSetEventFlag(m_events, 1<<index);
+#else
+	SetEvent(m_events[index]);
+#endif //__PS3__
+}
+
+void C4JThread::EventArray::Clear(int index)
+{
+#ifdef __PS3__
+	int err =sys_event_flag_clear(m_events, ~(1<<index));
+	assert(err == CELL_OK);
+#elif defined __ORBIS__
+	sceKernelClearEventFlag(m_events, ~(1<<index));
+#elif defined __PSVITA__
+	sceKernelClearEventFlag(m_events, ~(1<<index));
+#else
+	ResetEvent(m_events[index]);
+#endif //__PS3__
+}
+
+void C4JThread::EventArray::SetAll()
+{
+	for(int i=0;i<m_size;i++)
+		Set(i);
+}
+
+void C4JThread::EventArray::ClearAll()
+{
+	for(int i=0;i<m_size;i++)
+		Clear(i);
+}
+
+DWORD C4JThread::EventArray::WaitForSingle(int index, int timeoutMs )
+{
+	DWORD retVal;
+#ifdef __PS3__
+	int timeoutMicrosecs;
+	if(timeoutMs == INFINITE)
+		timeoutMicrosecs = SYS_NO_TIMEOUT;
+	else
+		timeoutMicrosecs = timeoutMs * 1000;
+	uint32_t mode = SYS_EVENT_FLAG_WAIT_AND;
+	if(m_mode == e_modeAutoClear)
+		mode |= SYS_EVENT_FLAG_WAIT_CLEAR;
+
+	int err = sys_event_flag_wait(m_events, 1<<index, mode, 0, timeoutMicrosecs);
+
+	switch(err)
+	{
+	case CELL_OK:
+		retVal = WAIT_OBJECT_0;
+		break;
+	case ETIMEDOUT:
+		retVal = WAIT_TIMEOUT;
+		break;
+	case ECANCELED:
+		retVal = WAIT_ABANDONED;
+		break;
+	default:
+		assert(0);
+		retVal = WAIT_FAILED;
+		break;
+	}
+#elif defined __ORBIS__
+	SceKernelUseconds timeoutMicrosecs;
+	SceKernelUseconds *pTimeoutMicrosecs;
+	if( timeoutMs == INFINITE )
+	{
+		pTimeoutMicrosecs = NULL;
+	}
+	else
+	{
+		timeoutMicrosecs = ((SceKernelUseconds)timeoutMs) * 1000;
+		pTimeoutMicrosecs = &timeoutMicrosecs;
+	}
+	uint32_t waitMode = SCE_KERNEL_EVF_WAITMODE_AND;
+	if(m_mode == e_modeAutoClear)
+	{
+		waitMode |= SCE_KERNEL_EVF_WAITMODE_CLEAR_PAT;
+	}
+	uint64_t resultPat;
+	int err = sceKernelWaitEventFlag(m_events, 1<<index, waitMode, &resultPat, pTimeoutMicrosecs);
+	assert(err != SCE_KERNEL_ERROR_ETIMEDOUT);
+	switch(err)
+	{
+		case SCE_OK:
+			retVal = WAIT_OBJECT_0;
+			break;
+		case SCE_KERNEL_ERROR_ETIMEDOUT:
+			retVal = WAIT_TIMEOUT;
+			break;
+		case SCE_KERNEL_ERROR_ECANCELED:
+			retVal = WAIT_ABANDONED;
+			break;
+		default:
+			retVal = WAIT_FAILED;
+			break;
+	}
+#elif defined __PSVITA__
+	SceUInt32 timeoutMicrosecs;
+	SceUInt32 *pTimeoutMicrosecs;
+	if( timeoutMs == INFINITE )
+	{
+		pTimeoutMicrosecs = NULL;
+	}
+	else
+	{
+		timeoutMicrosecs = ((SceUInt32)timeoutMs) * 1000;
+		pTimeoutMicrosecs = &timeoutMicrosecs;
+	}
+	uint32_t waitMode = SCE_KERNEL_EVF_WAITMODE_AND;
+	if(m_mode == e_modeAutoClear)
+	{
+		waitMode |= SCE_KERNEL_EVF_WAITMODE_CLEAR_ALL;
+	}
+	int err = sceKernelWaitEventFlag(m_events, 1<<index, waitMode, NULL, pTimeoutMicrosecs);
+	switch(err)
+	{
+		case SCE_OK: return WAIT_OBJECT_0;
+		case SCE_KERNEL_ERROR_WAIT_TIMEOUT: return WAIT_TIMEOUT;
+		case SCE_KERNEL_ERROR_WAIT_CANCEL: return WAIT_ABANDONED;
+		default: return WAIT_FAILED;
+	}
+#else
+	retVal = WaitForSingleObject(m_events[index], timeoutMs);
+#endif // __PS3__
+
+	return retVal;
+}
+
+DWORD C4JThread::EventArray::WaitForAll(int timeoutMs )
+{
+	DWORD retVal;
+#ifdef __PS3__
+	if(timeoutMs == INFINITE)
+		timeoutMs = SYS_NO_TIMEOUT ;
+	int timoutMicrosecs = timeoutMs * 1000;
+	unsigned int bitmask = 0;
+	for(int i=0;i<m_size;i++)
+		bitmask |= (1<<i);
+
+	uint32_t mode = SYS_EVENT_FLAG_WAIT_AND;
+	if(m_mode == e_modeAutoClear)
+		mode |= SYS_EVENT_FLAG_WAIT_CLEAR;
+
+	int err = sys_event_flag_wait(m_events, bitmask, mode, 0, timoutMicrosecs);
+
+	switch(err)
+	{
+	case CELL_OK:
+		retVal = WAIT_OBJECT_0;
+		break;
+	case ETIMEDOUT:
+		retVal = WAIT_TIMEOUT;
+		break;
+	case ECANCELED:
+		retVal = WAIT_ABANDONED;
+		break;
+	default:
+		assert(0);
+		retVal = WAIT_FAILED;
+		break;
+	}
+
+#elif defined __ORBIS__
+	SceKernelUseconds timeoutMicrosecs;
+	SceKernelUseconds *pTimeoutMicrosecs;
+	if( timeoutMs == INFINITE )
+	{
+		pTimeoutMicrosecs = NULL;
+	}
+	else
+	{
+		timeoutMicrosecs = ((SceKernelUseconds)timeoutMs) * 1000;
+		pTimeoutMicrosecs = &timeoutMicrosecs;
+	}
+	unsigned int bitmask = 0;
+	for(int i=0;i<m_size;i++)
+		bitmask |= (1<<i);
+	uint32_t waitMode = SCE_KERNEL_EVF_WAITMODE_AND;
+	if(m_mode == e_modeAutoClear)
+	{
+		waitMode |= SCE_KERNEL_EVF_WAITMODE_CLEAR_PAT;
+	}
+	int err = sceKernelWaitEventFlag(m_events, bitmask, waitMode, NULL, pTimeoutMicrosecs);
+	switch(err)
+	{
+		case SCE_OK:
+			retVal = WAIT_OBJECT_0;
+			break;
+		case SCE_KERNEL_ERROR_ETIMEDOUT:
+			retVal = WAIT_TIMEOUT;
+			break;
+		case SCE_KERNEL_ERROR_ECANCELED:
+			retVal = WAIT_ABANDONED;
+			break;
+		default:
+			retVal = WAIT_FAILED;
+			break;
+	}
+#elif defined __PSVITA__
+	SceUInt32 timeoutMicrosecs;
+	SceUInt32 *pTimeoutMicrosecs;
+	if( timeoutMs == INFINITE )
+	{
+		pTimeoutMicrosecs = NULL;
+	}
+	else
+	{
+		timeoutMicrosecs = ((SceUInt32)timeoutMs) * 1000;
+		pTimeoutMicrosecs = &timeoutMicrosecs;
+	}
+	unsigned int bitmask = 0;
+	for(int i=0;i<m_size;i++)
+		bitmask |= (1<<i);
+	uint32_t waitMode = SCE_KERNEL_EVF_WAITMODE_AND;
+	if(m_mode == e_modeAutoClear)
+	{
+		waitMode |= SCE_KERNEL_EVF_WAITMODE_CLEAR_ALL;
+	}
+	int err = sceKernelWaitEventFlag(m_events, bitmask, waitMode, NULL, pTimeoutMicrosecs);
+	switch(err)
+	{
+		case SCE_OK: return WAIT_OBJECT_0;
+		case SCE_KERNEL_ERROR_WAIT_TIMEOUT: return WAIT_TIMEOUT;
+		case SCE_KERNEL_ERROR_WAIT_CANCEL: return WAIT_ABANDONED;
+		default: return WAIT_FAILED;
+	}
+#else
+	retVal = WaitForMultipleObjects(m_size, m_events, true, timeoutMs);
+#endif // __PS3__
+
+	return retVal;
+}
+
+DWORD C4JThread::EventArray::WaitForAny(int timeoutMs )
+{
+#ifdef __PS3__
+	if(timeoutMs == INFINITE)
+		timeoutMs = SYS_NO_TIMEOUT ;
+	int timoutMicrosecs = timeoutMs * 1000;
+	unsigned int bitmask = 0;
+	for(int i=0;i<m_size;i++)
+		bitmask |= (1<<i);
+
+	uint32_t mode = SYS_EVENT_FLAG_WAIT_OR;
+	if(m_mode == e_modeAutoClear)
+		mode |= SYS_EVENT_FLAG_WAIT_CLEAR;
+
+	int err = sys_event_flag_wait(m_events, bitmask, mode, 0, timoutMicrosecs);
+
+	switch(err)
+	{
+	case CELL_OK: return WAIT_OBJECT_0;
+	case ETIMEDOUT: return WAIT_TIMEOUT;
+	case ECANCELED: return WAIT_ABANDONED;
+	default:
+		assert(0);
+		return WAIT_FAILED;
+	}
+
+#elif defined __ORBIS__
+	SceKernelUseconds timeoutMicrosecs;
+	SceKernelUseconds *pTimeoutMicrosecs;
+	if( timeoutMs == INFINITE )
+	{
+		pTimeoutMicrosecs = NULL;
+	}
+	else
+	{
+		timeoutMicrosecs = ((SceKernelUseconds)timeoutMs) * 1000;
+		pTimeoutMicrosecs = &timeoutMicrosecs;
+	}
+	unsigned int bitmask = 0;
+	for(int i=0;i<m_size;i++)
+		bitmask |= (1<<i);
+	uint32_t waitMode = SCE_KERNEL_EVF_WAITMODE_OR;
+	if(m_mode == e_modeAutoClear)
+	{
+		waitMode |= SCE_KERNEL_EVF_WAITMODE_CLEAR_PAT;
+	}
+	int err = sceKernelWaitEventFlag(m_events, bitmask, waitMode, NULL, pTimeoutMicrosecs);
+	switch(err)
+	{
+		case SCE_OK: return WAIT_OBJECT_0;
+		case SCE_KERNEL_ERROR_ETIMEDOUT: return WAIT_TIMEOUT;
+		case SCE_KERNEL_ERROR_ECANCELED: return WAIT_ABANDONED;
+		default: return WAIT_FAILED;
+	}
+#elif defined __PSVITA__
+	SceUInt32 timeoutMicrosecs;
+	SceUInt32 *pTimeoutMicrosecs;
+	if( timeoutMs == INFINITE )
+	{
+		pTimeoutMicrosecs = NULL;
+	}
+	else
+	{
+		timeoutMicrosecs = ((SceUInt32)timeoutMs) * 1000;
+		pTimeoutMicrosecs = &timeoutMicrosecs;
+	}
+	unsigned int bitmask = 0;
+	for(int i=0;i<m_size;i++)
+		bitmask |= (1<<i);
+	uint32_t waitMode = SCE_KERNEL_EVF_WAITMODE_OR;
+	if(m_mode == e_modeAutoClear)
+	{
+		waitMode |= SCE_KERNEL_EVF_WAITMODE_CLEAR_ALL;
+	}
+	int err = sceKernelWaitEventFlag(m_events, bitmask, waitMode, NULL, pTimeoutMicrosecs);
+	switch(err)
+	{
+		case SCE_OK: return WAIT_OBJECT_0;
+		case SCE_KERNEL_ERROR_WAIT_TIMEOUT: return WAIT_TIMEOUT;
+		case SCE_KERNEL_ERROR_WAIT_CANCEL: return WAIT_ABANDONED;
+		default: return WAIT_FAILED;
+	}
+#else
+	return WaitForMultipleObjects(m_size, m_events, false, timeoutMs);
+#endif // __PS3__
+}
+
+#ifdef __PS3__
+void C4JThread::EventArray::Cancel()
+{
+	sys_event_flag_cancel(m_events, NULL);
+}
+#endif 
+
+
+
+
+C4JThread::EventQueue::EventQueue( UpdateFunc* updateFunc, ThreadInitFunc threadInitFunc, const char* szThreadName)
+{
+	m_updateFunc = updateFunc;
+	m_threadInitFunc = threadInitFunc;
+	strcpy(m_threadName, szThreadName);
+	m_thread = NULL;
+	m_startEvent = NULL;
+	m_finishedEvent = NULL;
+	m_processor = -1;
+	m_priority = THREAD_PRIORITY_HIGHEST+1;
+}
+
+void C4JThread::EventQueue::init()
+{
+	m_startEvent = new C4JThread::EventArray(1);
+	m_finishedEvent = new C4JThread::Event();
+	InitializeCriticalSection(&m_critSect);
+	m_thread = new C4JThread(threadFunc, this, m_threadName);
+	if(m_processor >= 0)
+		m_thread->SetProcessor(m_processor);
+	if(m_priority != THREAD_PRIORITY_HIGHEST+1)
+		m_thread->SetPriority(m_priority);
+	m_thread->Run();
+}
+
+void C4JThread::EventQueue::sendEvent( Level* pLevel )
+{
+	if(m_thread == NULL)
+		init();
+	EnterCriticalSection(&m_critSect);
+	m_queue.push(pLevel);
+	m_startEvent->Set(0);
+	m_finishedEvent->Clear();
+	LeaveCriticalSection(&m_critSect);
+}
+
+void C4JThread::EventQueue::waitForFinish()
+{
+	if(m_thread == NULL)
+		init();
+	EnterCriticalSection(&m_critSect);
+	if(m_queue.empty())
+	{
+		LeaveCriticalSection((&m_critSect));
+		return;
+	}
+	LeaveCriticalSection((&m_critSect));
+	m_finishedEvent->WaitForSignal(INFINITE);
+}
+
+int C4JThread::EventQueue::threadFunc( void* lpParam )
+{
+	EventQueue* p = (EventQueue*)lpParam;
+	p->threadPoll();
+	return 0;
+}
+
+void C4JThread::EventQueue::threadPoll()
+{
+	ShutdownManager::HasStarted(ShutdownManager::eEventQueueThreads, m_startEvent);
+
+	if(m_threadInitFunc)
+		m_threadInitFunc();
+
+	while(ShutdownManager::ShouldRun(ShutdownManager::eEventQueueThreads))
+	{
+
+		DWORD err = m_startEvent->WaitForAny(INFINITE);
+		if(err == WAIT_OBJECT_0)
+		{
+			bool bListEmpty = true;
+			do 
+			{
+				EnterCriticalSection(&m_critSect);
+				void* updateParam = m_queue.front();
+				LeaveCriticalSection(&m_critSect);
+
+				m_updateFunc(updateParam);
+
+				EnterCriticalSection(&m_critSect);
+				m_queue.pop();
+				bListEmpty = m_queue.empty();
+				if(bListEmpty)
+				{
+					m_finishedEvent->Set();
+				}
+				LeaveCriticalSection(&m_critSect);
+
+			} while(!bListEmpty);
+		}
+	};
+
+	ShutdownManager::HasFinished(ShutdownManager::eEventQueueThreads);
+}
+
+
+#ifdef __ORBIS__
+
+void C4JThread::PushAffinityAllCores()
+{
+	assert(m_oldAffinityMask == 0);
+	int err;
+	ScePthread currThreadID = scePthreadSelf();
+	err = scePthreadGetaffinity(currThreadID, &m_oldAffinityMask);
+	assert(err == SCE_OK);
+	err = scePthreadSetaffinity(currThreadID, 63);
+	assert(err == SCE_OK);
+
+
+}
+
+void C4JThread::PopAffinity()
+{
+	int err;
+	ScePthread currThreadID = scePthreadSelf();
+	err = scePthreadSetaffinity(currThreadID, m_oldAffinityMask);
+	m_oldAffinityMask = 0;
+	assert(err == SCE_OK);
+}
+
+#endif // __ORBIS__
\ No newline at end of file