From b691c43c44ff180d10e7d4a9afc83b98551ff586 Mon Sep 17 00:00:00 2001 From: daoge_cmd <3523206925@qq.com> Date: Sun, 1 Mar 2026 12:16:08 +0800 Subject: Initial commit --- Minecraft.Client/Orbis/OrbisExtras/OrbisMaths.h | 11 + Minecraft.Client/Orbis/OrbisExtras/OrbisStubs.cpp | 790 + Minecraft.Client/Orbis/OrbisExtras/OrbisStubs.h | 422 + Minecraft.Client/Orbis/OrbisExtras/OrbisTypes.h | 176 + .../Orbis/OrbisExtras/ShutdownManager.h | 47 + Minecraft.Client/Orbis/OrbisExtras/TLSStorage.cpp | 71 + Minecraft.Client/Orbis/OrbisExtras/TLSStorage.h | 20 + Minecraft.Client/Orbis/OrbisExtras/winerror.h | 22031 +++++++++++++++++++ 8 files changed, 23568 insertions(+) create mode 100644 Minecraft.Client/Orbis/OrbisExtras/OrbisMaths.h create mode 100644 Minecraft.Client/Orbis/OrbisExtras/OrbisStubs.cpp create mode 100644 Minecraft.Client/Orbis/OrbisExtras/OrbisStubs.h create mode 100644 Minecraft.Client/Orbis/OrbisExtras/OrbisTypes.h create mode 100644 Minecraft.Client/Orbis/OrbisExtras/ShutdownManager.h create mode 100644 Minecraft.Client/Orbis/OrbisExtras/TLSStorage.cpp create mode 100644 Minecraft.Client/Orbis/OrbisExtras/TLSStorage.h create mode 100644 Minecraft.Client/Orbis/OrbisExtras/winerror.h (limited to 'Minecraft.Client/Orbis/OrbisExtras') diff --git a/Minecraft.Client/Orbis/OrbisExtras/OrbisMaths.h b/Minecraft.Client/Orbis/OrbisExtras/OrbisMaths.h new file mode 100644 index 00000000..fa6c3955 --- /dev/null +++ b/Minecraft.Client/Orbis/OrbisExtras/OrbisMaths.h @@ -0,0 +1,11 @@ +#pragma once +#include +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); \ No newline at end of file diff --git a/Minecraft.Client/Orbis/OrbisExtras/OrbisStubs.cpp b/Minecraft.Client/Orbis/OrbisExtras/OrbisStubs.cpp new file mode 100644 index 00000000..d3a21ac4 --- /dev/null +++ b/Minecraft.Client/Orbis/OrbisExtras/OrbisStubs.cpp @@ -0,0 +1,790 @@ +#include "stdafx.h" +#include +#include +#include +#include +#include +#include +#include +#include +#include + + +//#include + +// 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 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 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;im_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;im_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; +} \ No newline at end of file diff --git a/Minecraft.Client/Orbis/OrbisExtras/OrbisStubs.h b/Minecraft.Client/Orbis/OrbisExtras/OrbisStubs.h new file mode 100644 index 00000000..da9f872f --- /dev/null +++ b/Minecraft.Client/Orbis/OrbisExtras/OrbisStubs.h @@ -0,0 +1,422 @@ +#pragma once +#include + +#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 + diff --git a/Minecraft.Client/Orbis/OrbisExtras/OrbisTypes.h b/Minecraft.Client/Orbis/OrbisExtras/OrbisTypes.h new file mode 100644 index 00000000..006a0060 --- /dev/null +++ b/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 \ No newline at end of file diff --git a/Minecraft.Client/Orbis/OrbisExtras/ShutdownManager.h b/Minecraft.Client/Orbis/OrbisExtras/ShutdownManager.h new file mode 100644 index 00000000..38d9c36e --- /dev/null +++ b/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 +}; diff --git a/Minecraft.Client/Orbis/OrbisExtras/TLSStorage.cpp b/Minecraft.Client/Orbis/OrbisExtras/TLSStorage.cpp new file mode 100644 index 00000000..9f17e999 --- /dev/null +++ b/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