s32 main(s32 argc, const char* argv[])
{
atexit(appCleanup);
deadrsx_init();
ioPadInit(7);
sysRegisterCallback(EVENT_SLOT0, eventHandle, NULL);
u32 *frag_mem = rsxMemAlign(256, 256);
printf("frag_mem = 0x%08lx\n", (u64) frag_mem);
realityInstallFragmentProgram_old(context, &nv30_fp, frag_mem);
loading(); // where all the loading done xD
long frame = 0;
while(1){
ps3_pad(); // where all are controls are
waitFlip(); // Wait for the last flip to finish, so we can draw to the old buffer
drawFrame(currentBuffer, frame++); // Draw into the unused buffer
flip(currentBuffer); // Flip buffer onto screen
currentBuffer = !currentBuffer;
sysCheckCallback();
}
return 0;
}
// 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);
}
// Load a png from ram
// I can't be bothered handling errors correctly, lets just abort
Image loadPng(const uint8_t *png) {
// Make sure we have a valid png here.
assert(png_sig_cmp((png_bytep) png, 0, 8) == 0);
// get PNG file info struct
png_structp png_ptr = NULL;
png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
assert(png_ptr != NULL);
// get PNG image data info struct
png_infop info_ptr = NULL;
info_ptr = png_create_info_struct(png_ptr);
assert(info_ptr != NULL);
png_set_read_fn(png_ptr, (png_bytep) png, ReadDataFromMemory);
// seek to start of png.
seek = NULL;
png_read_info(png_ptr, info_ptr);
png_uint_32 width = 0;
png_uint_32 height = 0;
int bitDepth = 0;
int colorType = -1;
assert(png_get_IHDR(png_ptr, info_ptr,
&width,
&height,
&bitDepth,
&colorType,
NULL, NULL, NULL) == 1);
Image image;
image.data = rsxMemAlign(16, 2*1024*1024);
image.width = width;
image.height = height;
switch(colorType) {
case PNG_COLOR_TYPE_RGB:
parseRGB(image.data, width, height, png_ptr, info_ptr);
break;
case PNG_COLOR_TYPE_RGBA:
parseRGBA(image.data, width, height, png_ptr, info_ptr);
break;
default:
printf("Unsupported png type\n");
abort();
}
png_destroy_read_struct(&png_ptr, &info_ptr, NULL);
return image;
}
void makeBuffer(int id, int size) {
buffer *buf = malloc(sizeof(buffer));
buf->ptr = rsxMemAlign(16, size);
assert(buf->ptr != NULL);
assert(realityAddressToOffset(buf->ptr, &buf->offset) == 0);
// Register the display buffer with the RSX
assert(gcmSetDisplayBuffer(id, buf->offset, res.width * 4, res.width, res.height) == 0);
buf->width = res.width;
buf->height = res.height;
buffers[id] = buf;
}
s32 main(s32 argc, const char* argv[])
{
PadInfo padinfo;
PadData paddata;
int i;
atexit(appCleanup);
init_screen();
ioPadInit(7);
sysRegisterCallback(EVENT_SLOT0, eventHandle, NULL);
// Load texture
dice = loadPng(dice_bin);
assert(realityAddressToOffset(dice.data, &tx_offset) == 0);
//load_acid_texture((uint8_t *)tx_mem, 0);
// install fragment shader in rsx memory
u32 *frag_mem = rsxMemAlign(256, 256);
printf("frag_mem = 0x%08lx\n", (u64) frag_mem);
realityInstallFragmentProgram_old(context, &nv30_fp, frag_mem);
long frame = 0; // To keep track of how many frames we have rendered.
// Ok, everything is setup. Now for the main loop.
while(1){
// Check the pads.
ioPadGetInfo(&padinfo);
for(i=0; i<MAX_PADS; i++){
if(padinfo.status[i]){
ioPadGetData(i, &paddata);
if(paddata.BTN_CROSS || paddata.BTN_START){
return 0;
}
}
}
waitFlip(); // Wait for the last flip to finish, so we can draw to the old buffer
drawFrame(currentBuffer, frame++); // Draw into the unused buffer
flip(currentBuffer); // Flip buffer onto screen
currentBuffer = !currentBuffer;
sysCheckCallback();
}
return 0;
}
// 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();
}