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/PS3/PS3_UIController.cpp | 199 ++++++++++++++++++++++++++++++ 1 file changed, 199 insertions(+) create mode 100644 Minecraft.Client/PS3/PS3_UIController.cpp (limited to 'Minecraft.Client/PS3/PS3_UIController.cpp') diff --git a/Minecraft.Client/PS3/PS3_UIController.cpp b/Minecraft.Client/PS3/PS3_UIController.cpp new file mode 100644 index 00000000..7b634e3b --- /dev/null +++ b/Minecraft.Client/PS3/PS3_UIController.cpp @@ -0,0 +1,199 @@ +#include "stdafx.h" +#include "PS3_UIController.h" +#include "Common/UI/UIController.h" +#include + +// Temp +#include "..\Minecraft.h" +#include "..\Textures.h" + +#define _ENABLEIGGY + +ConsoleUIController ui; + +void ConsoleUIController::init(S32 w, S32 h) +{ +#ifdef _ENABLEIGGY + + // Shared init + preInit(w,h); + + + + + /* Now that Iggy is ready, we need to create a set of draw + callbacks for it to use to draw things with the platform + hardware (in this case, via GCM). To do this, we're building + this tutorial with the GCM GDraw implementaton that's included + with the Iggy SDK. To get it set up, we first need to set up + its memory configuration, then we create a context, and finally + we pass that context to Iggy so it will use it to render Flash + content. + First, we need to set up the GDraw memory configuration. GDraw + needs memory areas for various types of resources (such as textures, + and vertex buffers). Some of them, such as render targets, need to be + allocated in special types of memory to get optimal performance. In this + example, we allocate everything except for the dynamic vertex buffer + memory in local video memory. + Rendertargets deserve a special mention: They need to be allocated in a + tile region for optimum performance, which places some requirements on + their alignment and size. The size you specify here must be big enough to + cover the largest rendertarget you'll ever need for one Iggy rendering + call. In our case, we render the whole screen at once, so that's the + size we pass. */ + +// // Set up rendertarget memory. + S32 rt_mem_size = 16*1024*1024; // 16MB of render target memory. + void *rt_mem = RenderManager.allocVRAM(rt_mem_size, CELL_GCM_TILE_ALIGN_OFFSET); + S32 rt_pitch = cellGcmGetTiledPitchSize(w * 4); + gdraw_GCM_SetRendertargetMemory(rt_mem, rt_mem_size, w, h, rt_pitch); + + // Also configure a tile region for it. + RenderManager.setTileInfo(rt_mem, rt_pitch, CELL_GCM_COMPMODE_C32_2X1); + + // Texture and vertex buffer memory work in a similar fashion. + S32 tex_mem_size = 24*1024*1024; + S32 vert_mem_size = 2*1024*1024; + + gdraw_GCM_SetResourceMemory(GDRAW_GCM_RESOURCE_texture, 200, RenderManager.allocVRAM(tex_mem_size, 128), tex_mem_size); + gdraw_GCM_SetResourceMemory(GDRAW_GCM_RESOURCE_vertexbuffer, 1000, RenderManager.allocVRAM(vert_mem_size, 128), vert_mem_size); + + // In this example, we allocate dynamic vertex buffer memory from main memory, + // which is generally faster. + S32 dyn_vert_size = 128*1024; + gdraw_GCM_SetResourceMemory(GDRAW_GCM_RESOURCE_dyn_vertexbuffer, 0, RenderManager.allocIOMem(dyn_vert_size, 128), dyn_vert_size); + +// Whew! Now that the GDraw memory configuration is set up, we need to initialize +// GDraw. But first, we need to allocate yet another block of video memory for +// GDraw to store its shaders etc. in (this is the last alloc!). Unlike the +// rest of the memory configuration, the work area is reserved to GDraw and can't +// be freed or relocated afterwards without shutting GDraw and all attached Iggys +// down completely. But it's fairly small (64k as of this writing) so this shouldn't +// be much of a problem. + void *gdraw_work_mem = RenderManager.allocVRAM(GDRAW_GCM_LOCAL_WORKMEM_SIZE, 128); + + /* Finally, we can actually create the GDraw GCM driver and pass it to Iggy. */ + gdraw_funcs = gdraw_GCM_CreateContext( + gCellGcmCurrentContext, // The default GCM context provided by libgcm. + gdraw_work_mem, // The work area in local memory + 64); // RSX Label index to use for fences + IggySetGDraw(gdraw_funcs); + + // Initialize audio + // TODO: 4J Stu - Currently Iggy crashes if I have audio enabled. Disabling for now. + //IggyAudioUseDefault(); + + // Shared init + postInit(); +#endif +} + +void ConsoleUIController::render() +{ +#ifdef _ENABLEIGGY +// We need to tell GDraw which surface to render to. +// This tutorial just uses the backbuffer, but for in-game +// UI usage, you might want to use another rendertarget (like +// a texture) instead. + gdraw_GCM_SetTileOrigin(RenderManager.getCurrentBackBufferSurface(), 0, 0); + renderScenes(); + +// Finally we're ready to display the frame. First we +// call GDraw to let it know we're done rendering, so +// it can do any finalization it needs to do. Then we +// initiate the GCM buffer-flip procedure. + gdraw_GCM_NoMoreGDrawThisFrame(); +#endif +} + +CustomDrawData *ConsoleUIController::setupCustomDraw(UIScene *scene, IggyCustomDrawCallbackRegion *region) +{ + CustomDrawData *customDrawRegion = new CustomDrawData(); + customDrawRegion->x0 = region->x0; + customDrawRegion->x1 = region->x1; + customDrawRegion->y0 = region->y0; + customDrawRegion->y1 = region->y1; + + // get the correct object-to-world matrix from GDraw, and set the render state to a normal state + gdraw_GCM_BeginCustomDraw(region, customDrawRegion->mat); + + setupCustomDrawGameStateAndMatrices(scene, customDrawRegion); + + return customDrawRegion; +} + +CustomDrawData *ConsoleUIController::calculateCustomDraw(IggyCustomDrawCallbackRegion *region) +{ + CustomDrawData *customDrawRegion = new CustomDrawData(); + customDrawRegion->x0 = region->x0; + customDrawRegion->x1 = region->x1; + customDrawRegion->y0 = region->y0; + customDrawRegion->y1 = region->y1; + + gdraw_GCM_CalculateCustomDraw_4J(region, customDrawRegion->mat); + + return customDrawRegion; +} + +void ConsoleUIController::endCustomDraw(IggyCustomDrawCallbackRegion *region) +{ + endCustomDrawGameStateAndMatrices(); + + gdraw_GCM_EndCustomDraw(region); +} + +void ConsoleUIController::setTileOrigin(S32 xPos, S32 yPos) +{ + gdraw_GCM_SetTileOrigin(RenderManager.getCurrentBackBufferSurface(), xPos, yPos); +} + +GDrawTexture *ConsoleUIController::getSubstitutionTexture(int textureId) +{ + /* Create a wrapped texture from a shader resource view. + A wrapped texture can be used to let Iggy draw using the contents of a texture + you create and manage on your own. For example, you might render to this texture, + or stream video into it. Wrapped textures take up a handle. They will never be + freed or otherwise modified by GDraw; nor will GDraw change any reference counts. + All this is up to the application. */ + CellGcmTexture *tex = RenderManager.TextureGetTexture(textureId); + GDrawTexture *gdrawTex = gdraw_GCM_WrappedTextureCreate(tex); + return gdrawTex; +} + +void ConsoleUIController::destroySubstitutionTexture(void *destroyCallBackData, GDrawTexture *handle) +{ + /* Destroys the GDraw wrapper for a wrapped texture object. This will free up + a GDraw texture handle but not release the associated D3D texture; that is + up to you. */ + gdraw_GCM_WrappedTextureDestroy(handle); +} + +void ConsoleUIController::shutdown() +{ +#ifdef _ENABLEIGGY + /* Destroy the GDraw context. This frees all resources, shaders etc. + allocated by GDraw. Note this is only safe to call after all + active Iggy player have been destroyed! */ + gdraw_GCM_DestroyContext(); +#endif +} + +void ConsoleUIController::beginIggyCustomDraw4J(IggyCustomDrawCallbackRegion *region, CustomDrawData *customDrawRegion) +{ + PIXBeginNamedEvent(0,"Starting Iggy custom draw\n"); + + PIXBeginNamedEvent(0,"Gdraw setup"); + // get the correct object-to-world matrix from GDraw, and set the render state to a normal state + gdraw_GCM_BeginCustomDraw(region, customDrawRegion->mat); + PIXEndNamedEvent(); +} + + +void ConsoleUIController::handleUnlockFullVersionCallback() +{ + for(unsigned int i = 0; i < eUIGroup_COUNT; ++i) + { + ui.m_groups[i]->handleUnlockFullVersion(); + } +} + -- cgit v1.2.3