int
initScreen (void *host_addr, u32 size)
{
// gcmContextData *context = NULL; /* Context to keep track of the RSX
// buffer. */
videoState state;
videoConfiguration vconfig;
videoResolution res; /* Screen Resolution */
/* Initilise Reality, which sets up the command buffer and shared IO memory */
context = rsxInit (CB_SIZE, size, host_addr);
if (context == NULL)
goto error;
/* Get the state of the display */
if (videoGetState (0, 0, &state) != 0)
goto error;
/* Make sure display is enabled */
if (state.state != 0)
goto error;
/* Get the current resolution */
if (videoGetResolution (state.displayMode.resolution, &res) != 0)
goto error;
/* Configure the buffer format to xRGB */
memset (&vconfig, 0, sizeof (videoConfiguration));
vconfig.resolution = state.displayMode.resolution;
vconfig.format = VIDEO_BUFFER_FORMAT_XRGB;
vconfig.pitch = res.width * sizeof (u32);
vconfig.aspect = state.displayMode.aspect;
waitRSXIdle (context);
if (videoConfigure (0, &vconfig, NULL, 0) != 0)
goto error;
if (videoGetState (0, 0, &state) != 0)
goto error;
gcmSetFlipMode (GCM_FLIP_VSYNC); // Wait for VSYNC to flip
depth_pitch = res.width * sizeof (u32);
depth_buffer = (u32 *) rsxMemalign (64, (res.height * depth_pitch) * 2);
rsxAddressToOffset (depth_buffer, &depth_offset);
gcmResetFlipStatus ();
return 0;
error:
if (context)
rsxFinish (context, 0);
if (host_addr)
free (host_addr);
return 1;
}
void initializeGPU( SDL_DeviceData * devdata)
{
printf("initializeGPU()\n");
// Allocate a 1Mb buffer, alligned to a 1Mb boundary to be our shared IO memory with the RSX.
void *host_addr = memalign(1024*1024, 1024*1024);
assert(host_addr != NULL);
// Initilise Reality, which sets up the command buffer and shared IO memory
devdata->_CommandBuffer = rsxInit(0x10000, 1024*1024, host_addr);
assert(devdata->_CommandBuffer != NULL);
}
/* Initilize everything. */
void init_screen(displayData *vdat) {
int i;
/* Allocate a 1Mb buffer, alligned to a 1Mb boundary to be our shared IO memory with the RSX. */
void *host_addr = memalign(1024*1024, 1024*1024);
assert(host_addr != NULL);
/* Initilise libRSX, which sets up the command buffer and shared IO memory */
vdat->context = rsxInit(0x10000, 1024*1024, host_addr);
assert(vdat->context != NULL);
videoState state;
s32 status = videoGetState(0, 0, &state); // Get the state of the display
assert(status == 0);
assert(state.state == 0); // Make sure display is enabled
/* Get the current resolution */
status = videoGetResolution(state.displayMode.resolution, &vdat->res);
assert(status == 0);
/* Configure the buffer format to xRGB */
videoConfiguration vconfig;
memset(&vconfig, 0, sizeof(videoConfiguration));
vconfig.resolution = state.displayMode.resolution;
vconfig.format = VIDEO_BUFFER_FORMAT_XRGB;
vconfig.pitch = vdat->res.width * 4;
vconfig.aspect=state.displayMode.aspect;
status = videoConfigure(0, &vconfig, NULL, 0);
assert(status == 0);
status = videoGetState(0, 0, &state);
assert(status == 0);
gcmSetFlipMode(GCM_FLIP_VSYNC); /* Wait for VSYNC to flip */
/* Allocate and setup two buffers for the RSX to draw to the screen (double buffering) */
vdat->pitch = vdat->res.width*sizeof(u32);
for (i=0; i<2; ++i) {
vdat->buffer[i] = (u32*)rsxMemalign(64,vdat->res.width*vdat->pitch);
assert(vdat->buffer[i] != NULL);
status = rsxAddressToOffset(vdat->buffer[i], &vdat->offset[i]);
assert(status==0);
status = gcmSetDisplayBuffer(i, vdat->offset[i], vdat->pitch, vdat->res.width, vdat->res.height);
assert(status==0);
}
gcmResetFlipStatus();
vdat->curr_fb = 0;
vdat->framecnt = 0;
flip(vdat);
}
void init_screen(void *host_addr,u32 size)
{
printf("initializing screen....\n");
context = rsxInit(CB_SIZE,size,host_addr);
videoState state;
videoGetState(0,0,&state);
videoGetResolution(state.displayMode.resolution,&res);
videoConfiguration vconfig;
memset(&vconfig,0,sizeof(videoConfiguration));
vconfig.resolution = state.displayMode.resolution;
vconfig.format = VIDEO_BUFFER_FORMAT_XRGB;
vconfig.pitch = res.width*sizeof(u32);
waitRSXIdle();
videoConfigure(0,&vconfig,NULL,0);
videoGetState(0,0,&state);
gcmSetFlipMode(GCM_FLIP_VSYNC);
display_width = res.width;
display_height = res.height;
color_pitch = display_width*sizeof(u32);
color_buffer[0] = (u32*)rsxMemalign(64,(display_height*color_pitch));
color_buffer[1] = (u32*)rsxMemalign(64,(display_height*color_pitch));
rsxAddressToOffset(color_buffer[0],&color_offset[0]);
rsxAddressToOffset(color_buffer[1],&color_offset[1]);
gcmSetDisplayBuffer(0,color_offset[0],color_pitch,display_width,display_height);
gcmSetDisplayBuffer(1,color_offset[1],color_pitch,display_width,display_height);
depth_pitch = display_width*sizeof(u32);
depth_buffer = (u32*)rsxMemalign(64,(display_height*depth_pitch)*2);
rsxAddressToOffset(depth_buffer,&depth_offset);
printf("screen initialized....\n");
}
struct sw_winsys *
psl1ght_create_sw_winsys(gcmContextData *ctx)
{
struct psl1ght_sw_winsys *psl1ght;
if (ctx == NULL) {
void *host_addr = memalign (1024*1024, HOST_SIZE);
if (host_addr == NULL)
return NULL;
ctx = rsxInit(CB_SIZE, HOST_SIZE, host_addr);
if (ctx == NULL)
return NULL;
}
if (!rsxHeapInit())
return NULL;
gcmSetFlipMode (GCM_FLIP_VSYNC); // Wait for VSYNC to flip
psl1ght = CALLOC_STRUCT(psl1ght_sw_winsys);
if (!psl1ght)
return NULL;
psl1ght->ctx = ctx;
psl1ght->base.destroy = psl1ght_destroy;
psl1ght->base.is_displaytarget_format_supported =
psl1ght_is_displaytarget_format_supported;
psl1ght->base.displaytarget_create = psl1ght_displaytarget_create;
psl1ght->base.displaytarget_destroy = psl1ght_displaytarget_destroy;
psl1ght->base.displaytarget_map = psl1ght_displaytarget_map;
psl1ght->base.displaytarget_unmap = psl1ght_displaytarget_unmap;
psl1ght->base.displaytarget_display = psl1ght_displaytarget_display;
return &psl1ght->base;
}
// Initilize and rsx
void init_screen(int command_buffer, int z_method) {
// Allocate a 1Mb buffer, alligned to a 1Mb boundary to be our shared IO memory with the RSX.
void *host_addr = memalign(1024*1024, command_buffer);
assert(host_addr != NULL);
if(z_method) zformat = REALITY_TARGET_FORMAT_ZETA_Z24S8; else zformat = REALITY_TARGET_FORMAT_ZETA_Z16;
// Initilise Reality, which sets up the command buffer and shared IO memory
context = rsxInit(0x10000, command_buffer, host_addr);
assert(context != NULL);
videoState state;
assert(videoGetState(0, 0, &state) == 0); // Get the state of the display
assert(state.state == 0); // Make sure display is enabled
// Get the current resolution
assert(videoGetResolution(state.displayMode.resolution, &Video_Resolution) == 0);
Video_pitch = 4 * ((Video_Resolution.width + 15)/16) * 16; // each pixel is 4 bytes
if(!z_method)
// 16 bit float. Note it uses 1920 as minimun because i thinking to use buffer Z with setupRenderTarget2() with one surface > screen
depth_pitch = 2 * ((Video_Resolution.width > 1920) ? (((Video_Resolution.width+31)/32)*32) : 1920);
else
// 32 bit float. Note it uses 1920 as minimun because i thinking to use buffer Z with setupRenderTarget2() with one surface > screen
depth_pitch = 4 * ((Video_Resolution.width > 1920) ? (((Video_Resolution.width+15)/16)*16) : 1920);
// Configure the buffer format to xRGB
videoConfiguration vconfig;
memset(&vconfig, 0, sizeof(videoConfiguration));
vconfig.resolution = state.displayMode.resolution;
vconfig.format = VIDEO_BUFFER_FORMAT_XRGB;
vconfig.pitch = Video_pitch;
Video_aspect=vconfig.aspect=state.displayMode.aspect;
assert(videoConfigure(0, &vconfig, NULL, 0) == 0);
assert(videoGetState(0, 0, &state) == 0);
s32 buffer_size = Video_pitch * Video_Resolution.height;
s32 depth_buffer_size;
if(!z_method)
// 16 bit float. Note it uses 1088 as minimun because i thinking to use buffer Z with setupRenderTarget2() with one surface > screen
depth_buffer_size = depth_pitch * ((Video_Resolution.height > 1088) ? (((Video_Resolution.height+31)/32)*32) : 1088);
else
// 32 bit float. Note it uses 1920 as minimun because i thinking to use buffer Z with setupRenderTarget2() with one surface > screen
depth_buffer_size = depth_pitch * ((Video_Resolution.height > 1088) ? (((Video_Resolution.height+15)/16)*16) : 1088);
printf("buffers will be 0x%x bytes\n", buffer_size);
gcmSetFlipMode(GCM_FLIP_VSYNC); // Wait for VSYNC to flip
// Allocate two buffers for the RSX to draw to the screen (double buffering)
Video_buffer[0] = rsxMemalign(64, buffer_size);
Video_buffer[1] = rsxMemalign(64, buffer_size);
assert(Video_buffer[0] != NULL && Video_buffer[1] != NULL);
depth_buffer = rsxMemalign(64, depth_buffer_size);
assert(rsxAddressToOffset(Video_buffer[0], &offset[0]) == 0);
assert(rsxAddressToOffset(Video_buffer[1], &offset[1]) == 0);
// Setup the display buffers
assert(gcmSetDisplayBuffer(0, offset[0], Video_pitch, Video_Resolution.width, Video_Resolution.height) == 0);
assert(gcmSetDisplayBuffer(1, offset[1], Video_pitch, Video_Resolution.width, Video_Resolution.height) == 0);
assert(rsxAddressToOffset(depth_buffer, &depth_offset) == 0);
gcmResetFlipStatus();
flip(1);
waitFlip();
}
