// Minecraft.cpp : Defines the entry point for the application. // #include "stdafx.h" #include #include "GameConfig\Minecraft.spa.h" #include "..\MinecraftServer.h" #include "..\LocalPlayer.h" #include "..\..\Minecraft.World\ItemInstance.h" #include "..\..\Minecraft.World\MapItem.h" #include "..\..\Minecraft.World\Recipes.h" #include "..\..\Minecraft.World\Recipy.h" #include "..\..\Minecraft.World\Language.h" #include "..\..\Minecraft.World\StringHelpers.h" #include "..\..\Minecraft.World\AABB.h" #include "..\..\Minecraft.World\Vec3.h" #include "..\..\Minecraft.World\Level.h" #include "..\..\Minecraft.World\net.minecraft.world.level.tile.h" #include "..\KeyboardMouseInput.h" #include "..\ClientConnection.h" #include "..\User.h" #include "..\..\Minecraft.World\Socket.h" #include "..\..\Minecraft.World\ThreadName.h" #include "..\..\Minecraft.Client\StatsCounter.h" #include "..\ConnectScreen.h" //#include "Social\SocialManager.h" //#include "Leaderboards\LeaderboardManager.h" //#include "XUI\XUI_Scene_Container.h" //#include "NetworkManager.h" #include "..\..\Minecraft.Client\Tesselator.h" #include "..\..\Minecraft.Client\Options.h" #include "Sentient\SentientManager.h" #include "..\..\Minecraft.World\IntCache.h" #include "..\Textures.h" #include "Resource.h" #include "..\..\Minecraft.World\compression.h" #include "..\..\Minecraft.World\OldChunkStorage.h" #include "Network\WinsockNetLayer.h" #include "Extrax64Stubs.h" #include "Xbox/resource.h" #include "Windows64_Minecraft.h" #ifdef _WINDOWS64 #define VK_USE_PLATFORM_WIN32_KHR #include #endif HINSTANCE hMyInst; LRESULT CALLBACK DlgProc(HWND hWndDlg, UINT Msg, WPARAM wParam, LPARAM lParam); char chGlobalText[256]; uint16_t ui16GlobalText[256]; #define THEME_NAME "584111F70AAAAAAA" #define THEME_FILESIZE 2797568 //#define THREE_MB 3145728 // minimum save size (checking for this on a selected device) //#define FIVE_MB 5242880 // minimum save size (checking for this on a selected device) //#define FIFTY_TWO_MB (1024*1024*52) // Maximum TCR space required for a save (checking for this on a selected device) #define FIFTY_ONE_MB (1000000*51) // Maximum TCR space required for a save is 52MB (checking for this on a selected device) //#define PROFILE_VERSION 3 // new version for the interim bug fix 166 TU #define NUM_PROFILE_VALUES 5 #define NUM_PROFILE_SETTINGS 4 DWORD dwProfileSettingsA[NUM_PROFILE_VALUES]= { #ifdef _XBOX XPROFILE_OPTION_CONTROLLER_VIBRATION, XPROFILE_GAMER_YAXIS_INVERSION, XPROFILE_GAMER_CONTROL_SENSITIVITY, XPROFILE_GAMER_ACTION_MOVEMENT_CONTROL, XPROFILE_TITLE_SPECIFIC1, #else 0,0,0,0,0 #endif }; //------------------------------------------------------------------------------------- // Time Since fAppTime is a float, we need to keep the quadword app time // as a LARGE_INTEGER so that we don't lose precision after running // for a long time. //------------------------------------------------------------------------------------- BOOL g_bWidescreen = TRUE; int g_iScreenWidth = 1920; int g_iScreenHeight = 1080; char g_Win64Username[17] = {0}; wchar_t g_Win64UsernameW[17] = {0}; void DefineActions(void) { // The app needs to define the actions required, and the possible mappings for these // Split into Menu actions, and in-game actions InputManager.SetGameJoypadMaps(MAP_STYLE_0,ACTION_MENU_A, _360_JOY_BUTTON_A); InputManager.SetGameJoypadMaps(MAP_STYLE_0,ACTION_MENU_B, _360_JOY_BUTTON_B); InputManager.SetGameJoypadMaps(MAP_STYLE_0,ACTION_MENU_X, _360_JOY_BUTTON_X); InputManager.SetGameJoypadMaps(MAP_STYLE_0,ACTION_MENU_Y, _360_JOY_BUTTON_Y); InputManager.SetGameJoypadMaps(MAP_STYLE_0,ACTION_MENU_OK, _360_JOY_BUTTON_A); InputManager.SetGameJoypadMaps(MAP_STYLE_0,ACTION_MENU_CANCEL, _360_JOY_BUTTON_B); InputManager.SetGameJoypadMaps(MAP_STYLE_0,ACTION_MENU_UP, _360_JOY_BUTTON_DPAD_UP | _360_JOY_BUTTON_LSTICK_UP); InputManager.SetGameJoypadMaps(MAP_STYLE_0,ACTION_MENU_DOWN, _360_JOY_BUTTON_DPAD_DOWN | _360_JOY_BUTTON_LSTICK_DOWN); InputManager.SetGameJoypadMaps(MAP_STYLE_0,ACTION_MENU_LEFT, _360_JOY_BUTTON_DPAD_LEFT | _360_JOY_BUTTON_LSTICK_LEFT); InputManager.SetGameJoypadMaps(MAP_STYLE_0,ACTION_MENU_RIGHT, _360_JOY_BUTTON_DPAD_RIGHT | _360_JOY_BUTTON_LSTICK_RIGHT); InputManager.SetGameJoypadMaps(MAP_STYLE_0,ACTION_MENU_PAGEUP, _360_JOY_BUTTON_LT); InputManager.SetGameJoypadMaps(MAP_STYLE_0,ACTION_MENU_PAGEDOWN, _360_JOY_BUTTON_RT); InputManager.SetGameJoypadMaps(MAP_STYLE_0,ACTION_MENU_RIGHT_SCROLL, _360_JOY_BUTTON_RB); InputManager.SetGameJoypadMaps(MAP_STYLE_0,ACTION_MENU_LEFT_SCROLL, _360_JOY_BUTTON_LB); InputManager.SetGameJoypadMaps(MAP_STYLE_0,ACTION_MENU_PAUSEMENU, _360_JOY_BUTTON_START); InputManager.SetGameJoypadMaps(MAP_STYLE_0,ACTION_MENU_STICK_PRESS, _360_JOY_BUTTON_LTHUMB); InputManager.SetGameJoypadMaps(MAP_STYLE_0,ACTION_MENU_OTHER_STICK_PRESS, _360_JOY_BUTTON_RTHUMB); InputManager.SetGameJoypadMaps(MAP_STYLE_0,ACTION_MENU_OTHER_STICK_UP, _360_JOY_BUTTON_RSTICK_UP); InputManager.SetGameJoypadMaps(MAP_STYLE_0,ACTION_MENU_OTHER_STICK_DOWN, _360_JOY_BUTTON_RSTICK_DOWN); InputManager.SetGameJoypadMaps(MAP_STYLE_0,ACTION_MENU_OTHER_STICK_LEFT, _360_JOY_BUTTON_RSTICK_LEFT); InputManager.SetGameJoypadMaps(MAP_STYLE_0,ACTION_MENU_OTHER_STICK_RIGHT, _360_JOY_BUTTON_RSTICK_RIGHT); InputManager.SetGameJoypadMaps(MAP_STYLE_0,MINECRAFT_ACTION_JUMP, _360_JOY_BUTTON_A); InputManager.SetGameJoypadMaps(MAP_STYLE_0,MINECRAFT_ACTION_FORWARD, _360_JOY_BUTTON_LSTICK_UP); InputManager.SetGameJoypadMaps(MAP_STYLE_0,MINECRAFT_ACTION_BACKWARD, _360_JOY_BUTTON_LSTICK_DOWN); InputManager.SetGameJoypadMaps(MAP_STYLE_0,MINECRAFT_ACTION_LEFT, _360_JOY_BUTTON_LSTICK_LEFT); InputManager.SetGameJoypadMaps(MAP_STYLE_0,MINECRAFT_ACTION_RIGHT, _360_JOY_BUTTON_LSTICK_RIGHT); InputManager.SetGameJoypadMaps(MAP_STYLE_0,MINECRAFT_ACTION_LOOK_LEFT, _360_JOY_BUTTON_RSTICK_LEFT); InputManager.SetGameJoypadMaps(MAP_STYLE_0,MINECRAFT_ACTION_LOOK_RIGHT, _360_JOY_BUTTON_RSTICK_RIGHT); InputManager.SetGameJoypadMaps(MAP_STYLE_0,MINECRAFT_ACTION_LOOK_UP, _360_JOY_BUTTON_RSTICK_UP); InputManager.SetGameJoypadMaps(MAP_STYLE_0,MINECRAFT_ACTION_LOOK_DOWN, _360_JOY_BUTTON_RSTICK_DOWN); InputManager.SetGameJoypadMaps(MAP_STYLE_0,MINECRAFT_ACTION_USE, _360_JOY_BUTTON_LT); InputManager.SetGameJoypadMaps(MAP_STYLE_0,MINECRAFT_ACTION_ACTION, _360_JOY_BUTTON_RT); InputManager.SetGameJoypadMaps(MAP_STYLE_0,MINECRAFT_ACTION_RIGHT_SCROLL, _360_JOY_BUTTON_RB); InputManager.SetGameJoypadMaps(MAP_STYLE_0,MINECRAFT_ACTION_LEFT_SCROLL, _360_JOY_BUTTON_LB); InputManager.SetGameJoypadMaps(MAP_STYLE_0,MINECRAFT_ACTION_INVENTORY, _360_JOY_BUTTON_Y); InputManager.SetGameJoypadMaps(MAP_STYLE_0,MINECRAFT_ACTION_PAUSEMENU, _360_JOY_BUTTON_START); InputManager.SetGameJoypadMaps(MAP_STYLE_0,MINECRAFT_ACTION_DROP, _360_JOY_BUTTON_B); InputManager.SetGameJoypadMaps(MAP_STYLE_0,MINECRAFT_ACTION_SNEAK_TOGGLE, _360_JOY_BUTTON_RTHUMB); InputManager.SetGameJoypadMaps(MAP_STYLE_0,MINECRAFT_ACTION_CRAFTING, _360_JOY_BUTTON_X); InputManager.SetGameJoypadMaps(MAP_STYLE_0,MINECRAFT_ACTION_RENDER_THIRD_PERSON, _360_JOY_BUTTON_LTHUMB); InputManager.SetGameJoypadMaps(MAP_STYLE_0,MINECRAFT_ACTION_GAME_INFO, _360_JOY_BUTTON_BACK); InputManager.SetGameJoypadMaps(MAP_STYLE_0,MINECRAFT_ACTION_DPAD_LEFT, _360_JOY_BUTTON_DPAD_LEFT); InputManager.SetGameJoypadMaps(MAP_STYLE_0,MINECRAFT_ACTION_DPAD_RIGHT, _360_JOY_BUTTON_DPAD_RIGHT); InputManager.SetGameJoypadMaps(MAP_STYLE_0,MINECRAFT_ACTION_DPAD_UP, _360_JOY_BUTTON_DPAD_UP); InputManager.SetGameJoypadMaps(MAP_STYLE_0,MINECRAFT_ACTION_DPAD_DOWN, _360_JOY_BUTTON_DPAD_DOWN); InputManager.SetGameJoypadMaps(MAP_STYLE_1,ACTION_MENU_A, _360_JOY_BUTTON_A); InputManager.SetGameJoypadMaps(MAP_STYLE_1,ACTION_MENU_B, _360_JOY_BUTTON_B); InputManager.SetGameJoypadMaps(MAP_STYLE_1,ACTION_MENU_X, _360_JOY_BUTTON_X); InputManager.SetGameJoypadMaps(MAP_STYLE_1,ACTION_MENU_Y, _360_JOY_BUTTON_Y); InputManager.SetGameJoypadMaps(MAP_STYLE_1,ACTION_MENU_OK, _360_JOY_BUTTON_A); InputManager.SetGameJoypadMaps(MAP_STYLE_1,ACTION_MENU_CANCEL, _360_JOY_BUTTON_B); InputManager.SetGameJoypadMaps(MAP_STYLE_1,ACTION_MENU_UP, _360_JOY_BUTTON_DPAD_UP | _360_JOY_BUTTON_LSTICK_UP); InputManager.SetGameJoypadMaps(MAP_STYLE_1,ACTION_MENU_DOWN, _360_JOY_BUTTON_DPAD_DOWN | _360_JOY_BUTTON_LSTICK_DOWN); InputManager.SetGameJoypadMaps(MAP_STYLE_1,ACTION_MENU_LEFT, _360_JOY_BUTTON_DPAD_LEFT | _360_JOY_BUTTON_LSTICK_LEFT); InputManager.SetGameJoypadMaps(MAP_STYLE_1,ACTION_MENU_RIGHT, _360_JOY_BUTTON_DPAD_RIGHT | _360_JOY_BUTTON_LSTICK_RIGHT); InputManager.SetGameJoypadMaps(MAP_STYLE_1,ACTION_MENU_PAGEUP, _360_JOY_BUTTON_LB); InputManager.SetGameJoypadMaps(MAP_STYLE_1,ACTION_MENU_PAGEDOWN, _360_JOY_BUTTON_RT); InputManager.SetGameJoypadMaps(MAP_STYLE_1,ACTION_MENU_RIGHT_SCROLL, _360_JOY_BUTTON_RB); InputManager.SetGameJoypadMaps(MAP_STYLE_1,ACTION_MENU_LEFT_SCROLL, _360_JOY_BUTTON_LB); InputManager.SetGameJoypadMaps(MAP_STYLE_1,ACTION_MENU_PAUSEMENU, _360_JOY_BUTTON_START); InputManager.SetGameJoypadMaps(MAP_STYLE_1,ACTION_MENU_STICK_PRESS, _360_JOY_BUTTON_LTHUMB); InputManager.SetGameJoypadMaps(MAP_STYLE_1,ACTION_MENU_OTHER_STICK_PRESS, _360_JOY_BUTTON_RTHUMB); InputManager.SetGameJoypadMaps(MAP_STYLE_1,ACTION_MENU_OTHER_STICK_UP, _360_JOY_BUTTON_RSTICK_UP); InputManager.SetGameJoypadMaps(MAP_STYLE_1,ACTION_MENU_OTHER_STICK_DOWN, _360_JOY_BUTTON_RSTICK_DOWN); InputManager.SetGameJoypadMaps(MAP_STYLE_1,ACTION_MENU_OTHER_STICK_LEFT, _360_JOY_BUTTON_RSTICK_LEFT); InputManager.SetGameJoypadMaps(MAP_STYLE_1,ACTION_MENU_OTHER_STICK_RIGHT, _360_JOY_BUTTON_RSTICK_RIGHT); InputManager.SetGameJoypadMaps(MAP_STYLE_1,MINECRAFT_ACTION_JUMP, _360_JOY_BUTTON_RB); InputManager.SetGameJoypadMaps(MAP_STYLE_1,MINECRAFT_ACTION_FORWARD, _360_JOY_BUTTON_LSTICK_UP); InputManager.SetGameJoypadMaps(MAP_STYLE_1,MINECRAFT_ACTION_BACKWARD, _360_JOY_BUTTON_LSTICK_DOWN); InputManager.SetGameJoypadMaps(MAP_STYLE_1,MINECRAFT_ACTION_LEFT, _360_JOY_BUTTON_LSTICK_LEFT); InputManager.SetGameJoypadMaps(MAP_STYLE_1,MINECRAFT_ACTION_RIGHT, _360_JOY_BUTTON_LSTICK_RIGHT); InputManager.SetGameJoypadMaps(MAP_STYLE_1,MINECRAFT_ACTION_LOOK_LEFT, _360_JOY_BUTTON_RSTICK_LEFT); InputManager.SetGameJoypadMaps(MAP_STYLE_1,MINECRAFT_ACTION_LOOK_RIGHT, _360_JOY_BUTTON_RSTICK_RIGHT); InputManager.SetGameJoypadMaps(MAP_STYLE_1,MINECRAFT_ACTION_LOOK_UP, _360_JOY_BUTTON_RSTICK_UP); InputManager.SetGameJoypadMaps(MAP_STYLE_1,MINECRAFT_ACTION_LOOK_DOWN, _360_JOY_BUTTON_RSTICK_DOWN); InputManager.SetGameJoypadMaps(MAP_STYLE_1,MINECRAFT_ACTION_USE, _360_JOY_BUTTON_RT); InputManager.SetGameJoypadMaps(MAP_STYLE_1,MINECRAFT_ACTION_ACTION, _360_JOY_BUTTON_LT); InputManager.SetGameJoypadMaps(MAP_STYLE_1,MINECRAFT_ACTION_RIGHT_SCROLL, _360_JOY_BUTTON_DPAD_RIGHT); InputManager.SetGameJoypadMaps(MAP_STYLE_1,MINECRAFT_ACTION_LEFT_SCROLL, _360_JOY_BUTTON_DPAD_LEFT); InputManager.SetGameJoypadMaps(MAP_STYLE_1,MINECRAFT_ACTION_INVENTORY, _360_JOY_BUTTON_Y); InputManager.SetGameJoypadMaps(MAP_STYLE_1,MINECRAFT_ACTION_PAUSEMENU, _360_JOY_BUTTON_START); InputManager.SetGameJoypadMaps(MAP_STYLE_1,MINECRAFT_ACTION_DROP, _360_JOY_BUTTON_B); InputManager.SetGameJoypadMaps(MAP_STYLE_1,MINECRAFT_ACTION_SNEAK_TOGGLE, _360_JOY_BUTTON_LTHUMB); InputManager.SetGameJoypadMaps(MAP_STYLE_1,MINECRAFT_ACTION_CRAFTING, _360_JOY_BUTTON_X); InputManager.SetGameJoypadMaps(MAP_STYLE_1,MINECRAFT_ACTION_RENDER_THIRD_PERSON, _360_JOY_BUTTON_RTHUMB); InputManager.SetGameJoypadMaps(MAP_STYLE_1,MINECRAFT_ACTION_GAME_INFO, _360_JOY_BUTTON_BACK); InputManager.SetGameJoypadMaps(MAP_STYLE_1,MINECRAFT_ACTION_DPAD_LEFT, _360_JOY_BUTTON_DPAD_LEFT); InputManager.SetGameJoypadMaps(MAP_STYLE_1,MINECRAFT_ACTION_DPAD_RIGHT, _360_JOY_BUTTON_DPAD_RIGHT); InputManager.SetGameJoypadMaps(MAP_STYLE_1,MINECRAFT_ACTION_DPAD_UP, _360_JOY_BUTTON_DPAD_UP); InputManager.SetGameJoypadMaps(MAP_STYLE_1,MINECRAFT_ACTION_DPAD_DOWN, _360_JOY_BUTTON_DPAD_DOWN); InputManager.SetGameJoypadMaps(MAP_STYLE_2,ACTION_MENU_A, _360_JOY_BUTTON_A); InputManager.SetGameJoypadMaps(MAP_STYLE_2,ACTION_MENU_B, _360_JOY_BUTTON_B); InputManager.SetGameJoypadMaps(MAP_STYLE_2,ACTION_MENU_X, _360_JOY_BUTTON_X); InputManager.SetGameJoypadMaps(MAP_STYLE_2,ACTION_MENU_Y, _360_JOY_BUTTON_Y); InputManager.SetGameJoypadMaps(MAP_STYLE_2,ACTION_MENU_OK, _360_JOY_BUTTON_A); InputManager.SetGameJoypadMaps(MAP_STYLE_2,ACTION_MENU_CANCEL, _360_JOY_BUTTON_B); InputManager.SetGameJoypadMaps(MAP_STYLE_2,ACTION_MENU_UP, _360_JOY_BUTTON_DPAD_UP | _360_JOY_BUTTON_LSTICK_UP); InputManager.SetGameJoypadMaps(MAP_STYLE_2,ACTION_MENU_DOWN, _360_JOY_BUTTON_DPAD_DOWN | _360_JOY_BUTTON_LSTICK_DOWN); InputManager.SetGameJoypadMaps(MAP_STYLE_2,ACTION_MENU_LEFT, _360_JOY_BUTTON_DPAD_LEFT | _360_JOY_BUTTON_LSTICK_LEFT); InputManager.SetGameJoypadMaps(MAP_STYLE_2,ACTION_MENU_RIGHT, _360_JOY_BUTTON_DPAD_RIGHT | _360_JOY_BUTTON_LSTICK_RIGHT); InputManager.SetGameJoypadMaps(MAP_STYLE_2,ACTION_MENU_PAGEUP, _360_JOY_BUTTON_DPAD_UP | _360_JOY_BUTTON_LB); InputManager.SetGameJoypadMaps(MAP_STYLE_2,ACTION_MENU_PAGEDOWN, _360_JOY_BUTTON_RT); InputManager.SetGameJoypadMaps(MAP_STYLE_2,ACTION_MENU_RIGHT_SCROLL, _360_JOY_BUTTON_RB); InputManager.SetGameJoypadMaps(MAP_STYLE_2,ACTION_MENU_LEFT_SCROLL, _360_JOY_BUTTON_LB); InputManager.SetGameJoypadMaps(MAP_STYLE_2,MINECRAFT_ACTION_JUMP, _360_JOY_BUTTON_LT); InputManager.SetGameJoypadMaps(MAP_STYLE_2,MINECRAFT_ACTION_FORWARD, _360_JOY_BUTTON_LSTICK_UP); InputManager.SetGameJoypadMaps(MAP_STYLE_2,MINECRAFT_ACTION_BACKWARD, _360_JOY_BUTTON_LSTICK_DOWN); InputManager.SetGameJoypadMaps(MAP_STYLE_2,MINECRAFT_ACTION_LEFT, _360_JOY_BUTTON_LSTICK_LEFT); InputManager.SetGameJoypadMaps(MAP_STYLE_2,MINECRAFT_ACTION_RIGHT, _360_JOY_BUTTON_LSTICK_RIGHT); InputManager.SetGameJoypadMaps(MAP_STYLE_2,MINECRAFT_ACTION_LOOK_LEFT, _360_JOY_BUTTON_RSTICK_LEFT); InputManager.SetGameJoypadMaps(MAP_STYLE_2,MINECRAFT_ACTION_LOOK_RIGHT, _360_JOY_BUTTON_RSTICK_RIGHT); InputManager.SetGameJoypadMaps(MAP_STYLE_2,MINECRAFT_ACTION_LOOK_UP, _360_JOY_BUTTON_RSTICK_UP); InputManager.SetGameJoypadMaps(MAP_STYLE_2,MINECRAFT_ACTION_LOOK_DOWN, _360_JOY_BUTTON_RSTICK_DOWN); InputManager.SetGameJoypadMaps(MAP_STYLE_2,MINECRAFT_ACTION_USE, _360_JOY_BUTTON_RT); InputManager.SetGameJoypadMaps(MAP_STYLE_2,MINECRAFT_ACTION_ACTION, _360_JOY_BUTTON_A); InputManager.SetGameJoypadMaps(MAP_STYLE_2,MINECRAFT_ACTION_RIGHT_SCROLL, _360_JOY_BUTTON_DPAD_RIGHT); InputManager.SetGameJoypadMaps(MAP_STYLE_2,MINECRAFT_ACTION_LEFT_SCROLL, _360_JOY_BUTTON_DPAD_LEFT); InputManager.SetGameJoypadMaps(MAP_STYLE_2,MINECRAFT_ACTION_INVENTORY, _360_JOY_BUTTON_Y); InputManager.SetGameJoypadMaps(MAP_STYLE_2,MINECRAFT_ACTION_PAUSEMENU, _360_JOY_BUTTON_START); InputManager.SetGameJoypadMaps(MAP_STYLE_2,MINECRAFT_ACTION_DROP, _360_JOY_BUTTON_B); InputManager.SetGameJoypadMaps(MAP_STYLE_2,MINECRAFT_ACTION_SNEAK_TOGGLE, _360_JOY_BUTTON_LB); InputManager.SetGameJoypadMaps(MAP_STYLE_2,MINECRAFT_ACTION_CRAFTING, _360_JOY_BUTTON_X); InputManager.SetGameJoypadMaps(MAP_STYLE_2,MINECRAFT_ACTION_RENDER_THIRD_PERSON, _360_JOY_BUTTON_LTHUMB); InputManager.SetGameJoypadMaps(MAP_STYLE_2,MINECRAFT_ACTION_GAME_INFO, _360_JOY_BUTTON_BACK); InputManager.SetGameJoypadMaps(MAP_STYLE_2,ACTION_MENU_PAUSEMENU, _360_JOY_BUTTON_START); InputManager.SetGameJoypadMaps(MAP_STYLE_2,ACTION_MENU_STICK_PRESS, _360_JOY_BUTTON_LTHUMB); InputManager.SetGameJoypadMaps(MAP_STYLE_2,ACTION_MENU_OTHER_STICK_PRESS, _360_JOY_BUTTON_RTHUMB); InputManager.SetGameJoypadMaps(MAP_STYLE_2,ACTION_MENU_OTHER_STICK_UP, _360_JOY_BUTTON_RSTICK_UP); InputManager.SetGameJoypadMaps(MAP_STYLE_2,ACTION_MENU_OTHER_STICK_DOWN, _360_JOY_BUTTON_RSTICK_DOWN); InputManager.SetGameJoypadMaps(MAP_STYLE_2,ACTION_MENU_OTHER_STICK_LEFT, _360_JOY_BUTTON_RSTICK_LEFT); InputManager.SetGameJoypadMaps(MAP_STYLE_2,ACTION_MENU_OTHER_STICK_RIGHT, _360_JOY_BUTTON_RSTICK_RIGHT); InputManager.SetGameJoypadMaps(MAP_STYLE_2,MINECRAFT_ACTION_DPAD_LEFT, _360_JOY_BUTTON_DPAD_LEFT); InputManager.SetGameJoypadMaps(MAP_STYLE_2,MINECRAFT_ACTION_DPAD_RIGHT, _360_JOY_BUTTON_DPAD_RIGHT); InputManager.SetGameJoypadMaps(MAP_STYLE_2,MINECRAFT_ACTION_DPAD_UP, _360_JOY_BUTTON_DPAD_UP); InputManager.SetGameJoypadMaps(MAP_STYLE_2,MINECRAFT_ACTION_DPAD_DOWN, _360_JOY_BUTTON_DPAD_DOWN); } #if 0 HRESULT InitD3D( IDirect3DDevice9 **ppDevice, D3DPRESENT_PARAMETERS *pd3dPP ) { IDirect3D9 *pD3D; pD3D = Direct3DCreate9( D3D_SDK_VERSION ); ZeroMemory( pd3dPP, sizeof(D3DPRESENT_PARAMETERS) ); XVIDEO_MODE VideoMode; XGetVideoMode( &VideoMode ); g_bWidescreen = VideoMode.fIsWideScreen; pd3dPP->BackBufferWidth = 1280; pd3dPP->BackBufferHeight = 720; pd3dPP->BackBufferFormat = D3DFMT_A8R8G8B8; pd3dPP->BackBufferCount = 1; pd3dPP->EnableAutoDepthStencil = TRUE; pd3dPP->AutoDepthStencilFormat = D3DFMT_D24S8; pd3dPP->SwapEffect = D3DSWAPEFFECT_DISCARD; pd3dPP->PresentationInterval = D3DPRESENT_INTERVAL_ONE; //pd3dPP->Flags = D3DPRESENTFLAG_NO_LETTERBOX; //ERR[D3D]: Can't set D3DPRESENTFLAG_NO_LETTERBOX when wide-screen is enabled // in the launcher/dashboard. if(g_bWidescreen) pd3dPP->Flags=0; else pd3dPP->Flags = D3DPRESENTFLAG_NO_LETTERBOX; // Create the device. return pD3D->CreateDevice( 0, D3DDEVTYPE_HAL, NULL, D3DCREATE_HARDWARE_VERTEXPROCESSING|D3DCREATE_BUFFER_2_FRAMES, pd3dPP, ppDevice ); } #endif //#define MEMORY_TRACKING #ifdef MEMORY_TRACKING void ResetMem(); void DumpMem(); void MemPixStuff(); #else void MemSect(int sect) { } #endif HINSTANCE g_hInst = NULL; HWND g_hWnd = NULL; HWND GetMinecraftWindowHWND() { return g_hWnd; } static bool g_isFullscreen = false; static RECT g_windowedRect = {}; static LONG g_windowedStyle = 0; void ToggleFullscreen() { if (!g_hWnd) return; if (!g_isFullscreen) { g_windowedStyle = GetWindowLong(g_hWnd, GWL_STYLE); GetWindowRect(g_hWnd, &g_windowedRect); HMONITOR hMon = MonitorFromWindow(g_hWnd, MONITOR_DEFAULTTONEAREST); MONITORINFO mi = { sizeof(mi) }; GetMonitorInfo(hMon, &mi); SetWindowLong(g_hWnd, GWL_STYLE, WS_POPUP | WS_VISIBLE); SetWindowPos(g_hWnd, HWND_TOP, mi.rcMonitor.left, mi.rcMonitor.top, mi.rcMonitor.right - mi.rcMonitor.left, mi.rcMonitor.bottom - mi.rcMonitor.top, SWP_FRAMECHANGED | SWP_NOOWNERZORDER); g_isFullscreen = true; } else { SetWindowLong(g_hWnd, GWL_STYLE, g_windowedStyle); SetWindowPos(g_hWnd, HWND_NOTOPMOST, g_windowedRect.left, g_windowedRect.top, g_windowedRect.right - g_windowedRect.left, g_windowedRect.bottom - g_windowedRect.top, SWP_FRAMECHANGED | SWP_NOOWNERZORDER); g_isFullscreen = false; } if (g_KBMInput.IsWindowFocused()) g_KBMInput.SetWindowFocused(true); } D3D_DRIVER_TYPE g_driverType = D3D_DRIVER_TYPE_NULL; D3D_FEATURE_LEVEL g_featureLevel = D3D_FEATURE_LEVEL_11_0; ID3D11Device* g_pd3dDevice = NULL; ID3D11DeviceContext* g_pImmediateContext = NULL; IDXGISwapChain* g_pSwapChain = NULL; ID3D11RenderTargetView* g_pRenderTargetView = NULL; ID3D11DepthStencilView* g_pDepthStencilView = NULL; ID3D11Texture2D* g_pDepthStencilBuffer = NULL; enum ERendererBackend { RENDERER_BACKEND_D3D11 = 0, RENDERER_BACKEND_VULKAN, }; static ERendererBackend g_rendererBackendRequested = RENDERER_BACKEND_D3D11; static ERendererBackend g_rendererBackendActive = RENDERER_BACKEND_D3D11; struct LegacyRendererBridge { ID3D11Device *device; ID3D11DeviceContext *context; ID3D11RenderTargetView *renderTargetView; ID3D11DepthStencilView *depthStencilView; IDXGISwapChain *swapChain; bool ready; }; struct VulkanBootstrapState { VkInstance instance; VkSurfaceKHR surface; VkPhysicalDevice physicalDevice; VkDevice device; VkQueue graphicsQueue; uint32_t graphicsQueueFamilyIndex; VkSwapchainKHR swapChain; VkFormat swapChainFormat; VkExtent2D swapChainExtent; char gpuName[VK_MAX_PHYSICAL_DEVICE_NAME_SIZE]; bool initialised; }; static VulkanBootstrapState g_vulkanBootstrapState = { 0, 0, 0, 0, 0, 0, 0, VK_FORMAT_UNDEFINED, { 0, 0 }, { 0 }, false }; static WORD g_originalGammaRamp[3][256]; static bool g_gammaRampSaved = false; void Windows64_UpdateGamma(unsigned short usGamma) { if (!g_hWnd) return; HDC hdc = GetDC(g_hWnd); if (!hdc) return; if (!g_gammaRampSaved) { GetDeviceGammaRamp(hdc, g_originalGammaRamp); g_gammaRampSaved = true; } float gamma = (float)usGamma / 32768.0f; if (gamma < 0.01f) gamma = 0.01f; if (gamma > 1.0f) gamma = 1.0f; float invGamma = 1.0f / (0.5f + gamma * 0.5f); WORD ramp[3][256]; for (int i = 0; i < 256; i++) { float normalized = (float)i / 255.0f; float corrected = powf(normalized, invGamma); WORD val = (WORD)(corrected * 65535.0f + 0.5f); ramp[0][i] = val; ramp[1][i] = val; ramp[2][i] = val; } SetDeviceGammaRamp(hdc, ramp); ReleaseDC(g_hWnd, hdc); } void Windows64_RestoreGamma() { if (!g_gammaRampSaved || !g_hWnd) return; HDC hdc = GetDC(g_hWnd); if (!hdc) return; SetDeviceGammaRamp(hdc, g_originalGammaRamp); ReleaseDC(g_hWnd, hdc); } static const char* GetRendererBackendName(ERendererBackend backend) { switch (backend) { case RENDERER_BACKEND_VULKAN: return "vulkan"; case RENDERER_BACKEND_D3D11: default: return "d3d11"; } } static void PrintRendererStatusToConsole(const char *phase, const char *detail = "") { printf("[Renderer] %s | requested=%s active=%s %s\n", phase ? phase : "state", GetRendererBackendName(g_rendererBackendRequested), GetRendererBackendName(g_rendererBackendActive), detail ? detail : ""); fflush(stdout); } static LegacyRendererBridge GetLegacyRendererBridge() { LegacyRendererBridge bridge; bridge.device = g_pd3dDevice; bridge.context = g_pImmediateContext; bridge.renderTargetView = g_pRenderTargetView; bridge.depthStencilView = g_pDepthStencilView; bridge.swapChain = g_pSwapChain; bridge.ready = (bridge.device && bridge.context && bridge.renderTargetView && bridge.depthStencilView && bridge.swapChain); return bridge; } static const char* VkResultToString(VkResult result) { switch (result) { case VK_SUCCESS: return "VK_SUCCESS"; case VK_NOT_READY: return "VK_NOT_READY"; case VK_TIMEOUT: return "VK_TIMEOUT"; case VK_EVENT_SET: return "VK_EVENT_SET"; case VK_EVENT_RESET: return "VK_EVENT_RESET"; case VK_INCOMPLETE: return "VK_INCOMPLETE"; case VK_ERROR_OUT_OF_HOST_MEMORY: return "VK_ERROR_OUT_OF_HOST_MEMORY"; case VK_ERROR_OUT_OF_DEVICE_MEMORY: return "VK_ERROR_OUT_OF_DEVICE_MEMORY"; case VK_ERROR_INITIALIZATION_FAILED: return "VK_ERROR_INITIALIZATION_FAILED"; case VK_ERROR_DEVICE_LOST: return "VK_ERROR_DEVICE_LOST"; case VK_ERROR_MEMORY_MAP_FAILED: return "VK_ERROR_MEMORY_MAP_FAILED"; case VK_ERROR_LAYER_NOT_PRESENT: return "VK_ERROR_LAYER_NOT_PRESENT"; case VK_ERROR_EXTENSION_NOT_PRESENT: return "VK_ERROR_EXTENSION_NOT_PRESENT"; case VK_ERROR_FEATURE_NOT_PRESENT: return "VK_ERROR_FEATURE_NOT_PRESENT"; case VK_ERROR_INCOMPATIBLE_DRIVER: return "VK_ERROR_INCOMPATIBLE_DRIVER"; case VK_ERROR_TOO_MANY_OBJECTS: return "VK_ERROR_TOO_MANY_OBJECTS"; case VK_ERROR_FORMAT_NOT_SUPPORTED: return "VK_ERROR_FORMAT_NOT_SUPPORTED"; case VK_ERROR_SURFACE_LOST_KHR: return "VK_ERROR_SURFACE_LOST_KHR"; case VK_ERROR_NATIVE_WINDOW_IN_USE_KHR: return "VK_ERROR_NATIVE_WINDOW_IN_USE_KHR"; case VK_SUBOPTIMAL_KHR: return "VK_SUBOPTIMAL_KHR"; case VK_ERROR_OUT_OF_DATE_KHR: return "VK_ERROR_OUT_OF_DATE_KHR"; default: return "VK_UNKNOWN"; } } static void CleanupVulkanBootstrap() { if (g_vulkanBootstrapState.device != 0) { vkDeviceWaitIdle(g_vulkanBootstrapState.device); } if (g_vulkanBootstrapState.swapChain != 0) { vkDestroySwapchainKHR(g_vulkanBootstrapState.device, g_vulkanBootstrapState.swapChain, NULL); } if (g_vulkanBootstrapState.device != 0) { vkDestroyDevice(g_vulkanBootstrapState.device, NULL); } if (g_vulkanBootstrapState.surface != 0) { vkDestroySurfaceKHR(g_vulkanBootstrapState.instance, g_vulkanBootstrapState.surface, NULL); } if (g_vulkanBootstrapState.instance != 0) { vkDestroyInstance(g_vulkanBootstrapState.instance, NULL); } g_vulkanBootstrapState.instance = 0; g_vulkanBootstrapState.surface = 0; g_vulkanBootstrapState.physicalDevice = 0; g_vulkanBootstrapState.device = 0; g_vulkanBootstrapState.graphicsQueue = 0; g_vulkanBootstrapState.graphicsQueueFamilyIndex = 0; g_vulkanBootstrapState.swapChain = 0; g_vulkanBootstrapState.swapChainFormat = VK_FORMAT_UNDEFINED; g_vulkanBootstrapState.swapChainExtent.width = 0; g_vulkanBootstrapState.swapChainExtent.height = 0; g_vulkanBootstrapState.gpuName[0] = 0; g_vulkanBootstrapState.initialised = false; } static bool SelectVulkanPhysicalDevice(VkInstance instance, VkSurfaceKHR surface, VkPhysicalDevice *deviceOut, uint32_t *queueFamilyOut, VkPhysicalDeviceProperties *propsOut) { uint32_t deviceCount = 0; if (vkEnumeratePhysicalDevices(instance, &deviceCount, NULL) != VK_SUCCESS || deviceCount == 0) { return false; } vector devices(deviceCount); if (vkEnumeratePhysicalDevices(instance, &deviceCount, &devices[0]) != VK_SUCCESS) { return false; } for (uint32_t deviceIndex = 0; deviceIndex < deviceCount; ++deviceIndex) { VkPhysicalDevice candidate = devices[deviceIndex]; uint32_t extensionCount = 0; vkEnumerateDeviceExtensionProperties(candidate, NULL, &extensionCount, NULL); if (extensionCount == 0) { continue; } vector extensions(extensionCount); if (vkEnumerateDeviceExtensionProperties(candidate, NULL, &extensionCount, &extensions[0]) != VK_SUCCESS) { continue; } bool hasSwapchain = false; for (uint32_t ext = 0; ext < extensionCount; ++ext) { if (strcmp(extensions[ext].extensionName, VK_KHR_SWAPCHAIN_EXTENSION_NAME) == 0) { hasSwapchain = true; break; } } if (!hasSwapchain) { continue; } uint32_t queueFamilyCount = 0; vkGetPhysicalDeviceQueueFamilyProperties(candidate, &queueFamilyCount, NULL); if (queueFamilyCount == 0) { continue; } vector queueFamilies(queueFamilyCount); vkGetPhysicalDeviceQueueFamilyProperties(candidate, &queueFamilyCount, &queueFamilies[0]); for (uint32_t queueFamilyIndex = 0; queueFamilyIndex < queueFamilyCount; ++queueFamilyIndex) { VkBool32 supportsPresent = VK_FALSE; vkGetPhysicalDeviceSurfaceSupportKHR(candidate, queueFamilyIndex, surface, &supportsPresent); if ((queueFamilies[queueFamilyIndex].queueFlags & VK_QUEUE_GRAPHICS_BIT) && supportsPresent) { if (propsOut) { vkGetPhysicalDeviceProperties(candidate, propsOut); } *deviceOut = candidate; *queueFamilyOut = queueFamilyIndex; return true; } } } return false; } static HRESULT CreateVulkanBootstrap(HWND hWnd, UINT width, UINT height) { CleanupVulkanBootstrap(); const char *instanceExtensions[] = { VK_KHR_SURFACE_EXTENSION_NAME, VK_KHR_WIN32_SURFACE_EXTENSION_NAME }; VkApplicationInfo appInfo; ZeroMemory(&appInfo, sizeof(appInfo)); appInfo.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO; appInfo.pApplicationName = "MinecraftClient"; appInfo.applicationVersion = VK_MAKE_API_VERSION(0, 1, 0, 0); appInfo.pEngineName = "4JLegacy"; appInfo.engineVersion = VK_MAKE_API_VERSION(0, 1, 0, 0); appInfo.apiVersion = VK_API_VERSION_1_0; VkInstanceCreateInfo instanceInfo; ZeroMemory(&instanceInfo, sizeof(instanceInfo)); instanceInfo.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO; instanceInfo.pApplicationInfo = &appInfo; instanceInfo.enabledExtensionCount = ARRAYSIZE(instanceExtensions); instanceInfo.ppEnabledExtensionNames = instanceExtensions; VkResult vkResult = vkCreateInstance(&instanceInfo, NULL, &g_vulkanBootstrapState.instance); if (vkResult != VK_SUCCESS) { app.DebugPrintf("Vulkan bootstrap: vkCreateInstance failed (%s)\n", VkResultToString(vkResult)); return E_FAIL; } VkWin32SurfaceCreateInfoKHR surfaceInfo; ZeroMemory(&surfaceInfo, sizeof(surfaceInfo)); surfaceInfo.sType = VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR; surfaceInfo.hinstance = GetModuleHandle(NULL); surfaceInfo.hwnd = hWnd; vkResult = vkCreateWin32SurfaceKHR(g_vulkanBootstrapState.instance, &surfaceInfo, NULL, &g_vulkanBootstrapState.surface); if (vkResult != VK_SUCCESS) { app.DebugPrintf("Vulkan bootstrap: vkCreateWin32SurfaceKHR failed (%s)\n", VkResultToString(vkResult)); CleanupVulkanBootstrap(); return E_FAIL; } VkPhysicalDeviceProperties gpuProperties; ZeroMemory(&gpuProperties, sizeof(gpuProperties)); if (!SelectVulkanPhysicalDevice(g_vulkanBootstrapState.instance, g_vulkanBootstrapState.surface, &g_vulkanBootstrapState.physicalDevice, &g_vulkanBootstrapState.graphicsQueueFamilyIndex, &gpuProperties)) { app.DebugPrintf("Vulkan bootstrap: no suitable physical device found\n"); CleanupVulkanBootstrap(); return E_FAIL; } strncpy_s(g_vulkanBootstrapState.gpuName, sizeof(g_vulkanBootstrapState.gpuName), gpuProperties.deviceName, _TRUNCATE); float queuePriority = 1.0f; VkDeviceQueueCreateInfo queueInfo; ZeroMemory(&queueInfo, sizeof(queueInfo)); queueInfo.sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO; queueInfo.queueFamilyIndex = g_vulkanBootstrapState.graphicsQueueFamilyIndex; queueInfo.queueCount = 1; queueInfo.pQueuePriorities = &queuePriority; const char *deviceExtensions[] = { VK_KHR_SWAPCHAIN_EXTENSION_NAME }; VkDeviceCreateInfo deviceInfo; ZeroMemory(&deviceInfo, sizeof(deviceInfo)); deviceInfo.sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO; deviceInfo.queueCreateInfoCount = 1; deviceInfo.pQueueCreateInfos = &queueInfo; deviceInfo.enabledExtensionCount = ARRAYSIZE(deviceExtensions); deviceInfo.ppEnabledExtensionNames = deviceExtensions; vkResult = vkCreateDevice(g_vulkanBootstrapState.physicalDevice, &deviceInfo, NULL, &g_vulkanBootstrapState.device); if (vkResult != VK_SUCCESS) { app.DebugPrintf("Vulkan bootstrap: vkCreateDevice failed (%s)\n", VkResultToString(vkResult)); CleanupVulkanBootstrap(); return E_FAIL; } vkGetDeviceQueue(g_vulkanBootstrapState.device, g_vulkanBootstrapState.graphicsQueueFamilyIndex, 0, &g_vulkanBootstrapState.graphicsQueue); uint32_t formatCount = 0; vkResult = vkGetPhysicalDeviceSurfaceFormatsKHR(g_vulkanBootstrapState.physicalDevice, g_vulkanBootstrapState.surface, &formatCount, NULL); if (vkResult != VK_SUCCESS || formatCount == 0) { app.DebugPrintf("Vulkan bootstrap: surface formats unavailable (%s)\n", VkResultToString(vkResult)); CleanupVulkanBootstrap(); return E_FAIL; } vector formats(formatCount); vkResult = vkGetPhysicalDeviceSurfaceFormatsKHR(g_vulkanBootstrapState.physicalDevice, g_vulkanBootstrapState.surface, &formatCount, &formats[0]); if (vkResult != VK_SUCCESS) { app.DebugPrintf("Vulkan bootstrap: failed to read surface formats (%s)\n", VkResultToString(vkResult)); CleanupVulkanBootstrap(); return E_FAIL; } VkSurfaceFormatKHR selectedFormat = formats[0]; for (uint32_t i = 0; i < formatCount; ++i) { if (formats[i].format == VK_FORMAT_B8G8R8A8_UNORM && formats[i].colorSpace == VK_COLOR_SPACE_SRGB_NONLINEAR_KHR) { selectedFormat = formats[i]; break; } } VkSurfaceCapabilitiesKHR surfaceCaps; ZeroMemory(&surfaceCaps, sizeof(surfaceCaps)); vkResult = vkGetPhysicalDeviceSurfaceCapabilitiesKHR(g_vulkanBootstrapState.physicalDevice, g_vulkanBootstrapState.surface, &surfaceCaps); if (vkResult != VK_SUCCESS) { app.DebugPrintf("Vulkan bootstrap: failed to read surface capabilities (%s)\n", VkResultToString(vkResult)); CleanupVulkanBootstrap(); return E_FAIL; } uint32_t presentModeCount = 0; vkResult = vkGetPhysicalDeviceSurfacePresentModesKHR(g_vulkanBootstrapState.physicalDevice, g_vulkanBootstrapState.surface, &presentModeCount, NULL); if (vkResult != VK_SUCCESS || presentModeCount == 0) { app.DebugPrintf("Vulkan bootstrap: present modes unavailable (%s)\n", VkResultToString(vkResult)); CleanupVulkanBootstrap(); return E_FAIL; } vector presentModes(presentModeCount); vkResult = vkGetPhysicalDeviceSurfacePresentModesKHR(g_vulkanBootstrapState.physicalDevice, g_vulkanBootstrapState.surface, &presentModeCount, &presentModes[0]); if (vkResult != VK_SUCCESS) { app.DebugPrintf("Vulkan bootstrap: failed to read present modes (%s)\n", VkResultToString(vkResult)); CleanupVulkanBootstrap(); return E_FAIL; } VkPresentModeKHR presentMode = VK_PRESENT_MODE_FIFO_KHR; for (uint32_t i = 0; i < presentModeCount; ++i) { if (presentModes[i] == VK_PRESENT_MODE_MAILBOX_KHR) { presentMode = VK_PRESENT_MODE_MAILBOX_KHR; break; } } VkExtent2D extent; if (surfaceCaps.currentExtent.width != 0xFFFFFFFF) { extent = surfaceCaps.currentExtent; } else { extent.width = width; extent.height = height; if (extent.width < surfaceCaps.minImageExtent.width) extent.width = surfaceCaps.minImageExtent.width; if (extent.width > surfaceCaps.maxImageExtent.width) extent.width = surfaceCaps.maxImageExtent.width; if (extent.height < surfaceCaps.minImageExtent.height) extent.height = surfaceCaps.minImageExtent.height; if (extent.height > surfaceCaps.maxImageExtent.height) extent.height = surfaceCaps.maxImageExtent.height; } uint32_t imageCount = surfaceCaps.minImageCount + 1; if (surfaceCaps.maxImageCount > 0 && imageCount > surfaceCaps.maxImageCount) { imageCount = surfaceCaps.maxImageCount; } VkSwapchainCreateInfoKHR swapchainInfo; ZeroMemory(&swapchainInfo, sizeof(swapchainInfo)); swapchainInfo.sType = VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR; swapchainInfo.surface = g_vulkanBootstrapState.surface; swapchainInfo.minImageCount = imageCount; swapchainInfo.imageFormat = selectedFormat.format; swapchainInfo.imageColorSpace = selectedFormat.colorSpace; swapchainInfo.imageExtent = extent; swapchainInfo.imageArrayLayers = 1; swapchainInfo.imageUsage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT; swapchainInfo.imageSharingMode = VK_SHARING_MODE_EXCLUSIVE; swapchainInfo.preTransform = surfaceCaps.currentTransform; swapchainInfo.compositeAlpha = VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR; swapchainInfo.presentMode = presentMode; swapchainInfo.clipped = VK_TRUE; swapchainInfo.oldSwapchain = 0; vkResult = vkCreateSwapchainKHR(g_vulkanBootstrapState.device, &swapchainInfo, NULL, &g_vulkanBootstrapState.swapChain); if (vkResult != VK_SUCCESS) { app.DebugPrintf("Vulkan bootstrap: vkCreateSwapchainKHR failed (%s)\n", VkResultToString(vkResult)); CleanupVulkanBootstrap(); return E_FAIL; } g_vulkanBootstrapState.swapChainFormat = selectedFormat.format; g_vulkanBootstrapState.swapChainExtent = extent; g_vulkanBootstrapState.initialised = true; return S_OK; } static bool ParseRendererBackend(const char *value, ERendererBackend *backendOut) { if (!value || !*value || !backendOut) return false; if (_stricmp(value, "vulkan") == 0 || _stricmp(value, "vk") == 0) { *backendOut = RENDERER_BACKEND_VULKAN; return true; } if (_stricmp(value, "d3d11") == 0 || _stricmp(value, "dx11") == 0) { *backendOut = RENDERER_BACKEND_D3D11; return true; } return false; } static bool TryGetBackendFromEnv(ERendererBackend *backendOut) { char value[32] = { 0 }; DWORD chars = GetEnvironmentVariableA("MC_RENDERER", value, ARRAYSIZE(value)); if (chars == 0 || chars >= ARRAYSIZE(value)) return false; return ParseRendererBackend(value, backendOut); } static bool TryGetBackendFromCommandLine(const char *commandLine, ERendererBackend *backendOut) { if (!commandLine || !*commandLine || !backendOut) return false; const char *option = strstr(commandLine, "-renderer"); if (!option) option = strstr(commandLine, "/renderer"); if (!option) return false; option += 9; // strlen("-renderer") while (*option == ' ' || *option == '\t' || *option == '=') ++option; if (!*option) return false; char token[32] = { 0 }; int i = 0; while (option[i] && option[i] != ' ' && option[i] != '\t' && i < ((int)ARRAYSIZE(token) - 1)) { token[i] = option[i]; ++i; } token[i] = 0; return ParseRendererBackend(token, backendOut); } static void SelectRendererBackend(const char *commandLine) { ERendererBackend selected = RENDERER_BACKEND_D3D11; if (TryGetBackendFromEnv(&selected)) { g_rendererBackendRequested = selected; } if (TryGetBackendFromCommandLine(commandLine, &selected)) { g_rendererBackendRequested = selected; } g_rendererBackendActive = g_rendererBackendRequested; app.DebugPrintf("Renderer backend requested=%s active=%s\n", GetRendererBackendName(g_rendererBackendRequested), GetRendererBackendName(g_rendererBackendActive)); PrintRendererStatusToConsole("Selected"); } static void ReleaseD3D11Device() { if (g_pImmediateContext) { g_pImmediateContext->OMSetRenderTargets(0, NULL, NULL); g_pImmediateContext->ClearState(); g_pImmediateContext->Flush(); } if (g_pRenderTargetView) { g_pRenderTargetView->Release(); g_pRenderTargetView = NULL; } if (g_pDepthStencilView) { g_pDepthStencilView->Release(); g_pDepthStencilView = NULL; } if (g_pDepthStencilBuffer) { g_pDepthStencilBuffer->Release(); g_pDepthStencilBuffer = NULL; } if (g_pSwapChain) { g_pSwapChain->Release(); g_pSwapChain = NULL; } if (g_pImmediateContext) { g_pImmediateContext->Release(); g_pImmediateContext = NULL; } if (g_pd3dDevice) { g_pd3dDevice->Release(); g_pd3dDevice = NULL; } } static HRESULT CreateD3D11Device(HWND hWnd, UINT width, UINT height) { UINT createDeviceFlags = 0; #ifdef _DEBUG createDeviceFlags |= D3D11_CREATE_DEVICE_DEBUG; #endif D3D_DRIVER_TYPE driverTypes[] = { D3D_DRIVER_TYPE_HARDWARE, D3D_DRIVER_TYPE_WARP, D3D_DRIVER_TYPE_REFERENCE, }; D3D_FEATURE_LEVEL featureLevels[] = { D3D_FEATURE_LEVEL_11_0, D3D_FEATURE_LEVEL_10_1, D3D_FEATURE_LEVEL_10_0, }; DXGI_SWAP_CHAIN_DESC sd; ZeroMemory(&sd, sizeof(sd)); sd.BufferCount = 1; sd.BufferDesc.Width = width; sd.BufferDesc.Height = height; sd.BufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM; sd.BufferDesc.RefreshRate.Numerator = 60; sd.BufferDesc.RefreshRate.Denominator = 1; sd.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT; sd.OutputWindow = hWnd; sd.SampleDesc.Count = 1; sd.SampleDesc.Quality = 0; sd.Windowed = TRUE; HRESULT hr = E_FAIL; for (UINT i = 0; i < ARRAYSIZE(driverTypes); ++i) { g_driverType = driverTypes[i]; hr = D3D11CreateDeviceAndSwapChain(NULL, g_driverType, NULL, createDeviceFlags, featureLevels, ARRAYSIZE(featureLevels), D3D11_SDK_VERSION, &sd, &g_pSwapChain, &g_pd3dDevice, &g_featureLevel, &g_pImmediateContext); if (SUCCEEDED(hr)) break; } if (FAILED(hr)) return hr; ID3D11Texture2D *pBackBuffer = NULL; hr = g_pSwapChain->GetBuffer(0, __uuidof(ID3D11Texture2D), (LPVOID*)&pBackBuffer); if (FAILED(hr)) { ReleaseD3D11Device(); return hr; } hr = g_pd3dDevice->CreateRenderTargetView(pBackBuffer, NULL, &g_pRenderTargetView); pBackBuffer->Release(); if (FAILED(hr)) { ReleaseD3D11Device(); return hr; } D3D11_TEXTURE2D_DESC descDepth; ZeroMemory(&descDepth, sizeof(descDepth)); descDepth.Width = width; descDepth.Height = height; descDepth.MipLevels = 1; descDepth.ArraySize = 1; descDepth.Format = DXGI_FORMAT_D24_UNORM_S8_UINT; descDepth.SampleDesc.Count = 1; descDepth.SampleDesc.Quality = 0; descDepth.Usage = D3D11_USAGE_DEFAULT; descDepth.BindFlags = D3D11_BIND_DEPTH_STENCIL; hr = g_pd3dDevice->CreateTexture2D(&descDepth, NULL, &g_pDepthStencilBuffer); if (FAILED(hr)) { ReleaseD3D11Device(); return hr; } D3D11_DEPTH_STENCIL_VIEW_DESC descDSV; ZeroMemory(&descDSV, sizeof(descDSV)); descDSV.Format = DXGI_FORMAT_D24_UNORM_S8_UINT; descDSV.ViewDimension = D3D11_DSV_DIMENSION_TEXTURE2D; descDSV.Texture2D.MipSlice = 0; hr = g_pd3dDevice->CreateDepthStencilView(g_pDepthStencilBuffer, &descDSV, &g_pDepthStencilView); if (FAILED(hr)) { ReleaseD3D11Device(); return hr; } g_pImmediateContext->OMSetRenderTargets(1, &g_pRenderTargetView, g_pDepthStencilView); D3D11_VIEWPORT vp; vp.Width = (FLOAT)width; vp.Height = (FLOAT)height; vp.MinDepth = 0.0f; vp.MaxDepth = 1.0f; vp.TopLeftX = 0; vp.TopLeftY = 0; g_pImmediateContext->RSSetViewports(1, &vp); return S_OK; } static HRESULT ResizeD3D11Device(HWND hWnd, UINT width, UINT height) { ReleaseD3D11Device(); return CreateD3D11Device(hWnd, width, height); } static HRESULT CreateActiveRendererDevice(HWND hWnd, UINT width, UINT height) { if (g_rendererBackendRequested == RENDERER_BACKEND_VULKAN) { HRESULT vulkanProbeResult = CreateVulkanBootstrap(hWnd, width, height); if (SUCCEEDED(vulkanProbeResult)) { app.DebugPrintf("Vulkan bootstrap OK on GPU '%s' (%ux%u)\n", g_vulkanBootstrapState.gpuName, g_vulkanBootstrapState.swapChainExtent.width, g_vulkanBootstrapState.swapChainExtent.height); char detail[256]; sprintf_s(detail, sizeof(detail), "probe=ok gpu=%s extent=%ux%u", g_vulkanBootstrapState.gpuName, g_vulkanBootstrapState.swapChainExtent.width, g_vulkanBootstrapState.swapChainExtent.height); PrintRendererStatusToConsole("Vulkan", detail); } else { app.DebugPrintf("Vulkan bootstrap failed, continuing with d3d11 compatibility path.\n"); PrintRendererStatusToConsole("Vulkan", "probe=failed fallback=d3d11"); } CleanupVulkanBootstrap(); } g_rendererBackendActive = RENDERER_BACKEND_D3D11; HRESULT hr = CreateD3D11Device(hWnd, width, height); if (SUCCEEDED(hr)) { PrintRendererStatusToConsole("Startup", "active=d3d11"); } return hr; } static HRESULT ResizeActiveRendererDevice(HWND hWnd, UINT width, UINT height) { return ResizeD3D11Device(hWnd, width, height); } static void CleanupActiveRendererDevice() { CleanupVulkanBootstrap(); ReleaseD3D11Device(); } static void InitialiseRenderManager() { LegacyRendererBridge bridge = GetLegacyRendererBridge(); if (bridge.ready) { RenderManager.Initialise(bridge.device, bridge.swapChain); } else { app.DebugPrintf("RenderManager init skipped: legacy renderer bridge is unavailable.\n"); } } // // FUNCTION: WndProc(HWND, UINT, WPARAM, LPARAM) // // PURPOSE: Processes messages for the main window. // // WM_COMMAND - process the application menu // WM_PAINT - Paint the main window // WM_DESTROY - post a quit message and return // // LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam) { int wmId, wmEvent; PAINTSTRUCT ps; HDC hdc; switch (message) { case WM_SIZE: if (wParam != SIZE_MINIMIZED && g_pSwapChain != NULL) { UINT newWidth = LOWORD(lParam); UINT newHeight = HIWORD(lParam); if (newWidth == 0 || newHeight == 0) break; g_iScreenWidth = (int)newWidth; g_iScreenHeight = (int)newHeight; HRESULT hr = ResizeActiveRendererDevice(hWnd, newWidth, newHeight); if (FAILED(hr)) { app.DebugPrintf("WM_SIZE recreate failed for backend %s: 0x%08X\n", GetRendererBackendName(g_rendererBackendActive), hr); break; } app.DebugPrintf("WM_SIZE recreate ok for backend %s (%dx%d)\n", GetRendererBackendName(g_rendererBackendActive), newWidth, newHeight); Minecraft *pMinecraft = Minecraft::GetInstance(); if (pMinecraft) { pMinecraft->onWindowResize(g_iScreenWidth, g_iScreenHeight); } } break; case WM_COMMAND: wmId = LOWORD(wParam); wmEvent = HIWORD(wParam); // Parse the menu selections: switch (wmId) { case IDM_EXIT: DestroyWindow(hWnd); break; default: return DefWindowProc(hWnd, message, wParam, lParam); } break; case WM_PAINT: hdc = BeginPaint(hWnd, &ps); EndPaint(hWnd, &ps); break; case WM_DESTROY: PostQuitMessage(0); break; case WM_KILLFOCUS: g_KBMInput.ClearAllState(); g_KBMInput.SetWindowFocused(false); if (g_KBMInput.IsMouseGrabbed()) g_KBMInput.SetMouseGrabbed(false); break; case WM_SETFOCUS: g_KBMInput.SetWindowFocused(true); break; case WM_KEYDOWN: case WM_SYSKEYDOWN: { int vk = (int)wParam; if (vk == VK_F11) { ToggleFullscreen(); break; } if (vk == VK_SHIFT) vk = (MapVirtualKey((lParam >> 16) & 0xFF, MAPVK_VSC_TO_VK_EX) == VK_RSHIFT) ? VK_RSHIFT : VK_LSHIFT; else if (vk == VK_CONTROL) vk = (lParam & (1 << 24)) ? VK_RCONTROL : VK_LCONTROL; else if (vk == VK_MENU) vk = (lParam & (1 << 24)) ? VK_RMENU : VK_LMENU; g_KBMInput.OnKeyDown(vk); break; } case WM_KEYUP: case WM_SYSKEYUP: { int vk = (int)wParam; if (vk == VK_SHIFT) vk = (MapVirtualKey((lParam >> 16) & 0xFF, MAPVK_VSC_TO_VK_EX) == VK_RSHIFT) ? VK_RSHIFT : VK_LSHIFT; else if (vk == VK_CONTROL) vk = (lParam & (1 << 24)) ? VK_RCONTROL : VK_LCONTROL; else if (vk == VK_MENU) vk = (lParam & (1 << 24)) ? VK_RMENU : VK_LMENU; g_KBMInput.OnKeyUp(vk); break; } case WM_LBUTTONDOWN: g_KBMInput.OnMouseButtonDown(KeyboardMouseInput::MOUSE_LEFT); break; case WM_LBUTTONUP: g_KBMInput.OnMouseButtonUp(KeyboardMouseInput::MOUSE_LEFT); break; case WM_RBUTTONDOWN: g_KBMInput.OnMouseButtonDown(KeyboardMouseInput::MOUSE_RIGHT); break; case WM_RBUTTONUP: g_KBMInput.OnMouseButtonUp(KeyboardMouseInput::MOUSE_RIGHT); break; case WM_MBUTTONDOWN: g_KBMInput.OnMouseButtonDown(KeyboardMouseInput::MOUSE_MIDDLE); break; case WM_MBUTTONUP: g_KBMInput.OnMouseButtonUp(KeyboardMouseInput::MOUSE_MIDDLE); break; case WM_MOUSEMOVE: g_KBMInput.OnMouseMove(LOWORD(lParam), HIWORD(lParam)); break; case WM_MOUSEWHEEL: g_KBMInput.OnMouseWheel(GET_WHEEL_DELTA_WPARAM(wParam)); break; case WM_INPUT: { UINT dwSize = 0; GetRawInputData((HRAWINPUT)lParam, RID_INPUT, NULL, &dwSize, sizeof(RAWINPUTHEADER)); if (dwSize > 0 && dwSize <= 256) { BYTE rawBuffer[256]; if (GetRawInputData((HRAWINPUT)lParam, RID_INPUT, rawBuffer, &dwSize, sizeof(RAWINPUTHEADER)) == dwSize) { RAWINPUT* raw = (RAWINPUT*)rawBuffer; if (raw->header.dwType == RIM_TYPEMOUSE) { g_KBMInput.OnRawMouseDelta(raw->data.mouse.lLastX, raw->data.mouse.lLastY); } } } } break; default: return DefWindowProc(hWnd, message, wParam, lParam); } return 0; } // // FUNCTION: MyRegisterClass() // // PURPOSE: Registers the window class. // ATOM MyRegisterClass(HINSTANCE hInstance) { WNDCLASSEX wcex; wcex.cbSize = sizeof(WNDCLASSEX); wcex.style = CS_HREDRAW | CS_VREDRAW; wcex.lpfnWndProc = WndProc; wcex.cbClsExtra = 0; wcex.cbWndExtra = 0; wcex.hInstance = hInstance; wcex.hIcon = LoadIcon(hInstance, "Minecraft"); wcex.hCursor = LoadCursor(NULL, IDC_ARROW); wcex.hbrBackground = (HBRUSH)(COLOR_WINDOW+1); wcex.lpszMenuName = "Minecraft"; wcex.lpszClassName = "MinecraftClass"; wcex.hIconSm = LoadIcon(wcex.hInstance, MAKEINTRESOURCE(IDI_SMALL)); return RegisterClassEx(&wcex); } // // FUNCTION: InitInstance(HINSTANCE, int) // // PURPOSE: Saves instance handle and creates main window // // COMMENTS: // // In this function, we save the instance handle in a global variable and // create and display the main program window. // BOOL InitInstance(HINSTANCE hInstance, int nCmdShow) { g_hInst = hInstance; // Store instance handle in our global variable RECT wr = {0, 0, g_iScreenWidth, g_iScreenHeight}; // set the size, but not the position AdjustWindowRect(&wr, WS_OVERLAPPEDWINDOW, FALSE); // adjust the size g_hWnd = CreateWindow( "MinecraftClass", "Minecraft", WS_OVERLAPPEDWINDOW, CW_USEDEFAULT, 0, wr.right - wr.left, // width of the window wr.bottom - wr.top, // height of the window NULL, NULL, hInstance, NULL); if (!g_hWnd) { return FALSE; } ShowWindow(g_hWnd, nCmdShow); UpdateWindow(g_hWnd); return TRUE; } // 4J Stu - These functions are referenced from the Windows Input library void ClearGlobalText() { // clear the global text memset(chGlobalText,0,256); memset(ui16GlobalText,0,512); } uint16_t *GetGlobalText() { //copy the ch text to ui16 char * pchBuffer=(char *)ui16GlobalText; for(int i=0;i<256;i++) { pchBuffer[i*2]=chGlobalText[i]; } return ui16GlobalText; } void SeedEditBox() { DialogBox(hMyInst, MAKEINTRESOURCE(IDD_SEED), g_hWnd, reinterpret_cast(DlgProc)); } //--------------------------------------------------------------------------- LRESULT CALLBACK DlgProc(HWND hWndDlg, UINT Msg, WPARAM wParam, LPARAM lParam) { switch(Msg) { case WM_INITDIALOG: return TRUE; case WM_COMMAND: switch(wParam) { case IDOK: // Set the text GetDlgItemText(hWndDlg,IDC_EDIT,chGlobalText,256); EndDialog(hWndDlg, 0); return TRUE; } break; } return FALSE; } HRESULT InitDevice() { RECT rc; GetClientRect( g_hWnd, &rc ); UINT width = rc.right - rc.left; UINT height = rc.bottom - rc.top; //app.DebugPrintf("width: %d, height: %d\n", width, height); width = g_iScreenWidth; height = g_iScreenHeight; app.DebugPrintf("InitDevice backend=%s width=%d height=%d\n", GetRendererBackendName(g_rendererBackendActive), width, height); return CreateActiveRendererDevice(g_hWnd, width, height); } //-------------------------------------------------------------------------------------- // Render the frame //-------------------------------------------------------------------------------------- void Render() { // Just clear the backbuffer float ClearColor[4] = { 0.0f, 0.125f, 0.3f, 1.0f }; //red,green,blue,alpha g_pImmediateContext->ClearRenderTargetView( g_pRenderTargetView, ClearColor ); g_pSwapChain->Present( 0, 0 ); } //-------------------------------------------------------------------------------------- // Clean up the objects we've created //-------------------------------------------------------------------------------------- void CleanupDevice() { extern void Windows64_RestoreGamma(); Windows64_RestoreGamma(); CleanupActiveRendererDevice(); } int APIENTRY _tWinMain(_In_ HINSTANCE hInstance, _In_opt_ HINSTANCE hPrevInstance, _In_ LPTSTR lpCmdLine, _In_ int nCmdShow) { #ifdef _WINDOWS64 AllocConsole(); freopen("CONOUT$", "w", stdout); freopen("CONOUT$", "w", stderr); freopen("CONIN$", "r", stdin); std::ios::sync_with_stdio(true); #endif UNREFERENCED_PARAMETER(hPrevInstance); char cmdLineA[1024] = { 0 }; if (lpCmdLine) { strncpy_s(cmdLineA, sizeof(cmdLineA), lpCmdLine, _TRUNCATE); } if(lpCmdLine) { if(lpCmdLine[0] == '1') { g_iScreenWidth = 1280; g_iScreenHeight = 720; } else if(lpCmdLine[0] == '2') { g_iScreenWidth = 640; g_iScreenHeight = 480; } else if(lpCmdLine[0] == '3') { // Vita g_iScreenWidth = 720; g_iScreenHeight = 408; // Vita native //g_iScreenWidth = 960; //g_iScreenHeight = 544; } char *nameArg = strstr(cmdLineA, "-name "); if (nameArg) { nameArg += 6; while (*nameArg == ' ') nameArg++; char nameBuf[17]; int n = 0; while (nameArg[n] && nameArg[n] != ' ' && n < 16) { nameBuf[n] = nameArg[n]; n++; } nameBuf[n] = 0; strncpy_s(g_Win64Username, 17, nameBuf, _TRUNCATE); } } if (g_Win64Username[0] == 0) { DWORD sz = 17; if (!GetUserNameA(g_Win64Username, &sz)) strncpy_s(g_Win64Username, 17, "Player", _TRUNCATE); g_Win64Username[16] = 0; } MultiByteToWideChar(CP_ACP, 0, g_Win64Username, -1, g_Win64UsernameW, 17); SelectRendererBackend(cmdLineA); // Initialize global strings MyRegisterClass(hInstance); // Perform application initialization: if (!InitInstance (hInstance, nCmdShow)) { return FALSE; } hMyInst=hInstance; if( FAILED( InitDevice() ) ) { CleanupDevice(); return 0; } #if 0 // Main message loop MSG msg = {0}; while( WM_QUIT != msg.message ) { if( PeekMessage( &msg, NULL, 0, 0, PM_REMOVE ) ) { TranslateMessage( &msg ); DispatchMessage( &msg ); } else { Render(); } } return (int) msg.wParam; #endif static bool bTrialTimerDisplayed=true; #ifdef MEMORY_TRACKING ResetMem(); MEMORYSTATUS memStat; GlobalMemoryStatus(&memStat); printf("RESETMEM start: Avail. phys %d\n",memStat.dwAvailPhys/(1024*1024)); #endif #if 0 // Initialize D3D hr = InitD3D( &pDevice, &d3dpp ); g_pD3DDevice = pDevice; if( FAILED(hr) ) { app.DebugPrintf ( "Failed initializing D3D.\n" ); return -1; } // Initialize the application, assuming sharing of the d3d interface. hr = app.InitShared( pDevice, &d3dpp, XuiPNGTextureLoader ); if ( FAILED(hr) ) { app.DebugPrintf ( "Failed initializing application.\n" ); return -1; } #endif { wchar_t exePath[MAX_PATH] = { 0 }; if (GetModuleFileNameW(NULL, exePath, MAX_PATH)) { wstring exeDir(exePath); size_t lastSlash = exeDir.find_last_of(L"\\/"); if (lastSlash != wstring::npos) { exeDir = exeDir.substr(0, lastSlash); } wstring contentRoot = exeDir + L"\\..\\..\\Minecraft.Client"; wstring fontProbe = contentRoot + L"\\Common\\res\\font\\Mojangles_7.png"; if (GetFileAttributesW(fontProbe.c_str()) != INVALID_FILE_ATTRIBUTES) { SetCurrentDirectoryW(contentRoot.c_str()); } } } app.loadMediaArchive(); InitialiseRenderManager(); app.loadStringTable(); LegacyRendererBridge bridge = GetLegacyRendererBridge(); if (!bridge.ready) { app.DebugPrintf("UI init failed: legacy renderer bridge is unavailable.\n"); CleanupDevice(); return 0; } ui.init(bridge.device, bridge.context, bridge.renderTargetView, bridge.depthStencilView, g_iScreenWidth, g_iScreenHeight); //////////////// // Initialise // //////////////// // Set the number of possible joypad layouts that the user can switch between, and the number of actions InputManager.Initialise(1,3,MINECRAFT_ACTION_MAX, ACTION_MAX_MENU); // Set the default joypad action mappings for Minecraft DefineActions(); InputManager.SetJoypadMapVal(0,0); InputManager.SetKeyRepeatRate(0.3f,0.2f); g_KBMInput.Init(); // Initialise the profile manager with the game Title ID, Offer ID, a profile version number, and the number of profile values and settings ProfileManager.Initialise(TITLEID_MINECRAFT, app.m_dwOfferID, PROFILE_VERSION_10, NUM_PROFILE_VALUES, NUM_PROFILE_SETTINGS, dwProfileSettingsA, app.GAME_DEFINED_PROFILE_DATA_BYTES*XUSER_MAX_COUNT, &app.uiGameDefinedDataChangedBitmask ); #if 0 // register the awards ProfileManager.RegisterAward(eAward_TakingInventory, ACHIEVEMENT_01, eAwardType_Achievement); ProfileManager.RegisterAward(eAward_GettingWood, ACHIEVEMENT_02, eAwardType_Achievement); ProfileManager.RegisterAward(eAward_Benchmarking, ACHIEVEMENT_03, eAwardType_Achievement); ProfileManager.RegisterAward(eAward_TimeToMine, ACHIEVEMENT_04, eAwardType_Achievement); ProfileManager.RegisterAward(eAward_HotTopic, ACHIEVEMENT_05, eAwardType_Achievement); ProfileManager.RegisterAward(eAward_AquireHardware, ACHIEVEMENT_06, eAwardType_Achievement); ProfileManager.RegisterAward(eAward_TimeToFarm, ACHIEVEMENT_07, eAwardType_Achievement); ProfileManager.RegisterAward(eAward_BakeBread, ACHIEVEMENT_08, eAwardType_Achievement); ProfileManager.RegisterAward(eAward_TheLie, ACHIEVEMENT_09, eAwardType_Achievement); ProfileManager.RegisterAward(eAward_GettingAnUpgrade, ACHIEVEMENT_10, eAwardType_Achievement); ProfileManager.RegisterAward(eAward_DeliciousFish, ACHIEVEMENT_11, eAwardType_Achievement); ProfileManager.RegisterAward(eAward_OnARail, ACHIEVEMENT_12, eAwardType_Achievement); ProfileManager.RegisterAward(eAward_TimeToStrike, ACHIEVEMENT_13, eAwardType_Achievement); ProfileManager.RegisterAward(eAward_MonsterHunter, ACHIEVEMENT_14, eAwardType_Achievement); ProfileManager.RegisterAward(eAward_CowTipper, ACHIEVEMENT_15, eAwardType_Achievement); ProfileManager.RegisterAward(eAward_WhenPigsFly, ACHIEVEMENT_16, eAwardType_Achievement); ProfileManager.RegisterAward(eAward_LeaderOfThePack, ACHIEVEMENT_17, eAwardType_Achievement); ProfileManager.RegisterAward(eAward_MOARTools, ACHIEVEMENT_18, eAwardType_Achievement); ProfileManager.RegisterAward(eAward_DispenseWithThis, ACHIEVEMENT_19, eAwardType_Achievement); ProfileManager.RegisterAward(eAward_InToTheNether, ACHIEVEMENT_20, eAwardType_Achievement); ProfileManager.RegisterAward(eAward_mine100Blocks, GAMER_PICTURE_GAMERPIC1, eAwardType_GamerPic,false,app.GetStringTable(),IDS_AWARD_TITLE,IDS_AWARD_GAMERPIC1,IDS_CONFIRM_OK); ProfileManager.RegisterAward(eAward_kill10Creepers, GAMER_PICTURE_GAMERPIC2, eAwardType_GamerPic,false,app.GetStringTable(),IDS_AWARD_TITLE,IDS_AWARD_GAMERPIC2,IDS_CONFIRM_OK); ProfileManager.RegisterAward(eAward_eatPorkChop, AVATARASSETAWARD_PORKCHOP_TSHIRT, eAwardType_AvatarItem,false,app.GetStringTable(),IDS_AWARD_TITLE,IDS_AWARD_AVATAR1,IDS_CONFIRM_OK); ProfileManager.RegisterAward(eAward_play100Days, AVATARASSETAWARD_WATCH, eAwardType_AvatarItem,false,app.GetStringTable(),IDS_AWARD_TITLE,IDS_AWARD_AVATAR2,IDS_CONFIRM_OK); ProfileManager.RegisterAward(eAward_arrowKillCreeper, AVATARASSETAWARD_CAP, eAwardType_AvatarItem,false,app.GetStringTable(),IDS_AWARD_TITLE,IDS_AWARD_AVATAR3,IDS_CONFIRM_OK); ProfileManager.RegisterAward(eAward_socialPost, 0, eAwardType_Theme,false,app.GetStringTable(),IDS_AWARD_TITLE,IDS_AWARD_THEME,IDS_CONFIRM_OK,THEME_NAME,THEME_FILESIZE); // Rich Presence init - number of presences, number of contexts ProfileManager.RichPresenceInit(4,1); ProfileManager.RegisterRichPresenceContext(CONTEXT_GAME_STATE); // initialise the storage manager with a default save display name, a Minimum save size, and a callback for displaying the saving message StorageManager.Init(app.GetString(IDS_DEFAULT_SAVENAME),"savegame.dat",FIFTY_ONE_MB,&CConsoleMinecraftApp::DisplaySavingMessage,(LPVOID)&app); // Set up the global title storage path StorageManager.StoreTMSPathName(); // set a function to be called when there's a sign in change, so we can exit a level if the primary player signs out ProfileManager.SetSignInChangeCallback(&CConsoleMinecraftApp::SignInChangeCallback,(LPVOID)&app); // set a function to be called when the ethernet is disconnected, so we can back out if required ProfileManager.SetNotificationsCallback(&CConsoleMinecraftApp::NotificationsCallback,(LPVOID)&app); #endif // Ensure the GameHDD save directory exists at runtime (the 4J_Storage lib expects it) { wchar_t exePath[MAX_PATH]; if (GetModuleFileNameW(NULL, exePath, MAX_PATH)) { wstring exeDir(exePath); size_t lastSlash = exeDir.find_last_of(L"\\/"); if (lastSlash != wstring::npos) exeDir = exeDir.substr(0, lastSlash); wstring gameHDDPath = exeDir + L"\\Windows64\\GameHDD"; CreateDirectoryW((exeDir + L"\\Windows64").c_str(), NULL); CreateDirectoryW(gameHDDPath.c_str(), NULL); } } // Set a callback for the default player options to be set - when there is no profile data for the player ProfileManager.SetDefaultOptionsCallback(&CConsoleMinecraftApp::DefaultOptionsCallback,(LPVOID)&app); #if 0 // Set a callback to deal with old profile versions needing updated to new versions ProfileManager.SetOldProfileVersionCallback(&CConsoleMinecraftApp::OldProfileVersionCallback,(LPVOID)&app); // Set a callback for when there is a read error on profile data ProfileManager.SetProfileReadErrorCallback(&CConsoleMinecraftApp::ProfileReadErrorCallback,(LPVOID)&app); #endif // QNet needs to be setup after profile manager, as we do not want its Notify listener to handle // XN_SYS_SIGNINCHANGED notifications. This does mean that we need to have a callback in the // ProfileManager for XN_LIVE_INVITE_ACCEPTED for QNet. g_NetworkManager.Initialise(); for (int i = 0; i < MINECRAFT_NET_MAX_PLAYERS; i++) { IQNet::m_player[i].m_smallId = (BYTE)i; IQNet::m_player[i].m_isRemote = false; IQNet::m_player[i].m_isHostPlayer = (i == 0); swprintf_s(IQNet::m_player[i].m_gamertag, 32, L"Player%d", i); } extern wchar_t g_Win64UsernameW[17]; wcscpy_s(IQNet::m_player[0].m_gamertag, 32, g_Win64UsernameW); WinsockNetLayer::Initialize(); // 4J-PB moved further down //app.InitGameSettings(); // debug switch to trial version ProfileManager.SetDebugFullOverride(true); #if 0 //ProfileManager.AddDLC(2); StorageManager.SetDLCPackageRoot("DLCDrive"); StorageManager.RegisterMarketplaceCountsCallback(&CConsoleMinecraftApp::MarketplaceCountsCallback,(LPVOID)&app); // Kinect ! if(XNuiGetHardwareStatus()!=0) { // If the Kinect Sensor is not physically connected, this function returns 0. NuiInitialize(NUI_INITIALIZE_FLAG_USES_HIGH_QUALITY_COLOR | NUI_INITIALIZE_FLAG_USES_DEPTH | NUI_INITIALIZE_FLAG_EXTRAPOLATE_FLOOR_PLANE | NUI_INITIALIZE_FLAG_USES_FITNESS | NUI_INITIALIZE_FLAG_NUI_GUIDE_DISABLED | NUI_INITIALIZE_FLAG_SUPPRESS_AUTOMATIC_UI,NUI_INITIALIZE_DEFAULT_HARDWARE_THREAD ); } // Sentient ! hr = TelemetryManager->Init(); #endif // Initialise TLS for tesselator, for this main thread Tesselator::CreateNewThreadStorage(1024*1024); // Initialise TLS for AABB and Vec3 pools, for this main thread AABB::CreateNewThreadStorage(); Vec3::CreateNewThreadStorage(); IntCache::CreateNewThreadStorage(); Compression::CreateNewThreadStorage(); OldChunkStorage::CreateNewThreadStorage(); Level::enableLightingCache(); Tile::CreateNewThreadStorage(); Minecraft::main(); Minecraft *pMinecraft=Minecraft::GetInstance(); app.InitGameSettings(); #if 0 //bool bDisplayPauseMenu=false; // set the default gamma level float fVal=50.0f*327.68f; RenderManager.UpdateGamma((unsigned short)fVal); // load any skins //app.AddSkinsToMemoryTextureFiles(); // set the achievement text for a trial achievement, now we have the string table loaded ProfileManager.SetTrialTextStringTable(app.GetStringTable(),IDS_CONFIRM_OK, IDS_CONFIRM_CANCEL); ProfileManager.SetTrialAwardText(eAwardType_Achievement,IDS_UNLOCK_TITLE,IDS_UNLOCK_ACHIEVEMENT_TEXT); ProfileManager.SetTrialAwardText(eAwardType_GamerPic,IDS_UNLOCK_TITLE,IDS_UNLOCK_GAMERPIC_TEXT); ProfileManager.SetTrialAwardText(eAwardType_AvatarItem,IDS_UNLOCK_TITLE,IDS_UNLOCK_AVATAR_TEXT); ProfileManager.SetTrialAwardText(eAwardType_Theme,IDS_UNLOCK_TITLE,IDS_UNLOCK_THEME_TEXT); ProfileManager.SetUpsellCallback(&app.UpsellReturnedCallback,&app); // Set up a debug character press sequence #ifndef _FINAL_BUILD app.SetDebugSequence("LRLRYYY"); #endif // Initialise the social networking manager. CSocialManager::Instance()->Initialise(); // Update the base scene quick selects now that the minecraft class exists //CXuiSceneBase::UpdateScreenSettings(0); #endif app.InitialiseTips(); #if 0 DWORD initData=0; #ifndef _FINAL_BUILD #ifndef _DEBUG #pragma message(__LOC__"Need to define the _FINAL_BUILD before submission") #endif #endif // Set the default sound levels pMinecraft->options->set(Options::Option::MUSIC,1.0f); pMinecraft->options->set(Options::Option::SOUND,1.0f); app.NavigateToScene(XUSER_INDEX_ANY,eUIScene_Intro,&initData); #endif // Set the default sound levels pMinecraft->options->set(Options::Option::MUSIC,1.0f); pMinecraft->options->set(Options::Option::SOUND,1.0f); //app.TemporaryCreateGameStart(); //Sleep(10000); #if 0 // Intro loop ? while(app.IntroRunning()) { ProfileManager.Tick(); // Tick XUI app.RunFrame(); // 4J : WESTY : Added to ensure we always have clear background for intro. RenderManager.SetClearColour(D3DCOLOR_RGBA(0,0,0,255)); RenderManager.Clear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); // Render XUI hr = app.Render(); // Present the frame. RenderManager.Present(); // Update XUI Timers hr = XuiTimersRun(); } #endif MSG msg = {0}; while( WM_QUIT != msg.message ) { while( PeekMessage( &msg, NULL, 0, 0, PM_REMOVE ) ) { if( msg.message == WM_QUIT ) break; TranslateMessage( &msg ); DispatchMessage( &msg ); } if( msg.message == WM_QUIT ) break; g_KBMInput.Tick(); #ifdef _DEBUG for( int vk = 0; vk < 256; vk++ ) { if( g_KBMInput.IsKeyPressed(vk) ) { char dbgBuf[64]; sprintf_s(dbgBuf, "INPUT: Key pressed vk=0x%02X\n", vk); OutputDebugStringA(dbgBuf); } } #endif RenderManager.StartFrame(); #if 0 if(pMinecraft->soundEngine->isStreamingWavebankReady() && !pMinecraft->soundEngine->isPlayingStreamingGameMusic() && !pMinecraft->soundEngine->isPlayingStreamingCDMusic() ) { // play some music in the menus pMinecraft->soundEngine->playStreaming(L"", 0, 0, 0, 0, 0, false); } #endif // static bool bPlay=false; // if(bPlay) // { // bPlay=false; // app.audio.PlaySound(); // } app.UpdateTime(); PIXBeginNamedEvent(0,"Input manager tick"); InputManager.Tick(); PIXEndNamedEvent(); if (InputManager.IsPadConnected(0)) { bool controllerActive = InputManager.ButtonPressed(0) || InputManager.GetJoypadStick_LX(0,false) != 0.0f || InputManager.GetJoypadStick_LY(0,false) != 0.0f || InputManager.GetJoypadStick_RX(0,false) != 0.0f || InputManager.GetJoypadStick_RY(0,false) != 0.0f || InputManager.GetJoypadLTrigger(0,false) != 0 || InputManager.GetJoypadRTrigger(0,false) != 0; if (controllerActive && g_KBMInput.IsKBMActive()) { g_KBMInput.SetKBMActive(false); g_KBMInput.SetMouseGrabbed(false); g_KBMInput.SetCursorHiddenForUI(true); } else if (!g_KBMInput.IsKBMActive() && g_KBMInput.HasAnyInput()) { g_KBMInput.SetCursorHiddenForUI(false); g_KBMInput.SetKBMActive(true); } } PIXBeginNamedEvent(0,"Profile manager tick"); // ProfileManager.Tick(); PIXEndNamedEvent(); PIXBeginNamedEvent(0,"Storage manager tick"); StorageManager.Tick(); PIXEndNamedEvent(); PIXBeginNamedEvent(0,"Render manager tick"); RenderManager.Tick(); PIXEndNamedEvent(); // Tick the social networking manager. PIXBeginNamedEvent(0,"Social network manager tick"); // CSocialManager::Instance()->Tick(); PIXEndNamedEvent(); // Tick sentient. PIXBeginNamedEvent(0,"Sentient tick"); MemSect(37); // SentientManager.Tick(); MemSect(0); PIXEndNamedEvent(); PIXBeginNamedEvent(0,"Network manager do work #1"); g_NetworkManager.DoWork(); PIXEndNamedEvent(); TickDiscord(); // LeaderboardManager::Instance()->Tick(); // Render game graphics. if(app.GetGameStarted()) { pMinecraft->run_middle(); app.SetAppPaused( g_NetworkManager.IsLocalGame() && g_NetworkManager.GetPlayerCount() == 1 && ui.IsPauseMenuDisplayed(ProfileManager.GetPrimaryPad()) ); } else { MemSect(28); pMinecraft->soundEngine->tick(NULL, 0.0f); MemSect(0); pMinecraft->textures->tick(true,false); IntCache::Reset(); if( app.GetReallyChangingSessionType() ) { pMinecraft->tickAllConnections(); // Added to stop timing out when we are waiting after converting to an offline game } } pMinecraft->soundEngine->playMusicTick(); #ifdef MEMORY_TRACKING static bool bResetMemTrack = false; static bool bDumpMemTrack = false; MemPixStuff(); if( bResetMemTrack ) { ResetMem(); MEMORYSTATUS memStat; GlobalMemoryStatus(&memStat); printf("RESETMEM: Avail. phys %d\n",memStat.dwAvailPhys/(1024*1024)); bResetMemTrack = false; } if( bDumpMemTrack ) { DumpMem(); bDumpMemTrack = false; MEMORYSTATUS memStat; GlobalMemoryStatus(&memStat); printf("DUMPMEM: Avail. phys %d\n",memStat.dwAvailPhys/(1024*1024)); printf("Renderer used: %d\n",RenderManager.CBuffSize(-1)); } #endif #if 0 static bool bDumpTextureUsage = false; if( bDumpTextureUsage ) { RenderManager.TextureGetStats(); bDumpTextureUsage = false; } #endif ui.tick(); ui.render(); #if 0 app.HandleButtonPresses(); // store the minecraft renderstates, and re-set them after the xui render GetRenderAndSamplerStates(pDevice,RenderStateA,SamplerStateA); // Tick XUI PIXBeginNamedEvent(0,"Xui running"); app.RunFrame(); PIXEndNamedEvent(); // Render XUI PIXBeginNamedEvent(0,"XUI render"); MemSect(7); hr = app.Render(); MemSect(0); GetRenderAndSamplerStates(pDevice,RenderStateA2,SamplerStateA2); PIXEndNamedEvent(); for(int i=0;i<8;i++) { if(RenderStateA2[i]!=RenderStateA[i]) { //printf("Reseting RenderStateA[%d] after a XUI render\n",i); pDevice->SetRenderState(RenderStateModes[i],RenderStateA[i]); } } for(int i=0;i<5;i++) { if(SamplerStateA2[i]!=SamplerStateA[i]) { //printf("Reseting SamplerStateA[%d] after a XUI render\n",i); pDevice->SetSamplerState(0,SamplerStateModes[i],SamplerStateA[i]); } } RenderManager.Set_matrixDirty(); #endif // Present the frame. RenderManager.Present(); ui.CheckMenuDisplayed(); #if 0 PIXBeginNamedEvent(0,"Profile load check"); // has the game defined profile data been changed (by a profile load) if(app.uiGameDefinedDataChangedBitmask!=0) { void *pData; for(int i=0;istats[ i ]->clear(); pMinecraft->stats[i]->parse(pData); } } // Check to see if we can post to social networks. CSocialManager::Instance()->RefreshPostingCapability(); // clear the flag app.uiGameDefinedDataChangedBitmask=0; // Check if any profile write are needed app.CheckGameSettingsChanged(); } PIXEndNamedEvent(); app.TickDLCOffersRetrieved(); app.TickTMSPPFilesRetrieved(); PIXBeginNamedEvent(0,"Network manager do work #2"); g_NetworkManager.DoWork(); PIXEndNamedEvent(); PIXBeginNamedEvent(0,"Misc extra xui"); // Update XUI Timers hr = XuiTimersRun(); #endif // Any threading type things to deal with from the xui side? app.HandleXuiActions(); #if 0 PIXEndNamedEvent(); #endif // 4J-PB - Update the trial timer display if we are in the trial version if(!ProfileManager.IsFullVersion()) { // display the trial timer if(app.GetGameStarted()) { // 4J-PB - if the game is paused, add the elapsed time to the trial timer count so it doesn't tick down if(app.IsAppPaused()) { app.UpdateTrialPausedTimer(); } ui.UpdateTrialTimer(ProfileManager.GetPrimaryPad()); } } else { // need to turn off the trial timer if it was on , and we've unlocked the full version if(bTrialTimerDisplayed) { ui.ShowTrialTimer(false); bTrialTimerDisplayed=false; } } // Fix for #7318 - Title crashes after short soak in the leaderboards menu // A memory leak was caused because the icon renderer kept creating new Vec3's because the pool wasn't reset Vec3::resetPool(); } // Free resources, unregister custom classes, and exit. // app.Uninit(); CleanupDevice(); return 0; } #ifdef MEMORY_TRACKING int totalAllocGen = 0; unordered_map allocCounts; bool trackEnable = false; bool trackStarted = false; volatile size_t sizeCheckMin = 1160; volatile size_t sizeCheckMax = 1160; volatile int sectCheck = 48; CRITICAL_SECTION memCS; DWORD tlsIdx; LPVOID XMemAlloc(SIZE_T dwSize, DWORD dwAllocAttributes) { if( !trackStarted ) { void *p = XMemAllocDefault(dwSize,dwAllocAttributes); size_t realSize = XMemSizeDefault(p, dwAllocAttributes); totalAllocGen += realSize; return p; } EnterCriticalSection(&memCS); void *p=XMemAllocDefault(dwSize + 16,dwAllocAttributes); size_t realSize = XMemSizeDefault(p,dwAllocAttributes) - 16; if( trackEnable ) { #if 1 int sect = ((int) TlsGetValue(tlsIdx)) & 0x3f; *(((unsigned char *)p)+realSize) = sect; if( ( realSize >= sizeCheckMin ) && ( realSize <= sizeCheckMax ) && ( ( sect == sectCheck ) || ( sectCheck == -1 ) ) ) { app.DebugPrintf("Found one\n"); } #endif if( p ) { totalAllocGen += realSize; trackEnable = false; int key = ( sect << 26 ) | realSize; int oldCount = allocCounts[key]; allocCounts[key] = oldCount + 1; trackEnable = true; } } LeaveCriticalSection(&memCS); return p; } void* operator new (size_t size) { return (unsigned char *)XMemAlloc(size,MAKE_XALLOC_ATTRIBUTES(0,FALSE,TRUE,FALSE,0,XALLOC_PHYSICAL_ALIGNMENT_DEFAULT,XALLOC_MEMPROTECT_READWRITE,FALSE,XALLOC_MEMTYPE_HEAP)); } void operator delete (void *p) { XMemFree(p,MAKE_XALLOC_ATTRIBUTES(0,FALSE,TRUE,FALSE,0,XALLOC_PHYSICAL_ALIGNMENT_DEFAULT,XALLOC_MEMPROTECT_READWRITE,FALSE,XALLOC_MEMTYPE_HEAP)); } void WINAPI XMemFree(PVOID pAddress, DWORD dwAllocAttributes) { bool special = false; if( dwAllocAttributes == 0 ) { dwAllocAttributes = MAKE_XALLOC_ATTRIBUTES(0,FALSE,TRUE,FALSE,0,XALLOC_PHYSICAL_ALIGNMENT_DEFAULT,XALLOC_MEMPROTECT_READWRITE,FALSE,XALLOC_MEMTYPE_HEAP); special = true; } if(!trackStarted ) { size_t realSize = XMemSizeDefault(pAddress, dwAllocAttributes); XMemFreeDefault(pAddress, dwAllocAttributes); totalAllocGen -= realSize; return; } EnterCriticalSection(&memCS); if( pAddress ) { size_t realSize = XMemSizeDefault(pAddress, dwAllocAttributes) - 16; if(trackEnable) { int sect = *(((unsigned char *)pAddress)+realSize); totalAllocGen -= realSize; trackEnable = false; int key = ( sect << 26 ) | realSize; int oldCount = allocCounts[key]; allocCounts[key] = oldCount - 1; trackEnable = true; } XMemFreeDefault(pAddress, dwAllocAttributes); } LeaveCriticalSection(&memCS); } SIZE_T WINAPI XMemSize( PVOID pAddress, DWORD dwAllocAttributes ) { if( trackStarted ) { return XMemSizeDefault(pAddress, dwAllocAttributes) - 16; } else { return XMemSizeDefault(pAddress, dwAllocAttributes); } } void DumpMem() { int totalLeak = 0; for(AUTO_VAR(it, allocCounts.begin()); it != allocCounts.end(); it++ ) { if(it->second > 0 ) { app.DebugPrintf("%d %d %d %d\n",( it->first >> 26 ) & 0x3f,it->first & 0x03ffffff, it->second, (it->first & 0x03ffffff) * it->second); totalLeak += ( it->first & 0x03ffffff ) * it->second; } } app.DebugPrintf("Total %d\n",totalLeak); } void ResetMem() { if( !trackStarted ) { trackEnable = true; trackStarted = true; totalAllocGen = 0; InitializeCriticalSection(&memCS); tlsIdx = TlsAlloc(); } EnterCriticalSection(&memCS); trackEnable = false; allocCounts.clear(); trackEnable = true; LeaveCriticalSection(&memCS); } void MemSect(int section) { unsigned int value = (unsigned int)TlsGetValue(tlsIdx); if( section == 0 ) // pop { value = (value >> 6) & 0x03ffffff; } else { value = (value << 6) | section; } TlsSetValue(tlsIdx, (LPVOID)value); } void MemPixStuff() { const int MAX_SECT = 46; int totals[MAX_SECT] = {0}; for(AUTO_VAR(it, allocCounts.begin()); it != allocCounts.end(); it++ ) { if(it->second > 0 ) { int sect = ( it->first >> 26 ) & 0x3f; int bytes = it->first & 0x03ffffff; totals[sect] += bytes * it->second; } } unsigned int allSectsTotal = 0; for( int i = 0; i < MAX_SECT; i++ ) { allSectsTotal += totals[i]; PIXAddNamedCounter(((float)totals[i])/1024.0f,"MemSect%d",i); } PIXAddNamedCounter(((float)allSectsTotal)/(4096.0f),"MemSect total pages"); } #endif