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(); }