1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
|
#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();
}
}
|
