first commit

Minecraft.Client/Orbis/OrbisExtras/OrbisMaths.h

@@ -0,0 +1,11 @@
+#pragma once
+#include <vectormath.h>
+using namespace sce::Vectormath::Simd::Aos;
+
+typedef Vector4 XMVECTOR;
+typedef Matrix4 XMMATRIX;
+typedef Vector4 XMFLOAT4;
+
+XMMATRIX XMMatrixMultiply(XMMATRIX a, XMMATRIX b);
+XMVECTOR XMMatrixDeterminant(XMMATRIX a);
+XMMATRIX XMMatrixInverse(Vector4 *a, XMMATRIX b);

Minecraft.Client/Orbis/OrbisExtras/OrbisStubs.cpp

@@ -0,0 +1,790 @@
+#include "stdafx.h"
+#include <sce_atomic.h>
+#include <fios2.h>
+#include <libsysmodule.h>
+#include <perf.h>
+#include <audioout.h>
+#include <game_custom_data_dialog.h>
+#include <system_service.h>
+#include <error_dialog.h>
+#include <message_dialog.h>
+
+
+//#include <app_content.h>
+
+// These are required so that the heap will automatically expand - default is limited to 256KB
+size_t sceLibcHeapSize = SCE_LIBC_HEAP_SIZE_EXTENDED_ALLOC_NO_LIMIT;
+unsigned int sceLibcHeapExtendedAlloc = 1;
+
+//static char dirName[128];
+//static char contentInfoPath[128];
+static char usrdirPath[128];
+int32_t hBGMAudio;
+
+//static char sc_loadPath[] = {"/app0/"};
+//const char* getConsoleHomePath() { return sc_loadPath; }
+
+char* getUsrDirPath() 
+{ 
+	return usrdirPath; 
+}
+
+
+int _wcsicmp( const wchar_t * dst, const wchar_t * src )
+{
+	wchar_t f,l;
+
+	// validation section 
+	// 	_VALIDATE_RETURN(dst != NULL, EINVAL, _NLSCMPERROR);
+	// 	_VALIDATE_RETURN(src != NULL, EINVAL, _NLSCMPERROR);
+
+	do  {
+		f = towlower(*dst);
+		l = towlower(*src);
+		dst++;
+		src++;
+	} while ( (f) && (f == l) );
+	return (int)(f - l);
+}
+
+size_t wcsnlen(const wchar_t *wcs, size_t maxsize)
+{
+    size_t n;
+
+//      Note that we do not check if s == NULL, because we do not
+//      return errno_t...
+
+    for (n = 0; n < maxsize && *wcs; n++, wcs++)
+        ;
+
+    return n;
+}
+
+
+VOID GetSystemTime(	LPSYSTEMTIME lpSystemTime) 
+{
+	SceRtcDateTime dateTime;
+	int err = sceRtcGetCurrentClock(&dateTime, 0);
+	assert(err == SCE_OK);
+
+	lpSystemTime->wYear = sceRtcGetYear(&dateTime);
+	lpSystemTime->wMonth = sceRtcGetMonth(&dateTime);
+	lpSystemTime->wDay = sceRtcGetDay(&dateTime);
+	lpSystemTime->wDayOfWeek = sceRtcGetDayOfWeek(lpSystemTime->wYear, lpSystemTime->wMonth, lpSystemTime->wDay);
+	lpSystemTime->wHour = sceRtcGetHour(&dateTime);
+	lpSystemTime->wMinute = sceRtcGetMinute(&dateTime);
+	lpSystemTime->wSecond = sceRtcGetSecond(&dateTime);
+	lpSystemTime->wMilliseconds = sceRtcGetMicrosecond(&dateTime)/1000;
+}
+BOOL FileTimeToSystemTime(CONST FILETIME *lpFileTime, LPSYSTEMTIME lpSystemTime) { ORBIS_STUBBED; return false; }
+BOOL SystemTimeToFileTime(CONST SYSTEMTIME *lpSystemTime, LPFILETIME lpFileTime) { ORBIS_STUBBED; return false; }
+VOID GetLocalTime(LPSYSTEMTIME lpSystemTime) 
+{ 
+	SceRtcDateTime dateTime;
+	int err = sceRtcGetCurrentClockLocalTime(&dateTime);
+	assert(err == SCE_OK );
+
+	lpSystemTime->wYear = sceRtcGetYear(&dateTime);
+	lpSystemTime->wMonth = sceRtcGetMonth(&dateTime);
+	lpSystemTime->wDay = sceRtcGetDay(&dateTime);
+	lpSystemTime->wDayOfWeek = sceRtcGetDayOfWeek(lpSystemTime->wYear, lpSystemTime->wMonth, lpSystemTime->wDay);
+	lpSystemTime->wHour = sceRtcGetHour(&dateTime);
+	lpSystemTime->wMinute = sceRtcGetMinute(&dateTime);
+	lpSystemTime->wSecond = sceRtcGetSecond(&dateTime);
+	lpSystemTime->wMilliseconds = sceRtcGetMicrosecond(&dateTime)/1000;
+}
+
+HANDLE CreateEvent(void* lpEventAttributes,	BOOL bManualReset,	BOOL bInitialState,	LPCSTR lpName) { ORBIS_STUBBED; return NULL; }
+VOID Sleep(DWORD dwMilliseconds) 
+{ 
+	C4JThread::Sleep(dwMilliseconds);
+}
+
+BOOL SetThreadPriority(HANDLE hThread, int nPriority) { ORBIS_STUBBED; return FALSE; }
+DWORD WaitForSingleObject(HANDLE hHandle, DWORD dwMilliseconds) { ORBIS_STUBBED; return false; }
+
+LONG InterlockedCompareExchangeRelease(LONG volatile *Destination, LONG Exchange,LONG Comperand	) 
+{ 
+	return sceAtomicCompareAndSwap32((int32_t*)Destination, (int32_t)Comperand, (int32_t)Exchange);
+}
+
+LONG64 InterlockedCompareExchangeRelease64(LONG64 volatile *Destination, LONG64 Exchange, LONG64 Comperand) 
+{ 
+	return sceAtomicCompareAndSwap64((int64_t*)Destination, (int64_t)Comperand, (int64_t)Exchange);
+}
+
+
+ScePthreadMutexattr mutexParams;
+int64_t g_OpStorage[4*1024];    /* 32KiB */
+int64_t g_ChunkStorage[8*1024]; /* 64KiB */
+int64_t g_FHStorage[2*1024];    /* 16KiB */
+int64_t g_DHStorage[512];       /* 4KiB */
+
+VOID OrbisInit()
+{
+	static bool initialised = false;
+
+	if( initialised ) return;
+	initialised = true;
+
+	sceSysmoduleLoadModule(SCE_SYSMODULE_PNG_ENC);
+	sceSysmoduleLoadModule(SCE_SYSMODULE_PNG_DEC);
+	sceSysmoduleLoadModule(SCE_SYSMODULE_APP_CONTENT);
+	sceSysmoduleLoadModule(SCE_SYSMODULE_SAVE_DATA_DIALOG);
+	sceSysmoduleLoadModule(SCE_SYSMODULE_IME_DIALOG);
+	sceSysmoduleLoadModule(SCE_SYSMODULE_RUDP);
+	sceSysmoduleLoadModule(SCE_SYSMODULE_NP_MATCHING2);
+	sceSysmoduleLoadModule(SCE_SYSMODULE_INVITATION_DIALOG);
+	sceSysmoduleLoadModule(SCE_SYSMODULE_NP_PARTY ); 
+	sceSysmoduleLoadModule(SCE_SYSMODULE_GAME_CUSTOM_DATA_DIALOG ); 
+	sceSysmoduleLoadModule(SCE_SYSMODULE_NP_SCORE_RANKING ); 
+	sceSysmoduleLoadModule(SCE_SYSMODULE_NP_AUTH ); 
+	sceSysmoduleLoadModule(SCE_SYSMODULE_NP_COMMERCE);
+	sceSysmoduleLoadModule(SCE_SYSMODULE_REMOTE_PLAY);
+	sceSysmoduleLoadModule(SCE_SYSMODULE_ERROR_DIALOG);
+	sceSysmoduleLoadModule(SCE_SYSMODULE_MESSAGE_DIALOG);
+	sceSysmoduleLoadModule(SCE_SYSMODULE_VOICE);
+	sceSysmoduleLoadModule(SCE_SYSMODULE_GAME_LIVE_STREAMING);
+
+	SceFiosParams fiosParams = SCE_FIOS_PARAMS_INITIALIZER;
+	fiosParams.opStorage.pPtr = g_OpStorage;
+	fiosParams.opStorage.length = sizeof(g_OpStorage);
+	fiosParams.chunkStorage.pPtr = g_ChunkStorage;
+	fiosParams.chunkStorage.length = sizeof(g_ChunkStorage);
+	fiosParams.fhStorage.pPtr = g_FHStorage;
+	fiosParams.fhStorage.length = sizeof(g_FHStorage);
+	fiosParams.dhStorage.pPtr = g_DHStorage;
+	fiosParams.dhStorage.length = sizeof(g_DHStorage);
+
+	int err = sceFiosInitialize(&fiosParams);
+	assert(err == SCE_FIOS_OK);
+
+	scePthreadMutexattrInit(&mutexParams);
+	scePthreadMutexattrSettype(&mutexParams, SCE_PTHREAD_MUTEX_ADAPTIVE);
+#ifdef USE_RAZOR
+	const int RAZOR_BUFFER_SIZE = 65536;
+	void *razorMem = malloc(RAZOR_BUFFER_SIZE);
+	err = sceRazorCpuInit(razorMem, RAZOR_BUFFER_SIZE);
+	assert(err == 0 );
+#endif
+	scePthreadSetaffinity(scePthreadSelf(), 1);
+
+	sceAudioOutInit();
+	hBGMAudio=sceAudioOutOpen(
+		SCE_USER_SERVICE_USER_ID_SYSTEM,
+		SCE_AUDIO_OUT_PORT_TYPE_BGM,0,
+		256, 
+		48000,
+		2);
+
+	err = sceCommonDialogInitialize();
+	//err = sceNpCommerceDialogInitialize();
+	assert(err == SCE_OK);
+
+	// 4J-PB - Can't keep this initialised as we monitor and handle the finished status in the main menu for patches
+// 	err = sceErrorDialogInitialize();
+// 	assert(err == SCE_OK);
+
+	// 4J-PB - can't init this here - it conflicts with the commerce dialog for dlc checkouts/PSPlus upsells. We need to init it when we use it, and then terminate it.
+	//err = sceMsgDialogInitialize();
+	assert(err == SCE_OK);
+}
+
+int32_t GetAudioBGMHandle()
+{
+	return hBGMAudio;
+}
+
+VOID InitializeCriticalSection(PCRITICAL_SECTION CriticalSection) 
+{
+	char name[1] = {0};
+
+	int err = scePthreadMutexInit(&CriticalSection->mutex, &mutexParams, name);
+	CriticalSection->m_cLock = 0;
+	assert(err == SCE_OK);
+#ifdef _DEBUG
+	CriticalSection->m_pOwnerThread = NULL;
+#endif
+
+}
+
+
+VOID InitializeCriticalSectionAndSpinCount(PCRITICAL_SECTION CriticalSection, ULONG SpinCount) 
+{
+	InitializeCriticalSection(CriticalSection);
+}
+
+VOID DeleteCriticalSection(PCRITICAL_SECTION CriticalSection)
+{
+	int err = scePthreadMutexDestroy(&CriticalSection->mutex);
+	assert(err == SCE_OK);
+}
+
+extern CRITICAL_SECTION g_singleThreadCS; 
+
+VOID EnterCriticalSection(PCRITICAL_SECTION CriticalSection) 
+{
+	int err = scePthreadMutexLock(&CriticalSection->mutex);
+	assert(err == SCE_OK || err == SCE_KERNEL_ERROR_EDEADLK );
+	CriticalSection->m_cLock++;
+
+#ifdef _DEBUG
+	__thread static bool bRecursing = false;
+	if(bRecursing == false)
+	{
+		bRecursing = true;
+		CriticalSection->m_pOwnerThread = C4JThread::getCurrentThread();
+		bRecursing = false;
+	}
+#endif
+}
+
+
+VOID LeaveCriticalSection(PCRITICAL_SECTION CriticalSection) 
+{
+	if(--CriticalSection->m_cLock == 0 )
+	{
+		int err = scePthreadMutexUnlock(&CriticalSection->mutex);
+		assert(err == SCE_OK );
+#ifdef _DEBUG
+		CriticalSection->m_pOwnerThread = NULL;
+#endif
+
+	}
+}
+
+ULONG TryEnterCriticalSection(PCRITICAL_SECTION CriticalSection)
+{
+	int err = scePthreadMutexTrylock(&CriticalSection->mutex); 
+	if((err == SCE_OK || err == SCE_KERNEL_ERROR_EDEADLK ))
+	{
+		CriticalSection->m_cLock++;
+		return true;
+	}
+	return false;
+}
+
+DWORD WaitForMultipleObjects(DWORD nCount, CONST HANDLE *lpHandles,BOOL bWaitAll,DWORD dwMilliseconds) { ORBIS_STUBBED; return 0; }
+
+BOOL CloseHandle(HANDLE hObject) 
+{ 
+	sceFiosFHCloseSync(NULL,(SceFiosFH)((int64_t)hObject));
+	return true;
+// 	ORBIS_STUBBED; 
+// 	return false; 
+}
+
+BOOL SetEvent(HANDLE hEvent) { ORBIS_STUBBED; return false; }
+
+HMODULE GetModuleHandle(LPCSTR lpModuleName) { ORBIS_STUBBED; return 0; }
+
+DWORD GetCurrentThreadId(VOID) 
+{ 
+	return 0; // TODO
+}
+DWORD WaitForMultipleObjectsEx(DWORD nCount,CONST HANDLE *lpHandles,BOOL bWaitAll,DWORD dwMilliseconds,BOOL bAlertable	) { ORBIS_STUBBED; return 0; }
+BOOL GetExitCodeThread(HANDLE hThread, LPDWORD lpExitCode) { ORBIS_STUBBED; return false;}
+
+DWORD TlsAlloc(VOID) { return TLSStorageOrbis::Instance()->Alloc(); }
+BOOL TlsFree(DWORD dwTlsIndex) { return TLSStorageOrbis::Instance()->Free(dwTlsIndex); }
+LPVOID TlsGetValue(DWORD dwTlsIndex) { return TLSStorageOrbis::Instance()->GetValue(dwTlsIndex); }
+BOOL TlsSetValue(DWORD dwTlsIndex, LPVOID lpTlsValue) { return TLSStorageOrbis::Instance()->SetValue(dwTlsIndex, lpTlsValue); }
+
+
+// we have to manage our own virtual allocs here, so this class stores all the info for each of them
+class OrbisVAlloc
+{
+public:
+	class PageInfo
+	{
+	public:
+		off_t				m_physAddr;
+		void*				m_virtualAddr;
+		uint64_t			m_size;
+
+		PageInfo(off_t physAddr, void* virtualAddr, uint64_t size) 
+			: m_physAddr(physAddr)
+			, m_virtualAddr(virtualAddr)
+			, m_size(size) 
+		{}
+	};
+	void*					m_virtualAddr;
+	uint64_t				m_virtualSize;
+	std::vector<PageInfo>	m_pagesAllocated;
+	uint64_t				m_allocatedSize;
+
+	OrbisVAlloc(void* addr, uint64_t size) 
+		: m_virtualAddr(addr)
+		, m_virtualSize(size)
+		, m_allocatedSize(0)
+	{
+	}
+
+	~OrbisVAlloc()
+	{
+		Decommit();
+		int err = sceKernelMunmap(m_virtualAddr, m_virtualSize);
+		assert( err == SCE_OK );
+	}
+
+	void* Commit(uint64_t size)
+	{
+		uint64_t sizeToAdd = size - m_allocatedSize; // the extra memory size that we have to add on
+		assert(sizeToAdd >= 0);
+		
+		if(sizeToAdd == 0)
+			return m_virtualAddr; // nothing to add
+
+
+		off_t physAddr;
+		// Allocate the physical memory here
+		int err = sceKernelAllocateDirectMemory( 0, SCE_KERNEL_MAIN_DMEM_SIZE, sizeToAdd, 16*1024,	SCE_KERNEL_WB_ONION, &physAddr);
+		if(err != SCE_OK)
+		{
+			assert(0);
+			return NULL;
+		}
+		// work out where the next page should be in virtual addr space, and pass that to the mapping function
+		void* pageVirtualAddr = ((char*)m_virtualAddr) + m_allocatedSize;
+
+		void* inAddr = pageVirtualAddr;
+		err = sceKernelMapDirectMemory(
+			&inAddr,
+			sizeToAdd,
+			SCE_KERNEL_PROT_CPU_READ | SCE_KERNEL_PROT_CPU_WRITE,
+			SCE_KERNEL_MAP_FIXED,
+			physAddr,
+			16*1024	);
+
+		if(inAddr != pageVirtualAddr) // make sure we actually get the virtual address that we requested
+		{
+			assert(0);
+			return NULL;
+		}
+		if(err != SCE_OK)
+		{
+			assert(0);
+			return NULL;
+		}
+		m_pagesAllocated.push_back(PageInfo(physAddr, pageVirtualAddr, sizeToAdd));
+		m_allocatedSize += sizeToAdd;
+		return m_virtualAddr;
+	}
+
+
+
+	void Decommit()
+	{
+		// spin round all the pages, unmapping and deallocating them
+		for(int i=0;i<m_pagesAllocated.size();i++)
+		{
+			int err = sceKernelMunmap(m_pagesAllocated[i].m_virtualAddr, m_pagesAllocated[i].m_size);
+			assert(err == SCE_OK);
+			err = sceKernelReleaseDirectMemory(m_pagesAllocated[i].m_physAddr, m_pagesAllocated[i].m_size);
+			assert(err == SCE_OK);
+		}
+		m_pagesAllocated.clear();
+		m_allocatedSize = 0;
+	}
+
+};
+
+// List of all virtual allocs that have been made
+static std::vector<OrbisVAlloc*> s_orbisVAllocs;
+
+
+LPVOID VirtualAlloc(LPVOID lpAddress, SIZE_T dwSize, DWORD flAllocationType, DWORD flProtect) 
+{ 
+	if(lpAddress == NULL)
+	{
+		void *pAddr = (void*)SCE_KERNEL_APP_MAP_AREA_START_ADDR;
+		int err = sceKernelReserveVirtualRange(&pAddr, dwSize, 0, 16*1024);
+		if( err != SCE_OK )
+		{
+			app.DebugPrintf("sceKernelReserveVirtualRange failed: 0x%08X\n", err);
+			return NULL;
+		}
+		s_orbisVAllocs.push_back(new OrbisVAlloc(pAddr, dwSize));
+		return (LPVOID)pAddr;
+	}
+	else
+	{
+		if( flAllocationType & MEM_COMMIT )
+		{
+			for(int i=0;i<s_orbisVAllocs.size();i++)
+			{
+				if(s_orbisVAllocs[i]->m_virtualAddr == lpAddress)
+				{
+					return s_orbisVAllocs[i]->Commit(dwSize);
+				}
+			}
+			assert(0); // failed to find the virtual alloc in our table
+			return NULL;
+		}
+	}
+	return NULL;
+}
+
+BOOL VirtualFree(LPVOID lpAddress, SIZE_T dwSize, DWORD dwFreeType)
+{
+	int idx = -1;
+	for(int i=0;i<s_orbisVAllocs.size();i++)
+	{
+		if(s_orbisVAllocs[i]->m_virtualAddr == lpAddress)
+		{
+			idx = i;
+		}
+	}
+
+	assert(idx >= 0);
+	assert(dwSize == s_orbisVAllocs[idx]->m_virtualSize); // only supporting decommitting the entire memory size
+
+	if(dwFreeType == MEM_DECOMMIT)
+	{
+		s_orbisVAllocs[idx]->Decommit();
+	}
+	else if(dwFreeType == MEM_RELEASE)
+	{
+		delete s_orbisVAllocs[idx];
+		s_orbisVAllocs.erase(s_orbisVAllocs.begin()+idx); 
+	}
+
+	return TRUE;
+}
+
+DWORD GetFileSize( HANDLE hFile, LPDWORD lpFileSizeHigh	) 
+{ 
+	SceFiosSize FileSize;
+	SceFiosFH fh = (SceFiosFH)((int64_t)hFile);
+	//DWORD FileSizeLow;
+	FileSize=sceFiosFHGetSize(fh);
+	if(lpFileSizeHigh)
+		*lpFileSizeHigh= (DWORD)(FileSize>>32);
+	else
+	{
+		assert(FileSize>>32 == 0);
+	}
+
+	return (DWORD)FileSize;
+}
+
+BOOL GetFileSizeEx(HANDLE hFile, PLARGE_INTEGER lpFileSize ) 
+{ 
+	SceFiosSize FileSize;
+	SceFiosFH fh = (SceFiosFH)((int64_t)hFile);
+
+	FileSize=sceFiosFHGetSize(fh);
+	lpFileSize->QuadPart=FileSize;
+
+	return true; 
+}
+BOOL WriteFile(
+	HANDLE hFile, LPCVOID lpBuffer, DWORD nNumberOfBytesToWrite, LPDWORD lpNumberOfBytesWritten, LPOVERLAPPED lpOverlapped )
+{
+	SceFiosFH fh = (SceFiosFH)((int64_t)hFile);
+	// sceFiosFHReadSync - Non-negative values are the number of bytes read, 0 <= result <= length. Negative values are error codes.
+	SceFiosSize bytesRead = sceFiosFHWriteSync(NULL, fh, lpBuffer, (SceFiosSize)nNumberOfBytesToWrite);
+	if(bytesRead < 0)
+	{
+		// error
+		return FALSE;
+	}
+	else
+	{
+		*lpNumberOfBytesWritten = (DWORD)bytesRead;
+		return TRUE;
+	}
+}
+
+BOOL ReadFile(HANDLE hFile, LPVOID lpBuffer, DWORD nNumberOfBytesToRead, LPDWORD lpNumberOfBytesRead, LPOVERLAPPED lpOverlapped ) 
+{
+	SceFiosFH fh = (SceFiosFH)((int64_t)hFile);
+	// sceFiosFHReadSync - Non-negative values are the number of bytes read, 0 <= result <= length. Negative values are error codes.
+	SceFiosSize bytesRead = sceFiosFHReadSync(NULL, fh, lpBuffer, (SceFiosSize)nNumberOfBytesToRead);
+	*lpNumberOfBytesRead = (DWORD)bytesRead;
+	if(bytesRead < 0)
+	{
+		// error
+		return FALSE;
+	}
+	else
+	{
+		return TRUE;
+	}
+}
+
+BOOL SetFilePointer(HANDLE hFile, LONG lDistanceToMove, PLONG lpDistanceToMoveHigh, DWORD dwMoveMethod)
+{
+	SceFiosFH fd = (SceFiosFH)((int64_t)hFile);
+
+	uint64_t bitsToMove = (int64_t) lDistanceToMove;
+	SceFiosOffset pos = 0;
+
+	if (lpDistanceToMoveHigh != NULL)
+		bitsToMove |= ((uint64_t) (*lpDistanceToMoveHigh)) << 32;
+
+	SceFiosWhence whence = SCE_FIOS_SEEK_SET;
+	switch(dwMoveMethod)
+	{
+	case FILE_BEGIN:	whence = SCE_FIOS_SEEK_SET; break;
+	case FILE_CURRENT:	whence = SCE_FIOS_SEEK_CUR; break;
+	case FILE_END:		whence = SCE_FIOS_SEEK_END; break;
+	};
+
+	pos = sceFiosFHSeek(fd, (int64_t) lDistanceToMove, whence);
+
+	return (pos != -1);
+}
+
+
+HANDLE CreateFileA(LPCSTR lpFileName, DWORD dwDesiredAccess, DWORD dwShareMode, LPSECURITY_ATTRIBUTES lpSecurityAttributes, DWORD dwCreationDisposition, DWORD dwFlagsAndAttributes, HANDLE hTemplateFile) 
+{
+	char filePath[256];
+	std::string mountedPath = StorageManager.GetMountedPath(lpFileName);
+	if(mountedPath.length() > 0)
+	{
+		strcpy(filePath, mountedPath.c_str());
+	}
+	else if(lpFileName[0] == '/') // already fully qualified path
+		strcpy(filePath, lpFileName );
+	else
+		sprintf(filePath,"%s/%s",getUsrDirPath(), lpFileName );
+	
+#ifndef _CONTENT_PACKAGE
+	app.DebugPrintf("*** Opening %s\n",filePath);
+#endif
+
+	SceFiosFH fh;
+	SceFiosOpenParams openParams;
+	ZeroMemory(&openParams, sizeof(SceFiosOpenParams));
+	
+	switch(dwDesiredAccess)
+	{ 
+	case GENERIC_READ:
+		openParams.openFlags = SCE_FIOS_O_RDONLY;	break;
+	case GENERIC_WRITE:
+		openParams.openFlags = SCE_FIOS_O_WRONLY;	break;
+	default:
+		openParams.openFlags = SCE_FIOS_O_READ | SCE_FIOS_O_WRITE;		break;
+	}
+
+	switch(dwCreationDisposition)
+	{
+	case CREATE_ALWAYS:
+		openParams.openFlags |= SCE_FIOS_O_CREAT;	break;
+	case CREATE_NEW:
+		openParams.openFlags |= SCE_FIOS_O_CREAT;	break;
+	case OPEN_ALWAYS:
+		openParams.openFlags |= SCE_FIOS_O_CREAT;	break;
+	case OPEN_EXISTING:
+		break;
+	case TRUNCATE_EXISTING:
+		break;
+	}
+	int err = sceFiosFHOpenSync(NULL, &fh, filePath, &openParams);
+
+	if(err != SCE_FIOS_OK)
+	{
+		return INVALID_HANDLE_VALUE;
+	}
+	//assert( err == SCE_FIOS_OK );
+	
+	return (void*)fh;
+}
+
+BOOL CreateDirectoryA(LPCSTR lpPathName, LPSECURITY_ATTRIBUTES lpSecurityAttributes){ ORBIS_STUBBED; return false; }
+BOOL DeleteFileA(LPCSTR lpFileName) { ORBIS_STUBBED; return false; }
+
+// BOOL XCloseHandle(HANDLE a) 
+// {
+// 	sceFiosFHCloseSync(NULL,(SceFiosFH)((int64_t)a));
+// 	return true;
+// }
+
+
+DWORD GetFileAttributesA(LPCSTR lpFileName) 
+{
+	char filePath[256];
+	std::string mountedPath = StorageManager.GetMountedPath(lpFileName);
+	if(mountedPath.length() > 0)
+	{
+		strcpy(filePath, mountedPath.c_str());
+	}
+	else if(lpFileName[0] == '/') // already fully qualified path
+		strcpy(filePath, lpFileName );
+	else
+		sprintf(filePath,"%s/%s",getUsrDirPath(), lpFileName );	// set to load from host
+
+	// check if the file exists first
+	SceFiosStat  statData;
+	if(sceFiosStatSync(NULL, filePath, &statData) != SCE_FIOS_OK)
+	{
+		app.DebugPrintf("*** sceFiosStatSync Failed\n");
+		return -1;
+	}
+	if(statData.statFlags & SCE_FIOS_STATUS_DIRECTORY )
+		return FILE_ATTRIBUTE_DIRECTORY;
+	else
+		return FILE_ATTRIBUTE_NORMAL;
+}
+
+
+BOOL MoveFileA(LPCSTR lpExistingFileName, LPCSTR lpNewFileName) { ORBIS_STUBBED; return false; }
+
+
+DWORD GetLastError(VOID) { ORBIS_STUBBED; return 0; }
+VOID GlobalMemoryStatus(LPMEMORYSTATUS lpBuffer) 
+{
+	SceLibcMallocManagedSize stat;
+	int err = malloc_stats(&stat);
+	if(err != 0)
+	{
+		app.DebugPrintf("Failed to get mem stats\n");
+	}
+
+	lpBuffer->dwTotalPhys = stat.maxSystemSize;
+	lpBuffer->dwAvailPhys = stat.maxSystemSize - stat.currentSystemSize;
+	lpBuffer->dwAvailVirtual = stat.maxSystemSize - stat.currentInuseSize;
+}
+
+DWORD GetTickCount() 
+{
+	// This function returns the current system time at this function is called. 
+	// The system time is represented the time elapsed since the system starts up in microseconds.
+	uint64_t sysTime = sceKernelGetProcessTime();
+	return (DWORD)(sysTime / 1000); 
+}
+
+// we should really use libperf for this kind of thing, but this will do for now.
+BOOL QueryPerformanceFrequency(LARGE_INTEGER *lpFrequency) 
+{ 
+	// microseconds
+	lpFrequency->QuadPart =  (1000 * 1000);		
+	return false; 
+}
+BOOL QueryPerformanceCounter(LARGE_INTEGER *lpPerformanceCount)
+{
+	// microseconds
+	lpPerformanceCount->QuadPart = sceKernelGetProcessTime();
+	return true;
+}
+
+#ifndef _FINAL_BUILD
+
+VOID OutputDebugStringW(LPCWSTR lpOutputString) 
+{ 
+	wprintf(lpOutputString); 
+}
+
+VOID OutputDebugStringA(LPCSTR lpOutputString) 
+{ 
+	printf(lpOutputString); 
+}
+
+VOID OutputDebugString(LPCSTR lpOutputString) 
+{ 
+	printf(lpOutputString); 
+}
+#endif // _CONTENT_PACKAGE
+
+BOOL GetFileAttributesExA(LPCSTR lpFileName,GET_FILEEX_INFO_LEVELS fInfoLevelId,LPVOID lpFileInformation)
+{ 
+	ORBIS_STUBBED;
+	return false;
+}
+HANDLE FindFirstFileA(LPCSTR lpFileName, LPWIN32_FIND_DATA lpFindFileData) { ORBIS_STUBBED; return 0;}
+BOOL FindNextFileA(HANDLE hFindFile, LPWIN32_FIND_DATAA lpFindFileData) { ORBIS_STUBBED; return false;}
+
+errno_t _itoa_s(int _Value, char * _DstBuf, size_t _Size, int _Radix) { if(_Radix==10) sprintf(_DstBuf,"%d",_Value); else if(_Radix==16) sprintf(_DstBuf,"%lx",_Value); else return -1; return 0; }
+errno_t _i64toa_s(__int64 _Val, char * _DstBuf, size_t _Size, int _Radix) { if(_Radix==10) sprintf(_DstBuf,"%lld",_Val); else return -1; return 0; }
+
+DWORD XGetLanguage() 
+{ 
+	unsigned char ucLang = app.GetMinecraftLanguage(0);
+	int iLang;
+
+	// check if we should override the system language or not
+	if(ucLang==MINECRAFT_LANGUAGE_DEFAULT)	
+	{
+		sceSystemServiceParamGetInt(SCE_SYSTEM_SERVICE_PARAM_ID_LANG,&iLang);
+	}
+	else
+	{
+		return (DWORD)ucLang;
+	}
+
+	switch(iLang)
+	{
+	case SCE_SYSTEM_PARAM_LANG_JAPANESE			: return XC_LANGUAGE_JAPANESE;
+	case SCE_SYSTEM_PARAM_LANG_ENGLISH_US		: return XC_LANGUAGE_ENGLISH;
+	case SCE_SYSTEM_PARAM_LANG_FRENCH			: return XC_LANGUAGE_FRENCH;
+
+	case SCE_SYSTEM_PARAM_LANG_SPANISH			: return XC_LANGUAGE_SPANISH;
+	case SCE_SYSTEM_PARAM_LANG_SPANISH_LA		: return XC_LANGUAGE_LATINAMERICANSPANISH;
+
+	case SCE_SYSTEM_PARAM_LANG_GERMAN			: return XC_LANGUAGE_GERMAN;
+	case SCE_SYSTEM_PARAM_LANG_ITALIAN			: return XC_LANGUAGE_ITALIAN;
+	case SCE_SYSTEM_PARAM_LANG_PORTUGUESE_PT	: return XC_LANGUAGE_PORTUGUESE;
+
+	case SCE_SYSTEM_PARAM_LANG_RUSSIAN			: return XC_LANGUAGE_RUSSIAN;
+	case SCE_SYSTEM_PARAM_LANG_KOREAN			: return XC_LANGUAGE_KOREAN;
+	case SCE_SYSTEM_PARAM_LANG_CHINESE_T		: return XC_LANGUAGE_TCHINESE;
+	case SCE_SYSTEM_PARAM_LANG_PORTUGUESE_BR	: return XC_LANGUAGE_PORTUGUESE;
+	case SCE_SYSTEM_PARAM_LANG_ENGLISH_GB		: return XC_LANGUAGE_ENGLISH;
+
+	case SCE_SYSTEM_PARAM_LANG_DUTCH			: return XC_LANGUAGE_DUTCH;
+	case SCE_SYSTEM_PARAM_LANG_FINNISH			: return XC_LANGUAGE_FINISH;
+	case SCE_SYSTEM_PARAM_LANG_SWEDISH 			: return XC_LANGUAGE_SWEDISH;
+	case SCE_SYSTEM_PARAM_LANG_DANISH 			: return XC_LANGUAGE_DANISH;
+	case SCE_SYSTEM_PARAM_LANG_NORWEGIAN  		: return XC_LANGUAGE_BNORWEGIAN;
+	case SCE_SYSTEM_PARAM_LANG_POLISH  			: return XC_LANGUAGE_POLISH;
+	case SCE_SYSTEM_PARAM_LANG_TURKISH			: return XC_LANGUAGE_TURKISH;
+
+
+	case SCE_SYSTEM_PARAM_LANG_CHINESE_S		: return XC_LANGUAGE_SCHINESE;
+
+	default										: return XC_LANGUAGE_ENGLISH;
+	}
+
+}
+DWORD XGetLocale() 
+{ 
+	int iLang;
+	sceSystemServiceParamGetInt(SCE_SYSTEM_SERVICE_PARAM_ID_LANG,&iLang);
+	switch(iLang)
+	{
+	case SCE_SYSTEM_PARAM_LANG_JAPANESE			: return XC_LOCALE_JAPAN;
+	case SCE_SYSTEM_PARAM_LANG_ENGLISH_US		: return XC_LOCALE_UNITED_STATES;
+	case SCE_SYSTEM_PARAM_LANG_FRENCH			: return XC_LOCALE_FRANCE;
+
+	case SCE_SYSTEM_PARAM_LANG_SPANISH			: return XC_LOCALE_SPAIN;
+	case SCE_SYSTEM_PARAM_LANG_SPANISH_LA		: return XC_LOCALE_LATIN_AMERICA;
+
+	case SCE_SYSTEM_PARAM_LANG_GERMAN			: return XC_LOCALE_GERMANY;
+	case SCE_SYSTEM_PARAM_LANG_ITALIAN			: return XC_LOCALE_ITALY;
+	case SCE_SYSTEM_PARAM_LANG_PORTUGUESE_PT	: return XC_LOCALE_PORTUGAL;
+
+	case SCE_SYSTEM_PARAM_LANG_RUSSIAN			: return XC_LOCALE_RUSSIAN_FEDERATION;
+	case SCE_SYSTEM_PARAM_LANG_KOREAN			: return XC_LOCALE_KOREA;
+	case SCE_SYSTEM_PARAM_LANG_CHINESE_T		: return XC_LOCALE_CHINA;
+	case SCE_SYSTEM_PARAM_LANG_PORTUGUESE_BR	: return XC_LOCALE_BRAZIL;
+	case SCE_SYSTEM_PARAM_LANG_ENGLISH_GB		: return XC_LOCALE_GREAT_BRITAIN;
+
+	case SCE_SYSTEM_PARAM_LANG_DUTCH			: return XC_LOCALE_NETHERLANDS;
+	case SCE_SYSTEM_PARAM_LANG_FINNISH			: return XC_LOCALE_FINLAND;
+	case SCE_SYSTEM_PARAM_LANG_SWEDISH 			: return XC_LOCALE_SWEDEN;
+	case SCE_SYSTEM_PARAM_LANG_DANISH 			: return XC_LOCALE_DENMARK;
+	case SCE_SYSTEM_PARAM_LANG_NORWEGIAN  		: return XC_LOCALE_NORWAY;
+	case SCE_SYSTEM_PARAM_LANG_POLISH  			: return XC_LOCALE_POLAND;
+	case SCE_SYSTEM_PARAM_LANG_TURKISH			: return XC_LOCALE_TURKEY;
+
+
+	case SCE_SYSTEM_PARAM_LANG_CHINESE_S		: return XC_LOCALE_CHINA;
+	default										: return XC_LOCALE_UNITED_STATES;
+	}
+}
+
+DWORD XEnableGuestSignin(BOOL fEnable) 
+{ 
+	return 0; 
+}

