From b691c43c44ff180d10e7d4a9afc83b98551ff586 Mon Sep 17 00:00:00 2001 From: daoge_cmd <3523206925@qq.com> Date: Sun, 1 Mar 2026 12:16:08 +0800 Subject: Initial commit --- Minecraft.Client/Orbis/Orbis_UIController.cpp | 284 ++++++++++++++++++++++++++ 1 file changed, 284 insertions(+) create mode 100644 Minecraft.Client/Orbis/Orbis_UIController.cpp (limited to 'Minecraft.Client/Orbis/Orbis_UIController.cpp') diff --git a/Minecraft.Client/Orbis/Orbis_UIController.cpp b/Minecraft.Client/Orbis/Orbis_UIController.cpp new file mode 100644 index 00000000..38cc79e9 --- /dev/null +++ b/Minecraft.Client/Orbis/Orbis_UIController.cpp @@ -0,0 +1,284 @@ +#include "stdafx.h" +#include "Orbis_UIController.h" + +// 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 on the target platform. + We're using the GNM GDraw implementation that's included with + the Iggy SDK. To get it set up, we need to provide it with + memory for the different resource type. GDraw needs memory + for render targets (color buffers), textures, and vertex buffers. + There's also command buffers and the staging buffer; we'll get to + them later. + + We recommend that all resource pools be allocated in Garlic memory + for performance reasons. + + Note that render target memory is really only used while Iggy is + rendering; you can share the memory space with other resources that + aren't in use while Iggy is rendering - for example, post-processing + render targets or shadow maps. + + The texture and vertex buffer pools contain multiple textures and + vertex buffers. Each object requires a bit of main memory for management + overhead. We need to specify how many object handles can be in use at + the same time in any given pool. If Iggy runs out of GDraw handles, it + won't crash, but instead throw out old cache data in a LRU fashion. + If the number of handles is too small, this will happen frequently, and + textures will need to decoded multiple times (or vertex buffers re-generated + multiple times), which causes a performance hit. */ + + // Size of the various memory pools. All these values are intentionally + // picked to be way larger than necessary for typical Flash files. + S32 rt_mem_size = 32*1024*1024; // Render target space + S32 tex_mem_size = 30*1024*1024; // Texture pool + S32 vert_mem_size = 2*1024*1024; // Vertex buffer pool + + S32 tex_handles = 200; + S32 vert_handles = 1000; + + /* SetResourceMemory is the call that actually sets up the location and size + of a resource pool. */ + gdraw_orbis_SetResourceMemory(GDRAW_ORBIS_RESOURCE_rendertarget, // Pool type + 0, // Number of handles (unused for render targets) + RenderManager.MemoryAllocateGPUMem(GDRAW_ORBIS_TEXTURE_ALIGNMENT,rt_mem_size), // Pointer + rt_mem_size); // Size + gdraw_orbis_SetResourceMemory(GDRAW_ORBIS_RESOURCE_texture, tex_handles, + RenderManager.MemoryAllocateGPUMem(GDRAW_ORBIS_TEXTURE_ALIGNMENT,tex_mem_size), tex_mem_size); + gdraw_orbis_SetResourceMemory(GDRAW_ORBIS_RESOURCE_vertexbuffer, vert_handles, + RenderManager.MemoryAllocateGPUMem(GDRAW_ORBIS_VERTEXBUFFER_ALIGNMENT,vert_mem_size), vert_mem_size); + + /* There's one more resource-related buffer we need to allocate: the staging + buffer. The staging buffer is used as a staging area for texture and vertex + buffer uploads. GDraw doesn't write such data directly to resource memory + from the CPU because doing so would require us to synchronize GPU and CPU such + that the CPU never accesses memory that the GPU might currently be using. This + wastes both CPU and GPU time, and makes it very hard to record command buffers + (GfxContexts) early in the frame and then kick them off later. + + Instead, GDraw writes all data to the staging buffer, and lets the GPU copy it + from the there to its final location. While this costs more memory, it avoids + all need for fine-grained CPU/GPU synchronization and makes it easy to, say, + have Iggy rendering happen on a second thread. + + The staging buffer is also where per-frame dynamic vertex data and dynamic + textures (which in the case of Iggy means animated gradients) get allocated + from. The right way to think of the staging buffer is just as an extra block + of memory associated with the Iggy command buffer: if you always use the same + command buffer for Iggy rendering, you only need one staging buffer, if you + double-buffer commands, you need to use the same scheme for the staging buffer, + and so forth. Since this example uses only one GfxContext, we also use a single + staging buffer. + + It's not immediately obvious how big the staging buffer should be; this example + sizes it so it's big enough to replace all resource pools every frame. This keeps + things simple but is excessive in practice. $gdraw_orbis_End can report back how + much of the staging buffer was used every frame, so you can use this as a guideline + to size it appropriately. If the staging buffer is too small, Iggy will issue a + warning, and some textures or shapes might pop in a frame late (because they + couldn't be uploaded in time). + */ + staging_buf_size = 12 * 1024 * 1024; // This value determined by experimentation - was (with original comment): tex_mem_size + vert_mem_size; // This is very generous! + staging_buf[0] = RenderManager.MemoryAllocateCPUMem(Gnm::kAlignmentOfBufferInBytes,staging_buf_size); + staging_buf[1] = RenderManager.MemoryAllocateCPUMem(Gnm::kAlignmentOfBufferInBytes,staging_buf_size); + currentStagingBuf = 0; + + /* 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. 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. It should + be allocated in Garlic memory. */ + void *gdraw_context_mem = RenderManager.MemoryAllocateGPUMem(1,GDRAW_ORBIS_CONTEXT_MEM_SIZE); + + /* Finally, we can actually create the GDraw GNM driver and pass it to Iggy. */ + gdraw_funcs = gdraw_orbis_CreateContext( + w, + h, + gdraw_context_mem); + IggySetGDraw(gdraw_funcs); + + /* Flash content can have audio embedded. We'd like to be able + to play back any audio there is in the Flash that we load, + but in this tutorial we don't care about processing the sound + ourselves. So we call $IggyAudioUseDefault to tell Iggy + to go ahead and use the default sound driver. */ + //IggyAudioUseDefault(); + + // Shared init + postInit(); +#endif +} + +void ConsoleUIController::render() +{ +#ifdef _ENABLEIGGY + /* Tell GDraw which command buffer and staging buffer to use + for rendering. GDraw can either render to its own command + buffer or resume writing to a GfxContext you're already + using. In this example, we render only Iggy content, so + we have the command buffer to ourselves. Between this + call and $gdraw_orbis_End, you are not allowed to write + to the command buffer ("gfxc" in this case). */ + gdraw_orbis_Begin(RenderManager.GetCurrentBackBufferContext(), staging_buf[currentStagingBuf], staging_buf_size); + currentStagingBuf ^= 1; + + /* We need to tell GDraw which surface to render to. + This tutorial just uses our main color and depth buffers, + but for in-game UI usage, you might want to use another + render target (like a texture) instead. */ + gdraw_orbis_SetTileOrigin(RenderManager.GetCurrentBackBufferTarget(), RenderManager.GetCurrentBackBufferDepthTarget(), 0, 0); + + renderScenes(); + + /* That's it for this frame, so tell GDraw we're done rendering. + This function can optionally return $gdraw_orbis_staging_stats + to track staging buffer usage, which is useful information to + size the buffer appropriately. In this example though, we + don't bother. + + After this call, you may resume writing to the command buffer + passed to $gdraw_orbis_Begin ("gfxc" in this example). */ + +#if 0 + gdraw_orbis_staging_stats stagingStats; + gdraw_orbis_End(&stagingStats); + + static int throttle = 0; + static int maxAttempted = 0; + static int maxSucceeded = 0; + + if( stagingStats.bytes_attempted > maxAttempted ) maxAttempted = stagingStats.bytes_attempted; + if( stagingStats.bytes_succeeded > maxSucceeded ) maxSucceeded = stagingStats.bytes_succeeded; + + if( ( throttle & 400 ) == 0 ) + { + app.DebugPrintf("\nIGGY END DRAW\n"); + app.DebugPrintf(" - allocs_attempted = %d\n", stagingStats.allocs_attempted); // number of allocations attempted from the staging buffer + app.DebugPrintf(" - allocs_succeeded = %d\n", stagingStats.allocs_succeeded);// number of allocations that succeeded + app.DebugPrintf(" - bytes_attempted = %d\n", stagingStats.bytes_attempted);// number of bytes attempted to allocate + app.DebugPrintf(" - bytes_succeeded = %d\n", stagingStats.bytes_succeeded);// number of bytes successfully allocated + app.DebugPrintf(" - max bytes_attempted = %d\n", maxAttempted); + app.DebugPrintf(" - max bytes_succeeded = %d\n", maxSucceeded); + app.DebugPrintf(" - largest_bytes_attempted = %d\n", stagingStats.largest_bytes_attempted);// number of bytes in largest attempted alloc + app.DebugPrintf(" - largest_bytes_succeeded = %d\n", stagingStats.largest_bytes_succeeded);// number of bytes in lagrest successful allo + app.DebugPrintf("\n\n"); + } + throttle++; + +#else + gdraw_orbis_End(NULL); +#endif + +#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_orbis_BeginCustomDraw(region, customDrawRegion->mat); + PIXEndNamedEvent(); +} + +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_orbis_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_orbis_CalculateCustomDraw_4J(region, customDrawRegion->mat); + + return customDrawRegion; +} + +void ConsoleUIController::endCustomDraw(IggyCustomDrawCallbackRegion *region) +{ + endCustomDrawGameStateAndMatrices(); + + gdraw_orbis_EndCustomDraw(region); +} + +void ConsoleUIController::setTileOrigin(S32 xPos, S32 yPos) +{ + gdraw_orbis_SetTileOrigin(RenderManager.GetCurrentBackBufferTarget(), RenderManager.GetCurrentBackBufferDepthTarget(), 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. */ + + sce::Gnm::Texture *tex = RenderManager.TextureGetTexture(textureId); + GDrawTexture *gdrawTex = gdraw_orbis_WrappedTextureCreate(tex); + return gdrawTex; + + return NULL; +} + +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_orbis_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_orbis_DestroyContext(); +#endif +} + + +void ConsoleUIController::handleUnlockFullVersionCallback() +{ + for(unsigned int i = 0; i < eUIGroup_COUNT; ++i) + { + ui.m_groups[i]->handleUnlockFullVersion(); + } +} + -- cgit v1.2.3