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/Durango/Durango_Minecraft.cpp | 1173 ++++++++++++++++++++++++ 1 file changed, 1173 insertions(+) create mode 100644 Minecraft.Client/Durango/Durango_Minecraft.cpp (limited to 'Minecraft.Client/Durango/Durango_Minecraft.cpp') diff --git a/Minecraft.Client/Durango/Durango_Minecraft.cpp b/Minecraft.Client/Durango/Durango_Minecraft.cpp new file mode 100644 index 00000000..48d5c319 --- /dev/null +++ b/Minecraft.Client/Durango/Durango_Minecraft.cpp @@ -0,0 +1,1173 @@ +// Minecraft.cpp : Defines the entry point for the application. +// + +#include "stdafx.h" + +#include +#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 "Leaderboards\GameProgress.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 "Leaderboards\DurangoLeaderboardManager.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 + +//using namespace Windows::Xbox::Input; +using namespace Windows::Foundation::Collections; + +#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; + + +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 | _360_GTC_BACK); + 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 | _360_GTC_BACK); + 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 | _360_GTC_MENU); + + InputManager.SetGameJoypadMaps(MAP_STYLE_0,ACTION_MENU_GTC_PAUSE, _360_GTC_PAUSE); + InputManager.SetGameJoypadMaps(MAP_STYLE_0,ACTION_MENU_GTC_RESUME, _360_GTC_PLAY); + + 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 | _360_GTC_MENU); + 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 | _360_GTC_VIEW); + + 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 | _360_GTC_BACK); + 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 | _360_GTC_BACK); + 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 | _360_GTC_MENU); + + InputManager.SetGameJoypadMaps(MAP_STYLE_1,ACTION_MENU_GTC_PAUSE, _360_GTC_PAUSE); + InputManager.SetGameJoypadMaps(MAP_STYLE_1,ACTION_MENU_GTC_RESUME, _360_GTC_PLAY); + + 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 | _360_GTC_MENU); + 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 | _360_GTC_VIEW); + + 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 | _360_GTC_BACK); + 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 | _360_GTC_BACK); + 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,ACTION_MENU_PAUSEMENU, _360_JOY_BUTTON_START | _360_GTC_MENU); + 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,ACTION_MENU_GTC_PAUSE, _360_GTC_PAUSE); + InputManager.SetGameJoypadMaps(MAP_STYLE_2,ACTION_MENU_GTC_RESUME, _360_GTC_PLAY); + + 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 | _360_GTC_MENU); + 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 | _360_GTC_VIEW); + + 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 ); + + // Set up the structure used to create the D3DDevice + // Using a permanent 1280x720 backbuffer now no matter what the actual video resolution.right Have also disabled letterboxing, + // which would letterbox a 1280x720 output if it detected a 4:3 video source - we're doing an anamorphic squash in this + // mode so don't need this functionality. + + 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; + +Platform::Agile g_window; +Windows::Foundation::Rect g_windowBounds; + +D3D_DRIVER_TYPE g_driverType = D3D_DRIVER_TYPE_NULL; +D3D_FEATURE_LEVEL g_featureLevel = D3D_FEATURE_LEVEL_11_0; +Microsoft::WRL::ComPtr g_d3dDevice; +Microsoft::WRL::ComPtr g_d3dContext; +Microsoft::WRL::ComPtr g_swapChain; +Microsoft::WRL::ComPtr g_renderTargetView; +Microsoft::WRL::ComPtr g_depthStencilView; +Microsoft::WRL::ComPtr g_depthStencil; + +void CreateDevice(); +void CreateResources(); +void InitializeDurango(Windows::UI::Core::CoreWindow^ window) +{ + SetThreadAffinityMask(GetCurrentThread(),1); + + g_window = window; + + CreateDevice(); + + CreateResources(); + + // TODO: Begin asynchronous loading of game assets. + + C4JThread::StaticInit(); +} + +namespace DX +{ + inline void ThrowIfFailed(HRESULT hr) + { + if (FAILED(hr)) + { + // Set a breakpoint on this line to catch DirectX API errors + throw Platform::Exception::CreateException(hr); + } + } +} + +void CreateDevice() +{ + // This flag adds support for surfaces with a different color channel ordering than the API default. + // It is recommended usage, and is required for compatibility with Direct2D. + UINT creationFlags = D3D11_CREATE_DEVICE_FAST_KICKOFFS; +#ifndef _CONTENT_PACKAGE + creationFlags |= D3D11_CREATE_DEVICE_VALIDATED; + creationFlags |= D3D11_CREATE_DEVICE_INSTRUMENTED; +#endif + + // This array defines the set of DirectX hardware feature levels this app will support. + // Note the ordering should be preserved. + // Don't forget to declare your application's minimum required feature level in its + // description. All applications are assumed to support 9.1 unless otherwise stated. + D3D_FEATURE_LEVEL featureLevels[] = + { + D3D_FEATURE_LEVEL_11_0 + }; + + // Create the DX11 API device object, and get a corresponding context. + Microsoft::WRL::ComPtr device; + Microsoft::WRL::ComPtr context; + + DX::ThrowIfFailed( + D3D11CreateDevice( + nullptr, // specify null to use the default adapter + D3D_DRIVER_TYPE_HARDWARE, + nullptr, // leave as nullptr unless software device + creationFlags, // optionally set debug and Direct2D compatibility flags + featureLevels, // list of feature levels this app can support + ARRAYSIZE(featureLevels), // number of entries in above list + D3D11_SDK_VERSION, // always set this to D3D11_SDK_VERSION + &device, // returns the Direct3D device created + &g_featureLevel, // returns feature level of device created + &context // returns the device immediate context + ) + ); + + // Get the DirectX11.1 device by QI off the DirectX11 one. + DX::ThrowIfFailed(device.As(&g_d3dDevice)); + + // And get the corresponding device context in the same way. + DX::ThrowIfFailed(context.As(&g_d3dContext)); +} + +// Allocate all memory resources that change on a window SizeChanged event. +void CreateResources() +{ + // Store the window bounds so the next time we get a SizeChanged event we can + // avoid rebuilding everything if the size is identical. + g_windowBounds = g_window.Get()->Bounds; + + // If the swap chain already exists, resize it, + // otherwise create one. + if(g_swapChain != nullptr) + { + DX::ThrowIfFailed(g_swapChain->ResizeBuffers(2, 0, 0, DXGI_FORMAT_B8G8R8A8_UNORM, 0)); + } + else + { + // First, retrieve the underlying DXGI Device from the D3D Device + Microsoft::WRL::ComPtr dxgiDevice; + DX::ThrowIfFailed(g_d3dDevice.As(&dxgiDevice)); + + // Identify the physical adapter (GPU or card) this device is running on. + Microsoft::WRL::ComPtr dxgiAdapter; + DX::ThrowIfFailed(dxgiDevice->GetAdapter(&dxgiAdapter)); + + // And obtain the factory object that created it. + Microsoft::WRL::ComPtr dxgiFactory; + DX::ThrowIfFailed(dxgiAdapter->GetParent(__uuidof(IDXGIFactory2), &dxgiFactory)); + + // Create a descriptor for the swap chain. + DXGI_SWAP_CHAIN_DESC1 swapChainDesc = {0}; + + swapChainDesc.Width = 1920; + swapChainDesc.Height = 1080; + swapChainDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM; + swapChainDesc.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT | DXGI_USAGE_SHADER_INPUT; + swapChainDesc.BufferCount = 2; + swapChainDesc.Stereo = false; + swapChainDesc.SampleDesc.Count = 1; + swapChainDesc.SampleDesc.Quality = 0; + swapChainDesc.Scaling = DXGI_SCALING_STRETCH; + swapChainDesc.SwapEffect = DXGI_SWAP_EFFECT_FLIP_SEQUENTIAL; + swapChainDesc.Flags = 0; + + // Create a SwapChain from a CoreWindow. + DX::ThrowIfFailed(dxgiFactory->CreateSwapChainForCoreWindow(g_d3dDevice.Get(), reinterpret_cast(g_window.Get()), &swapChainDesc, nullptr, &g_swapChain)); + } + + // Obtain the backbuffer for this window which will be the final 3D rendertarget. + Microsoft::WRL::ComPtr backBuffer; + DX::ThrowIfFailed(g_swapChain->GetBuffer(0, __uuidof(ID3D11Texture2D), &backBuffer)); + + // Create a view interface on the rendertarget to use on bind. + DX::ThrowIfFailed(g_d3dDevice->CreateRenderTargetView(backBuffer.Get(), nullptr, &g_renderTargetView)); + + // Cache the rendertarget dimensions in our helper class for convenient use. + D3D11_TEXTURE2D_DESC backBufferDesc = {0}; + backBuffer->GetDesc(&backBufferDesc); + + // Allocate a 2-D surface as the depth/stencil buffer and + // create a DepthStencil view on this surface to use on bind. + CD3D11_TEXTURE2D_DESC depthStencilDesc(DXGI_FORMAT_D24_UNORM_S8_UINT, backBufferDesc.Width, backBufferDesc.Height, 1, 1, D3D11_BIND_DEPTH_STENCIL); + + Microsoft::WRL::ComPtr depthStencil; + DX::ThrowIfFailed(g_d3dDevice->CreateTexture2D(&depthStencilDesc, nullptr, &depthStencil)); + + CD3D11_DEPTH_STENCIL_VIEW_DESC depthStencilViewDesc(D3D11_DSV_DIMENSION_TEXTURE2D); + DX::ThrowIfFailed(g_d3dDevice->CreateDepthStencilView(depthStencil.Get(), &depthStencilViewDesc, &g_depthStencilView)); + + // Create a viewport descriptor of the full window size. + CD3D11_VIEWPORT viewPort(0.0f, 0.0f, static_cast(backBufferDesc.Width), static_cast(backBufferDesc.Height)); + + // Set the current viewport using the descriptor. + g_d3dContext->RSSetViewports(1, &viewPort); + g_d3dContext->OMSetRenderTargets( 1, g_renderTargetView.GetAddressOf(), g_depthStencilView.Get() ); +} + +//-------------------------------------------------------------------------------------- +// 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_d3dContext->ClearRenderTargetView( g_renderTargetView.Get(), ClearColor ); + g_swapChain->Present( 0, 0 ); +} + + +void oldWinMainInit() +{ +#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 + + +#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 + + app.loadMediaArchive(); + + RenderManager.Initialise(g_d3dDevice.Get(), g_swapChain.Get()); + + app.loadStringTable(); + + ui.init(g_d3dDevice,g_d3dContext,g_renderTargetView,g_depthStencilView,1920,1080); + + //////////////// + // Initialise // + //////////////// + +#if 0 + // 4J Stu - XACT was creating these automatically, but we need them for QNet. The setup params + // are just copied from a sample app and may need changed for our purposes + // Start XAudio2 + hr = XAudio2Create( &g_pXAudio2, 0, XAUDIO2_DEFAULT_PROCESSOR ); + if( FAILED( hr ) ) + { + app.DebugPrintf( "Initializing XAudio2 failed (err = 0x%08x)!\n", hr ); + app.FatalLoadError(); + } + + // Create an XAudio2 mastering voice (utilized by XHV2 when voice data is mixed to main speakers) + hr = g_pXAudio2->CreateMasteringVoice(&g_pXAudio2MasteringVoice, XAUDIO2_DEFAULT_CHANNELS, XAUDIO2_DEFAULT_SAMPLERATE, 0, 0, NULL); + if ( FAILED( hr ) ) + { + app.DebugPrintf( "Creating XAudio2 mastering voice failed (err = 0x%08x)!\n", hr ); + app.FatalLoadError(); + } +#endif + app.InitTime(); + + // 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); + + // looks like the Durango controller is a good bit more sensitive than XBOX360/PS3. Defaults in the lib are 10000 for deadzone and 32767 for movement range + InputManager.SetDeadzoneAndMovementRange(10000,20000,32767); + + // 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(SERVICE_CONFIG_ID, TITLE_PRODUCT_ID); + + ProfileManager.RegisterPresence(CONTEXT_PRESENCE_IDLE,L"Idle"); + ProfileManager.RegisterPresence(CONTEXT_PRESENCE_MENUS,L"InMenus"); + ProfileManager.RegisterPresence(CONTEXT_PRESENCE_MULTIPLAYER,L"PlayingMultiplayer"); + ProfileManager.RegisterPresence(CONTEXT_PRESENCE_MULTIPLAYEROFFLINE,L"PlayingMultiplayerOffline"); + ProfileManager.RegisterPresence(CONTEXT_PRESENCE_MULTIPLAYER_1P,L"PlayingAlone"); + ProfileManager.RegisterPresence(CONTEXT_PRESENCE_MULTIPLAYER_1POFFLINE,L"PlayingAloneOffline"); + + // Fix for XboxOne #165025 - XR-049: Compliance: Title does not display Rich Presence strings for profiles in main menu. + ProfileManager.SetGameActivityForAllActiveUsers(CONTEXT_PRESENCE_IDLE); + + Compression::CreateNewThreadStorage(); + app.ReadLocalDLCList(); + + // initialise the storage manager with a default save display name, a Minimum save size, and a callback for displaying the saving message + StorageManager.Init(0,app.GetString(IDS_DEFAULT_SAVENAME),"savegame.dat",FIFTY_ONE_MB,&CConsoleMinecraftApp::DisplaySavingMessage,(LPVOID)&app, app.UpdateProductId,SERVICE_CONFIG_ID,TITLE_PRODUCT_ID); + + StorageManager.SetMaxSaves(99); + + byteArray baSaveThumbnail = app.getArchiveFile(L"DefaultSaveThumbnail64x64.png"); + + StorageManager.InitialiseProfileData(PROFILE_VERSION_BUILD_JUNE14, + NUM_PROFILE_VALUES, + NUM_PROFILE_SETTINGS, + dwProfileSettingsA, + app.GAME_DEFINED_PROFILE_DATA_BYTES*XUSER_MAX_COUNT, + &app.uiGameDefinedDataChangedBitmask); + + StorageManager.SetDefaultImages((PBYTE)baSaveThumbnail.data, baSaveThumbnail.length); + + // Set function to be called if a save game operation can't complete due to running out of storage space etc. + StorageManager.SetIncompleteSaveCallback(CConsoleMinecraftApp::Callback_SaveGameIncomplete, (LPVOID)&app); + + // 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 callback for the default player options to be set - when there is no profile data for the player + StorageManager.SetDefaultOptionsCallback(&CConsoleMinecraftApp::DefaultOptionsCallback,(LPVOID)&app); + StorageManager.SetOptionsDataCallback(&CConsoleMinecraftApp::OptionsDataCallback,(LPVOID)&app); + + + // Set a callback to deal with old profile versions needing updated to new versions + StorageManager.SetOldProfileVersionCallback(&CConsoleMinecraftApp::OldProfileVersionCallback,(LPVOID)&app); + + g_NetworkManager.Initialise(); + + + // 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(); + OldChunkStorage::CreateNewThreadStorage(); + Level::enableLightingCache(); + Tile::CreateNewThreadStorage(); + + //4J-PB - after the init, which will have read all the local DLC, update the product ids by reading the local dlc file + StorageManager.UpdateDLCProductIDs(); + + Minecraft::main(); + Minecraft *pMinecraft=Minecraft::GetInstance(); + app.InitGameSettings(); + + // read the options here for controller 0 + // 4J-PB - we have no valid user to read a profile for on Xbox One, and there's no EULA anyway + //StorageManager.ReadFromProfile(0); + + app.InitialiseDLCDetails(); + StorageManager.SetLicenseChangeFn(&app.HandleDLCLicenseChange); + + + // debug switch to trial version + ProfileManager.SetDebugFullOverride(true); + + // set default values for controllers +// for(int i=0;i<4;i++) +// { +// //app.SetDefaultOptions(app.GetGameDefinedProfileData(i),i); +// app.SetDefaultOptions(ProfileManager.GetGameDefinedProfileData(i),i); +// } + + +#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 + + + + //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 +} +void oldWinMainTick() +{ + static bool bTrialTimerDisplayed=true; + + Minecraft *pMinecraft=Minecraft::GetInstance(); + 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 + app.UpdateTime(); + PIXBeginNamedEvent(0,"Input manager tick"); + InputManager.Tick(); + PIXEndNamedEvent(); + 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(); + + GameProgress::Tick(); + + PIXBeginNamedEvent(PIX_COLOR_INDEX(2),"Network manager do work #1"); + g_NetworkManager.DoWork(); + PIXEndNamedEvent(); + + 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 + +#if 0 // ndef _CONTENT_PACKAGE + if( InputManager.ButtonPressed(0,MINECRAFT_ACTION_DPAD_LEFT) || + InputManager.ButtonPressed(0,ACTION_MENU_STICK_PRESS)) + { + RenderManager.DoScreenGrabOnNextPresent(); + } +#endif + + // Present the frame. + RenderManager.Present(); + + ui.CheckMenuDisplayed(); + + 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); + } + } + +#if 0 + // Check to see if we can post to social networks. + CSocialManager::Instance()->RefreshPostingCapability(); +#endif + + // clear the flag + app.uiGameDefinedDataChangedBitmask=0; + + // Check if any profile write are needed + app.CheckGameSettingsChanged(); + + } + PIXEndNamedEvent(); + app.TickTMSPPFilesRetrieved(); + + app.TickDLCOffersRetrieved(); + + PIXBeginNamedEvent(0,"Network manager do work #2"); + // 4J Stu - Added this back as it was causing horrendous lag (and eventually a crash on a client) when playing with multiple clients + g_NetworkManager.DoWork(); // TODO - consider putting this back in. Removed because we are having trouble with how long the tick is taking on Durango + PIXEndNamedEvent(); + +#if 0 + 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(); +} + +#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 -- cgit v1.2.3