Something went wrong. Try again.
the game where you go into mines and start crafting! but for consoles (forked directly from smartcmd's github)
Something went wrong. Try again.
7.5 kB · 199 lines
C++
at main
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200#include "stdafx.h"#include "PS3_UIController.h"#include "Common/UI/UIController.h"#include <cell/gcm.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 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(); }}