The-Homebrew-Cloud/snes9xgx
2
0
Fork 0
mirror of https://github.com/dborth/snes9xgx.git synced 2024-11-01 00:15:14 +01:00
Code Issues Packages Projects Releases Wiki Activity

- original snes rendering modes supported

Browse Source 
- zoom broken for now
(thanks eke-eke for pointers)
This commit is contained in:
michniewski 2008-08-23 23:15:58 +00:00
parent 28e26a943d
commit a2048e60ab
6 changed files with 536 additions and 267 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

37
source/ngc/input.cpp
View File

@ -19,8 +19,6 @@
#include "video.h" #include "video.h"
#include "input.h" #include "input.h"
#include "menudraw.h"
extern int ConfigRequested; extern int ConfigRequested;
/**************************************************************************** /****************************************************************************
@ -487,41 +485,6 @@ void NGCReportButtons ()
} }
} }
/****************************************************************************
* wpad_get_analogues()
*
* gets the analogue stick magnitude and angle values (
* from classic or nunchuk expansions)
***************************************************************************
u32 wpad_get_analogues(int pad, float* mag1, u16* ang1, float* mag2, u16* ang2)
{
*mag1 = *ang1 = *mag2 = *ang2 = 0;
u32 exp_type = 0;
#ifdef HW_RVL
struct expansion_t exp;
memset( &exp, 0, sizeof(exp) );
if ( WPAD_Probe( pad, &exp_type) == 0) // check wiimote and expansion status (first if wiimote is connected & no errors)
{
WPAD_Expansion(pad, &exp); // expansion connected. get info
if (exp_type == WPAD_EXP_CLASSIC)
{
*ang1 = exp.classic.ljs.ang; // left cc joystick
*mag1 = exp.classic.ljs.mag;
*ang2 = exp.classic.rjs.ang; // right cc joystick
*mag2 = exp.classic.rjs.mag;
}
else if (exp_type == WPAD_EXP_NUNCHUK)
{
*ang1 = exp.nunchuk.js.ang; // nunchuk joystick
*mag1 = exp.nunchuk.js.mag;
}
}
#endif
return exp_type; // return expansion type
}
*/
void SetControllers () void SetControllers ()
{ {
if (Settings.MultiPlayer5Master == true) if (Settings.MultiPlayer5Master == true)

6
source/ngc/input.h
View File

@ -18,7 +18,7 @@ extern unsigned int wmmousemap[];
extern unsigned int gcjustmap[]; extern unsigned int gcjustmap[];
extern unsigned int wmjustmap[]; extern unsigned int wmjustmap[];
START_EXTERN_C //START_EXTERN_C
s8 WPAD_StickX(u8 chan,u8 right); s8 WPAD_StickX(u8 chan,u8 right);
s8 WPAD_StickY(u8 chan, u8 right); s8 WPAD_StickY(u8 chan, u8 right);
@ -29,8 +29,6 @@ void NGCReportButtons ();
void SetControllers (); void SetControllers ();
void SetDefaultButtonMap (); void SetDefaultButtonMap ();
//extern u32 wpad_get_analogues(int pad, float* mag1, u16* ang1, float* mag2, u16* ang2); //END_EXTERN_C
END_EXTERN_C
#endif #endif

4
source/ngc/menu.cpp
View File

@ -239,8 +239,8 @@ PreferencesMenu ()
sprintf (prefmenu[11], "C-Stick Zoom %s", sprintf (prefmenu[11], "C-Stick Zoom %s",
GCSettings.NGCZoom == true ? " ON" : "OFF"); GCSettings.NGCZoom == true ? " ON" : "OFF");
sprintf (prefmenu[12], "Video Filtering %s", sprintf (prefmenu[12], "Render Mode %s",
GCSettings.render == true ? " ON" : "OFF"); GCSettings.render == true ? "Filtered" : "Original");
ret = RunMenu (prefmenu, prefmenuCount, (char*)"Preferences", 16); ret = RunMenu (prefmenu, prefmenuCount, (char*)"Preferences", 16);

15
source/ngc/snes9xGX.cpp
View File

@ -249,6 +249,7 @@ void setFrameTimerMethod()
****************************************************************************/ ****************************************************************************/
/* Eke-Eke: initialize frame Sync */ /* Eke-Eke: initialize frame Sync */
extern void S9xInitSync(); extern void S9xInitSync();
extern int oldvwidth, oldvheight; // for forcing video reset in video.cpp
void void
emulate () emulate ()
@ -266,7 +267,8 @@ emulate ()
if (ConfigRequested) if (ConfigRequested)
{ {
VIDEO_WaitVSync (); // change to menu video mode
ResetVideo_Menu ();
if ( GCSettings.AutoSave == 1 ) if ( GCSettings.AutoSave == 1 )
{ {
@ -288,18 +290,19 @@ emulate ()
mainmenu (3); // go to game menu mainmenu (3); // go to game menu
/*** Update any emulation settings changed in the menu ***/
ReInitGCVideo(); // update video after reading settings
FrameTimer = 0; FrameTimer = 0;
setFrameTimerMethod(); // set frametimer method every time a ROM is loaded setFrameTimerMethod (); // set frametimer method every time a ROM is loaded
Settings.SuperScopeMaster = (GCSettings.Superscope > 0 ? true : false); Settings.SuperScopeMaster = (GCSettings.Superscope > 0 ? true : false);
Settings.MouseMaster = (GCSettings.Mouse > 0 ? true : false); Settings.MouseMaster = (GCSettings.Mouse > 0 ? true : false);
Settings.JustifierMaster = (GCSettings.Justifier > 0 ? true : false); Settings.JustifierMaster = (GCSettings.Justifier > 0 ? true : false);
SetControllers(); SetControllers ();
S9xReportControllers(); // FIX //S9xReportControllers ();
ConfigRequested = 0; ConfigRequested = 0;
oldvheight = oldvwidth = 0; // force video update
}//if ConfigRequested }//if ConfigRequested
}//while }//while

728
source/ngc/video.cpp
View File

@ -31,7 +31,7 @@ extern unsigned int SMBTimer;
/*** 2D Video ***/ /*** 2D Video ***/
unsigned int *xfb[2] = { NULL, NULL }; /*** Double buffered ***/ unsigned int *xfb[2] = { NULL, NULL }; /*** Double buffered ***/
int whichfb = 0; /*** Switch ***/ int whichfb = 0; /*** Switch ***/
GXRModeObj *vmode; /*** General video mode ***/ GXRModeObj *vmode; /*** Menu video mode ***/
int screenheight; int screenheight;
extern u32* backdrop; extern u32* backdrop;
@ -50,8 +50,8 @@ u32 FrameTimer = 0;
u8 vmode_60hz = 0; u8 vmode_60hz = 0;
#define HASPECT 76 #define HASPECT 320
#define VASPECT 54 #define VASPECT 240
/* New texture based scaler */ /* New texture based scaler */
typedef struct tagcamera typedef struct tagcamera
@ -78,11 +78,169 @@ s16 square[] ATTRIBUTE_ALIGN (32) =
-HASPECT, -VASPECT, 0, // 3 -HASPECT, -VASPECT, 0, // 3
}; };
static camera cam = { {0.0F, 0.0F, 0.0F}, static camera cam = { {0.0F, 0.0F, 0.0F},
{0.0F, 0.5F, 0.0F}, {0.0F, 0.5F, 0.0F},
{0.0F, 0.0F, -0.5F} {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) */
GXRModeObj TV_239p =
{
VI_TVMODE_PAL_DS, // viDisplayMode
256, // fbWidth
239, // efbHeight
239, // xfbHeight
(VI_MAX_WIDTH_PAL - 640)/2, // viXOrigin
(VI_MAX_HEIGHT_PAL - 574)/2, // viYOrigin
640, // viWidth
574, // 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) */
GXRModeObj TV_478i =
{
VI_TVMODE_PAL_INT, // viDisplayMode
512, // fbWidth
478, // efbHeight
478, // xfbHeight
(VI_MAX_WIDTH_PAL - 640)/2, // viXOrigin
(VI_MAX_HEIGHT_PAL - 572)/2, // viYOrigin
640, // viWidth
574, // 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) */
GXRModeObj TV_224p =
{
VI_TVMODE_EURGB60_DS, // viDisplayMode
256, // fbWidth
224, // efbHeight
224, // xfbHeight
(VI_MAX_WIDTH_NTSC - 640)/2, // viXOrigin
(VI_MAX_HEIGHT_NTSC - 480)/2 + 8, // viYOrigin // +8 if we want to maintain rendered pixel aspect ratio (not 4:3)
640, // viWidth
480, // 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) */
GXRModeObj TV_448i =
{
VI_TVMODE_EURGB60_INT, // viDisplayMode
512, // fbWidth
448, // efbHeight
448, // xfbHeight
(VI_MAX_WIDTH_NTSC - 640)/2, // viXOrigin
(VI_MAX_HEIGHT_NTSC - 480)/2, // viYOrigin
640, // viWidth
480, // 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
}
};
/* TV Modes table */
GXRModeObj *tvmodes[4] = {
&TV_239p, &TV_478i, /* Snes PAL video modes */
&TV_224p, &TV_448i, /* Snes NTSC video modes */
};
#ifdef VIDEO_THREADING #ifdef VIDEO_THREADING
/**************************************************************************** /****************************************************************************
* VideoThreading * VideoThreading
@ -103,13 +261,13 @@ static unsigned char vbstack[TSTACK];
static void * static void *
vbgetback (void *arg) vbgetback (void *arg)
{ {
while (1) while (1)
{ {
VIDEO_WaitVSync (); /**< Wait for video vertical blank */ VIDEO_WaitVSync (); /**< Wait for video vertical blank */
LWP_SuspendThread (vbthread); LWP_SuspendThread (vbthread);
} }
return NULL; return NULL;
} }
@ -123,10 +281,10 @@ void
InitVideoThread () InitVideoThread ()
{ {
/*** Initialise a new queue ***/ /*** Initialise a new queue ***/
LWP_InitQueue (&videoblankqueue); LWP_InitQueue (&videoblankqueue);
/*** Create the thread on this queue ***/ /*** Create the thread on this queue ***/
LWP_CreateThread (&vbthread, vbgetback, NULL, vbstack, TSTACK, 80); LWP_CreateThread (&vbthread, vbgetback, NULL, vbstack, TSTACK, 80);
} }
#endif #endif
@ -141,123 +299,140 @@ static void
copy_to_xfb (u32 arg) copy_to_xfb (u32 arg)
{ {
if (copynow == GX_TRUE) if (copynow == GX_TRUE)
{ {
GX_SetZMode (GX_TRUE, GX_LEQUAL, GX_TRUE); GX_SetZMode (GX_TRUE, GX_LEQUAL, GX_TRUE);
GX_SetColorUpdate (GX_TRUE); GX_SetColorUpdate (GX_TRUE);
GX_CopyDisp (xfb[whichfb], GX_TRUE); GX_CopyDisp (xfb[whichfb], GX_TRUE);
GX_Flush (); GX_Flush ();
copynow = GX_FALSE; copynow = GX_FALSE;
} }
FrameTimer++; FrameTimer++;
SMBTimer++; SMBTimer++;
} }
/**************************************************************************** /****************************************************************************
* WIP3 - Scaler Support Functions * Scaler Support Functions
****************************************************************************/ ****************************************************************************/
static void static void
draw_init () draw_init ()
{ {
GX_ClearVtxDesc (); GX_ClearVtxDesc ();
GX_SetVtxDesc (GX_VA_POS, GX_INDEX8); GX_SetVtxDesc (GX_VA_POS, GX_INDEX8);
GX_SetVtxDesc (GX_VA_CLR0, GX_INDEX8); GX_SetVtxDesc (GX_VA_CLR0, GX_INDEX8);
GX_SetVtxDesc (GX_VA_TEX0, GX_DIRECT); 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_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_CLR0, GX_CLR_RGBA, GX_RGBA8, 0);
GX_SetVtxAttrFmt (GX_VTXFMT0, GX_VA_TEX0, GX_TEX_ST, GX_F32, 0); GX_SetVtxAttrFmt (GX_VTXFMT0, GX_VA_TEX0, GX_TEX_ST, GX_F32, 0);
GX_SetArray (GX_VA_POS, square, 3 * sizeof (s16)); GX_SetArray (GX_VA_POS, square, 3 * sizeof (s16));
GX_SetNumTexGens (1); GX_SetNumTexGens (1);
GX_SetTexCoordGen (GX_TEXCOORD0, GX_TG_MTX2x4, GX_TG_TEX0, GX_IDENTITY); GX_SetNumChans (0);
GX_SetTexCoordGen (GX_TEXCOORD0, GX_TG_MTX2x4, GX_TG_TEX0, GX_IDENTITY);
//GX_SetTevOp (GX_TEVSTAGE0, GX_DECAL);
//GX_SetTevOrder (GX_TEVSTAGE0, GX_TEXCOORD0, GX_TEXMAP0, GX_COLOR0A0);
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_InvalidateTexAll ();
GX_InitTexObj (&texobj, texturemem, vwidth, vheight, GX_TF_RGB565, GX_CLAMP, GX_CLAMP, GX_FALSE);
/* original video mode: force filtering OFF */
if (!GCSettings.render)
GX_InitTexObjLOD(&texobj,GX_NEAR,GX_NEAR_MIP_NEAR,2.5,9.0,0.0,GX_FALSE,GX_FALSE,GX_ANISO_1);
GX_InvalidateTexAll ();
GX_InitTexObj (&texobj, texturemem, vwidth, vheight, GX_TF_RGB565,
GX_CLAMP, GX_CLAMP, GX_FALSE);
} }
static void static void
draw_vert (u8 pos, u8 c, f32 s, f32 t) draw_vert (u8 pos, u8 c, f32 s, f32 t)
{ {
GX_Position1x8 (pos); GX_Position1x8 (pos);
GX_Color1x8 (c); GX_Color1x8 (c);
GX_TexCoord2f32 (s, t); GX_TexCoord2f32 (s, t);
} }
static void static void
draw_square (Mtx v) draw_square (Mtx v)
{ {
Mtx m; // model matrix. Mtx m; // model matrix.
Mtx mv; // modelview matrix. Mtx mv; // modelview matrix.
/* guMtxIdentity (m);
* Use C functions! guMtxTransApply (m, m, 0, 0, -100);
* Calling the faster asm ones cause reboot! guMtxConcat (v, m, mv);
*/
guMtxIdentity (m);
guMtxTransApply (m, m, 0, 0, -100);
guMtxConcat (v, m, mv);
GX_LoadPosMtxImm (mv, GX_PNMTX0); GX_LoadPosMtxImm (mv, GX_PNMTX0);
GX_Begin (GX_QUADS, GX_VTXFMT0, 4); GX_Begin (GX_QUADS, GX_VTXFMT0, 4);
draw_vert (0, 0, 0.0, 0.0); draw_vert (0, 0, 0.0, 0.0);
draw_vert (1, 0, 1.0, 0.0); draw_vert (1, 0, 1.0, 0.0);
draw_vert (2, 0, 1.0, 1.0); draw_vert (2, 0, 1.0, 1.0);
draw_vert (3, 0, 0.0, 1.0); draw_vert (3, 0, 0.0, 1.0);
GX_End (); GX_End ();
} }
/**************************************************************************** /****************************************************************************
* StartGX * StartGX
* *
* This function initialises the GX. * This function initialises the GX.
* WIP3 - Based on texturetest from libOGC examples.
****************************************************************************/ ****************************************************************************/
static void static void
StartGX () StartGX ()
{ {
Mtx p; Mtx p;
GXColor background = { 0, 0, 0, 0xff }; GXColor background = { 0, 0, 0, 0xff };
/*** Clear out FIFO area ***/ /*** Clear out FIFO area ***/
memset (&gp_fifo, 0, DEFAULT_FIFO_SIZE); memset (&gp_fifo, 0, DEFAULT_FIFO_SIZE);
/*** Initialise GX ***/ /*** Initialise GX ***/
GX_Init (&gp_fifo, DEFAULT_FIFO_SIZE); GX_Init (&gp_fifo, DEFAULT_FIFO_SIZE);
GX_SetCopyClear (background, 0x00ffffff); GX_SetCopyClear (background, 0x00ffffff);
GX_SetViewport (0, 0, vmode->fbWidth, vmode->efbHeight, 0, 1);
GX_SetDispCopyYScale ((f32) vmode->xfbHeight / (f32) vmode->efbHeight);
GX_SetScissor (0, 0, vmode->fbWidth, vmode->efbHeight);
GX_SetDispCopySrc (0, 0, vmode->fbWidth, vmode->efbHeight);
GX_SetDispCopyDst (vmode->fbWidth, vmode->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));
GX_SetPixelFmt (GX_PF_RGB8_Z24, GX_ZC_LINEAR);
GX_SetCullMode (GX_CULL_NONE);
GX_CopyDisp (xfb[whichfb], GX_TRUE);
GX_SetDispCopyGamma (GX_GM_1_0);
guPerspective (p, 60, 1.33F, 10.0F, 1000.0F); GX_SetViewport (0, 0, vmode->fbWidth, vmode->efbHeight, 0, 1);
GX_LoadProjectionMtx (p, GX_PERSPECTIVE); GX_SetDispCopyYScale ((f32) vmode->xfbHeight / (f32) vmode->efbHeight);
GX_SetScissor (0, 0, vmode->fbWidth, vmode->efbHeight);
vwidth = 100; GX_SetDispCopySrc (0, 0, vmode->fbWidth, vmode->efbHeight);
vheight = 100; GX_SetDispCopyDst (vmode->fbWidth, vmode->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));
GX_SetPixelFmt (GX_PF_RGB8_Z24, GX_ZC_LINEAR);
GX_SetCullMode (GX_CULL_NONE);
GX_SetDispCopyGamma (GX_GM_1_0);
GX_SetZMode(GX_FALSE, GX_ALWAYS, GX_TRUE);
GX_SetColorUpdate (GX_TRUE);
// guPerspective (p, 60, 1.33F, 10.0F, 1000.0F);
// GX_LoadProjectionMtx (p, GX_PERSPECTIVE);
guOrtho(p, vmode->efbHeight/2, -(vmode->efbHeight/2), -(vmode->fbWidth/2), vmode->fbWidth/2, 10, 1000); // matrix, t, b, l, r, n, f
GX_LoadProjectionMtx (p, GX_ORTHOGRAPHIC);
GX_CopyDisp (xfb[whichfb], GX_TRUE); // reset xfb
vwidth = 100;
vheight = 100;
} }
/**************************************************************************** /****************************************************************************
* UpdatePads * UpdatePadsCB
* *
* called by postRetraceCallback in InitGCVideo - scans gcpad and wpad * called by postRetraceCallback in InitGCVideo - scans gcpad and wpad
****************************************************************************/ ****************************************************************************/
void UpdatePadsCB() void
UpdatePadsCB ()
{ {
#ifdef HW_RVL #ifdef HW_RVL
WPAD_ScanPads(); WPAD_ScanPads();
@ -269,25 +444,21 @@ void UpdatePadsCB()
* InitGCVideo * InitGCVideo
* *
* This function MUST be called at startup. * This function MUST be called at startup.
* - also sets up menu video mode
****************************************************************************/ ****************************************************************************/
void void
InitGCVideo () InitGCVideo ()
{ {
/* int *romptr = (int *) 0x81000000; // injected rom
* Before doing anything else under libogc,
* Call VIDEO_Init
*/
int *romptr = (int *) 0x81000000;
// init video
VIDEO_Init (); VIDEO_Init ();
PAD_Init (); PAD_Init ();
AUDIO_Init (NULL); AUDIO_Init (NULL);
AR_Init (NULL, 0); AR_Init (NULL, 0);
/* Before going any further, let's copy any attached ROM image ** */ // Before going any further, let's copy any attached ROM image
if (memcmp ((char *) romptr, "SNESROM0", 8) == 0) if (memcmp ((char *) romptr, "SNESROM0", 8) == 0)
{ {
ARAM_ROMSIZE = romptr[2]; ARAM_ROMSIZE = romptr[2];
@ -295,27 +466,70 @@ InitGCVideo ()
ARAMPut ((char *) romptr, (char *) AR_SNESROM, ARAM_ROMSIZE); ARAMPut ((char *) romptr, (char *) AR_SNESROM, ARAM_ROMSIZE);
} }
/*
* Always use NTSC mode - this works on NTSC and PAL, GC and Wii // get default video mode
vmode = &TVNtsc480IntDf;
*/
vmode = VIDEO_GetPreferredMode(NULL); vmode = VIDEO_GetPreferredMode(NULL);
switch(vmode->viTVMode) switch (vmode->viTVMode >> 2)
{ {
case VI_TVMODE_PAL_DS: case VI_PAL: /* 576 lines (PAL 50Hz) */
case VI_TVMODE_PAL_INT:
// 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 sizing
TV_239p.viWidth = TV_478i.viWidth = TV_224p.viWidth = TV_448i.viWidth = 640;
TV_239p.viHeight = TV_478i.viHeight = TV_224p.viHeight = TV_448i.viHeight = 480;
TV_239p.viXOrigin = TV_478i.viXOrigin = TV_224p.viXOrigin = TV_448i.viXOrigin = (VI_MAX_WIDTH_PAL - 640)/2;
TV_239p.viYOrigin = TV_478i.viYOrigin = TV_224p.viYOrigin = TV_448i.viYOrigin = (VI_MAX_HEIGHT_PAL - 574)/2;
vmode_60hz = 0; vmode_60hz = 0;
/* display should be centered vertically (borders) */
vmode = &TVPal574IntDfScale;
vmode->xfbHeight = 480;
vmode->viYOrigin = (VI_MAX_HEIGHT_PAL - 480)/2;
vmode->viHeight = 480;
break; break;
case VI_TVMODE_EURGB60_PROG: case VI_NTSC: /* 480 lines (NTSC 60hz) */
case VI_TVMODE_EURGB60_DS:
case VI_TVMODE_NTSC_DS: // set video signal mode
case VI_TVMODE_NTSC_INT: TV_239p.viTVMode = VI_TVMODE_NTSC_DS;
case VI_TVMODE_NTSC_PROG: TV_478i.viTVMode = VI_TVMODE_NTSC_INT;
case VI_TVMODE_MPAL_INT: TV_224p.viTVMode = VI_TVMODE_NTSC_DS;
default: TV_448i.viTVMode = VI_TVMODE_NTSC_INT;
// set VI sizing
TV_239p.viWidth = TV_478i.viWidth = TV_224p.viWidth = TV_448i.viWidth = 640;
TV_239p.viHeight = TV_478i.viHeight = TV_224p.viHeight = TV_448i.viHeight = 480;
TV_239p.viXOrigin = TV_478i.viXOrigin = TV_224p.viXOrigin = TV_448i.viXOrigin = (VI_MAX_WIDTH_NTSC - 640)/2;
TV_239p.viYOrigin = TV_478i.viYOrigin = TV_224p.viYOrigin = TV_448i.viYOrigin = (VI_MAX_HEIGHT_NTSC - 480)/2;
// special additions (origin shifts can be moved to rendered square shifts during re-scaling)
TV_224p.viYOrigin += 8; // centering
TV_239p.viYOrigin += 2; //
TV_448i.viYOrigin += 16; //
vmode_60hz = 1;
break;
default: /* 480 lines (PAL 60Hz) */
// set video signal mode
TV_239p.viTVMode = VI_TVMODE(vmode->viTVMode >> 2, VI_NON_INTERLACE);
TV_478i.viTVMode = VI_TVMODE(vmode->viTVMode >> 2, VI_INTERLACE);
TV_224p.viTVMode = VI_TVMODE(vmode->viTVMode >> 2, VI_NON_INTERLACE);
TV_448i.viTVMode = VI_TVMODE(vmode->viTVMode >> 2, VI_INTERLACE);
// set VI sizing
TV_239p.viWidth = TV_478i.viWidth = TV_224p.viWidth = TV_448i.viWidth = 640;
TV_239p.viHeight = TV_478i.viHeight = TV_224p.viHeight = TV_448i.viHeight = 480;
TV_239p.viXOrigin = TV_478i.viXOrigin = TV_224p.viXOrigin = TV_448i.viXOrigin = (VI_MAX_WIDTH_NTSC - 640)/2;
TV_239p.viYOrigin = TV_478i.viYOrigin = TV_224p.viYOrigin = TV_448i.viYOrigin = (VI_MAX_HEIGHT_NTSC - 480)/2;
vmode_60hz = 1; vmode_60hz = 1;
break; break;
} }
@ -324,106 +538,127 @@ InitGCVideo ()
screenheight = vmode->xfbHeight; screenheight = vmode->xfbHeight;
/*
* Allocate the video buffers // Allocate the video buffers
*/
xfb[0] = (u32 *) MEM_K0_TO_K1 (SYS_AllocateFramebuffer (vmode)); xfb[0] = (u32 *) MEM_K0_TO_K1 (SYS_AllocateFramebuffer (vmode));
xfb[1] = (u32 *) MEM_K0_TO_K1 (SYS_AllocateFramebuffer (vmode)); xfb[1] = (u32 *) MEM_K0_TO_K1 (SYS_AllocateFramebuffer (vmode));
/* // A console is always useful while debugging.
* A console is always useful while debugging.
*/
console_init (xfb[0], 20, 64, vmode->fbWidth, vmode->xfbHeight, vmode->fbWidth * 2); console_init (xfb[0], 20, 64, vmode->fbWidth, vmode->xfbHeight, vmode->fbWidth * 2);
/* // Clear framebuffers etc.
* Clear framebuffers etc.
*/
VIDEO_ClearFrameBuffer (vmode, xfb[0], COLOR_BLACK); VIDEO_ClearFrameBuffer (vmode, xfb[0], COLOR_BLACK);
VIDEO_ClearFrameBuffer (vmode, xfb[1], COLOR_BLACK); VIDEO_ClearFrameBuffer (vmode, xfb[1], COLOR_BLACK);
VIDEO_SetNextFramebuffer (xfb[0]); VIDEO_SetNextFramebuffer (xfb[0]);
/* // video callbacks
* Let libogc populate manage the PADs for us
*/
//VIDEO_SetPostRetraceCallback ((VIRetraceCallback)PAD_ScanPads);
VIDEO_SetPostRetraceCallback ((VIRetraceCallback)UpdatePadsCB); VIDEO_SetPostRetraceCallback ((VIRetraceCallback)UpdatePadsCB);
VIDEO_SetPreRetraceCallback ((VIRetraceCallback)copy_to_xfb); VIDEO_SetPreRetraceCallback ((VIRetraceCallback)copy_to_xfb);
VIDEO_SetBlack (FALSE); VIDEO_SetBlack (FALSE);
VIDEO_Flush (); VIDEO_Flush ();
VIDEO_WaitVSync (); VIDEO_WaitVSync ();
if (vmode->viTVMode & VI_NON_INTERLACE) if (vmode->viTVMode & VI_NON_INTERLACE)
VIDEO_WaitVSync (); VIDEO_WaitVSync ();
copynow = GX_FALSE; copynow = GX_FALSE;
StartGX (); StartGX ();
draw_init ();
#ifdef VIDEO_THREADING #ifdef VIDEO_THREADING
InitVideoThread (); InitVideoThread ();
#endif #endif
/* // Finally, the video is up and ready for use :)
* Finally, the video is up and ready for use :)
*/
}
void ReInitGCVideo()
{
Mtx p;
GX_SetViewport (0, 0, vmode->fbWidth, vmode->efbHeight, 0, 1);
GX_SetDispCopyYScale ((f32) vmode->xfbHeight / (f32) vmode->efbHeight);
GX_SetScissor (0, 0, vmode->fbWidth, vmode->efbHeight);
GX_SetDispCopySrc (0, 0, vmode->fbWidth, vmode->efbHeight);
GX_SetDispCopyDst (vmode->fbWidth, vmode->xfbHeight);
GX_SetCopyFilter (vmode->aa, vmode->sample_pattern, GCSettings.render ? GX_TRUE : GX_FALSE,
vmode->vfilter);
GX_SetFieldMode (vmode->field_rendering,
((vmode->viHeight ==
2 * vmode->xfbHeight) ? GX_ENABLE : GX_DISABLE));
GX_SetPixelFmt (GX_PF_RGB8_Z24, GX_ZC_LINEAR);
// GX_CopyDisp (xfb[whichfb], GX_TRUE);
guPerspective (p, 60, 1.33F, 10.0F, 1000.0F);
GX_LoadProjectionMtx (p, GX_PERSPECTIVE);
} }
/**************************************************************************** /****************************************************************************
* Drawing screen * ResetVideo_Emu
****************************************************************************/ *
* reset the video/rendering mode for the emulator rendering
****************************************************************************/
void void
clearscreen (int colour) ResetVideo_Emu ()
{ {
whichfb ^= 1; GXRModeObj *rmode;
VIDEO_ClearFrameBuffer (vmode, xfb[whichfb], colour); Mtx p;
#ifdef HW_RVL
// on wii copy from memory if (!GCSettings.render) // original render mode
memcpy ((char *) xfb[whichfb], (char *) backdrop, 640 * screenheight * 2); {
#else int i;
// on gc copy from aram for (i=0; i<4; i++) {
ARAMFetch ((char *) xfb[whichfb], (char *) AR_BACKDROP, 640 * screenheight * 2); if (tvmodes[i]->efbHeight == vheight) break;
#endif }
} rmode = tvmodes[i];
}
else
rmode = vmode; // same mode as menu
VIDEO_Configure (rmode);
VIDEO_ClearFrameBuffer (rmode, xfb[whichfb], COLOR_BLACK);
VIDEO_Flush();
VIDEO_WaitVSync();
if (rmode->viTVMode & VI_NON_INTERLACE) VIDEO_WaitVSync();
else while (VIDEO_GetNextField()) VIDEO_WaitVSync();
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);
GX_SetCopyFilter (rmode->aa, rmode->sample_pattern, GCSettings.render ? GX_TRUE : GX_FALSE, rmode->vfilter);
GX_SetFieldMode (rmode->field_rendering, ((rmode->viHeight == 2 * rmode->xfbHeight) ? GX_ENABLE : GX_DISABLE));
GX_SetPixelFmt (GX_PF_RGB8_Z24, GX_ZC_LINEAR);
// guPerspective (p, 60, 1.33F, 10.0F, 1000.0F);
// GX_LoadProjectionMtx (p, GX_PERSPECTIVE);
guOrtho(p, rmode->efbHeight/2, -(rmode->efbHeight/2), -(rmode->fbWidth/2), rmode->fbWidth/2, 10, 1000); // matrix, t, b, l, r, n, f
GX_LoadProjectionMtx (p, GX_ORTHOGRAPHIC);
// DEBUG
char* msg = "";
sprintf (msg, "Interlaced: %i, vwidth: %d, vheight: %d, fb_W: %u, efb_H: %u", IPPU.Interlace, vwidth, vheight, rmode->fbWidth, rmode->efbHeight);
S9xMessage (0, 0, msg);
void
showscreen ()
{
copynow = GX_FALSE;
VIDEO_SetNextFramebuffer (xfb[whichfb]);
VIDEO_Flush ();
VIDEO_WaitVSync ();
} }
/**************************************************************************** /****************************************************************************
* setGFX * ResetVideo_Menu
* *
* Setup the global GFX information for Snes9x * reset the video/rendering mode for the menu
****************************************************************************/ ****************************************************************************/
void void
setGFX () ResetVideo_Menu ()
{ {
GFX.Screen = (unsigned short *) snes9xgfx; Mtx p;
GFX.Pitch = 1024;
VIDEO_Configure (vmode);
VIDEO_ClearFrameBuffer (vmode, xfb[whichfb], COLOR_BLACK);
VIDEO_Flush();
VIDEO_WaitVSync();
if (vmode->viTVMode & VI_NON_INTERLACE) VIDEO_WaitVSync();
else while (VIDEO_GetNextField()) VIDEO_WaitVSync();
GX_SetViewport (0, 0, vmode->fbWidth, vmode->efbHeight, 0, 1);
GX_SetDispCopyYScale ((f32) vmode->xfbHeight / (f32) vmode->efbHeight);
GX_SetScissor (0, 0, vmode->fbWidth, vmode->efbHeight);
GX_SetDispCopySrc (0, 0, vmode->fbWidth, vmode->efbHeight);
GX_SetDispCopyDst (vmode->fbWidth, vmode->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));
GX_SetPixelFmt (GX_PF_RGB8_Z24, GX_ZC_LINEAR);
// guPerspective (p, 60, 1.33F, 10.0F, 1000.0F);
// GX_LoadProjectionMtx (p, GX_PERSPECTIVE);
guOrtho(p, vmode->efbHeight/2, -(vmode->efbHeight/2), -(vmode->fbWidth/2), vmode->fbWidth/2, 10, 1000); // matrix, t, b, l, r, n, f
GX_LoadProjectionMtx (p, GX_ORTHOGRAPHIC);
} }
/**************************************************************************** /****************************************************************************
@ -477,77 +712,146 @@ MakeTexture (const void *src, void *dst, s32 width, s32 height)
void void
update_video (int width, int height) update_video (int width, int height)
{ {
vwidth = width; GXRModeObj *rmode;
vheight = height;
vwidth = width;
vheight = height;
#ifdef VIDEO_THREADING #ifdef VIDEO_THREADING
/* Ensure previous vb has complete */ /* Ensure previous vb has complete */
while ((LWP_ThreadIsSuspended (vbthread) == 0) || (copynow == GX_TRUE)) while ((LWP_ThreadIsSuspended (vbthread) == 0) || (copynow == GX_TRUE))
#else #else
while (copynow == GX_TRUE) while (copynow == GX_TRUE)
#endif #endif
{ {
usleep (50); usleep (50);
} }
whichfb ^= 1;
if ((oldvheight != vheight) || (oldvwidth != vwidth)) whichfb ^= 1;
{
if ((oldvheight != vheight) || (oldvwidth != vwidth)) // if rendered width/height changes
{
int xscale, yscale, xshift, yshift;
yshift = xshift = 0;
ResetVideo_Emu (); // reset video to emulator rendering settings
/** Update scaling **/ /** Update scaling **/
oldvwidth = vwidth; if (!GCSettings.render)
oldvheight = vheight; {
draw_init (); // original render modes
xscale = vwidth / 2;
yscale = vheight / 2;
} else {
xscale = 320;
yscale = (vmode_60hz) ? 240 : 287; // ntsc, pal scaling
}
memset (&view, 0, sizeof (Mtx)); square[6] = square[3] = xscale + xshift;
guLookAt(view, &cam.pos, &cam.up, &cam.view); square[0] = square[9] = -xscale + xshift;
GX_SetViewport (0, 0, vmode->fbWidth, vmode->efbHeight, 0, 1); square[4] = square[1] = yscale + yshift;
} square[7] = square[10] = -yscale + yshift;
GX_InvVtxCache (); draw_init ();
GX_InvalidateTexAll ();
GX_SetTevOp (GX_TEVSTAGE0, GX_DECAL);
GX_SetTevOrder (GX_TEVSTAGE0, GX_TEXCOORD0, GX_TEXMAP0, GX_COLOR0A0);
//GX_SetViewport (0, 0, rmode->fbWidth, rmode->efbHeight, 0, 1);
oldvwidth = vwidth;
oldvheight = vheight;
}
MakeTexture ((char *) GFX.Screen, (char *) texturemem, vwidth, vheight); GX_InvVtxCache ();
GX_InvalidateTexAll ();
MakeTexture ((char *) GFX.Screen, (char *) texturemem, vwidth, vheight);
DCFlushRange (texturemem, TEX_WIDTH * TEX_HEIGHT * 2);
DCFlushRange (texturemem, TEX_WIDTH * TEX_HEIGHT * 2); GX_LoadTexObj (&texobj, GX_TEXMAP0);
GX_SetNumChans (1); draw_square (view);
GX_LoadTexObj (&texobj, GX_TEXMAP0); GX_DrawDone ();
VIDEO_SetNextFramebuffer (xfb[whichfb]);
draw_square (view); VIDEO_Flush ();
copynow = GX_TRUE;
GX_DrawDone ();
VIDEO_SetNextFramebuffer (xfb[whichfb]);
VIDEO_Flush ();
copynow = GX_TRUE;
#ifdef VIDEO_THREADING #ifdef VIDEO_THREADING
/* Return to caller, don't waste time waiting for vb */ /* Return to caller, don't waste time waiting for vb */
LWP_ResumeThread (vbthread); LWP_ResumeThread (vbthread);
#endif #endif
} }
// FIX
/****************************************************************************
* Zoom Functions
****************************************************************************/
void void
zoom (float speed) zoom (float speed)
{ {
Vector v; Vector v;
v.x = cam.view.x - cam.pos.x; v.x = cam.view.x - cam.pos.x;
v.y = cam.view.y - cam.pos.y; v.y = cam.view.y - cam.pos.y;
v.z = cam.view.z - cam.pos.z; v.z = cam.view.z - cam.pos.z;
cam.pos.x += v.x * speed; cam.pos.x += v.x * speed;
cam.pos.z += v.z * speed; cam.pos.z += v.z * speed;
cam.view.x += v.x * speed; cam.view.x += v.x * speed;
cam.view.z += v.z * speed; cam.view.z += v.z * speed;
oldvheight = 0; oldvheight = 0; // update video
} }
void
zoom_reset ()
{
// reset cam to defaults
cam.pos.x = cam.pos.y = cam.pos.z = cam.up.x = cam.up.z = 0.0F;
cam.up.y = 0.0F;
cam.view.z = -0.5F;
oldvheight = 0; // update video
}
/****************************************************************************
* Drawing screen
****************************************************************************/
void
clearscreen (int colour)
{
whichfb ^= 1;
VIDEO_ClearFrameBuffer (vmode, xfb[whichfb], colour);
#ifdef HW_RVL
// on wii copy from memory
memcpy ((char *) xfb[whichfb], (char *) backdrop, 640 * screenheight * 2);
#else
// on gc copy from aram
ARAMFetch ((char *) xfb[whichfb], (char *) AR_BACKDROP, 640 * screenheight * 2);
#endif
}
void
showscreen ()
{
copynow = GX_FALSE;
VIDEO_SetNextFramebuffer (xfb[whichfb]);
VIDEO_Flush ();
VIDEO_WaitVSync ();
}
/****************************************************************************
* setGFX
*
* Setup the global GFX information for Snes9x
****************************************************************************/
void
setGFX ()
{
GFX.Screen = (unsigned short *) snes9xgfx;
GFX.Pitch = 1024;
}

9
source/ngc/video.h
View File

@ -17,12 +17,13 @@
#include "snes9x.h" #include "snes9x.h"
void InitGCVideo (); void InitGCVideo ();
void ReInitGCVideo(); void ResetVideo_Emu ();
void clearscreen (int colour = COLOR_WHITE); void ResetVideo_Menu ();
void showscreen ();
void setGFX (); void setGFX ();
void update_video (int width, int height); void update_video (int width, int height);
void clearscreen (int colour = COLOR_BLACK);
void showscreen ();
void zoom (float speed); void zoom (float speed);
void UpdatePadsCB(); void zoom_reset ();
#endif #endif