Minecraft.Client/Orbis/OrbisExtras/OrbisStubs.h

@@ -0,0 +1,422 @@
+#pragma once
+#include <libdbg.h>
+
+#include "TLSStorage.h"
+
+class C4JThread;
+
+//const char* getConsoleHomePath();
+char* getUsrDirPath();
+
+void OrbisInit();
+
+DWORD TlsAlloc(VOID);
+LPVOID TlsGetValue(DWORD dwTlsIndex);
+BOOL TlsSetValue(DWORD dwTlsIndex, LPVOID lpTlsValue);
+
+typedef struct _RECT 
+{
+	LONG left;
+	LONG top;
+	LONG right;
+	LONG bottom;
+} RECT, *PRECT;
+
+typedef void ID3D11Device;
+typedef void ID3D11DeviceContext;
+typedef void IDXGISwapChain;
+typedef RECT D3D11_RECT;
+typedef void ID3D11Buffer;
+typedef DWORD (*PTHREAD_START_ROUTINE)(	LPVOID lpThreadParameter);
+typedef PTHREAD_START_ROUTINE LPTHREAD_START_ROUTINE;
+
+typedef int errno_t;
+
+// typedef struct _RTL_CRITICAL_SECTION {
+// 	//
+// 	//  The following field is used for blocking when there is contention for
+// 	//  the resource
+// 	//
+// 
+// 	union {
+// 		ULONG_PTR RawEvent[4];
+// 	} Synchronization;
+// 
+// 	//
+// 	//  The following three fields control entering and exiting the critical
+// 	//  section for the resource
+// 	//
+// 
+// 	LONG LockCount;
+// 	LONG RecursionCount;
+// 	HANDLE OwningThread;
+// } RTL_CRITICAL_SECTION, *PRTL_CRITICAL_SECTION;
+
+class OrbisCriticalSection
+{
+public:
+	ScePthreadMutex mutex;
+	int				m_cLock;
+#ifdef _DEBUG
+	C4JThread* m_pOwnerThread;
+#endif
+};
+
+typedef OrbisCriticalSection RTL_CRITICAL_SECTION;
+typedef OrbisCriticalSection* PRTL_CRITICAL_SECTION;
+
+typedef RTL_CRITICAL_SECTION CRITICAL_SECTION;
+typedef PRTL_CRITICAL_SECTION PCRITICAL_SECTION;
+typedef PRTL_CRITICAL_SECTION LPCRITICAL_SECTION;
+
+void EnterCriticalSection(CRITICAL_SECTION* _c);
+void LeaveCriticalSection(CRITICAL_SECTION* _c);
+void InitializeCriticalSection(CRITICAL_SECTION* _c);
+void DeleteCriticalSection(CRITICAL_SECTION* _c);
+HANDLE CreateEvent(void* lpEventAttributes,	BOOL bManualReset,	BOOL bInitialState,	LPCSTR lpName);
+VOID Sleep(DWORD dwMilliseconds);
+BOOL SetThreadPriority(HANDLE hThread, int nPriority);
+DWORD WaitForSingleObject(HANDLE hHandle, DWORD dwMilliseconds);
+
+LONG InterlockedCompareExchangeRelease(LONG volatile *Destination, LONG Exchange,LONG Comperand	);
+
+int32_t GetAudioBGMHandle();
+
+VOID InitializeCriticalSection(PCRITICAL_SECTION CriticalSection);
+VOID InitializeCriticalSectionAndSpinCount(PCRITICAL_SECTION CriticalSection, ULONG SpinCount);
+VOID DeleteCriticalSection(PCRITICAL_SECTION CriticalSection);
+VOID EnterCriticalSection(PCRITICAL_SECTION CriticalSection);
+VOID LeaveCriticalSection(PCRITICAL_SECTION CriticalSection);
+ULONG TryEnterCriticalSection(PCRITICAL_SECTION CriticalSection);
+DWORD WaitForMultipleObjects(DWORD nCount, CONST HANDLE *lpHandles,BOOL bWaitAll,DWORD dwMilliseconds);
+
+LONG64 InterlockedCompareExchangeRelease64(LONG64 volatile *Destination, LONG64 Exchange, LONG64 Comperand);
+
+BOOL CloseHandle(HANDLE hObject);
+BOOL SetEvent(HANDLE hEvent);
+
+HMODULE GetModuleHandle(LPCSTR lpModuleName);
+
+HANDLE CreateThread( void* lpThreadAttributes, DWORD dwStackSize, void* lpStartAddress, LPVOID lpParameter, DWORD dwCreationFlags, LPDWORD lpThreadId );
+DWORD ResumeThread( HANDLE hThread );
+DWORD GetCurrentThreadId(VOID);
+DWORD WaitForMultipleObjectsEx(DWORD nCount,CONST HANDLE *lpHandles,BOOL bWaitAll,DWORD dwMilliseconds,BOOL bAlertable	);
+BOOL GetExitCodeThread(HANDLE hThread, LPDWORD lpExitCode);
+
+
+LPVOID VirtualAlloc(LPVOID lpAddress, SIZE_T dwSize, DWORD flAllocationType, DWORD flProtect);
+BOOL VirtualFree(LPVOID lpAddress, SIZE_T dwSize, DWORD dwFreeType);
+
+DWORD GetFileSize( HANDLE hFile, LPDWORD lpFileSizeHigh	);
+BOOL GetFileSizeEx(HANDLE hFile, PLARGE_INTEGER lpFileSize );
+BOOL WriteFile(
+HANDLE hFile, LPCVOID lpBuffer, DWORD nNumberOfBytesToWrite, LPDWORD lpNumberOfBytesWritten, LPOVERLAPPED lpOverlapped );
+BOOL ReadFile(HANDLE hFile, LPVOID lpBuffer, DWORD nNumberOfBytesToRead, LPDWORD lpNumberOfBytesRead, LPOVERLAPPED lpOverlapped );
+#define INVALID_SET_FILE_POINTER false
+BOOL SetFilePointer(HANDLE hFile, LONG lDistanceToMove, PLONG lpDistanceToMoveHigh, DWORD dwMoveMethod);
+HANDLE CreateFileA(LPCSTR lpFileName, DWORD dwDesiredAccess, DWORD dwShareMode, LPSECURITY_ATTRIBUTES lpSecurityAttributes, DWORD dwCreationDisposition, DWORD dwFlagsAndAttributes, HANDLE hTemplateFile);
+#define CreateFile CreateFileA
+BOOL CreateDirectoryA(LPCSTR lpPathName, LPSECURITY_ATTRIBUTES lpSecurityAttributes);
+#define CreateDirectory CreateDirectoryA
+BOOL DeleteFileA(LPCSTR lpFileName);
+#define DeleteFile DeleteFileA
+DWORD GetFileAttributesA(LPCSTR lpFileName);
+#define GetFileAttributes GetFileAttributesA
+BOOL MoveFileA(LPCSTR lpExistingFileName, LPCSTR lpNewFileName);
+#define MoveFile MoveFileA
+
+#define MAX_PATH          260
+
+void __debugbreak();
+VOID DebugBreak(VOID);
+
+
+enum D3D11_BLEND
+{
+	D3D11_BLEND_ZERO	= 1,
+	D3D11_BLEND_ONE	= 2,
+	D3D11_BLEND_SRC_COLOR	= 3,
+	D3D11_BLEND_INV_SRC_COLOR	= 4,
+	D3D11_BLEND_SRC_ALPHA	= 5,
+	D3D11_BLEND_INV_SRC_ALPHA	= 6,
+	D3D11_BLEND_DEST_ALPHA	= 7,
+	D3D11_BLEND_INV_DEST_ALPHA	= 8,
+	D3D11_BLEND_DEST_COLOR	= 9,
+	D3D11_BLEND_INV_DEST_COLOR	= 10,
+	D3D11_BLEND_SRC_ALPHA_SAT	= 11,
+	D3D11_BLEND_BLEND_FACTOR	= 14,
+	D3D11_BLEND_INV_BLEND_FACTOR	= 15,
+	D3D11_BLEND_SRC1_COLOR	= 16,
+	D3D11_BLEND_INV_SRC1_COLOR	= 17,
+	D3D11_BLEND_SRC1_ALPHA	= 18,
+	D3D11_BLEND_INV_SRC1_ALPHA	= 19
+};
+
+
+enum D3D11_COMPARISON_FUNC
+{
+	D3D11_COMPARISON_NEVER	= 1,
+	D3D11_COMPARISON_LESS	= 2,
+	D3D11_COMPARISON_EQUAL	= 3,
+	D3D11_COMPARISON_LESS_EQUAL	= 4,
+	D3D11_COMPARISON_GREATER	= 5,
+	D3D11_COMPARISON_NOT_EQUAL	= 6,
+	D3D11_COMPARISON_GREATER_EQUAL	= 7,
+	D3D11_COMPARISON_ALWAYS	= 8
+};
+
+
+typedef struct _SYSTEMTIME {
+	WORD wYear;
+	WORD wMonth;
+	WORD wDayOfWeek;
+	WORD wDay;
+	WORD wHour;
+	WORD wMinute;
+	WORD wSecond;
+	WORD wMilliseconds;
+} SYSTEMTIME, *PSYSTEMTIME, *LPSYSTEMTIME;
+
+VOID GetSystemTime(	LPSYSTEMTIME lpSystemTime);
+BOOL FileTimeToSystemTime(CONST FILETIME *lpFileTime, LPSYSTEMTIME lpSystemTime);
+BOOL SystemTimeToFileTime(CONST SYSTEMTIME *lpSystemTime, LPFILETIME lpFileTime);
+VOID GetLocalTime(LPSYSTEMTIME lpSystemTime);
+
+typedef struct _MEMORYSTATUS {
+	DWORD dwLength;
+	DWORD dwMemoryLoad;
+	SIZE_T dwTotalPhys;
+	SIZE_T dwAvailPhys;
+	SIZE_T dwTotalPageFile;
+	SIZE_T dwAvailPageFile;
+	SIZE_T dwTotalVirtual;
+	SIZE_T dwAvailVirtual;
+} MEMORYSTATUS, *LPMEMORYSTATUS;
+
+
+#define WINAPI
+
+#define CREATE_SUSPENDED				0x00000004
+
+#define THREAD_BASE_PRIORITY_LOWRT  15  // value that gets a thread to LowRealtime-1
+#define THREAD_BASE_PRIORITY_MAX    2   // maximum thread base priority boost
+#define THREAD_BASE_PRIORITY_MIN    -2  // minimum thread base priority boost
+#define THREAD_BASE_PRIORITY_IDLE   -15 // value that gets a thread to idle
+
+#define THREAD_PRIORITY_LOWEST          THREAD_BASE_PRIORITY_MIN
+#define THREAD_PRIORITY_BELOW_NORMAL    (THREAD_PRIORITY_LOWEST+1)
+#define THREAD_PRIORITY_NORMAL          0
+#define THREAD_PRIORITY_HIGHEST         THREAD_BASE_PRIORITY_MAX
+#define THREAD_PRIORITY_ABOVE_NORMAL    (THREAD_PRIORITY_HIGHEST-1)
+#define THREAD_PRIORITY_ERROR_RETURN    (MAXLONG)
+
+#define THREAD_PRIORITY_TIME_CRITICAL   THREAD_BASE_PRIORITY_LOWRT
+#define THREAD_PRIORITY_IDLE            THREAD_BASE_PRIORITY_IDLE
+
+#define WAIT_TIMEOUT                     258L
+#define STATUS_ABANDONED_WAIT_0          ((DWORD   )0x00000080L)    
+#define WAIT_ABANDONED         ((STATUS_ABANDONED_WAIT_0 ) + 0 )
+
+#define MAXUINT_PTR  (~((UINT_PTR)0))
+#define MAXINT_PTR   ((INT_PTR)(MAXUINT_PTR >> 1))
+#define MININT_PTR   (~MAXINT_PTR)
+
+#define MAXULONG_PTR (~((ULONG_PTR)0))
+#define MAXLONG_PTR  ((LONG_PTR)(MAXULONG_PTR >> 1))
+#define MINLONG_PTR  (~MAXLONG_PTR)
+
+#define MAXUHALF_PTR ((UHALF_PTR)~0)
+#define MAXHALF_PTR  ((HALF_PTR)(MAXUHALF_PTR >> 1))
+#define MINHALF_PTR  (~MAXHALF_PTR)
+
+#define INVALID_HANDLE_VALUE ((HANDLE)-1)
+//
+// Generic test for success on any status value (non-negative numbers
+// indicate success).
+//
+
+//#define HRESULT_SUCCEEDED(Status) ((HRESULT)(Status) >= 0)
+
+//
+// and the inverse
+//
+#define _HRESULT_TYPEDEF_(_sc) _sc
+
+#define FAILED(Status) ((HRESULT)(Status)<0)
+#define MAKE_HRESULT(sev,fac,code) \
+	((HRESULT) (((unsigned int)(sev)<<31) | ((unsigned int)(fac)<<16) | ((unsigned int)(code))) )
+#define MAKE_SCODE(sev,fac,code) \
+	((SCODE) (((unsigned int)(sev)<<31) | ((unsigned int)(fac)<<16) | ((unsigned int)(code))) )
+#define E_FAIL                           _HRESULT_TYPEDEF_(0x80004005L)
+#define E_ABORT                          _HRESULT_TYPEDEF_(0x80004004L)
+#define E_NOINTERFACE                    _HRESULT_TYPEDEF_(0x80004002L)
+
+#define GENERIC_READ                     (0x80000000L)
+#define GENERIC_WRITE                    (0x40000000L)
+#define GENERIC_EXECUTE                  (0x20000000L)
+#define GENERIC_ALL                      (0x10000000L)
+
+#define FILE_SHARE_READ                 0x00000001  
+#define FILE_SHARE_WRITE                0x00000002  
+#define FILE_SHARE_DELETE               0x00000004  
+#define FILE_ATTRIBUTE_READONLY             0x00000001  
+#define FILE_ATTRIBUTE_HIDDEN               0x00000002  
+#define FILE_ATTRIBUTE_SYSTEM               0x00000004  
+#define FILE_ATTRIBUTE_DIRECTORY            0x00000010  
+#define FILE_ATTRIBUTE_ARCHIVE              0x00000020  
+#define FILE_ATTRIBUTE_DEVICE               0x00000040  
+#define FILE_ATTRIBUTE_NORMAL               0x00000080  
+#define FILE_ATTRIBUTE_TEMPORARY            0x00000100  
+
+#define FILE_FLAG_WRITE_THROUGH         0x80000000
+#define FILE_FLAG_OVERLAPPED            0x40000000
+#define FILE_FLAG_NO_BUFFERING          0x20000000
+#define FILE_FLAG_RANDOM_ACCESS         0x10000000
+#define FILE_FLAG_SEQUENTIAL_SCAN       0x08000000
+#define FILE_FLAG_DELETE_ON_CLOSE       0x04000000
+#define FILE_FLAG_BACKUP_SEMANTICS      0x02000000
+
+#define FILE_BEGIN           0
+#define FILE_CURRENT         1
+#define FILE_END             2
+
+#define CREATE_NEW          1
+#define CREATE_ALWAYS       2
+#define OPEN_EXISTING       3
+#define OPEN_ALWAYS         4
+#define TRUNCATE_EXISTING   5
+
+#define PAGE_NOACCESS          0x01     
+#define PAGE_READONLY          0x02     
+#define PAGE_READWRITE         0x04     
+#define PAGE_WRITECOPY         0x08     
+#define PAGE_EXECUTE           0x10     
+#define PAGE_EXECUTE_READ      0x20     
+#define PAGE_EXECUTE_READWRITE 0x40     
+#define PAGE_EXECUTE_WRITECOPY 0x80     
+#define PAGE_GUARD            0x100     
+#define PAGE_NOCACHE          0x200     
+#define PAGE_WRITECOMBINE     0x400     
+#define PAGE_USER_READONLY   0x1000     
+#define PAGE_USER_READWRITE  0x2000     
+#define MEM_COMMIT           0x1000     
+#define MEM_RESERVE          0x2000     
+#define MEM_DECOMMIT         0x4000     
+#define MEM_RELEASE          0x8000     
+#define MEM_FREE            0x10000     
+#define MEM_PRIVATE         0x20000     
+#define MEM_RESET           0x80000     
+#define MEM_TOP_DOWN       0x100000     
+#define MEM_NOZERO         0x800000     
+#define MEM_LARGE_PAGES  0x20000000     
+#define MEM_HEAP         0x40000000     
+#define MEM_16MB_PAGES   0x80000000     
+
+#define IGNORE              0       // Ignore signal
+#define INFINITE            0xFFFFFFFF  // Infinite timeout
+#define WAIT_FAILED ((DWORD)0xFFFFFFFF)
+#define STATUS_WAIT_0                    ((DWORD   )0x00000000L)    
+#define WAIT_OBJECT_0       ((STATUS_WAIT_0 ) + 0 )
+#define STATUS_PENDING                   ((DWORD   )0x00000103L)    
+#define STILL_ACTIVE                        STATUS_PENDING
+
+DWORD GetLastError(VOID);
+VOID GlobalMemoryStatus(LPMEMORYSTATUS lpBuffer);
+
+DWORD GetTickCount();
+BOOL QueryPerformanceFrequency(LARGE_INTEGER *lpFrequency);
+BOOL QueryPerformanceCounter(LARGE_INTEGER *lpPerformanceCount);
+
+
+#define ERROR_SUCCESS                    0L
+#define ERROR_IO_PENDING                 997L    // dderror
+#define ERROR_CANCELLED                  1223L
+#define S_OK                                   ((HRESULT)0x00000000L)
+#define S_FALSE                                ((HRESULT)0x00000001L)
+
+#define RtlEqualMemory(Destination,Source,Length) (!memcmp((Destination),(Source),(Length)))
+#define RtlMoveMemory(Destination,Source,Length) memmove((Destination),(Source),(Length))
+#define RtlCopyMemory(Destination,Source,Length) memcpy((Destination),(Source),(Length))
+#define RtlFillMemory(Destination,Length,Fill) memset((Destination),(Fill),(Length))
+#define RtlZeroMemory(Destination,Length) memset((Destination),0,(Length))
+
+#define MoveMemory       RtlMoveMemory
+#define CopyMemory       RtlCopyMemory
+#define FillMemory       RtlFillMemory
+#define ZeroMemory       RtlZeroMemory
+
+#define CDECL
+#define APIENTRY
+
+#define VK_ESCAPE                       0x1B
+#define VK_RETURN                       0x0D
+
+VOID OutputDebugStringW(LPCWSTR lpOutputString);
+VOID OutputDebugString(LPCSTR lpOutputString);
+VOID OutputDebugStringA(LPCSTR lpOutputString);
+
+errno_t _itoa_s(int _Value, char * _DstBuf, size_t _Size, int _Radix);
+errno_t _i64toa_s(__int64 _Val, char * _DstBuf, size_t _Size, int _Radix);
+
+#define __declspec(a) 
+extern "C" int _wcsicmp (const wchar_t * dst, const wchar_t * src);
+
+size_t wcsnlen(const wchar_t *wcs, size_t maxsize);
+
+typedef struct _WIN32_FIND_DATAA {
+	DWORD dwFileAttributes;
+	FILETIME ftCreationTime;
+	FILETIME ftLastAccessTime;
+	FILETIME ftLastWriteTime;
+	DWORD nFileSizeHigh;
+	DWORD nFileSizeLow;
+	DWORD dwReserved0;
+	DWORD dwReserved1;
+	CHAR cFileName[ MAX_PATH ];
+	CHAR cAlternateFileName[ 14 ];
+} WIN32_FIND_DATAA, *PWIN32_FIND_DATAA, *LPWIN32_FIND_DATAA;
+typedef WIN32_FIND_DATAA WIN32_FIND_DATA;
+typedef PWIN32_FIND_DATAA PWIN32_FIND_DATA;
+typedef LPWIN32_FIND_DATAA LPWIN32_FIND_DATA;
+
+typedef struct _WIN32_FILE_ATTRIBUTE_DATA {
+	DWORD dwFileAttributes;
+	FILETIME ftCreationTime;
+	FILETIME ftLastAccessTime;
+	FILETIME ftLastWriteTime;
+	DWORD nFileSizeHigh;
+	DWORD nFileSizeLow;
+} WIN32_FILE_ATTRIBUTE_DATA, *LPWIN32_FILE_ATTRIBUTE_DATA;
+
+
+DWORD GetFileAttributesA(LPCSTR lpFileName);
+#define GetFileAttributes GetFileAttributesA
+typedef enum _GET_FILEEX_INFO_LEVELS {
+	GetFileExInfoStandard,
+	GetFileExMaxInfoLevel
+} GET_FILEEX_INFO_LEVELS;
+
+BOOL GetFileAttributesExA(LPCSTR lpFileName,GET_FILEEX_INFO_LEVELS fInfoLevelId,LPVOID lpFileInformation);
+#define GetFileAttributesEx GetFileAttributesExA
+
+BOOL DeleteFileA(LPCSTR lpFileName);
+#define DeleteFile DeleteFileA
+
+
+HANDLE FindFirstFileA(LPCSTR lpFileName, LPWIN32_FIND_DATA lpFindFileData);
+#define FindFirstFile FindFirstFileA
+
+BOOL FindNextFileA(HANDLE hFindFile, LPWIN32_FIND_DATAA lpFindFileData);
+#define FindNextFile FindNextFileA
+#define FindClose(hFindFile) CloseHandle(hFindFile)
+
+DWORD XGetLanguage();
+DWORD XGetLocale();
+DWORD XEnableGuestSignin(BOOL fEnable);
+
+#ifdef _CONTENT_PACKAGE
+#define ORBIS_STUBBED { }
+#else
+#define ORBIS_STUBBED { static bool bSet = false; if(!bSet){printf("missing function on PS4 : %s\n Tell MarkH about this, then press f5 to continue.\n", __FUNCTION__); bSet = true; SCE_BREAK();} }
+#endif
+

