#include "stdafx.h" #include "UIController.h" #include "UI.h" #include "UIScene.h" #include "..\..\..\Minecraft.World\StringHelpers.h" #include "..\..\LocalPlayer.h" #include "..\..\DLCTexturePack.h" #include "..\..\TexturePackRepository.h" #include "..\..\Minecraft.h" #include "..\..\..\Minecraft.World\net.minecraft.world.entity.boss.enderdragon.h" #include "..\..\EnderDragonRenderer.h" #include "..\..\MultiPlayerLocalPlayer.h" #include "UIFontData.h" // 4J Stu - Enable this to override the Iggy Allocator //#define ENABLE_IGGY_ALLOCATOR //#define EXCLUDE_IGGY_ALLOCATIONS_FROM_HEAP_INSPECTOR //#define ENABLE_IGGY_EXPLORER #ifdef ENABLE_IGGY_EXPLORER #include "Windows64\Iggy\include\iggyexpruntime.h" #endif //#define ENABLE_IGGY_PERFMON #ifdef ENABLE_IGGY_PERFMON #define PM_ORIGIN_X 24 #define PM_ORIGIN_Y 34 #if defined __PS3__ #include "PS3\Iggy\include\iggyperfmon.h" #include "PS3\Iggy\include\iggyperfmon_ps3.h" #endif #endif CRITICAL_SECTION UIController::ms_reloadSkinCS; bool UIController::ms_bReloadSkinCSInitialised = false; DWORD UIController::m_dwTrialTimerLimitSecs=DYNAMIC_CONFIG_DEFAULT_TRIAL_TIME; static void RADLINK WarningCallback(void *user_callback_data, Iggy *player, IggyResult code, const char *message) { //enum IggyResult{ IGGY_RESULT_SUCCESS = 0, IGGY_RESULT_Warning_None = 0, // IGGY_RESULT_Warning_Misc = 100, IGGY_RESULT_Warning_GDraw = 101, // IGGY_RESULT_Warning_ProgramFlow = 102, // IGGY_RESULT_Warning_Actionscript = 103, // IGGY_RESULT_Warning_Graphics = 104, IGGY_RESULT_Warning_Font = 105, // IGGY_RESULT_Warning_Timeline = 106, IGGY_RESULT_Warning_Library = 107, // IGGY_RESULT_Warning_CannotSustainFrameRate = 201, // IGGY_RESULT_Warning_ThrewException = 202, // IGGY_RESULT_Error_Threshhold = 400, IGGY_RESULT_Error_Misc = 400, // IGGY_RESULT_Error_GDraw = 401, IGGY_RESULT_Error_ProgramFlow = 402, // IGGY_RESULT_Error_Actionscript = 403, IGGY_RESULT_Error_Graphics = 404, // IGGY_RESULT_Error_Font = 405, IGGY_RESULT_Error_Create = 406, // IGGY_RESULT_Error_Library = 407, IGGY_RESULT_Error_ValuePath = 408, // IGGY_RESULT_Error_Audio = 409, IGGY_RESULT_Error_Internal = 499, // IGGY_RESULT_Error_InvalidIggy = 501, // IGGY_RESULT_Error_InvalidArgument = 502, // IGGY_RESULT_Error_InvalidEntity = 503, // IGGY_RESULT_Error_UndefinedEntity = 504, // IGGY_RESULT_Error_OutOfMemory = 1001,}; switch(code) { case IGGY_RESULT_Warning_CannotSustainFrameRate: // Ignore warning break; default: /* Normally, we'd want to issue this warning to some kind of logging system or error reporting system, but since this is a tutorial app, we just use Win32's default error stream. Since ActionScript 3 exceptions are routed through this warning callback, it's definitely a good idea to make sure these warnings get printed somewhere that's easy for you to read and use for debugging, otherwise debugging errors in the ActionScript 3 code in your Flash content will be very difficult! */ app.DebugPrintf(app.USER_SR, message); app.DebugPrintf(app.USER_SR, "\n"); break; }; } /* Flash provides a way for ActionScript 3 code to print debug output using a function called "trace". It's very useful for debugging Flash programs, so ideally, when using Iggy, we'd like to see any trace output alongside our own debugging output. To facilitate this, Iggy allows us to install a callback that will be called any time ActionScript code calls trace. */ static void RADLINK TraceCallback(void *user_callback_data, Iggy *player, char const *utf8_string, S32 length_in_bytes) { app.DebugPrintf(app.USER_UI, (char *)utf8_string); } #ifdef ENABLE_IGGY_PERFMON static void *RADLINK perf_malloc(void *handle, U32 size) { return malloc(size); } static void RADLINK perf_free(void *handle, void *ptr) { return free(ptr); } #endif #ifdef EXCLUDE_IGGY_ALLOCATIONS_FROM_HEAP_INSPECTOR extern "C" void *__real_malloc(size_t t); extern "C" void __real_free(void *t); #endif __int64 UIController::iggyAllocCount = 0; static unordered_map allocations; static void * RADLINK AllocateFunction ( void * alloc_callback_user_data , size_t size_requested , size_t * size_returned ) { UIController *controller = (UIController *)alloc_callback_user_data; EnterCriticalSection(&controller->m_Allocatorlock); #ifdef EXCLUDE_IGGY_ALLOCATIONS_FROM_HEAP_INSPECTOR void *alloc = __real_malloc(size_requested); #else void *alloc = malloc(size_requested); #endif *size_returned = size_requested; UIController::iggyAllocCount += size_requested; allocations[alloc] = size_requested; app.DebugPrintf(app.USER_SR, "Allocating %d, new total: %d\n", size_requested, UIController::iggyAllocCount); LeaveCriticalSection(&controller->m_Allocatorlock); return alloc; } static void RADLINK DeallocateFunction ( void * alloc_callback_user_data , void * ptr ) { UIController *controller = (UIController *)alloc_callback_user_data; EnterCriticalSection(&controller->m_Allocatorlock); size_t size = allocations[ptr]; UIController::iggyAllocCount -= size; allocations.erase(ptr); app.DebugPrintf(app.USER_SR, "Freeing %d, new total %d\n", size, UIController::iggyAllocCount); #ifdef EXCLUDE_IGGY_ALLOCATIONS_FROM_HEAP_INSPECTOR __real_free(ptr); #else free(ptr); #endif LeaveCriticalSection(&controller->m_Allocatorlock); } UIController::UIController() { m_uiDebugConsole = NULL; m_reloadSkinThread = NULL; m_navigateToHomeOnReload = false; m_mcTTFFont= NULL; m_moj7 = NULL; m_moj11 = NULL; #ifdef ENABLE_IGGY_ALLOCATOR InitializeCriticalSection(&m_Allocatorlock); #endif // 4J Stu - This is a bit of a hack until we change the Minecraft initialisation to store the proper screen size for other platforms m_fScreenWidth = 1280.0f; m_fScreenHeight = 720.0f; m_bScreenWidthSetup = false; for(unsigned int i = 0; i < eLibrary_Count; ++i) { m_iggyLibraries[i] = IGGY_INVALID_LIBRARY; } for(unsigned int i = 0; i < XUSER_MAX_COUNT; ++i) { m_bMenuDisplayed[i] = false; m_iCountDown[i]=0; m_bMenuToBeClosed[i]=false; for(unsigned int key = 0; key <= ACTION_MAX_MENU; ++key) { m_actionRepeatTimer[i][key] = 0; } } for(unsigned int i = 0; i < eUIGroup_COUNT; ++i) { m_bCloseAllScenes[i] = false; } m_iPressStartQuadrantsMask = 0; m_currentRenderViewport = C4JRender::VIEWPORT_TYPE_FULLSCREEN; m_bCustomRenderPosition = false; m_winUserIndex = 0; m_accumulatedTicks = 0; InitializeCriticalSection(&m_navigationLock); InitializeCriticalSection(&m_registeredCallbackScenesCS); //m_bSysUIShowing=false; m_bSystemUIShowing=false; if(!ms_bReloadSkinCSInitialised) { // MGH - added to prevent crash loading Iggy movies while the skins were being reloaded InitializeCriticalSection(&ms_reloadSkinCS); ms_bReloadSkinCSInitialised = true; } } void UIController::SetSysUIShowing(bool bVal) { if(bVal) app.DebugPrintf("System UI showing\n"); else app.DebugPrintf("System UI stopped showing\n"); m_bSystemUIShowing=bVal; } void UIController::SetSystemUIShowing(LPVOID lpParam,bool bVal) { UIController *pClass=(UIController *)lpParam; pClass->SetSysUIShowing(bVal); } // SETUP void UIController::preInit(S32 width, S32 height) { m_fScreenWidth = width; m_fScreenHeight = height; m_bScreenWidthSetup = true; #ifdef ENABLE_IGGY_ALLOCATOR IggyAllocator allocator; allocator.user_callback_data = this; allocator.mem_alloc = &AllocateFunction; allocator.mem_free = &DeallocateFunction; IggyInit(&allocator); #else IggyInit(0); #endif IggySetWarningCallback(WarningCallback, 0); IggySetTraceCallbackUTF8(TraceCallback, 0); setFontCachingCalculationBuffer(-1); } void UIController::postInit() { // set up a custom rendering callback IggySetCustomDrawCallback(&UIController::CustomDrawCallback, this); IggySetAS3ExternalFunctionCallbackUTF16 ( &UIController::ExternalFunctionCallback, this ); IggySetTextureSubstitutionCallbacks ( &UIController::TextureSubstitutionCreateCallback , &UIController::TextureSubstitutionDestroyCallback, this ); SetupFont(); // loadSkins(); for(unsigned int i = 0; i < eUIGroup_COUNT; ++i) { m_groups[i] = new UIGroup((EUIGroup)i,i-1); } #ifdef ENABLE_IGGY_EXPLORER iggy_explorer = IggyExpCreate("127.0.0.1", 9190, malloc(IGGYEXP_MIN_STORAGE), IGGYEXP_MIN_STORAGE); if ( iggy_explorer == NULL ) { // not normally an error, just an error for this demo! app.DebugPrintf( "Couldn't connect to Iggy Explorer, did you run it first?" ); } else { IggyUseExplorer( m_groups[1]->getHUD()->getMovie(), iggy_explorer); } #endif #ifdef ENABLE_IGGY_PERFMON m_iggyPerfmonEnabled = false; iggy_perfmon = IggyPerfmonCreate(perf_malloc, perf_free, NULL); IggyInstallPerfmon(iggy_perfmon); #endif NavigateToScene(0, eUIScene_Intro); } void UIController::SetupFont() { bool bBitmapFont=false; if(m_mcTTFFont!=NULL) { delete m_mcTTFFont; } switch(XGetLanguage()) { #if defined(__PS3__) case XC_LANGUAGE_JAPANESE: m_mcTTFFont = new UITTFFont("Common/Media/font/JPN/DF-DotDotGothic16.ttf", 0x203B); // JPN break; case XC_LANGUAGE_SCHINESE: //TODO case XC_LANGUAGE_TCHINESE: m_mcTTFFont = new UITTFFont("Common/Media/font/CHT/DFTT_R5.TTC", 0x203B); // CHT break; case XC_LANGUAGE_KOREAN: m_mcTTFFont = new UITTFFont("Common/Media/font/KOR/candadite2.ttf", 0x203B); // KOR break; // 4J-JEV, Cyrillic characters have been added to this font now, (4/July/14) //case XC_LANGUAGE_RUSSIAN: //case XC_LANGUAGE_GREEK: #else case XC_LANGUAGE_JAPANESE: m_mcTTFFont = new UITTFFont("Common/Media/font/JPN/DFGMaruGothic-Md.ttf", 0x2022); // JPN break; case XC_LANGUAGE_SCHINESE: //TODO case XC_LANGUAGE_TCHINESE: m_mcTTFFont = new UITTFFont("Common/Media/font/CHT/DFHeiMedium-B5.ttf", 0x2022); // CHT break; case XC_LANGUAGE_KOREAN: m_mcTTFFont = new UITTFFont("Common/Media/font/KOR/BOKMSD.ttf", 0x2022); // KOR break; #endif default: bBitmapFont=true; // m_mcTTFFont = new UITTFFont("Common/Media/font/Mojangles.ttf", 0x2022); // 4J-JEV: Shouldn't be using this. break; } if(bBitmapFont) { // these may have been set up by a previous language being chosen if(m_moj7==NULL) { m_moj7 = new UIBitmapFont(SFontData::Mojangles_7); m_moj7->registerFont(); } if(m_moj11==NULL) { m_moj11 = new UIBitmapFont(SFontData::Mojangles_11); m_moj11->registerFont(); } } else { app.DebugPrintf("IggyFontSetIndirectUTF8\n"); IggyFontSetIndirectUTF8( "Mojangles7", -1, IGGY_FONTFLAG_all, "Mojangles_TTF",-1 ,IGGY_FONTFLAG_none ); IggyFontSetIndirectUTF8( "Mojangles11", -1, IGGY_FONTFLAG_all, "Mojangles_TTF",-1 ,IGGY_FONTFLAG_none ); } } // TICKING void UIController::tick() { if(m_navigateToHomeOnReload && !ui.IsReloadingSkin()) { ui.CleanUpSkinReload(); m_navigateToHomeOnReload = false; ui.NavigateToScene(ProfileManager.GetPrimaryPad(),eUIScene_MainMenu); } for(unsigned int i = 0; i < eUIGroup_COUNT; ++i) { if(m_bCloseAllScenes[i]) { m_groups[i]->closeAllScenes(); m_groups[i]->getTooltips()->SetTooltips(-1); m_bCloseAllScenes[i] = false; } } if(m_accumulatedTicks == 0) tickInput(); m_accumulatedTicks = 0; for(unsigned int i = 0; i < eUIGroup_COUNT; ++i) { m_groups[i]->tick(); // TODO: May wish to skip ticking other groups here } // Fix for HUD ticks so that they all tick before this reference is cleared EnderDragonRenderer::bossInstance = nullptr; // Clear out the cached movie file data __int64 currentTime = System::currentTimeMillis(); for(AUTO_VAR(it, m_cachedMovieData.begin()); it != m_cachedMovieData.end();) { if(it->second.m_expiry < currentTime) { delete [] it->second.m_ba.data; it = m_cachedMovieData.erase(it); } else { ++it; } } } void UIController::loadSkins() { wstring platformSkinPath = L""; #if defined(__PS3__) platformSkinPath = L"skinPS3.swf"; #endif // Every platform has one of these, so nothing shared if(m_fScreenHeight==1080.0f) { m_iggyLibraries[eLibrary_Platform] = loadSkin(platformSkinPath, L"platformskinHD.swf"); } else { m_iggyLibraries[eLibrary_Platform] = loadSkin(platformSkinPath, L"platformskin.swf"); } #if defined(__PS3__) m_iggyLibraries[eLibrary_GraphicsDefault] = loadSkin(L"skinGraphics.swf", L"skinGraphics.swf"); m_iggyLibraries[eLibrary_GraphicsHUD] = loadSkin(L"skinGraphicsHud.swf", L"skinGraphicsHud.swf"); m_iggyLibraries[eLibrary_GraphicsInGame] = loadSkin(L"skinGraphicsInGame.swf", L"skinGraphicsInGame.swf"); m_iggyLibraries[eLibrary_GraphicsTooltips] = loadSkin(L"skinGraphicsTooltips.swf", L"skinGraphicsTooltips.swf"); m_iggyLibraries[eLibrary_GraphicsLabels] = loadSkin(L"skinGraphicsLabels.swf", L"skinGraphicsLabels.swf"); m_iggyLibraries[eLibrary_Labels] = loadSkin(L"skinLabels.swf", L"skinLabels.swf"); m_iggyLibraries[eLibrary_InGame] = loadSkin(L"skinInGame.swf", L"skinInGame.swf"); m_iggyLibraries[eLibrary_HUD] = loadSkin(L"skinHud.swf", L"skinHud.swf"); m_iggyLibraries[eLibrary_Tooltips] = loadSkin(L"skinTooltips.swf", L"skinTooltips.swf"); m_iggyLibraries[eLibrary_Default] = loadSkin(L"skin.swf", L"skin.swf"); #endif } IggyLibrary UIController::loadSkin(const wstring &skinPath, const wstring &skinName) { IggyLibrary lib = IGGY_INVALID_LIBRARY; // 4J Stu - We need to load the platformskin before the normal skin, as the normal skin requires some elements from the platform skin if(!skinPath.empty() && app.hasArchiveFile(skinPath)) { byteArray baFile = app.getArchiveFile(skinPath); lib = IggyLibraryCreateFromMemoryUTF16( (IggyUTF16 *)skinName.c_str() , (void *)baFile.data, baFile.length, NULL ); delete[] baFile.data; #ifdef _DEBUG IggyMemoryUseInfo memoryInfo; rrbool res; int iteration = 0; __int64 totalStatic = 0; while(res = IggyDebugGetMemoryUseInfo ( NULL , lib , "" , 0 , iteration , &memoryInfo )) { totalStatic += memoryInfo.static_allocation_bytes; app.DebugPrintf(app.USER_SR, "%ls - %.*s, static: %dB, dynamic: %dB\n", skinPath.c_str(), memoryInfo.subcategory_stringlen, memoryInfo.subcategory, memoryInfo.static_allocation_bytes, memoryInfo.dynamic_allocation_bytes); ++iteration; } app.DebugPrintf(app.USER_SR, "%ls - Total static: %dB (%dKB)\n", skinPath.c_str(), totalStatic, totalStatic/1024); #endif } return lib; } void UIController::ReloadSkin() { // Destroy all scene swf for(unsigned int i = 0; i < eUIGroup_COUNT; ++i) { //m_bCloseAllScenes[i] = true; m_groups[i]->DestroyAll(); } // Unload the current libraries // Some libraries reference others, so we destroy in reverse order for(int i = eLibrary_Count - 1; i >= 0; --i) { if(m_iggyLibraries[i] != IGGY_INVALID_LIBRARY) IggyLibraryDestroy(m_iggyLibraries[i]); m_iggyLibraries[i] = IGGY_INVALID_LIBRARY; } // Navigate to the timer scene so that we can display something while the loading is happening ui.NavigateToScene(0,eUIScene_Timer,(void *)1,eUILayer_Tooltips,eUIGroup_Fullscreen); m_reloadSkinThread = new C4JThread(reloadSkinThreadProc, (void*)this, "Reload skin thread"); m_reloadSkinThread->SetProcessor(CPU_CORE_UI_SCENE); //m_reloadSkinThread->Run(); //// Load new skin //loadSkins(); //// Reload all scene swf //for(int i = eUIGroup_Player1; i <= eUIGroup_Player4; ++i) //{ // m_groups[i]->ReloadAll(); //} //// Always reload the fullscreen group //m_groups[eUIGroup_Fullscreen]->ReloadAll(); } void UIController::StartReloadSkinThread() { if(m_reloadSkinThread) m_reloadSkinThread->Run(); } int UIController::reloadSkinThreadProc(void* lpParam) { EnterCriticalSection(&ms_reloadSkinCS); // MGH - added to prevent crash loading Iggy movies while the skins were being reloaded UIController *controller = (UIController *)lpParam; // Load new skin controller->loadSkins(); // Reload all scene swf for(int i = eUIGroup_Player1; i < eUIGroup_COUNT; ++i) { controller->m_groups[i]->ReloadAll(); } // Always reload the fullscreen group controller->m_groups[eUIGroup_Fullscreen]->ReloadAll(); // 4J Stu - Don't do this on windows, as we never navigated forwards to start with #ifndef _WINDOW64 controller->NavigateBack(0, false, eUIScene_COUNT, eUILayer_Tooltips); #endif LeaveCriticalSection(&ms_reloadSkinCS); return 0; } bool UIController::IsReloadingSkin() { return m_reloadSkinThread && (!m_reloadSkinThread->hasStarted() || m_reloadSkinThread->isRunning()); } bool UIController::IsExpectingOrReloadingSkin() { return Minecraft::GetInstance()->skins->getSelected()->isLoadingData() || Minecraft::GetInstance()->skins->needsUIUpdate() || IsReloadingSkin(); } void UIController::CleanUpSkinReload() { delete m_reloadSkinThread; m_reloadSkinThread = NULL; if(!Minecraft::GetInstance()->skins->isUsingDefaultSkin()) { if(!Minecraft::GetInstance()->skins->getSelected()->hasAudio()) { DWORD result = StorageManager.UnmountInstalledDLC("TPACK"); } } for(AUTO_VAR(it,m_queuedMessageBoxData.begin()); it != m_queuedMessageBoxData.end(); ++it) { QueuedMessageBoxData *queuedData = *it; ui.NavigateToScene(queuedData->iPad, eUIScene_MessageBox, &queuedData->info, queuedData->layer, eUIGroup_Fullscreen); delete queuedData->info.uiOptionA; delete queuedData; } m_queuedMessageBoxData.clear(); } byteArray UIController::getMovieData(const wstring &filename) { // Cache everything we load in the current tick __int64 targetTime = System::currentTimeMillis() + (1000LL * 60); AUTO_VAR(it,m_cachedMovieData.find(filename)); if(it == m_cachedMovieData.end() ) { byteArray baFile = app.getArchiveFile(filename); CachedMovieData cmd; cmd.m_ba = baFile; cmd.m_expiry = targetTime; m_cachedMovieData[filename] = cmd; return baFile; } else { it->second.m_expiry = targetTime; return it->second.m_ba; } } // INPUT void UIController::tickInput() { // If system/commerce UI up, don't handle input //if(!m_bSysUIShowing && !m_bSystemUIShowing) if(!m_bSystemUIShowing) { #ifdef ENABLE_IGGY_PERFMON if (m_iggyPerfmonEnabled) { if(InputManager.ButtonPressed(ProfileManager.GetPrimaryPad(), ACTION_MENU_STICK_PRESS)) m_iggyPerfmonEnabled = !m_iggyPerfmonEnabled; } else #endif { handleInput(); ++m_accumulatedTicks; } } } void UIController::handleInput() { // For each user, loop over each key type and send messages based on the state for(unsigned int iPad = 0; iPad < XUSER_MAX_COUNT; ++iPad) { for(unsigned int key = 0; key <= ACTION_MAX_MENU; ++key) { handleKeyPress(iPad, key); } } } void UIController::handleKeyPress(unsigned int iPad, unsigned int key) { bool down = false; bool pressed = false; // Toggle bool released = false; // Toggle bool repeat = false; down = InputManager.ButtonDown(iPad,key); pressed = InputManager.ButtonPressed(iPad,key); // Toggle released = InputManager.ButtonReleased(iPad,key); // Toggle if(pressed) app.DebugPrintf("Pressed %d\n",key); if(released) app.DebugPrintf("Released %d\n",key); // Repeat handling if(pressed) { // Start repeat timer m_actionRepeatTimer[iPad][key] = GetTickCount() + UI_REPEAT_KEY_DELAY_MS; } else if (released) { // Stop repeat timer m_actionRepeatTimer[iPad][key] = 0; } else if (down) { // Check is enough time has elapsed to be a repeat key DWORD currentTime = GetTickCount(); if(m_actionRepeatTimer[iPad][key] > 0 && currentTime > m_actionRepeatTimer[iPad][key]) { repeat = true; pressed = true; m_actionRepeatTimer[iPad][key] = currentTime + UI_REPEAT_KEY_REPEAT_RATE_MS; } } #ifndef _CONTENT_PACKAGE #ifdef ENABLE_IGGY_PERFMON if ( pressed && !repeat && key == ACTION_MENU_STICK_PRESS) { m_iggyPerfmonEnabled = !m_iggyPerfmonEnabled; } #endif // 4J Stu - Removed this function #if 0 #ifdef __PS3__ //if ( pressed && // !repeat && // //app.GetGameSettingsDebugMask(ProfileManager.GetPrimaryPad())&(1L<PrintTotalMemoryUsage(totalStatic, totalDynamic); } for(unsigned int i = 0; i < eLibrary_Count; ++i) { __int64 libraryStatic = 0; __int64 libraryDynamic = 0; if(m_iggyLibraries[i] != IGGY_INVALID_LIBRARY) { IggyMemoryUseInfo memoryInfo; rrbool res; int iteration = 0; while(res = IggyDebugGetMemoryUseInfo ( NULL , m_iggyLibraries[i] , "" , 0 , iteration , &memoryInfo )) { libraryStatic += memoryInfo.static_allocation_bytes; libraryDynamic += memoryInfo.dynamic_allocation_bytes; totalStatic += memoryInfo.static_allocation_bytes; totalDynamic += memoryInfo.dynamic_allocation_bytes; ++iteration; } } app.DebugPrintf(app.USER_SR, "Library static: %dB , Library dynamic: %d, ID: %d\n", libraryStatic, libraryDynamic, i); } app.DebugPrintf(app.USER_SR, "Total static: %d , Total dynamic: %d\n", totalStatic, totalDynamic); app.DebugPrintf(app.USER_SR, "\n\nEND TOTAL SWF MEMORY USAGE\n"); app.DebugPrintf(app.USER_SR, "********************************\n\n"); } else #endif #endif #endif //#endif if(repeat || pressed || released) { bool handled = false; // Send the key to the fullscreen group first m_groups[(int)eUIGroup_Fullscreen]->handleInput(iPad, key, repeat, pressed, released, handled); if(!handled) { // If it's not been handled yet, then pass the event onto the players specific group m_groups[(iPad+1)]->handleInput(iPad, key, repeat, pressed, released, handled); } } } rrbool RADLINK UIController::ExternalFunctionCallback( void * user_callback_data , Iggy * player , IggyExternalFunctionCallUTF16 * call) { UIScene *scene = (UIScene *)IggyPlayerGetUserdata(player); if(scene != NULL) { scene->externalCallback(call); } return true; } // RENDERING void UIController::renderScenes() { PIXBeginNamedEvent(0, "Rendering Iggy scenes"); // Only render player scenes if the game is started if(app.GetGameStarted() && !m_groups[eUIGroup_Fullscreen]->hidesLowerScenes()) { for(int i = eUIGroup_Player1; i < eUIGroup_COUNT; ++i) { PIXBeginNamedEvent(0, "Rendering layer %d scenes", i); m_groups[i]->render(); PIXEndNamedEvent(); } } // Always render the fullscreen group PIXBeginNamedEvent(0, "Rendering fullscreen scenes"); m_groups[eUIGroup_Fullscreen]->render(); PIXEndNamedEvent(); PIXEndNamedEvent(); #ifdef ENABLE_IGGY_PERFMON if (m_iggyPerfmonEnabled) { IggyPerfmonPad pm_pad; pm_pad.bits = 0; pm_pad.field.dpad_up = InputManager.ButtonPressed(ProfileManager.GetPrimaryPad(),ACTION_MENU_UP); pm_pad.field.dpad_down = InputManager.ButtonPressed(ProfileManager.GetPrimaryPad(),ACTION_MENU_DOWN); pm_pad.field.dpad_left = InputManager.ButtonPressed(ProfileManager.GetPrimaryPad(),ACTION_MENU_LEFT); pm_pad.field.dpad_right = InputManager.ButtonPressed(ProfileManager.GetPrimaryPad(),ACTION_MENU_RIGHT); pm_pad.field.button_up = InputManager.ButtonPressed(ProfileManager.GetPrimaryPad(),ACTION_MENU_Y); pm_pad.field.button_down = InputManager.ButtonPressed(ProfileManager.GetPrimaryPad(),ACTION_MENU_A); pm_pad.field.button_left = InputManager.ButtonPressed(ProfileManager.GetPrimaryPad(),ACTION_MENU_X); pm_pad.field.button_right = InputManager.ButtonPressed(ProfileManager.GetPrimaryPad(),ACTION_MENU_B); pm_pad.field.shoulder_left_hi = InputManager.ButtonPressed(ProfileManager.GetPrimaryPad(),ACTION_MENU_LEFT_SCROLL); pm_pad.field.shoulder_right_hi = InputManager.ButtonPressed(ProfileManager.GetPrimaryPad(),ACTION_MENU_RIGHT_SCROLL); pm_pad.field.trigger_left_low = InputManager.ButtonPressed(ProfileManager.GetPrimaryPad(),ACTION_MENU_PAGEUP); pm_pad.field.trigger_right_low = InputManager.ButtonPressed(ProfileManager.GetPrimaryPad(),ACTION_MENU_PAGEDOWN); //IggyPerfmonPadFromXInputStatePointer(pm_pad, &xi_pad); //gdraw_D3D_SetTileOrigin( fb, // zb, // PM_ORIGIN_X, // PM_ORIGIN_Y ); IggyPerfmonTickAndDraw(iggy_perfmon, gdraw_funcs, &pm_pad, PM_ORIGIN_X, PM_ORIGIN_Y, getScreenWidth(), getScreenHeight()); // perfmon draw area in window coords } #endif } void UIController::getRenderDimensions(C4JRender::eViewportType viewport, S32 &width, S32 &height) { switch( viewport ) { case C4JRender::VIEWPORT_TYPE_FULLSCREEN: width = (S32)(getScreenWidth()); height = (S32)(getScreenHeight()); break; case C4JRender::VIEWPORT_TYPE_SPLIT_TOP: case C4JRender::VIEWPORT_TYPE_SPLIT_BOTTOM: width = (S32)(getScreenWidth() / 2); height = (S32)(getScreenHeight() / 2); break; case C4JRender::VIEWPORT_TYPE_SPLIT_LEFT: case C4JRender::VIEWPORT_TYPE_SPLIT_RIGHT: width = (S32)(getScreenWidth() / 2); height = (S32)(getScreenHeight() / 2); break; case C4JRender::VIEWPORT_TYPE_QUADRANT_TOP_LEFT: case C4JRender::VIEWPORT_TYPE_QUADRANT_TOP_RIGHT: case C4JRender::VIEWPORT_TYPE_QUADRANT_BOTTOM_LEFT: case C4JRender::VIEWPORT_TYPE_QUADRANT_BOTTOM_RIGHT: width = (S32)(getScreenWidth() / 2); height = (S32)(getScreenHeight() / 2); break; } } void UIController::setupRenderPosition(C4JRender::eViewportType viewport) { if(m_bCustomRenderPosition || m_currentRenderViewport != viewport) { m_currentRenderViewport = viewport; m_bCustomRenderPosition = false; S32 xPos = 0; S32 yPos = 0; switch( viewport ) { case C4JRender::VIEWPORT_TYPE_SPLIT_TOP: xPos = (S32)(getScreenWidth() / 4); break; case C4JRender::VIEWPORT_TYPE_SPLIT_BOTTOM: xPos = (S32)(getScreenWidth() / 4); yPos = (S32)(getScreenHeight() / 2); break; case C4JRender::VIEWPORT_TYPE_SPLIT_LEFT: yPos = (S32)(getScreenHeight() / 4); break; case C4JRender::VIEWPORT_TYPE_SPLIT_RIGHT: xPos = (S32)(getScreenWidth() / 2); yPos = (S32)(getScreenHeight() / 4); break; case C4JRender::VIEWPORT_TYPE_QUADRANT_TOP_LEFT: break; case C4JRender::VIEWPORT_TYPE_QUADRANT_TOP_RIGHT: xPos = (S32)(getScreenWidth() / 2); break; case C4JRender::VIEWPORT_TYPE_QUADRANT_BOTTOM_LEFT: yPos = (S32)(getScreenHeight() / 2); break; case C4JRender::VIEWPORT_TYPE_QUADRANT_BOTTOM_RIGHT: xPos = (S32)(getScreenWidth() / 2); yPos = (S32)(getScreenHeight() / 2); break; } m_tileOriginX = xPos; m_tileOriginY = yPos; setTileOrigin(xPos, yPos); } } void UIController::setupRenderPosition(S32 xOrigin, S32 yOrigin) { m_bCustomRenderPosition = true; m_tileOriginX = xOrigin; m_tileOriginY = yOrigin; setTileOrigin(xOrigin, yOrigin); } void UIController::setupCustomDrawGameState() { // Rest the clear rect m_customRenderingClearRect.left = LONG_MAX; m_customRenderingClearRect.right = LONG_MIN; m_customRenderingClearRect.top = LONG_MAX; m_customRenderingClearRect.bottom = LONG_MIN; #if defined __PS3__ RenderManager.StartFrame(); #endif RenderManager.Set_matrixDirty(); // 4J Stu - We don't need to clear this here as iggy hasn't written anything to the depth buffer. // We DO however clear after we render which is why we still setup the rectangle here //RenderManager.Clear(GL_DEPTH_BUFFER_BIT, &m_customRenderingClearRect); //glClear(GL_DEPTH_BUFFER_BIT); PIXBeginNamedEvent(0,"Final setup"); glMatrixMode(GL_PROJECTION); glLoadIdentity(); glOrtho(0, m_fScreenWidth, m_fScreenHeight, 0, 1000, 3000); glMatrixMode(GL_MODELVIEW); glEnable(GL_ALPHA_TEST); glAlphaFunc(GL_GREATER, 0.1f); glEnable(GL_DEPTH_TEST); glDepthFunc(GL_LEQUAL); glDepthMask(true); PIXEndNamedEvent(); } void UIController::setupCustomDrawMatrices(UIScene *scene, CustomDrawData *customDrawRegion) { Minecraft *pMinecraft=Minecraft::GetInstance(); // Clear just the region required for this control. float sceneWidth = (float)scene->getRenderWidth(); float sceneHeight = (float)scene->getRenderHeight(); LONG left, right, top, bottom; #ifdef __PS3__ if(!RenderManager.IsHiDef() && !RenderManager.IsWidescreen()) { // 4J Stu - Our SD target on PS3 is double width left = m_tileOriginX + (sceneWidth + customDrawRegion->mat[(0*4)+3]*sceneWidth); right = left + ( (sceneWidth * customDrawRegion->mat[0]) ) * customDrawRegion->x1; } else #endif { left = m_tileOriginX + (sceneWidth + customDrawRegion->mat[(0*4)+3]*sceneWidth)/2; right = left + ( (sceneWidth * customDrawRegion->mat[0])/2 ) * customDrawRegion->x1; } top = m_tileOriginY + (sceneHeight - customDrawRegion->mat[(1*4)+3]*sceneHeight)/2; bottom = top + (sceneHeight * -customDrawRegion->mat[(1*4) + 1])/2 * customDrawRegion->y1; m_customRenderingClearRect.left = min(m_customRenderingClearRect.left, left); m_customRenderingClearRect.right = max(m_customRenderingClearRect.right, right);; m_customRenderingClearRect.top = min(m_customRenderingClearRect.top, top); m_customRenderingClearRect.bottom = max(m_customRenderingClearRect.bottom, bottom); if(!m_bScreenWidthSetup) { Minecraft *pMinecraft=Minecraft::GetInstance(); if(pMinecraft != NULL) { m_fScreenWidth=(float)pMinecraft->width_phys; m_fScreenHeight=(float)pMinecraft->height_phys; m_bScreenWidthSetup = true; } } glLoadIdentity(); glTranslatef(0, 0, -2000); // Iggy translations are based on a double-size target, with the origin in the centre glTranslatef((m_fScreenWidth + customDrawRegion->mat[(0*4)+3]*m_fScreenWidth)/2,(m_fScreenHeight - customDrawRegion->mat[(1*4)+3]*m_fScreenHeight)/2,0); // Iggy scales are based on a double-size target glScalef( (m_fScreenWidth * customDrawRegion->mat[0])/2,(m_fScreenHeight * -customDrawRegion->mat[(1*4) + 1])/2,1.0f); } void UIController::setupCustomDrawGameStateAndMatrices(UIScene *scene, CustomDrawData *customDrawRegion) { setupCustomDrawGameState(); setupCustomDrawMatrices(scene, customDrawRegion); } void UIController::endCustomDrawGameState() { RenderManager.Clear(GL_DEPTH_BUFFER_BIT, &m_customRenderingClearRect); //glClear(GL_DEPTH_BUFFER_BIT); glDepthMask(false); glDisable(GL_ALPHA_TEST); } void UIController::endCustomDrawMatrices() { } void UIController::endCustomDrawGameStateAndMatrices() { endCustomDrawMatrices(); endCustomDrawGameState(); } void RADLINK UIController::CustomDrawCallback(void *user_callback_data, Iggy *player, IggyCustomDrawCallbackRegion *region) { UIScene *scene = (UIScene *)IggyPlayerGetUserdata(player); if(scene != NULL) { scene->customDraw(region); } } //Description //Callback to create a user-defined texture to replace SWF-defined textures. //Parameters //width - Input value: optional number of pixels wide specified from AS3, or -1 if not defined. Output value: the number of pixels wide to pretend to Iggy that the bitmap is. SWF and AS3 scales bitmaps based on their pixel dimensions, so you can use this to substitute a texture that is higher or lower resolution that ActionScript thinks it is. //height - Input value: optional number of pixels high specified from AS3, or -1 if not defined. Output value: the number of pixels high to pretend to Iggy that the bitmap is. SWF and AS3 scales bitmaps based on their pixel dimensions, so you can use this to substitute a texture that is higher or lower resolution that ActionScript thinks it is. //destroy_callback_data - Optional additional output value you can set; the value will be passed along to the corresponding Iggy_TextureSubstitutionDestroyCallback (e.g. you can store the pointer to your own internal structure here). //return - A platform-independent wrapped texture handle provided by GDraw, or NULL (NULL with throw an ActionScript 3 ArgumentError that the Flash developer can catch) Use by calling IggySetTextureSubstitutionCallbacks. // //Discussion // //If your texture includes an alpha channel, you must use a premultiplied alpha (where the R,G, and B channels have been multiplied by the alpha value); all Iggy shaders assume premultiplied alpha (and it looks better anyway). GDrawTexture * RADLINK UIController::TextureSubstitutionCreateCallback ( void * user_callback_data , IggyUTF16 * texture_name , S32 * width , S32 * height , void * * destroy_callback_data ) { UIController *uiController = (UIController *)user_callback_data; AUTO_VAR(it,uiController->m_substitutionTextures.find((wchar_t *)texture_name)); if(it != uiController->m_substitutionTextures.end()) { app.DebugPrintf("Found substitution texture %ls, with %d bytes\n", (wchar_t *)texture_name,it->second.length); BufferedImage image(it->second.data, it->second.length); if( image.getData() != NULL ) { image.preMultiplyAlpha(); Textures *t = Minecraft::GetInstance()->textures; int id = t->getTexture(&image,C4JRender::TEXTURE_FORMAT_RxGyBzAw,false); // 4J Stu - All our flash controls that allow replacing textures use a special 64x64 symbol // Force this size here so that our images don't get scaled wildly *width = 64; *height = 64; *destroy_callback_data = (void *)id; app.DebugPrintf("Found substitution texture %ls (%d) - %dx%d\n", (wchar_t *)texture_name, id, image.getWidth(), image.getHeight()); return ui.getSubstitutionTexture(id); } else { return NULL; } } else { app.DebugPrintf("Could not find substitution texture %ls\n", (wchar_t *)texture_name); return NULL; } } //Description //Callback received from Iggy when it stops using a user-defined texture. void RADLINK UIController::TextureSubstitutionDestroyCallback ( void * user_callback_data , void * destroy_callback_data , GDrawTexture * handle ) { // Orbis complains about casting a pointer to an int LONGLONG llVal=(LONGLONG)destroy_callback_data; int id=(int)llVal; app.DebugPrintf("Destroying iggy texture %d\n", id); ui.destroySubstitutionTexture(user_callback_data, handle); Textures *t = Minecraft::GetInstance()->textures; t->releaseTexture( id ); } void UIController::registerSubstitutionTexture(const wstring &textureName, PBYTE pbData, DWORD dwLength) { // Remove it if it already exists unregisterSubstitutionTexture(textureName,false); m_substitutionTextures[textureName] = byteArray(pbData, dwLength); } void UIController::unregisterSubstitutionTexture(const wstring &textureName, bool deleteData) { AUTO_VAR(it,m_substitutionTextures.find(textureName)); if(it != m_substitutionTextures.end()) { if(deleteData) delete [] it->second.data; m_substitutionTextures.erase(it); } } // NAVIGATION bool UIController::NavigateToScene(int iPad, EUIScene scene, void *initData, EUILayer layer, EUIGroup group) { // if you're trying to navigate to the inventory,the crafting, pause or game info or any of the trigger scenes and there's already a menu up (because you were pressing a few buttons at the same time) then ignore the navigate if(GetMenuDisplayed(iPad)) { switch(scene) { case eUIScene_PauseMenu: case eUIScene_Crafting2x2Menu: case eUIScene_Crafting3x3Menu: case eUIScene_FurnaceMenu: case eUIScene_ContainerMenu: case eUIScene_LargeContainerMenu: case eUIScene_InventoryMenu: case eUIScene_CreativeMenu: case eUIScene_DispenserMenu: case eUIScene_SignEntryMenu: case eUIScene_InGameInfoMenu: case eUIScene_EnchantingMenu: case eUIScene_BrewingStandMenu: case eUIScene_AnvilMenu: case eUIScene_TradingMenu: app.DebugPrintf("IGNORING NAVIGATE - we're trying to navigate to a user selected scene when there's already a scene up: pad:%d, scene:%d\n", iPad, scene); return false; break; } } switch(scene) { case eUIScene_FullscreenProgress: { // 4J Stu - The fullscreen progress scene should not interfere with any other scene stack, so should be placed in it's own group/layer layer = eUILayer_Fullscreen; group = eUIGroup_Fullscreen; } break; case eUIScene_ConnectingProgress: { // The connecting progress scene shouldn't interfere with other scenes layer = eUILayer_Fullscreen; } break; case eUIScene_EndPoem: { // The end poem scene shouldn't interfere with other scenes, but will be underneath the autosave progress group = eUIGroup_Fullscreen; layer = eUILayer_Scene; } break; }; int menuDisplayedPad = XUSER_INDEX_ANY; if(group == eUIGroup_PAD) { if( app.GetGameStarted() ) { // If the game isn't running treat as user 0, otherwise map index directly from pad if( ( iPad != 255 ) && ( iPad >= 0 ) ) { menuDisplayedPad = iPad; group = (EUIGroup)(iPad+1); } else group = eUIGroup_Fullscreen; } else { layer = eUILayer_Fullscreen; group = eUIGroup_Fullscreen; } } PerformanceTimer timer; EnterCriticalSection(&m_navigationLock); SetMenuDisplayed(menuDisplayedPad,true); bool success = m_groups[(int)group]->NavigateToScene(iPad, scene, initData, layer); if(success && group == eUIGroup_Fullscreen) setFullscreenMenuDisplayed(true); LeaveCriticalSection(&m_navigationLock); timer.PrintElapsedTime(L"Navigate to scene"); return success; //return true; } bool UIController::NavigateBack(int iPad, bool forceUsePad, EUIScene eScene, EUILayer eLayer) { bool navComplete = false; if( app.GetGameStarted() ) { bool navComplete = m_groups[(int)eUIGroup_Fullscreen]->NavigateBack(iPad, eScene, eLayer); if(!navComplete && ( iPad != 255 ) && ( iPad >= 0 ) ) { EUIGroup group = (EUIGroup)(iPad+1); navComplete = m_groups[(int)group]->NavigateBack(iPad, eScene, eLayer); if(!m_groups[(int)group]->GetMenuDisplayed())SetMenuDisplayed(iPad,false); } // 4J-PB - autosave in fullscreen doesn't clear the menuDisplayed flag else { if(!m_groups[(int)eUIGroup_Fullscreen]->GetMenuDisplayed()) { setFullscreenMenuDisplayed(false); for(unsigned int i = 0; i < XUSER_MAX_COUNT; ++i) { SetMenuDisplayed(i,m_groups[i+1]->GetMenuDisplayed()); } } } } else { navComplete = m_groups[(int)eUIGroup_Fullscreen]->NavigateBack(iPad, eScene, eLayer); if(!m_groups[(int)eUIGroup_Fullscreen]->GetMenuDisplayed()) SetMenuDisplayed(XUSER_INDEX_ANY,false); } return navComplete; } void UIController::NavigateToHomeMenu() { ui.CloseAllPlayersScenes(); // Alert the app the we no longer want to be informed of ethernet connections app.SetLiveLinkRequired( false ); Minecraft *pMinecraft = Minecraft::GetInstance(); // 4J-PB - just about to switched to the default texture pack , so clean up anything texture pack related here // unload any texture pack audio // if there is audio in use, clear out the audio, and unmount the pack TexturePack *pTexPack=Minecraft::GetInstance()->skins->getSelected(); DLCTexturePack *pDLCTexPack=NULL; if(pTexPack->hasAudio()) { // get the dlc texture pack, and store it pDLCTexPack=(DLCTexturePack *)pTexPack; } // change to the default texture pack pMinecraft->skins->selectTexturePackById(TexturePackRepository::DEFAULT_TEXTURE_PACK_ID); if(pTexPack->hasAudio()) { // need to stop the streaming audio - by playing streaming audio from the default texture pack now // reset the streaming sounds back to the normal ones pMinecraft->soundEngine->SetStreamingSounds(eStream_Overworld_Calm1,eStream_Overworld_piano3, eStream_Nether1,eStream_Nether4, eStream_end_dragon,eStream_end_end, eStream_CD_1); pMinecraft->soundEngine->playStreaming(L"", 0, 0, 0, 1, 1); // if(pDLCTexPack->m_pStreamedWaveBank!=NULL) // { // pDLCTexPack->m_pStreamedWaveBank->Destroy(); // } // if(pDLCTexPack->m_pSoundBank!=NULL) // { // pDLCTexPack->m_pSoundBank->Destroy(); // } DWORD result = StorageManager.UnmountInstalledDLC("TPACK"); app.DebugPrintf("Unmount result is %d\n",result); } g_NetworkManager.ForceFriendsSessionRefresh(); if(pMinecraft->skins->needsUIUpdate()) { m_navigateToHomeOnReload = true; } else { ui.NavigateToScene(ProfileManager.GetPrimaryPad(),eUIScene_MainMenu); } } UIScene *UIController::GetTopScene(int iPad, EUILayer layer, EUIGroup group) { if(group == eUIGroup_PAD) { if( app.GetGameStarted() ) { // If the game isn't running treat as user 0, otherwise map index directly from pad if( ( iPad != 255 ) && ( iPad >= 0 ) ) { group = (EUIGroup)(iPad+1); } else group = eUIGroup_Fullscreen; } else { layer = eUILayer_Fullscreen; group = eUIGroup_Fullscreen; } } return m_groups[(int)group]->GetTopScene(layer); } size_t UIController::RegisterForCallbackId(UIScene *scene) { EnterCriticalSection(&m_registeredCallbackScenesCS); size_t newId = GetTickCount(); newId &= 0xFFFFFF; // Chop off the top byte, we don't need any more accuracy than that newId |= (scene->getSceneType() << 24); // Add in the scene's type to help keep this unique m_registeredCallbackScenes[newId] = scene; LeaveCriticalSection(&m_registeredCallbackScenesCS); return newId; } void UIController::UnregisterCallbackId(size_t id) { EnterCriticalSection(&m_registeredCallbackScenesCS); AUTO_VAR(it, m_registeredCallbackScenes.find(id) ); if(it != m_registeredCallbackScenes.end() ) { m_registeredCallbackScenes.erase(it); } LeaveCriticalSection(&m_registeredCallbackScenesCS); } UIScene *UIController::GetSceneFromCallbackId(size_t id) { UIScene *scene = NULL; AUTO_VAR(it, m_registeredCallbackScenes.find(id) ); if(it != m_registeredCallbackScenes.end() ) { scene = it->second; } return scene; } void UIController::EnterCallbackIdCriticalSection() { EnterCriticalSection(&m_registeredCallbackScenesCS); } void UIController::LeaveCallbackIdCriticalSection() { LeaveCriticalSection(&m_registeredCallbackScenesCS); } void UIController::CloseAllPlayersScenes() { m_groups[(int)eUIGroup_Fullscreen]->getTooltips()->SetTooltips(-1); for(unsigned int i = 0; i < eUIGroup_COUNT; ++i) { //m_bCloseAllScenes[i] = true; m_groups[i]->closeAllScenes(); m_groups[i]->getTooltips()->SetTooltips(-1); } if (!m_groups[eUIGroup_Fullscreen]->GetMenuDisplayed()) { for(unsigned int i = 0; i < XUSER_MAX_COUNT; ++i) { SetMenuDisplayed(i,false); } } setFullscreenMenuDisplayed(false); } void UIController::CloseUIScenes(int iPad, bool forceIPad) { EUIGroup group; if( app.GetGameStarted() || forceIPad ) { // If the game isn't running treat as user 0, otherwise map index directly from pad if( ( iPad != 255 ) && ( iPad >= 0 ) ) group = (EUIGroup)(iPad+1); else group = eUIGroup_Fullscreen; } else { group = eUIGroup_Fullscreen; } m_groups[(int)group]->closeAllScenes(); m_groups[(int)group]->getTooltips()->SetTooltips(-1); // This should cause the popup to dissappear TutorialPopupInfo popupInfo; if(m_groups[(int)group]->getTutorialPopup()) m_groups[(int)group]->getTutorialPopup()->SetTutorialDescription(&popupInfo); if(group==eUIGroup_Fullscreen) setFullscreenMenuDisplayed(false); SetMenuDisplayed((group == eUIGroup_Fullscreen ? XUSER_INDEX_ANY : iPad), m_groups[(int)group]->GetMenuDisplayed()); } void UIController::setFullscreenMenuDisplayed(bool displayed) { // Show/hide the tooltips for the fullscreen group m_groups[(int)eUIGroup_Fullscreen]->showComponent(ProfileManager.GetPrimaryPad(),eUIComponent_Tooltips,eUILayer_Tooltips,displayed); // Show/hide tooltips for the other layers for(unsigned int i = (eUIGroup_Fullscreen+1); i < eUIGroup_COUNT; ++i) { m_groups[i]->showComponent(i,eUIComponent_Tooltips,eUILayer_Tooltips,!displayed); } } bool UIController::IsPauseMenuDisplayed(int iPad) { EUIGroup group; if( app.GetGameStarted() ) { // If the game isn't running treat as user 0, otherwise map index directly from pad if( ( iPad != 255 ) && ( iPad >= 0 ) ) group = (EUIGroup)(iPad+1); else group = eUIGroup_Fullscreen; } else { group = eUIGroup_Fullscreen; } return m_groups[(int)group]->IsPauseMenuDisplayed(); } bool UIController::IsContainerMenuDisplayed(int iPad) { EUIGroup group; if( app.GetGameStarted() ) { // If the game isn't running treat as user 0, otherwise map index directly from pad if( ( iPad != 255 ) && ( iPad >= 0 ) ) group = (EUIGroup)(iPad+1); else group = eUIGroup_Fullscreen; } else { group = eUIGroup_Fullscreen; } return m_groups[(int)group]->IsContainerMenuDisplayed(); } bool UIController::IsIgnorePlayerJoinMenuDisplayed(int iPad) { EUIGroup group; if( app.GetGameStarted() ) { // If the game isn't running treat as user 0, otherwise map index directly from pad if( ( iPad != 255 ) && ( iPad >= 0 ) ) group = (EUIGroup)(iPad+1); else group = eUIGroup_Fullscreen; } else { group = eUIGroup_Fullscreen; } return m_groups[(int)group]->IsIgnorePlayerJoinMenuDisplayed(); } bool UIController::IsIgnoreAutosaveMenuDisplayed(int iPad) { EUIGroup group; if( app.GetGameStarted() ) { // If the game isn't running treat as user 0, otherwise map index directly from pad if( ( iPad != 255 ) && ( iPad >= 0 ) ) group = (EUIGroup)(iPad+1); else group = eUIGroup_Fullscreen; } else { group = eUIGroup_Fullscreen; } return m_groups[(int)eUIGroup_Fullscreen]->IsIgnoreAutosaveMenuDisplayed() || (group != eUIGroup_Fullscreen && m_groups[(int)group]->IsIgnoreAutosaveMenuDisplayed()); } void UIController::SetIgnoreAutosaveMenuDisplayed(int iPad, bool displayed) { app.DebugPrintf(app.USER_SR, "UIController::SetIgnoreAutosaveMenuDisplayed is not implemented\n"); } bool UIController::IsSceneInStack(int iPad, EUIScene eScene) { EUIGroup group; if( app.GetGameStarted() ) { // If the game isn't running treat as user 0, otherwise map index directly from pad if( ( iPad != 255 ) && ( iPad >= 0 ) ) group = (EUIGroup)(iPad+1); else group = eUIGroup_Fullscreen; } else { group = eUIGroup_Fullscreen; } return m_groups[(int)group]->IsSceneInStack(eScene); } bool UIController::GetMenuDisplayed(int iPad) { return m_bMenuDisplayed[iPad]; } void UIController::SetMenuDisplayed(int iPad,bool bVal) { if(bVal) { if(iPad==XUSER_INDEX_ANY) { for(int i=0;igetTooltips()) m_groups[(int)group]->getTooltips()->SetTooltipText(tooltip, iTextID); } void UIController::SetEnableTooltips( unsigned int iPad, BOOL bVal ) { EUIGroup group; if( app.GetGameStarted() ) { // If the game isn't running treat as user 0, otherwise map index directly from pad if( ( iPad != 255 ) ) group = (EUIGroup)(iPad+1); else group = eUIGroup_Fullscreen; } else { group = eUIGroup_Fullscreen; } if(m_groups[(int)group]->getTooltips()) m_groups[(int)group]->getTooltips()->SetEnableTooltips(bVal); } void UIController::ShowTooltip( unsigned int iPad, unsigned int tooltip, bool show ) { EUIGroup group; if( app.GetGameStarted() ) { // If the game isn't running treat as user 0, otherwise map index directly from pad if( ( iPad != 255 ) ) group = (EUIGroup)(iPad+1); else group = eUIGroup_Fullscreen; } else { group = eUIGroup_Fullscreen; } if(m_groups[(int)group]->getTooltips()) m_groups[(int)group]->getTooltips()->ShowTooltip(tooltip,show); } void UIController::SetTooltips( unsigned int iPad, int iA, int iB, int iX, int iY, int iLT, int iRT, int iLB, int iRB, int iLS, bool forceUpdate) { EUIGroup group; // 4J-PB - strip out any that are not applicable on the platform if(iX==IDS_TOOLTIPS_SELECTDEVICE) iX=-1; if(iX==IDS_TOOLTIPS_CHANGEDEVICE) iX=-1; #if defined(__PS3__) if(iY==IDS_TOOLTIPS_VIEW_GAMERCARD) iY=-1; if(iY==IDS_TOOLTIPS_VIEW_GAMERPROFILE) iY=-1; #endif if( app.GetGameStarted() ) { // If the game isn't running treat as user 0, otherwise map index directly from pad if( ( iPad != 255 ) ) group = (EUIGroup)(iPad+1); else group = eUIGroup_Fullscreen; } else { group = eUIGroup_Fullscreen; } if(m_groups[(int)group]->getTooltips()) m_groups[(int)group]->getTooltips()->SetTooltips(iA, iB, iX, iY, iLT, iRT, iLB, iRB, iLS, forceUpdate); } void UIController::EnableTooltip( unsigned int iPad, unsigned int tooltip, bool enable ) { EUIGroup group; if( app.GetGameStarted() ) { // If the game isn't running treat as user 0, otherwise map index directly from pad if( ( iPad != 255 ) ) group = (EUIGroup)(iPad+1); else group = eUIGroup_Fullscreen; } else { group = eUIGroup_Fullscreen; } if(m_groups[(int)group]->getTooltips()) m_groups[(int)group]->getTooltips()->EnableTooltip(tooltip,enable); } void UIController::RefreshTooltips(unsigned int iPad) { app.DebugPrintf(app.USER_SR, "UIController::RefreshTooltips is not implemented\n"); } void UIController::AnimateKeyPress(int iPad, int iAction, bool bRepeat, bool bPressed, bool bReleased) { EUIGroup group; if(bPressed==false) { // only animating button press return; } if( app.GetGameStarted() ) { // If the game isn't running treat as user 0, otherwise map index directly from pad if( ( iPad != 255 ) && ( iPad >= 0 ) ) group = (EUIGroup)(iPad+1); else group = eUIGroup_Fullscreen; } else { group = eUIGroup_Fullscreen; } bool handled = false; if(m_groups[(int)group]->getTooltips()) m_groups[(int)group]->getTooltips()->handleInput(iPad, iAction, bRepeat, bPressed, bReleased, handled); } void UIController::OverrideSFX(int iPad, int iAction,bool bVal) { EUIGroup group; if( app.GetGameStarted() ) { // If the game isn't running treat as user 0, otherwise map index directly from pad if( ( iPad != 255 ) && ( iPad >= 0 ) ) group = (EUIGroup)(iPad+1); else group = eUIGroup_Fullscreen; } else { group = eUIGroup_Fullscreen; } bool handled = false; if(m_groups[(int)group]->getTooltips()) m_groups[(int)group]->getTooltips()->overrideSFX(iPad, iAction,bVal); } void UIController::PlayUISFX(ESoundEffect eSound) { Minecraft::GetInstance()->soundEngine->playUI(eSound,1.0f,1.0f); } void UIController::DisplayGamertag(unsigned int iPad, bool show) { // The host decides whether these are on or off if( app.GetGameSettings(ProfileManager.GetPrimaryPad(),eGameSetting_DisplaySplitscreenGamertags) == 0) { show = false; } EUIGroup group = (EUIGroup)(iPad+1); if(m_groups[(int)group]->getHUD()) m_groups[(int)group]->getHUD()->ShowDisplayName(show); // Update TutorialPopup in Splitscreen if no container is displayed (to make sure the Popup does not overlap with the Gamertag!) if(app.GetLocalPlayerCount() > 1 && m_groups[(int)group]->getTutorialPopup() && !m_groups[(int)group]->IsContainerMenuDisplayed()) { m_groups[(int)group]->getTutorialPopup()->UpdateTutorialPopup(); } } void UIController::SetSelectedItem(unsigned int iPad, const wstring &name) { EUIGroup group; if( app.GetGameStarted() ) { // If the game isn't running treat as user 0, otherwise map index directly from pad if( ( iPad != 255 ) && ( iPad >= 0 ) ) group = (EUIGroup)(iPad+1); else group = eUIGroup_Fullscreen; } else { group = eUIGroup_Fullscreen; } bool handled = false; if(m_groups[(int)group]->getHUD()) m_groups[(int)group]->getHUD()->SetSelectedLabel(name); } void UIController::UpdateSelectedItemPos(unsigned int iPad) { app.DebugPrintf(app.USER_SR, "UIController::UpdateSelectedItemPos not implemented\n"); } void UIController::HandleDLCMountingComplete() { for(unsigned int i = 0; i < eUIGroup_COUNT; ++i) { app.DebugPrintf("UIController::HandleDLCMountingComplete - m_groups[%d]\n",i); m_groups[i]->HandleDLCMountingComplete(); } } void UIController::HandleDLCInstalled(int iPad) { //app.DebugPrintf(app.USER_SR, "UIController::HandleDLCInstalled not implemented\n"); for(unsigned int i = 0; i < eUIGroup_COUNT; ++i) { m_groups[i]->HandleDLCInstalled(); } } void UIController::HandleTMSDLCFileRetrieved(int iPad) { app.DebugPrintf(app.USER_SR, "UIController::HandleTMSDLCFileRetrieved not implemented\n"); } void UIController::HandleTMSBanFileRetrieved(int iPad) { app.DebugPrintf(app.USER_SR, "UIController::HandleTMSBanFileRetrieved not implemented\n"); } void UIController::HandleInventoryUpdated(int iPad) { app.DebugPrintf(app.USER_SR, "UIController::HandleInventoryUpdated not implemented\n"); } void UIController::HandleGameTick() { tickInput(); for(unsigned int i = 0; i < eUIGroup_COUNT; ++i) { if(m_groups[i]->getHUD()) m_groups[i]->getHUD()->handleGameTick(); } } void UIController::SetTutorial(int iPad, Tutorial *tutorial) { EUIGroup group; if( app.GetGameStarted() ) { // If the game isn't running treat as user 0, otherwise map index directly from pad if( ( iPad != 255 ) && ( iPad >= 0 ) ) group = (EUIGroup)(iPad+1); else group = eUIGroup_Fullscreen; } else { group = eUIGroup_Fullscreen; } if(m_groups[(int)group]->getTutorialPopup()) m_groups[(int)group]->getTutorialPopup()->SetTutorial(tutorial); } void UIController::SetTutorialDescription(int iPad, TutorialPopupInfo *info) { EUIGroup group; if( app.GetGameStarted() ) { // If the game isn't running treat as user 0, otherwise map index directly from pad if( ( iPad != 255 ) && ( iPad >= 0 ) ) group = (EUIGroup)(iPad+1); else group = eUIGroup_Fullscreen; } else { group = eUIGroup_Fullscreen; } if(m_groups[(int)group]->getTutorialPopup()) { // tutorial popup needs to know if a container menu is being displayed m_groups[(int)group]->getTutorialPopup()->SetContainerMenuVisible(m_groups[(int)group]->IsContainerMenuDisplayed()); m_groups[(int)group]->getTutorialPopup()->SetTutorialDescription(info); } } void UIController::RemoveInteractSceneReference(int iPad, UIScene *scene) { EUIGroup group; if( app.GetGameStarted() ) { // If the game isn't running treat as user 0, otherwise map index directly from pad if( ( iPad != 255 ) && ( iPad >= 0 ) ) group = (EUIGroup)(iPad+1); else group = eUIGroup_Fullscreen; } else { group = eUIGroup_Fullscreen; } if(m_groups[(int)group]->getTutorialPopup()) m_groups[(int)group]->getTutorialPopup()->RemoveInteractSceneReference(scene); } void UIController::SetTutorialVisible(int iPad, bool visible) { EUIGroup group; if( app.GetGameStarted() ) { // If the game isn't running treat as user 0, otherwise map index directly from pad if( ( iPad != 255 ) && ( iPad >= 0 ) ) group = (EUIGroup)(iPad+1); else group = eUIGroup_Fullscreen; } else { group = eUIGroup_Fullscreen; } if(m_groups[(int)group]->getTutorialPopup()) m_groups[(int)group]->getTutorialPopup()->SetVisible(visible); } bool UIController::IsTutorialVisible(int iPad) { EUIGroup group; if( app.GetGameStarted() ) { // If the game isn't running treat as user 0, otherwise map index directly from pad if( ( iPad != 255 ) && ( iPad >= 0 ) ) group = (EUIGroup)(iPad+1); else group = eUIGroup_Fullscreen; } else { group = eUIGroup_Fullscreen; } bool visible = false; if(m_groups[(int)group]->getTutorialPopup()) visible = m_groups[(int)group]->getTutorialPopup()->IsVisible(); return visible; } void UIController::UpdatePlayerBasePositions() { Minecraft *pMinecraft = Minecraft::GetInstance(); for( BYTE idx = 0; idx < XUSER_MAX_COUNT; ++idx) { if(pMinecraft->localplayers[idx] != NULL) { if(pMinecraft->localplayers[idx]->m_iScreenSection==C4JRender::VIEWPORT_TYPE_FULLSCREEN) { DisplayGamertag(idx,false); } else { DisplayGamertag(idx,true); } m_groups[idx+1]->SetViewportType((C4JRender::eViewportType)pMinecraft->localplayers[idx]->m_iScreenSection); } else { // 4J Stu - This is a legacy thing from our XUI implementation that we don't need // Changing the viewport to fullscreen for users that no longer exist is SLOW // This should probably be on all platforms, but I don't have time to test them all just now! m_groups[idx+1]->SetViewportType(C4JRender::VIEWPORT_TYPE_FULLSCREEN); DisplayGamertag(idx,false); } } } void UIController::SetEmptyQuadrantLogo(int iSection) { // 4J Stu - We shouldn't need to implement this } void UIController::HideAllGameUIElements() { // 4J Stu - We might not need to implement this app.DebugPrintf(app.USER_SR, "UIController::HideAllGameUIElements not implemented\n"); } void UIController::ShowOtherPlayersBaseScene(unsigned int iPad, bool show) { // 4J Stu - We shouldn't need to implement this } void UIController::ShowTrialTimer(bool show) { if(m_groups[(int)eUIGroup_Fullscreen]->getPressStartToPlay()) m_groups[(int)eUIGroup_Fullscreen]->getPressStartToPlay()->showTrialTimer(show); } void UIController::SetTrialTimerLimitSecs(unsigned int uiSeconds) { UIController::m_dwTrialTimerLimitSecs = uiSeconds; } void UIController::UpdateTrialTimer(unsigned int iPad) { WCHAR wcTime[20]; DWORD dwTimeTicks=(DWORD)app.getTrialTimer(); if(dwTimeTicks>m_dwTrialTimerLimitSecs) { dwTimeTicks=m_dwTrialTimerLimitSecs; } dwTimeTicks=m_dwTrialTimerLimitSecs-dwTimeTicks; #ifndef _CONTENT_PACKAGE if(true) #else // display the time - only if there's less than 3 minutes if(dwTimeTicks<180) #endif { int iMins=dwTimeTicks/60; int iSeconds=dwTimeTicks%60; swprintf( wcTime, 20, L"%d:%02d",iMins,iSeconds); if(m_groups[(int)eUIGroup_Fullscreen]->getPressStartToPlay()) m_groups[(int)eUIGroup_Fullscreen]->getPressStartToPlay()->setTrialTimer(wcTime); } else { if(m_groups[(int)eUIGroup_Fullscreen]->getPressStartToPlay()) m_groups[(int)eUIGroup_Fullscreen]->getPressStartToPlay()->setTrialTimer(L""); } // are we out of time? if((dwTimeTicks==0)) { // Trial over // bring up the pause menu to stop the trial over message box being called again? if(!ui.GetMenuDisplayed( iPad ) ) { ui.NavigateToScene(iPad, eUIScene_PauseMenu, NULL, eUILayer_Scene); app.SetAction(iPad,eAppAction_TrialOver); } } } void UIController::ReduceTrialTimerValue() { DWORD dwTimeTicks=(int)app.getTrialTimer(); if(dwTimeTicks>m_dwTrialTimerLimitSecs) { dwTimeTicks=m_dwTrialTimerLimitSecs; } m_dwTrialTimerLimitSecs-=dwTimeTicks; } void UIController::ShowAutosaveCountdownTimer(bool show) { if(m_groups[(int)eUIGroup_Fullscreen]->getPressStartToPlay()) m_groups[(int)eUIGroup_Fullscreen]->getPressStartToPlay()->showTrialTimer(show); } void UIController::UpdateAutosaveCountdownTimer(unsigned int uiSeconds) { #if !(0 || 0) WCHAR wcAutosaveCountdown[100]; swprintf( wcAutosaveCountdown, 100, app.GetString(IDS_AUTOSAVE_COUNTDOWN),uiSeconds); if(m_groups[(int)eUIGroup_Fullscreen]->getPressStartToPlay()) m_groups[(int)eUIGroup_Fullscreen]->getPressStartToPlay()->setTrialTimer(wcAutosaveCountdown); #endif } void UIController::ShowSavingMessage(unsigned int iPad, C4JStorage::ESavingMessage eVal) { bool show = false; switch(eVal) { case C4JStorage::ESavingMessage_None: show = false; break; case C4JStorage::ESavingMessage_Short: case C4JStorage::ESavingMessage_Long: show = true; break; } if(m_groups[(int)eUIGroup_Fullscreen]->getPressStartToPlay()) m_groups[(int)eUIGroup_Fullscreen]->getPressStartToPlay()->showSaveIcon(show); } void UIController::ShowPlayerDisplayname(bool show) { if(m_groups[(int)eUIGroup_Fullscreen]->getPressStartToPlay()) m_groups[(int)eUIGroup_Fullscreen]->getPressStartToPlay()->showPlayerDisplayName(show); } void UIController::SetWinUserIndex(unsigned int iPad) { m_winUserIndex = iPad; } unsigned int UIController::GetWinUserIndex() { return m_winUserIndex; } void UIController::ShowUIDebugConsole(bool show) { #ifndef _CONTENT_PACKAGE if(show) { m_uiDebugConsole = (UIComponent_DebugUIConsole *)m_groups[eUIGroup_Fullscreen]->addComponent(0, eUIComponent_DebugUIConsole, eUILayer_Debug); } else { m_groups[eUIGroup_Fullscreen]->removeComponent(eUIComponent_DebugUIConsole, eUILayer_Debug); m_uiDebugConsole = NULL; } #endif } void UIController::ShowUIDebugMarketingGuide(bool show) { #ifndef _CONTENT_PACKAGE if(show) { m_uiDebugMarketingGuide = (UIComponent_DebugUIMarketingGuide *)m_groups[eUIGroup_Fullscreen]->addComponent(0, eUIComponent_DebugUIMarketingGuide, eUILayer_Debug); } else { m_groups[eUIGroup_Fullscreen]->removeComponent(eUIComponent_DebugUIMarketingGuide, eUILayer_Debug); m_uiDebugMarketingGuide = NULL; } #endif } void UIController::logDebugString(const string &text) { if(m_uiDebugConsole) m_uiDebugConsole->addText(text); } bool UIController::PressStartPlaying(unsigned int iPad) { return m_iPressStartQuadrantsMask&(1<getPressStartToPlay()) m_groups[(int)eUIGroup_Fullscreen]->getPressStartToPlay()->showPressStart(iPad, true); } void UIController::HidePressStart() { ClearPressStart(); if(m_groups[(int)eUIGroup_Fullscreen]->getPressStartToPlay()) m_groups[(int)eUIGroup_Fullscreen]->getPressStartToPlay()->showPressStart(0, false); } void UIController::ClearPressStart() { m_iPressStartQuadrantsMask = 0; } // 4J Stu - For the different StringTable classes. Should really fix the libraries. #ifndef __PS3__ C4JStorage::EMessageResult UIController::RequestMessageBox(UINT uiTitle, UINT uiText, UINT *uiOptionA,UINT uiOptionC, DWORD dwPad, int( *Func)(LPVOID,int,const C4JStorage::EMessageResult),LPVOID lpParam, C4JStringTable *pStringTable, WCHAR *pwchFormatString,DWORD dwFocusButton, bool bIsError) #else C4JStorage::EMessageResult UIController::RequestMessageBox(UINT uiTitle, UINT uiText, UINT *uiOptionA,UINT uiOptionC, DWORD dwPad, int( *Func)(LPVOID,int,const C4JStorage::EMessageResult),LPVOID lpParam, StringTable *pStringTable, WCHAR *pwchFormatString,DWORD dwFocusButton, bool bIsError) #endif { MessageBoxInfo param; param.uiTitle = uiTitle; param.uiText = uiText; param.uiOptionA = uiOptionA; param.uiOptionC = uiOptionC; param.dwPad = dwPad; param.Func = Func;\ param.lpParam = lpParam; param.pwchFormatString = pwchFormatString; param.dwFocusButton = dwFocusButton; EUILayer layer = bIsError?eUILayer_Error:eUILayer_Alert; bool completed = false; if(ui.IsReloadingSkin()) { // Queue this message box QueuedMessageBoxData *queuedData = new QueuedMessageBoxData(); queuedData->info = param; queuedData->info.uiOptionA = new UINT[param.uiOptionC]; memcpy(queuedData->info.uiOptionA, param.uiOptionA, param.uiOptionC * sizeof(UINT)); queuedData->iPad = dwPad; queuedData->layer = eUILayer_Error; // Ensures that these don't get wiped out by a CloseAllScenes call m_queuedMessageBoxData.push_back(queuedData); } else { completed = ui.NavigateToScene(dwPad, eUIScene_MessageBox, ¶m, layer, eUIGroup_Fullscreen); } if( completed ) { // This may happen if we had to queue the message box, or there was already a message box displaying and so the NavigateToScene returned false; return C4JStorage::EMessage_Pending; } else { return C4JStorage::EMessage_Busy; } } C4JStorage::EMessageResult UIController::RequestUGCMessageBox(UINT title/* = -1 */, UINT message/* = -1 */, int iPad/* = -1*/, int( *Func)(LPVOID,int,const C4JStorage::EMessageResult)/* = NULL*/, LPVOID lpParam/* = NULL*/) { // Default title / messages if (title == -1) { title = IDS_FAILED_TO_CREATE_GAME_TITLE; } if (message == -1) { message = IDS_NO_USER_CREATED_CONTENT_PRIVILEGE_CREATE; } // Default pad to primary player if (iPad == -1) iPad = ProfileManager.GetPrimaryPad(); UINT uiIDA[1]; uiIDA[0]=IDS_CONFIRM_OK; return ui.RequestMessageBox( title, message, uiIDA, 1, iPad, Func, lpParam, app.GetStringTable(), NULL, 0, false); } C4JStorage::EMessageResult UIController::RequestContentRestrictedMessageBox(UINT title/* = -1 */, UINT message/* = -1 */, int iPad/* = -1*/, int( *Func)(LPVOID,int,const C4JStorage::EMessageResult)/* = NULL*/, LPVOID lpParam/* = NULL*/) { // Default title / messages if (title == -1) { title = IDS_FAILED_TO_CREATE_GAME_TITLE; } if (message == -1) { message = IDS_CONTENT_RESTRICTION; } // Default pad to primary player if (iPad == -1) iPad = ProfileManager.GetPrimaryPad(); UINT uiIDA[1]; uiIDA[0]=IDS_CONFIRM_OK; return ui.RequestMessageBox( title, message, uiIDA, 1, iPad, Func, lpParam, app.GetStringTable(), NULL, 0, false); } void UIController::setFontCachingCalculationBuffer(int length) { /* 4J-JEV: As described in an email from Sean. If your `optional_temp_buffer` is NULL, Iggy will allocate the temp buffer on the stack during Iggy draw calls. The size of the buffer it will allocate is 16 bytes times `max_chars` in 32-bit, and 24 bytes times `max_chars` in 64-bit. If the stack of the thread making the draw call is not large enough, Iggy will crash or otherwise behave incorrectly. */ #if defined _WIN64 static const int CHAR_SIZE = 24; #else static const int CHAR_SIZE = 16; #endif if (m_tempBuffer != NULL) delete [] m_tempBuffer; if (length<0) { if (m_defaultBuffer == NULL) m_defaultBuffer = new char[CHAR_SIZE*5000]; IggySetFontCachingCalculationBuffer(5000, m_defaultBuffer, CHAR_SIZE*5000); } else { m_tempBuffer = new char[CHAR_SIZE*length]; IggySetFontCachingCalculationBuffer(length, m_tempBuffer, CHAR_SIZE*length); } } // Returns the first scene of given type if it exists, NULL otherwise UIScene *UIController::FindScene(EUIScene sceneType) { UIScene *pScene = NULL; for (int i = 0; i < eUIGroup_COUNT; i++) { pScene = m_groups[i]->FindScene(sceneType); #ifdef __PS3__ if (pScene != NULL) return pScene; #else if (pScene != nullptr) return pScene; #endif } return pScene; }