/**************************************************************************** * Snes9x Nintendo Wii/Gamecube Port * * softdev July 2006 * crunchy2 May 2007 * Michniewski 2008 * Tantric 2008-2023 * * video.cpp * * Video routines ***************************************************************************/ #include #include #include #include #include #include #include #include #include "snes9xgx.h" #include "menu.h" #include "filter.h" #include "filelist.h" #include "audio.h" #include "gui/gui.h" #include "input.h" #include "snes9x/snes9x.h" #include "snes9x/memmap.h" extern void UpdatePlaybackRate(void); /*** Snes9x GFX Buffer ***/ #define SNES9XGFX_SIZE (EXT_PITCH*EXT_HEIGHT) #define FILTERMEM_SIZE (512*MAX_SNES_HEIGHT*4) static unsigned char * snes9xgfx = NULL; unsigned char * filtermem = NULL; // only want ((512*2) X (239*2)) /*** 2D Video ***/ static u32 *xfb[2] = { NULL, NULL }; // Double buffered static int whichfb = 0; // Switch GXRModeObj *vmode = NULL; // Current video mode int screenheight = 480; int screenwidth = 640; static int oldRenderMode = -1; // set to GCSettings.render when changing (temporarily) to another mode int CheckVideo = 0; // for forcing video reset /*** GX ***/ #define TEX_WIDTH 512 #define TEX_HEIGHT 512 #define TEXTUREMEM_SIZE TEX_WIDTH*(TEX_HEIGHT+8)*2 static unsigned char texturemem[TEXTUREMEM_SIZE] ATTRIBUTE_ALIGN (32); #define DEFAULT_FIFO_SIZE 256 * 1024 static unsigned int copynow = GX_FALSE; static unsigned char gp_fifo[DEFAULT_FIFO_SIZE] ATTRIBUTE_ALIGN (32); static GXTexObj texobj; static Mtx view; static Mtx GXmodelView2D; static int vwidth, vheight, oldvwidth, oldvheight; u8 * gameScreenPng = NULL; int gameScreenPngSize = 0; u32 FrameTimer = 0; bool vmode_60hz = true; int timerstyle = 0; bool progressive = 0; #define HASPECT 320 #define VASPECT 240 /* New texture based scaler */ typedef struct tagcamera { guVector pos; guVector up; guVector view; } camera; /*** Square Matrix This structure controls the size of the image on the screen. Think of the output as a -80 x 80 by -60 x 60 graph. ***/ s16 square[] ATTRIBUTE_ALIGN (32) = { /* * X, Y, Z * Values set are for roughly 4:3 aspect */ -HASPECT, VASPECT, 0, // 0 HASPECT, VASPECT, 0, // 1 HASPECT, -VASPECT, 0, // 2 -HASPECT, -VASPECT, 0 // 3 }; static camera cam = { {0.0F, 0.0F, 0.0F}, {0.0F, 0.5F, 0.0F}, {0.0F, 0.0F, -0.5F} }; /*** Custom Video modes (used to emulate original console video modes) ***/ /** Original SNES PAL Resolutions: **/ /* 239 lines progressive (PAL 50Hz) */ static GXRModeObj TV_239p = { VI_TVMODE_PAL_DS, // viDisplayMode 512, // fbWidth 239, // efbHeight 239, // xfbHeight (VI_MAX_WIDTH_PAL - 644)/2, // viXOrigin (VI_MAX_HEIGHT_PAL/2 - 478/2)/2, // viYOrigin 644, // viWidth 478, // viHeight VI_XFBMODE_SF, // xFBmode GX_FALSE, // field_rendering GX_FALSE, // aa // sample points arranged in increasing Y order { {6,6},{6,6},{6,6}, // pix 0, 3 sample points, 1/12 units, 4 bits each {6,6},{6,6},{6,6}, // pix 1 {6,6},{6,6},{6,6}, // pix 2 {6,6},{6,6},{6,6} // pix 3 }, // vertical filter[7], 1/64 units, 6 bits each { 0, // line n-1 0, // line n-1 21, // line n 22, // line n 21, // line n 0, // line n+1 0 // line n+1 } }; /* 478 lines interlaced (PAL 50Hz, Deflicker) */ static GXRModeObj TV_478i = { VI_TVMODE_PAL_INT, // viDisplayMode 512, // fbWidth 478, // efbHeight 478, // xfbHeight (VI_MAX_WIDTH_PAL - 644)/2, // viXOrigin (VI_MAX_HEIGHT_PAL - 478)/2, // viYOrigin 644, // viWidth 478, // viHeight VI_XFBMODE_DF, // xFBmode GX_FALSE, // field_rendering GX_FALSE, // aa // sample points arranged in increasing Y order { {6,6},{6,6},{6,6}, // pix 0, 3 sample points, 1/12 units, 4 bits each {6,6},{6,6},{6,6}, // pix 1 {6,6},{6,6},{6,6}, // pix 2 {6,6},{6,6},{6,6} // pix 3 }, // vertical filter[7], 1/64 units, 6 bits each { 8, // line n-1 8, // line n-1 10, // line n 12, // line n 10, // line n 8, // line n+1 8 // line n+1 } }; /** Original SNES NTSC Resolutions: **/ /* 224 lines progressive (NTSC or PAL 60Hz) */ static GXRModeObj TV_224p = { VI_TVMODE_EURGB60_DS, // viDisplayMode 512, // fbWidth 224, // efbHeight 224, // xfbHeight (VI_MAX_WIDTH_NTSC - 644)/2, // viXOrigin (VI_MAX_HEIGHT_NTSC/2 - 448/2)/2, // viYOrigin 644, // viWidth 448, // viHeight VI_XFBMODE_SF, // xFBmode GX_FALSE, // field_rendering GX_FALSE, // aa // sample points arranged in increasing Y order { {6,6},{6,6},{6,6}, // pix 0, 3 sample points, 1/12 units, 4 bits each {6,6},{6,6},{6,6}, // pix 1 {6,6},{6,6},{6,6}, // pix 2 {6,6},{6,6},{6,6} // pix 3 }, // vertical filter[7], 1/64 units, 6 bits each { 0, // line n-1 0, // line n-1 21, // line n 22, // line n 21, // line n 0, // line n+1 0 // line n+1 } }; /* 448 lines interlaced (NTSC or PAL 60Hz, Deflicker) */ static GXRModeObj TV_448i = { VI_TVMODE_EURGB60_INT, // viDisplayMode 512, // fbWidth 448, // efbHeight 448, // xfbHeight (VI_MAX_WIDTH_NTSC - 644)/2, // viXOrigin (VI_MAX_HEIGHT_NTSC - 448)/2, // viYOrigin 644, // viWidth 448, // viHeight VI_XFBMODE_DF, // xFBmode GX_FALSE, // field_rendering GX_FALSE, // aa // sample points arranged in increasing Y order { {6,6},{6,6},{6,6}, // pix 0, 3 sample points, 1/12 units, 4 bits each {6,6},{6,6},{6,6}, // pix 1 {6,6},{6,6},{6,6}, // pix 2 {6,6},{6,6},{6,6} // pix 3 }, // vertical filter[7], 1/64 units, 6 bits each { 8, // line n-1 8, // line n-1 10, // line n 12, // line n 10, // line n 8, // line n+1 8 // line n+1 } }; static GXRModeObj TV_Custom; /* TV Modes table */ static GXRModeObj *tvmodes[4] = { &TV_239p, &TV_478i, /* SNES PAL video modes */ &TV_224p, &TV_448i, /* SNES NTSC video modes */ }; /**************************************************************************** * VideoThreading ***************************************************************************/ #define TSTACK 16384 static lwp_t vbthread = LWP_THREAD_NULL; static unsigned char vbstack[TSTACK]; /**************************************************************************** * vbgetback * * This callback enables the emulator to keep running while waiting for a * vertical blank. * * Putting LWP to good use :) ***************************************************************************/ static void * vbgetback (void *arg) { while (1) { VIDEO_WaitVSync (); /**< Wait for video vertical blank */ LWP_SuspendThread (vbthread); } return NULL; } /**************************************************************************** * copy_to_xfb * * Stock code to copy the GX buffer to the current display mode. * Also increments the frameticker, as it's called for each vb. ***************************************************************************/ static inline void copy_to_xfb (u32 arg) { if (copynow == GX_TRUE) { GX_CopyDisp (xfb[whichfb], GX_TRUE); GX_Flush (); copynow = GX_FALSE; } ++FrameTimer; } /**************************************************************************** * Scaler Support Functions ***************************************************************************/ static inline void draw_init () { GX_ClearVtxDesc (); GX_SetVtxDesc (GX_VA_POS, GX_INDEX8); GX_SetVtxDesc (GX_VA_CLR0, GX_INDEX8); GX_SetVtxDesc (GX_VA_TEX0, GX_DIRECT); GX_SetVtxAttrFmt (GX_VTXFMT0, GX_VA_POS, GX_POS_XYZ, GX_S16, 0); GX_SetVtxAttrFmt (GX_VTXFMT0, GX_VA_CLR0, GX_CLR_RGBA, GX_RGBA8, 0); GX_SetVtxAttrFmt (GX_VTXFMT0, GX_VA_TEX0, GX_TEX_ST, GX_F32, 0); GX_SetArray (GX_VA_POS, square, 3 * sizeof (s16)); GX_SetNumTexGens (1); GX_SetNumChans (0); GX_SetTexCoordGen (GX_TEXCOORD0, GX_TG_MTX2x4, GX_TG_TEX0, GX_IDENTITY); GX_SetTevOp (GX_TEVSTAGE0, GX_REPLACE); GX_SetTevOrder (GX_TEVSTAGE0, GX_TEXCOORD0, GX_TEXMAP0, GX_COLORNULL); memset (&view, 0, sizeof (Mtx)); guLookAt(view, &cam.pos, &cam.up, &cam.view); GX_LoadPosMtxImm (view, GX_PNMTX0); GX_InvVtxCache (); // update vertex cache } static inline void draw_vert (u8 pos, u8 c, f32 s, f32 t) { GX_Position1x8 (pos); GX_Color1x8 (c); GX_TexCoord2f32 (s, t); } static inline void draw_square (Mtx v) { Mtx m; // model matrix. Mtx mv; // modelview matrix. guMtxIdentity (m); guMtxTransApply (m, m, 0, 0, -100); guMtxConcat (v, m, mv); GX_LoadPosMtxImm (mv, GX_PNMTX0); GX_Begin (GX_QUADS, GX_VTXFMT0, 4); draw_vert (0, 0, 0.0, 0.0); draw_vert (1, 0, 1.0, 0.0); draw_vert (2, 0, 1.0, 1.0); draw_vert (3, 0, 0.0, 1.0); GX_End (); } /**************************************************************************** * StopGX * * Stops GX (when exiting) ***************************************************************************/ void StopGX() { GX_AbortFrame(); GX_Flush(); VIDEO_SetBlack(TRUE); VIDEO_Flush(); } /**************************************************************************** * FindVideoMode * * Finds the optimal video mode, or uses the user-specified one * Also configures original video modes ***************************************************************************/ static GXRModeObj * FindVideoMode() { GXRModeObj * mode; // choose the desired video mode switch(GCSettings.videomode) { case 1: // NTSC (480i) mode = &TVNtsc480IntDf; break; case 2: // Progressive (480p) mode = &TVNtsc480Prog; break; case 3: // PAL (50Hz) mode = &TVPal576IntDfScale; break; case 4: // PAL (60Hz) mode = &TVEurgb60Hz480IntDf; break; case 5: // Progressive (576p) mode = &TVPal576ProgScale; break; default: mode = VIDEO_GetPreferredMode(NULL); #ifdef HW_DOL /* we have component cables, but the preferred mode is interlaced * why don't we switch into progressive? * on the Wii, the user can do this themselves on their Wii Settings */ if(VIDEO_HaveComponentCable()) mode = &TVNtsc480Prog; #endif break; } // configure original modes switch (mode->viTVMode >> 2) { case VI_PAL: // 576 lines (PAL 50Hz) vmode_60hz = false; // Original Video modes (forced to PAL 50Hz) // set video signal mode TV_239p.viTVMode = VI_TVMODE_PAL_DS; TV_478i.viTVMode = VI_TVMODE_PAL_INT; TV_224p.viTVMode = VI_TVMODE_PAL_DS; TV_448i.viTVMode = VI_TVMODE_PAL_INT; // set VI position TV_239p.viYOrigin = (VI_MAX_HEIGHT_PAL/2 - 478/2)/2; TV_478i.viYOrigin = (VI_MAX_HEIGHT_PAL - 478)/2; TV_224p.viYOrigin = (VI_MAX_HEIGHT_PAL/2 - 448/2)/2; TV_448i.viYOrigin = (VI_MAX_HEIGHT_PAL - 448)/2; break; case VI_NTSC: // 480 lines (NTSC 60Hz) vmode_60hz = true; // Original Video modes (forced to NTSC 60hz) // set video signal mode TV_239p.viTVMode = VI_TVMODE_NTSC_DS; TV_478i.viTVMode = VI_TVMODE_NTSC_INT; TV_224p.viTVMode = VI_TVMODE_NTSC_DS; TV_448i.viTVMode = VI_TVMODE_NTSC_INT; // set VI position TV_239p.viYOrigin = (VI_MAX_HEIGHT_NTSC/2 - 478/2)/2; TV_478i.viYOrigin = (VI_MAX_HEIGHT_NTSC - 478)/2; TV_224p.viYOrigin = (VI_MAX_HEIGHT_NTSC/2 - 448/2)/2; TV_448i.viYOrigin = (VI_MAX_HEIGHT_NTSC - 448)/2; break; default: // 480 lines (PAL 60Hz) vmode_60hz = true; // Original Video modes (forced to PAL 60hz) // set video signal mode TV_239p.viTVMode = VI_TVMODE(mode->viTVMode >> 2, VI_NON_INTERLACE); TV_478i.viTVMode = VI_TVMODE(mode->viTVMode >> 2, VI_INTERLACE); TV_224p.viTVMode = VI_TVMODE(mode->viTVMode >> 2, VI_NON_INTERLACE); TV_448i.viTVMode = VI_TVMODE(mode->viTVMode >> 2, VI_INTERLACE); // set VI position TV_239p.viYOrigin = (VI_MAX_HEIGHT_NTSC/2 - 478/2)/2; TV_478i.viYOrigin = (VI_MAX_HEIGHT_NTSC - 478)/2; TV_224p.viYOrigin = (VI_MAX_HEIGHT_NTSC/2 - 448/2)/2; TV_448i.viYOrigin = (VI_MAX_HEIGHT_NTSC - 448)/2; break; } // check for progressive scan if (mode->viTVMode == VI_TVMODE_NTSC_PROG || VI_TVMODE_PAL_PROG) progressive = true; else progressive = false; #ifdef HW_RVL if (CONF_GetAspectRatio() == CONF_ASPECT_16_9) mode->viWidth = 678; else mode->viWidth = 672; if (vmode_60hz) { mode->viXOrigin = (VI_MAX_WIDTH_NTSC - mode->viWidth) / 2; mode->viYOrigin = (VI_MAX_HEIGHT_NTSC - mode->viHeight) / 2; } else { mode->viXOrigin = (VI_MAX_WIDTH_PAL - mode->viWidth) / 2; mode->viYOrigin = (VI_MAX_HEIGHT_PAL - mode->viHeight) / 2; } #endif return mode; } /**************************************************************************** * SetupVideoMode * * Sets up the given video mode ***************************************************************************/ static void SetupVideoMode(GXRModeObj * mode) { if(vmode == mode) return; VIDEO_SetPostRetraceCallback (NULL); copynow = GX_FALSE; VIDEO_Configure (mode); VIDEO_Flush(); // Clear framebuffers etc. VIDEO_ClearFrameBuffer (mode, xfb[0], COLOR_BLACK); VIDEO_ClearFrameBuffer (mode, xfb[1], COLOR_BLACK); VIDEO_SetNextFramebuffer (xfb[0]); VIDEO_SetBlack (FALSE); VIDEO_Flush (); VIDEO_WaitVSync (); if (mode->viTVMode & VI_NON_INTERLACE) VIDEO_WaitVSync(); else while (VIDEO_GetNextField()) VIDEO_WaitVSync(); VIDEO_SetPostRetraceCallback ((VIRetraceCallback)copy_to_xfb); vmode = mode; } /**************************************************************************** * InitGCVideo * * This function MUST be called at startup. * - also sets up menu video mode ***************************************************************************/ void InitGCVideo () { VIDEO_Init(); // Allocate the video buffers xfb[0] = (u32 *) memalign(32, 640*576*2); xfb[1] = (u32 *) memalign(32, 640*576*2); DCInvalidateRange(xfb[0], 640*576*2); DCInvalidateRange(xfb[1], 640*576*2); xfb[0] = (u32 *) MEM_K0_TO_K1 (xfb[0]); xfb[1] = (u32 *) MEM_K0_TO_K1 (xfb[1]); GXRModeObj *rmode = FindVideoMode(); #ifdef HW_RVL if (CONF_GetAspectRatio() == CONF_ASPECT_16_9 && (*(u32*)(0xCD8005A0) >> 16) == 0xCAFE) // Wii U { write32(0xd8006a0, 0x30000004), mask32(0xd8006a8, 0, 2); } #endif SetupVideoMode(rmode); #ifdef HW_RVL InitLUTs(); // init LUTs for hq2x #endif LWP_CreateThread (&vbthread, vbgetback, NULL, vbstack, TSTACK, 68); // Initialize GX GXColor background = { 0, 0, 0, 0xff }; memset (&gp_fifo, 0, DEFAULT_FIFO_SIZE); GX_Init (&gp_fifo, DEFAULT_FIFO_SIZE); GX_SetCopyClear (background, 0x00ffffff); GX_SetDispCopyGamma (GX_GM_1_0); GX_SetCullMode (GX_CULL_NONE); vwidth = 100; vheight = 100; } void ResetFbWidth(int width, GXRModeObj *rmode) { if(rmode->fbWidth == width) return; rmode->fbWidth = width; if(rmode != vmode) return; GX_InvVtxCache(); VIDEO_Configure(rmode); VIDEO_Flush(); } /**************************************************************************** * ResetVideo_Emu * * Reset the video/rendering mode for the emulator rendering ****************************************************************************/ void ResetVideo_Emu () { GXRModeObj *rmode; Mtx44 p; int i = -1; // original render mode or hq2x if (GCSettings.render == 0) { for (int j=0; j<4; j++) { if (tvmodes[j]->efbHeight == vheight) { i = j; break; } } } if(i >= 0) // we found a matching original mode { rmode = tvmodes[i]; // hack to fix video output for hq2x (only when actually filtering; h<=239, w<=256) if (GCSettings.FilterMethod != FILTER_NONE && vheight <= 239 && vwidth <= 256) { memcpy(&TV_Custom, tvmodes[i], sizeof(TV_Custom)); rmode = &TV_Custom; rmode->fbWidth = 512; rmode->efbHeight *= 2; rmode->xfbHeight *= 2; rmode->xfbMode = VI_XFBMODE_DF; rmode->viTVMode |= VI_INTERLACE; } if (Settings.PAL == 1) Settings.SoundInputRate = 32090; else Settings.SoundInputRate = 31894; UpdatePlaybackRate(); } else { rmode = FindVideoMode(); if (GCSettings.widescreen) ResetFbWidth(640, rmode); else ResetFbWidth(512, rmode); Settings.SoundInputRate = 31920; UpdatePlaybackRate(); } SetupVideoMode(rmode); // reconfigure VI GXColor background = {0, 0, 0, 255}; GX_SetCopyClear (background, 0x00ffffff); GX_SetViewport (0, 0, rmode->fbWidth, rmode->efbHeight, 0, 1); GX_SetDispCopyYScale ((f32) rmode->xfbHeight / (f32) rmode->efbHeight); GX_SetScissor (0, 0, rmode->fbWidth, rmode->efbHeight); GX_SetDispCopySrc (0, 0, rmode->fbWidth, rmode->efbHeight); GX_SetDispCopyDst (rmode->fbWidth, rmode->xfbHeight); u8 sharp[7] = {0,0,21,22,21,0,0}; u8 soft[7] = {8,8,10,12,10,8,8}; u8* vfilter = GCSettings.render == 3 ? sharp : GCSettings.render == 4 ? soft : rmode->vfilter; GX_SetCopyFilter(rmode->aa, rmode->sample_pattern, (rmode->xfbMode == VI_XFBMODE_SF) ? GX_FALSE : GX_TRUE, vfilter); GX_SetFieldMode (rmode->field_rendering, ((rmode->viHeight == 2 * rmode->xfbHeight) ? GX_ENABLE : GX_DISABLE)); if (rmode->aa) GX_SetPixelFmt(GX_PF_RGB565_Z16, GX_ZC_LINEAR); else GX_SetPixelFmt(GX_PF_RGB8_Z24, GX_ZC_LINEAR); GX_SetZMode (GX_TRUE, GX_LEQUAL, GX_TRUE); GX_SetColorUpdate (GX_TRUE); guOrtho(p, rmode->efbHeight/2, -(rmode->efbHeight/2), -(rmode->fbWidth/2), rmode->fbWidth/2, 100, 1000); // matrix, t, b, l, r, n, f GX_LoadProjectionMtx (p, GX_ORTHOGRAPHIC); draw_init (); } /**************************************************************************** * MakeTexture * * Modified for a buffer with an offset (border) ***************************************************************************/ void MakeTexture (const void *src, void *dst, s32 width, s32 height) { u32 tmp0=0,tmp1=0,tmp2=0,tmp3=0; __asm__ __volatile__ ( " srwi %6,%6,2\n" " srwi %7,%7,2\n" " subi %3,%4,4\n" " mr %4,%3\n" " subi %4,%4,4\n" "2: mtctr %6\n" " mr %0,%5\n" // "1: lwz %1,0(%5)\n" //1 " stwu %1,8(%4)\n" " lwz %2,4(%5)\n" //1 " stwu %2,8(%3)\n" " lwz %1,1032(%5)\n" //2 " stwu %1,8(%4)\n" " lwz %2,1036(%5)\n" //2 " stwu %2,8(%3)\n" " lwz %1,2064(%5)\n" //3 " stwu %1,8(%4)\n" " lwz %2,2068(%5)\n" //3 " stwu %2,8(%3)\n" " lwz %1,3096(%5)\n" //4 " stwu %1,8(%4)\n" " lwz %2,3100(%5)\n" //4 " stwu %2,8(%3)\n" " addi %5,%5,8\n" " bdnz 1b\n" " addi %5,%0,4128\n" //5 " subic. %7,%7,1\n" " bne 2b" // 0 1 2 3 4 5 6 7 : "=&b"(tmp0), "=&b"(tmp1), "=&b"(tmp2), "=&b"(tmp3), "+b"(dst) : "b"(src), "b"(width), "b"(height) ); } /**************************************************************************** * Update Video ***************************************************************************/ uint32 prevRenderedFrameCount = 0; int fscale = 1; void update_video (int width, int height) { vwidth = width; vheight = height; if(CheckVideo == 2 && IPPU.RenderedFramesCount == prevRenderedFrameCount) return; // we haven't rendered any frames yet, so we can't draw anything! // Ensure previous vb has complete while ((LWP_ThreadIsSuspended (vbthread) == 0) || (copynow == GX_TRUE)) usleep (50); whichfb ^= 1; if (oldvheight != vheight || oldvwidth != vwidth) // if rendered width/height changes, update scaling CheckVideo = 1; if (CheckVideo) // if we get back from the menu, and have rendered at least 1 frame { int xscale, yscale; #ifdef HW_RVL if(vwidth <= 256) fscale = GetFilterScale((RenderFilter)GCSettings.FilterMethod); else fscale = 1; #endif ResetVideo_Emu (); // reset video to emulator rendering settings #ifdef HW_RVL memset(filtermem, 0, FILTERMEM_SIZE); #endif /** Update scaling **/ if (GCSettings.render == 0) // original render mode { if (GCSettings.FilterMethod != FILTER_NONE && vheight <= 239 && vwidth <= 256) { // filters; normal operation xscale = vwidth; yscale = vheight; } else { // no filtering fscale = 1; xscale = 256; yscale = vheight / 2; } } else // unfiltered and filtered mode { xscale = 256; if(vheight == 224 || vheight == 448) yscale = 224; else yscale = 239; } if (GCSettings.widescreen) { if(GCSettings.render == 0) xscale = (3*xscale)/4; else xscale = 256; // match the original console's width for "widescreen" to prevent flickering } xscale *= GCSettings.zoomHor; yscale *= GCSettings.zoomVert; square[6] = square[3] = xscale + GCSettings.xshift; square[0] = square[9] = -xscale + GCSettings.xshift; square[4] = square[1] = yscale - GCSettings.yshift; square[7] = square[10] = -yscale - GCSettings.yshift; DCFlushRange (square, 32); // update memory BEFORE the GPU accesses it! draw_init (); // initialize the texture obj we are going to use GX_InitTexObj (&texobj, texturemem, vwidth*fscale, vheight*fscale, GX_TF_RGB565, GX_CLAMP, GX_CLAMP, GX_FALSE); if (GCSettings.render == 0 || GCSettings.render == 2) GX_InitTexObjLOD(&texobj,GX_NEAR,GX_NEAR_MIP_NEAR,2.5,9.0,0.0,GX_FALSE,GX_FALSE,GX_ANISO_1); // original/unfiltered video mode: force texture filtering OFF GX_LoadTexObj (&texobj, GX_TEXMAP0); // load texture object so its ready to use oldvwidth = vwidth; oldvheight = vheight; CheckVideo = 0; } #ifdef HW_RVL // convert image to texture if (GCSettings.FilterMethod != FILTER_NONE && vheight <= 239 && vwidth <= 256) // don't do filtering on game textures > 256 x 239 { FilterMethod ((uint8*) GFX.Screen, EXT_PITCH, (uint8*) filtermem, vwidth*fscale*2, vwidth, vheight); MakeTexture565((char *) filtermem, (char *) texturemem, vwidth*fscale, vheight*fscale); } else #endif { MakeTexture((char *) GFX.Screen, (char *) texturemem, vwidth, vheight); } DCFlushRange (texturemem, TEXTUREMEM_SIZE); // update the texture memory GX_InvalidateTexAll (); draw_square (view); // draw the quad GX_DrawDone (); if(ScreenshotRequested) { if(GCSettings.render == 0) // we can't take a screenshot in Original mode { oldRenderMode = 0; GCSettings.render = 2; // switch to unfiltered mode CheckVideo = 1; // request the switch } else { ScreenshotRequested = 0; TakeScreenshot(); if(oldRenderMode != -1) { GCSettings.render = oldRenderMode; oldRenderMode = -1; } ConfigRequested = 1; } } VIDEO_SetNextFramebuffer (xfb[whichfb]); VIDEO_Flush (); copynow = GX_TRUE; // Return to caller, don't waste time waiting for vb LWP_ResumeThread (vbthread); } void AllocGfxMem() { snes9xgfx = (unsigned char *)memalign(32, SNES9XGFX_SIZE); memset(snes9xgfx, 0, SNES9XGFX_SIZE); #ifdef HW_RVL filtermem = (unsigned char *)memalign(32, FILTERMEM_SIZE); memset(filtermem, 0, FILTERMEM_SIZE); #endif GFX.Pitch = EXT_PITCH; GFX.Screen = (uint16*)(snes9xgfx + EXT_OFFSET); } /**************************************************************************** * setGFX * * Setup the global GFX information for Snes9x ***************************************************************************/ void setGFX () { GFX.Pitch = EXT_PITCH; } /**************************************************************************** * TakeScreenshot * * Copies the current screen into a GX texture ***************************************************************************/ void TakeScreenshot() { IMGCTX pngContext = PNGU_SelectImageFromBuffer(savebuffer); if (pngContext != NULL) { gameScreenPngSize = PNGU_EncodeFromEFB(pngContext, vmode->fbWidth, vmode->efbHeight); PNGU_ReleaseImageContext(pngContext); gameScreenPng = (u8 *)malloc(gameScreenPngSize); memcpy(gameScreenPng, savebuffer, gameScreenPngSize); } } void ClearScreenshot() { if(gameScreenPng) { gameScreenPngSize = 0; free(gameScreenPng); gameScreenPng = NULL; } } /**************************************************************************** * ResetVideo_Menu * * Reset the video/rendering mode for the menu ****************************************************************************/ void ResetVideo_Menu () { Mtx44 p; f32 yscale; u32 xfbHeight; GXRModeObj * rmode = FindVideoMode(); SetupVideoMode(rmode); // reconfigure VI // clears the bg to color and clears the z buffer GXColor background = {0, 0, 0, 255}; GX_SetCopyClear (background, 0x00ffffff); yscale = GX_GetYScaleFactor(vmode->efbHeight,vmode->xfbHeight); xfbHeight = GX_SetDispCopyYScale(yscale); GX_SetScissor(0,0,vmode->fbWidth,vmode->efbHeight); GX_SetDispCopySrc(0,0,vmode->fbWidth,vmode->efbHeight); GX_SetDispCopyDst(vmode->fbWidth,xfbHeight); GX_SetCopyFilter(vmode->aa,vmode->sample_pattern,GX_TRUE,vmode->vfilter); GX_SetFieldMode(vmode->field_rendering,((vmode->viHeight==2*vmode->xfbHeight)?GX_ENABLE:GX_DISABLE)); if (vmode->aa) GX_SetPixelFmt(GX_PF_RGB565_Z16, GX_ZC_LINEAR); else GX_SetPixelFmt(GX_PF_RGB8_Z24, GX_ZC_LINEAR); // setup the vertex descriptor // tells the flipper to expect direct data GX_ClearVtxDesc(); GX_InvVtxCache (); GX_InvalidateTexAll(); GX_SetVtxDesc(GX_VA_TEX0, GX_NONE); GX_SetVtxDesc(GX_VA_POS, GX_DIRECT); GX_SetVtxDesc (GX_VA_CLR0, GX_DIRECT); GX_SetVtxAttrFmt (GX_VTXFMT0, GX_VA_POS, GX_POS_XYZ, GX_F32, 0); GX_SetVtxAttrFmt (GX_VTXFMT0, GX_VA_CLR0, GX_CLR_RGBA, GX_RGBA8, 0); GX_SetVtxAttrFmt(GX_VTXFMT0, GX_VA_TEX0, GX_TEX_ST, GX_F32, 0); GX_SetZMode (GX_FALSE, GX_LEQUAL, GX_TRUE); GX_SetNumChans(1); GX_SetNumTexGens(1); GX_SetTevOp (GX_TEVSTAGE0, GX_PASSCLR); GX_SetTevOrder(GX_TEVSTAGE0, GX_TEXCOORD0, GX_TEXMAP0, GX_COLOR0A0); GX_SetTexCoordGen(GX_TEXCOORD0, GX_TG_MTX2x4, GX_TG_TEX0, GX_IDENTITY); guMtxIdentity(GXmodelView2D); guMtxTransApply (GXmodelView2D, GXmodelView2D, 0.0F, 0.0F, -50.0F); GX_LoadPosMtxImm(GXmodelView2D,GX_PNMTX0); guOrtho(p,0,479,0,639,0,300); GX_LoadProjectionMtx(p, GX_ORTHOGRAPHIC); GX_SetViewport(0,0,vmode->fbWidth,vmode->efbHeight,0,1); GX_SetBlendMode(GX_BM_BLEND, GX_BL_SRCALPHA, GX_BL_INVSRCALPHA, GX_LO_CLEAR); GX_SetAlphaUpdate(GX_TRUE); } /**************************************************************************** * Menu_Render * * Renders everything current sent to GX, and flushes video ***************************************************************************/ void Menu_Render() { whichfb ^= 1; // flip framebuffer GX_SetZMode(GX_TRUE, GX_LEQUAL, GX_TRUE); GX_SetColorUpdate(GX_TRUE); GX_CopyDisp(xfb[whichfb],GX_TRUE); GX_DrawDone(); VIDEO_SetNextFramebuffer(xfb[whichfb]); VIDEO_Flush(); VIDEO_WaitVSync(); } /**************************************************************************** * Menu_DrawImg * * Draws the specified image on screen using GX ***************************************************************************/ void Menu_DrawImg(f32 xpos, f32 ypos, u16 width, u16 height, u8 data[], f32 degrees, f32 scaleX, f32 scaleY, u8 alpha) { if(data == NULL) return; GXTexObj texObj; GX_InitTexObj(&texObj, data, width,height, GX_TF_RGBA8,GX_CLAMP, GX_CLAMP,GX_FALSE); GX_LoadTexObj(&texObj, GX_TEXMAP0); GX_InvalidateTexAll(); GX_SetTevOp (GX_TEVSTAGE0, GX_MODULATE); GX_SetVtxDesc (GX_VA_TEX0, GX_DIRECT); Mtx m,m1,m2, mv; width >>= 1; height >>= 1; guMtxIdentity (m1); guMtxScaleApply(m1,m1,scaleX,scaleY,1.0); guVector axis = (guVector) {0 , 0, 1 }; guMtxRotAxisDeg (m2, &axis, degrees); guMtxConcat(m2,m1,m); guMtxTransApply(m,m, xpos+width,ypos+height,0); guMtxConcat (GXmodelView2D, m, mv); GX_LoadPosMtxImm (mv, GX_PNMTX0); GX_Begin(GX_QUADS, GX_VTXFMT0,4); GX_Position3f32(-width, -height, 0); GX_Color4u8(0xFF,0xFF,0xFF,alpha); GX_TexCoord2f32(0, 0); GX_Position3f32(width, -height, 0); GX_Color4u8(0xFF,0xFF,0xFF,alpha); GX_TexCoord2f32(1, 0); GX_Position3f32(width, height, 0); GX_Color4u8(0xFF,0xFF,0xFF,alpha); GX_TexCoord2f32(1, 1); GX_Position3f32(-width, height, 0); GX_Color4u8(0xFF,0xFF,0xFF,alpha); GX_TexCoord2f32(0, 1); GX_End(); GX_LoadPosMtxImm (GXmodelView2D, GX_PNMTX0); GX_SetTevOp (GX_TEVSTAGE0, GX_PASSCLR); GX_SetVtxDesc (GX_VA_TEX0, GX_NONE); } /**************************************************************************** * Menu_DrawRectangle * * Draws a rectangle at the specified coordinates using GX ***************************************************************************/ void Menu_DrawRectangle(f32 x, f32 y, f32 width, f32 height, GXColor color, u8 filled) { long n = 4; f32 x2 = x+width; f32 y2 = y+height; guVector v[] = {{x,y,0.0f}, {x2,y,0.0f}, {x2,y2,0.0f}, {x,y2,0.0f}, {x,y,0.0f}}; u8 fmt = GX_TRIANGLEFAN; if(!filled) { fmt = GX_LINESTRIP; n = 5; } GX_Begin(fmt, GX_VTXFMT0, n); for(long i=0; i