void init_screen()
{
void *host_addr = memalign(1024 * 1024, 1024 * 1024);
assert(host_addr != NULL);
context = realityInit(0x10000, 1024 * 1024, host_addr);
assert(context != NULL);
assert(videoGetState(0, 0, &state) == 0);
assert(state.state == 0);
assert(videoGetResolution(state.displayMode.resolution, &res) == 0);
memset(&vconfig, 0, sizeof(VideoConfiguration));
vconfig.resolution = state.displayMode.resolution;
vconfig.format = VIDEO_BUFFER_FORMAT_XRGB;
vconfig.pitch = res.width * 4;
assert(videoConfigure(0, &vconfig, NULL, 0) == 0);
assert(videoGetState(0, 0, &state) == 0);
s32 buffer_size = 4 * res.width * res.height;
gcmSetFlipMode(GCM_FLIP_VSYNC);
makeBuffer(0, buffer_size);
makeBuffer(1, buffer_size);
gcmResetFlipStatus();
flip(1);
}
// Initilize everything. You can probally skip over this function.
void init_screen() {
// 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
context = realityInit(0x10000, 1024*1024, 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, &res) == 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 = res.width * 4;
vconfig.aspect=state.displayMode.aspect;
assert(videoConfigure(0, &vconfig, NULL, 0) == 0);
assert(videoGetState(0, 0, &state) == 0);
s32 buffer_size = 4 * res.width * res.height; // each pixel is 4 bytes
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)
buffer[0] = rsxMemAlign(16, buffer_size);
buffer[1] = rsxMemAlign(16, buffer_size);
assert(buffer[0] != NULL && buffer[1] != NULL);
u32 offset[2];
assert(realityAddressToOffset(buffer[0], &offset[0]) == 0);
assert(realityAddressToOffset(buffer[1], &offset[1]) == 0);
// Setup the display buffers
assert(gcmSetDisplayBuffer(0, offset[0], res.width * 4, res.width, res.height) == 0);
assert(gcmSetDisplayBuffer(1, offset[1], res.width * 4, res.width, res.height) == 0);
gcmResetFlipStatus();
flip(1);
}
// 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 = realityInit(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(realityAddressToOffset(Video_buffer[0], &offset[0]) == 0);
assert(realityAddressToOffset(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(realityAddressToOffset(depth_buffer, &depth_offset) == 0);
gcmResetFlipStatus();
flip(1);
waitFlip();
}
static void
init_screen(glw_ps3_t *gp)
{
// 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
gp->gr.gr_be.be_ctx = realityInit(0x10000, 1024*1024, host_addr);
assert(gp->gr.gr_be.be_ctx != NULL);
gcmConfiguration config;
gcmGetConfiguration(&config);
TRACE(TRACE_INFO, "RSX", "memory @ 0x%x size = %d\n",
config.localAddress, config.localSize);
hts_mutex_init(&gp->gr.gr_be.be_mempool_lock);
gp->gr.gr_be.be_mempool = extent_create(0, config.localSize >> 4);
gp->gr.gr_be.be_rsx_address = (void *)(uint64_t)config.localAddress;
VideoState state;
videoGetState(0, 0, &state);
// Get the current resolution
videoGetResolution(state.displayMode.resolution, &gp->res);
int num = gp->res.width;
int den = gp->res.height;
switch(state.displayMode.aspect) {
case VIDEO_ASPECT_4_3:
num = 4; den = 3;
break;
case VIDEO_ASPECT_16_9:
num = 16; den = 9;
break;
}
gp->scale = (float)(num * gp->res.height) / (float)(den * gp->res.width);
TRACE(TRACE_INFO, "RSX",
"Video resolution %d x %d aspect=%d, pixel wscale=%f",
gp->res.width, gp->res.height, state.displayMode.aspect, gp->scale);
gp->framebuffer_pitch = 4 * gp->res.width; // each pixel is 4 bytes
gp->depthbuffer_pitch = 4 * gp->res.width; // And each value in the depth buffer is a 16 bit float
// 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 = gp->framebuffer_pitch;
videoConfigure(0, &vconfig, NULL, 0);
videoGetState(0, 0, &state);
const s32 buffer_size = gp->framebuffer_pitch * gp->res.height;
const s32 depth_buffer_size = gp->depthbuffer_pitch * gp->res.height;
TRACE(TRACE_INFO, "RSX", "Buffer will be %d bytes", buffer_size);
gcmSetFlipMode(GCM_FLIP_VSYNC); // Wait for VSYNC to flip
// Allocate two buffers for the RSX to draw to the screen (double buffering)
gp->framebuffer[0] = rsx_alloc(&gp->gr, buffer_size, 16);
gp->framebuffer[1] = rsx_alloc(&gp->gr, buffer_size, 16);
TRACE(TRACE_INFO, "RSX", "Buffers at 0x%x 0x%x\n",
gp->framebuffer[0], gp->framebuffer[1]);
gp->depthbuffer = rsx_alloc(&gp->gr, depth_buffer_size * 4, 16);
// Setup the display buffers
gcmSetDisplayBuffer(0, gp->framebuffer[0],
gp->framebuffer_pitch, gp->res.width, gp->res.height);
gcmSetDisplayBuffer(1, gp->framebuffer[1],
gp->framebuffer_pitch, gp->res.width, gp->res.height);
gcmResetFlipStatus();
flip(gp, 1);
}