Minecraft.Client/Orbis/OrbisExtras/OrbisTypes.h

@@ -0,0 +1,176 @@
+#pragma once
+
+//#include "winerror.h"
+
+typedef unsigned int       DWORD;
+typedef int                 BOOL;
+typedef unsigned char       BYTE;
+typedef unsigned short      WORD;
+typedef float               FLOAT;
+typedef int					__int32;
+typedef FLOAT               *PFLOAT;
+typedef BOOL           *PBOOL;
+typedef BOOL            *LPBOOL;
+typedef BYTE           *PBYTE;
+typedef BYTE            *LPBYTE;
+typedef int            *PINT;
+typedef int             *LPINT;
+typedef WORD           *PWORD;
+typedef WORD            *LPWORD;
+typedef int            *PLONG;
+typedef int            *LPLONG;
+typedef DWORD          *PDWORD;
+typedef DWORD           *LPDWORD;
+typedef void            *LPVOID;
+typedef const void      *LPCVOID;
+typedef void *PVOID;
+typedef unsigned int ULONG;
+
+typedef unsigned char boolean;
+
+typedef int                 INT;
+typedef unsigned int        UINT;
+typedef unsigned int        *PUINT;
+
+
+typedef unsigned char		byte;
+typedef long 			    __int64;
+typedef unsigned long		__uint64;
+typedef unsigned int		DWORD;
+typedef int                 INT;
+typedef unsigned long		ULONG_PTR, *PULONG_PTR;
+typedef ULONG_PTR SIZE_T, *PSIZE_T;
+
+typedef long LONG64, *PLONG64;
+
+#define VOID void
+typedef char CHAR;
+typedef short SHORT;
+typedef int LONG;
+typedef long LONGLONG;
+typedef unsigned long ULONGLONG;
+
+
+#define CONST               const
+typedef wchar_t WCHAR;    // wc,   16-bit UNICODE character
+typedef WCHAR *PWCHAR;
+typedef WCHAR *LPWCH, *PWCH;
+typedef CONST WCHAR *LPCWCH, *PCWCH;
+typedef WCHAR *NWPSTR;
+typedef WCHAR *LPWSTR, *PWSTR;
+typedef CONST WCHAR *LPCWSTR, *PCWSTR;
+
+//
+// ANSI (Multi-byte Character) types
+//
+typedef CHAR *PCHAR;
+typedef CHAR *LPCH, *PCH;
+typedef CONST CHAR *LPCCH, *PCCH;
+typedef CHAR *NPSTR;
+typedef CHAR *LPSTR, *PSTR;
+typedef CONST CHAR *LPCSTR, *PCSTR;
+
+#ifndef FALSE
+#define FALSE               0
+#endif
+
+#ifndef TRUE
+#define TRUE                1
+#endif
+
+
+typedef struct _FILETIME {
+#ifdef _M_PPCBE
+	DWORD dwHighDateTime;
+	DWORD dwLowDateTime;
+#else
+	DWORD dwLowDateTime;
+	DWORD dwHighDateTime;
+#endif
+} FILETIME, *PFILETIME, *LPFILETIME;
+
+
+#if defined(MIDL_PASS)
+typedef struct _LARGE_INTEGER {
+#else // MIDL_PASS
+typedef union _LARGE_INTEGER {
+	struct {
+#if defined(_M_PPCBE)
+		LONG HighPart;
+		DWORD LowPart;
+#else
+		DWORD LowPart;
+		LONG HighPart;
+#endif
+	};
+	struct {
+#if defined(_M_PPCBE)
+		LONG HighPart;
+		DWORD LowPart;
+#else
+		DWORD LowPart;
+		LONG HighPart;
+#endif
+	} u;
+#endif //MIDL_PASS
+	LONGLONG QuadPart;
+} LARGE_INTEGER;
+
+typedef LARGE_INTEGER *PLARGE_INTEGER;
+
+#if defined(MIDL_PASS)
+typedef struct _ULARGE_INTEGER {
+#else // MIDL_PASS
+typedef union _ULARGE_INTEGER {
+	struct {
+#if defined(_M_PPCBE)
+		DWORD HighPart;
+		DWORD LowPart;
+#else
+		DWORD LowPart;
+		DWORD HighPart;
+#endif
+	};
+	struct {
+#if defined(_M_PPCBE)
+		DWORD HighPart;
+		DWORD LowPart;
+#else
+		DWORD LowPart;
+		DWORD HighPart;
+#endif
+	} u;
+#endif //MIDL_PASS
+	ULONGLONG QuadPart;
+} ULARGE_INTEGER;
+
+typedef ULARGE_INTEGER *PULARGE_INTEGER;
+
+// 360 specifics
+typedef int32_t			HRESULT;
+typedef void*			HANDLE;
+
+#define DECLARE_HANDLE(name) typedef HANDLE name
+DECLARE_HANDLE(HINSTANCE);
+
+typedef HINSTANCE HMODULE;      /* HMODULEs can be used in place of HINSTANCEs */
+
+typedef struct _OVERLAPPED {
+	ULONG_PTR Internal;
+	ULONG_PTR InternalHigh;
+	DWORD   Offset;
+	DWORD   OffsetHigh;
+	HANDLE  hEvent;
+} OVERLAPPED, *LPOVERLAPPED;
+
+typedef LPVOID PSECURITY_ATTRIBUTES;
+typedef LPVOID LPSECURITY_ATTRIBUTES;
+
+
+
+#define __in_ecount(a)
+#define __in_bcount(a)
+
+#ifndef AUTO_VAR
+#define AUTO_VAR(_var, _val) auto _var = _val
+#endif

Minecraft.Client/Orbis/OrbisExtras/ShutdownManager.h

@@ -0,0 +1,47 @@
+#pragma once
+
+class ShutdownManager
+{
+public:
+	typedef enum
+	{
+		eMainThread,
+
+		eLeaderboardThread,
+		eCommerceThread,
+		ePostProcessThread,
+		eRunUpdateThread,
+		eRenderChunkUpdateThread,
+		eServerThread,
+		eStorageManagerThreads,
+		eConnectionReadThreads,
+		eConnectionWriteThreads,
+		eEventQueueThreads,
+
+		eThreadIdCount
+	} EThreadId;
+
+	static void Initialise() {}
+	static void StartShutdown() {}
+	static void MainThreadHandleShutdown() {}
+#ifdef __PS3__
+	static void SysUtilCallback(uint64_t status, uint64_t param, void *userdata);
+#endif
+
+	static void HasStarted(EThreadId threadId) {};
+	static void HasStarted(EThreadId threadId, C4JThread::EventArray *eventArray) {};
+	static bool ShouldRun(EThreadId threadId) {return true;};
+	static void HasFinished(EThreadId threadId) {};
+
+private:
+#ifdef __PS3__
+	static bool s_threadShouldRun[eThreadIdCount];
+	static int s_threadRunning[eThreadIdCount];
+	static CRITICAL_SECTION s_threadRunningCS;
+	static C4JThread::EventArray *s_eventArray[eThreadIdCount];
+
+	static void RequestThreadToStop(int i);
+	static void WaitForSignalledToComplete();
+	static void StorageManagerCompleteFn();
+#endif
+};

Minecraft.Client/Orbis/OrbisExtras/TLSStorage.cpp

@@ -0,0 +1,71 @@
+
+
+#include "stdafx.h"
+
+
+
+TLSStorageOrbis* TLSStorageOrbis::m_pInstance = NULL;
+
+BOOL TLSStorageOrbis::m_activeList[sc_maxSlots];
+__thread LPVOID TLSStorageOrbis::m_values[sc_maxSlots];
+
+
+
+TLSStorageOrbis::TLSStorageOrbis()
+{
+	for(int i=0;i<sc_maxSlots; i++)
+	{
+		m_activeList[i] = false;
+		m_values[i] = NULL;
+	}
+}
+
+TLSStorageOrbis* TLSStorageOrbis::Instance()
+{
+	if ( m_pInstance == 0 )			// Is this the first time?
+	{
+		m_pInstance = new TLSStorageOrbis;		// Create the singleton instance.
+	}
+	return m_pInstance;
+}
+
+
+int TLSStorageOrbis::Alloc()
+{
+	for(int i=0; i<sc_maxSlots; i++) 
+	{
+		if(m_activeList[i] == false)
+		{
+			m_activeList[i] = true;
+			m_values[i] = NULL;
+			return i;
+		}
+	}
+	assert(0);		// we've ran out of slots
+}
+
+BOOL TLSStorageOrbis::Free( DWORD _index )
+{
+	if(m_activeList[_index] == false)
+		return false; // not been allocated
+
+	m_activeList[_index] = false;
+	m_values[_index] = NULL;
+	return true;
+}
+
+BOOL TLSStorageOrbis::SetValue( DWORD _index, LPVOID _val )
+{
+	if(m_activeList[_index] == false)
+		return false;
+	m_values[_index] = _val;
+	return true;
+}
+
+LPVOID TLSStorageOrbis::GetValue( DWORD _index )
+{
+	if(m_activeList[_index] == false)
+		return NULL;
+	return m_values[_index];
+}
+

Minecraft.Client/Orbis/OrbisExtras/TLSStorage.h

@@ -0,0 +1,20 @@
+#pragma once
+
+class TLSStorageOrbis
+{
+	static TLSStorageOrbis* m_pInstance;
+
+	static const int	sc_maxSlots = 64;
+	static BOOL 		m_activeList[sc_maxSlots];
+	__thread static LPVOID	m_values[sc_maxSlots];
+
+public:
+	TLSStorageOrbis();
+
+	// Retrieve singleton instance.
+	static TLSStorageOrbis* Instance();
+	int Alloc();
+	BOOL Free(DWORD _index);
+	BOOL SetValue(DWORD _index, LPVOID _val);
+	LPVOID GetValue(DWORD _index);
+};