+++ /dev/null
-/***************************************************************************\r
- gpu.c - description\r
- -------------------\r
- begin : Sun Mar 08 2009\r
- copyright : (C) 1999-2009 by Pete Bernert\r
- email : BlackDove@addcom.de\r
- ***************************************************************************/\r
-\r
-/***************************************************************************\r
- * *\r
- * This program is free software; you can redistribute it and/or modify *\r
- * it under the terms of the GNU General Public License as published by *\r
- * the Free Software Foundation; either version 2 of the License, or *\r
- * (at your option) any later version. See also the license.txt file for *\r
- * additional informations. *\r
- * *\r
- ***************************************************************************/\r
-\r
-// !!! enable this, if Linux XF86VidMode is not supported: \r
-//#define NOVMODE\r
-\r
-#include "stdafx.h"\r
-#include "config.h"\r
-\r
-#ifndef NOVMODE\r
-#include <X11/extensions/xf86vmode.h>\r
-static XF86VidModeModeInfo **modes=0;\r
-static int iOldMode=0;\r
-#endif\r
-\r
-#define _IN_GPU\r
-\r
-#include "externals.h"\r
-#include "gpu.h"\r
-#include "draw.h"\r
-#include "cfg.h"\r
-#include "prim.h"\r
-#include "psemu_plugin_defs.h"\r
-#include "texture.h"\r
-#include "menu.h"\r
-#include "fps.h"\r
-#include "key.h"\r
-#ifdef ENABLE_NLS\r
-#include <libintl.h>\r
-#include <locale.h>\r
-#define _(x) gettext(x)\r
-#define N_(x) (x)\r
-#else\r
-#define _(x) (x)\r
-#define N_(x) (x)\r
-#endif\r
- \r
-////////////////////////////////////////////////////////////////////////\r
-// PPDK developer must change libraryName field and can change revision and build\r
-////////////////////////////////////////////////////////////////////////\r
-\r
-const unsigned char version = 1; // do not touch - library for PSEmu 1.x\r
-const unsigned char revision = 1;\r
-const unsigned char build = 78;\r
-\r
-static char *libraryName = N_("OpenGL Driver");\r
-\r
-static char *PluginAuthor = N_("Pete Bernert");\r
-static char *libraryInfo = N_("Based on P.E.Op.S. MesaGL Driver V1.78\nCoded by Pete Bernert\n");\r
-\r
-////////////////////////////////////////////////////////////////////////\r
-// memory image of the PSX vram\r
-////////////////////////////////////////////////////////////////////////\r
-\r
-unsigned char *psxVSecure;\r
-unsigned char *psxVub;\r
-signed char *psxVsb;\r
-unsigned short *psxVuw;\r
-unsigned short *psxVuw_eom;\r
-signed short *psxVsw;\r
-uint32_t *psxVul;\r
-signed int *psxVsl;\r
-\r
-// macro for easy access to packet information\r
-#define GPUCOMMAND(x) ((x>>24) & 0xff)\r
-\r
-GLfloat gl_z=0.0f;\r
-BOOL bNeedInterlaceUpdate=FALSE;\r
-BOOL bNeedRGB24Update=FALSE;\r
-BOOL bChangeWinMode=FALSE;\r
-\r
-uint32_t ulStatusControl[256];\r
-\r
-////////////////////////////////////////////////////////////////////////\r
-// global GPU vars\r
-////////////////////////////////////////////////////////////////////////\r
-\r
-static int GPUdataRet;\r
-int lGPUstatusRet;\r
-char szDispBuf[64];\r
-\r
-uint32_t dwGPUVersion = 0;\r
-int iGPUHeight = 512;\r
-int iGPUHeightMask = 511;\r
-int GlobalTextIL = 0;\r
-int iTileCheat = 0;\r
-\r
-static uint32_t gpuDataM[256];\r
-static unsigned char gpuCommand = 0;\r
-static int gpuDataC = 0;\r
-static int gpuDataP = 0;\r
-\r
-VRAMLoad_t VRAMWrite;\r
-VRAMLoad_t VRAMRead;\r
-int iDataWriteMode;\r
-int iDataReadMode;\r
-\r
-int lClearOnSwap;\r
-int lClearOnSwapColor;\r
-BOOL bSkipNextFrame = FALSE;\r
-int iColDepth;\r
-BOOL bChangeRes;\r
-BOOL bWindowMode;\r
-int iWinSize;\r
-\r
-// possible psx display widths\r
-short dispWidths[8] = {256,320,512,640,368,384,512,640};\r
-\r
-PSXDisplay_t PSXDisplay;\r
-PSXDisplay_t PreviousPSXDisplay;\r
-TWin_t TWin;\r
-short imageX0,imageX1;\r
-short imageY0,imageY1;\r
-BOOL bDisplayNotSet = TRUE;\r
-GLuint uiScanLine=0;\r
-int iUseScanLines=0;\r
-int lSelectedSlot=0;\r
-unsigned char * pGfxCardScreen=0;\r
-int iBlurBuffer=0;\r
-int iScanBlend=0;\r
-int iRenderFVR=0;\r
-int iNoScreenSaver=0;\r
-uint32_t ulGPUInfoVals[16];\r
-int iFakePrimBusy = 0;\r
-int iRumbleVal = 0;\r
-int iRumbleTime = 0;\r
-\r
-////////////////////////////////////////////////////////////////////////\r
-// stuff to make this a true PDK module\r
-////////////////////////////////////////////////////////////////////////\r
-\r
-char * CALLBACK PSEgetLibName(void)\r
-{\r
- return _(libraryName);\r
-}\r
-\r
-unsigned long CALLBACK PSEgetLibType(void)\r
-{\r
- return PSE_LT_GPU;\r
-}\r
-\r
-unsigned long CALLBACK PSEgetLibVersion(void)\r
-{\r
- return version<<16|revision<<8|build;\r
-}\r
-\r
-char * GPUgetLibInfos(void)\r
-{\r
- return _(libraryInfo);\r
-}\r
-\r
-////////////////////////////////////////////////////////////////////////\r
-// snapshot funcs (saves screen to bitmap / text infos into file)\r
-////////////////////////////////////////////////////////////////////////\r
-\r
-char * GetConfigInfos(int hW)\r
-{\r
- char szO[2][4]={"off","on "};\r
- char szTxt[256];\r
- char * pB=(char *)malloc(32767);\r
-\r
- if(!pB) return NULL;\r
- *pB=0;\r
- //----------------------------------------------------//\r
- sprintf(szTxt,"Plugin: %s %d.%d.%d\r\n",libraryName,version,revision,build);\r
- strcat(pB,szTxt);\r
- sprintf(szTxt,"Author: %s\r\n",PluginAuthor);\r
- strcat(pB,szTxt);\r
-\r
- sprintf(szTxt,"Card vendor: %s\r\n",(char *)glGetString(GL_VENDOR));\r
- strcat(pB,szTxt);\r
- sprintf(szTxt,"GFX card: %s\r\n",(char *)glGetString(GL_RENDERER));\r
- strcat(pB,szTxt);\r
- sprintf(szTxt,"OGL version: %s\r\n\r\n",(char *)glGetString(GL_VERSION));\r
- strcat(pB,szTxt);\r
- //strcat(pB,(char *)glGetString(GL_EXTENSIONS));\r
- //strcat(pB,"\r\n\r\n");\r
-\r
- if(hW && bWindowMode)\r
- sprintf(szTxt,"Resolution/Color:\r\n- %dx%d ",LOWORD(iWinSize),HIWORD(iWinSize));\r
- else\r
- sprintf(szTxt,"Resolution/Color:\r\n- %dx%d ",iResX,iResY);\r
- strcat(pB,szTxt);\r
- if(bWindowMode) sprintf(szTxt,"Window mode\r\n");\r
- else\r
- {\r
- sprintf(szTxt,"Fullscreen ");\r
- strcat(pB,szTxt);\r
- if(bChangeRes) sprintf(szTxt,"- Desktop changing [%d Bit]\r\n",iColDepth);\r
- else sprintf(szTxt,"- NO desktop changing\r\n");\r
- } \r
- strcat(pB,szTxt);\r
-\r
- if(iForceVSync>=0) sprintf(szTxt,"- V-Sync: %s\r\n",szO[iForceVSync]);\r
- else strcpy(szTxt,"- V-Sync: Driver\r\n");\r
- strcat(pB,szTxt); \r
- sprintf(szTxt,"- Keep psx aspect ratio: %s\r\n\r\n",szO[bKeepRatio]);\r
- strcat(pB,szTxt);\r
- //----------------------------------------------------//\r
- strcpy(szTxt,"Textures:\r\n- ");\r
- if(iTexQuality==0) strcat(szTxt,"Default");\r
- else if(iTexQuality==1) strcat(szTxt,"R4G4B4A4");\r
- else if(iTexQuality==2) strcat(szTxt,"R5G5B5A1");\r
- else if(iTexQuality==3) strcat(szTxt,"R8G8A8A8");\r
- else if(iTexQuality==4) strcat(szTxt,"B8G8R8A8");\r
- if(!hW && bGLExt) strcat(szTxt," (packed pixels)\r\n");\r
- else strcat(szTxt,"\r\n");\r
- strcat(pB,szTxt);\r
- if(!hW)\r
- {\r
- sprintf(szTxt,"- Filtering: %d - edge clamping ",iFilterType);\r
- if(iClampType==GL_TO_EDGE_CLAMP) strcat(szTxt,"supported\r\n");\r
- else strcat(szTxt,"NOT supported\r\n");\r
- }\r
- else sprintf(szTxt,"- iFiltering: %d\r\n",iFilterType);\r
- strcat(pB,szTxt);\r
- sprintf(szTxt,"- Hi-Res textures: %d\r\n",iHiResTextures);\r
- strcat(pB,szTxt); \r
- if(!hW)\r
- {\r
- sprintf(szTxt,"- Palettized tex windows: %s\r\n",szO[iUsePalTextures]);\r
- strcat(pB,szTxt); \r
- }\r
- sprintf(szTxt,"- VRam size: %d MBytes",iVRamSize);\r
- if(!hW)\r
- sprintf(szTxt+strlen(szTxt)," - %d textures usable\r\n\r\n",iSortTexCnt);\r
- else strcat(szTxt,"\r\n\r\n");\r
- strcat(pB,szTxt);\r
- //----------------------------------------------------//\r
- sprintf(szTxt,"Framerate:\r\n- FPS limitation: %s\r\n",szO[bUseFrameLimit]);\r
- strcat(pB,szTxt);\r
- sprintf(szTxt,"- Frame skipping: %s\r\n",szO[bUseFrameSkip]);\r
- strcat(pB,szTxt);\r
- if(iFrameLimit==2)\r
- strcpy(szTxt,"- FPS limit: Auto\r\n\r\n");\r
- else sprintf(szTxt,"- FPS limit: %.1f\r\n\r\n",fFrameRate);\r
- strcat(pB,szTxt);\r
- //----------------------------------------------------//\r
- sprintf(szTxt,"Compatibility:\r\n- Offscreen drawing: %d\r\n",iOffscreenDrawing);\r
- strcat(pB,szTxt);\r
- sprintf(szTxt,"- Framebuffer texture: %d",iFrameTexType);\r
- if(!hW && iFrameTexType==2)\r
- {\r
- if(gTexFrameName) strcat(szTxt," - texture created\r\n");\r
- else strcat(szTxt," - not used yet\r\n");\r
- }\r
- else strcat(szTxt,"\r\n");\r
- strcat(pB,szTxt);\r
- sprintf(szTxt,"- Framebuffer access: %d\r\n",iFrameReadType);\r
- strcat(pB,szTxt);\r
- sprintf(szTxt,"- Alpha multipass: %s\r\n",szO[bOpaquePass]);\r
- strcat(pB,szTxt);\r
- sprintf(szTxt,"- Mask bit: %s\r\n",szO[iUseMask]);\r
- strcat(pB,szTxt);\r
- sprintf(szTxt,"- Advanced blending: %s",szO[bAdvancedBlend]);\r
- if(!hW && bAdvancedBlend)\r
- {\r
- if(bGLBlend) strcat(szTxt," (hardware)\r\n");\r
- else strcat(szTxt," (software)\r\n");\r
- }\r
- else strcat(szTxt,"\r\n");\r
- strcat(pB,szTxt);\r
-\r
- if(!hW)\r
- {\r
- strcpy(szTxt,"- Subtractive blending: ");\r
- if(glBlendEquationEXTEx)\r
- {\r
- if(bUseMultiPass) strcat(szTxt,"supported, but not used!");\r
- else strcat(szTxt,"activated");\r
- }\r
- else strcat(szTxt," NOT supported!");\r
- strcat(szTxt,"\r\n\r\n");\r
- }\r
- else strcpy(szTxt,"\r\n");\r
- \r
- strcat(pB,szTxt); \r
- //----------------------------------------------------//\r
- sprintf(szTxt,"Misc:\r\n- Scanlines: %s",szO[iUseScanLines]);\r
- strcat(pB,szTxt);\r
- if(iUseScanLines) sprintf(szTxt," [%d]\r\n",iScanBlend);\r
- else strcpy(szTxt,"\r\n");\r
- strcat(pB,szTxt);\r
- sprintf(szTxt,"- Line mode: %s\r\n",szO[bUseLines]);\r
- strcat(pB,szTxt);\r
-// sprintf(szTxt,"- Line AA: %s\r\n",szO[bUseAntiAlias]);\r
-// fwrite(szTxt,lstrlen(szTxt),1,txtfile);\r
- sprintf(szTxt,"- Unfiltered FB: %s\r\n",szO[bUseFastMdec]);\r
- strcat(pB,szTxt);\r
- sprintf(szTxt,"- 15 bit FB: %s\r\n",szO[bUse15bitMdec]);\r
- strcat(pB,szTxt);\r
- sprintf(szTxt,"- Dithering: %s\r\n",szO[bDrawDither]);\r
- strcat(pB,szTxt);\r
- sprintf(szTxt,"- Screen smoothing: %s",szO[iBlurBuffer]);\r
- strcat(pB,szTxt);\r
- if(!hW && iBlurBuffer) \r
- {\r
- if(gTexBlurName) strcat(pB," - supported\r\n");\r
- else strcat(pB," - not supported\r\n");\r
- }\r
- else strcat(pB,"\r\n");\r
- sprintf(szTxt,"- Game fixes: %s [%08x]\r\n",szO[bUseFixes],dwCfgFixes);\r
- strcat(pB,szTxt);\r
- //----------------------------------------------------//\r
- return pB;\r
-}\r
-\r
-////////////////////////////////////////////////////////////////////////\r
-// save text infos to file\r
-////////////////////////////////////////////////////////////////////////\r
-\r
-void DoTextSnapShot(int iNum)\r
-{\r
- FILE *txtfile;char szTxt[256];char * pB;\r
-\r
- sprintf(szTxt,"%s/pcsx%04d.txt",getenv("HOME"),iNum);\r
-\r
- if((txtfile=fopen(szTxt,"wb"))==NULL)\r
- return; \r
-\r
- pB=GetConfigInfos(0);\r
- if(pB)\r
- {\r
- fwrite(pB,strlen(pB),1,txtfile);\r
- free(pB);\r
- }\r
- fclose(txtfile); \r
-}\r
-\r
-////////////////////////////////////////////////////////////////////////\r
-// saves screen bitmap to file\r
-////////////////////////////////////////////////////////////////////////\r
-\r
-void DoSnapShot(void)\r
-{\r
- unsigned char * snapshotdumpmem=NULL,* p,c;\r
- FILE *bmpfile;char filename[256];\r
- unsigned char header[0x36];int size;\r
- unsigned char empty[2]={0,0};int i;\r
- unsigned int snapshotnr = 0;\r
- short SnapWidth;\r
- short SnapHeigth;\r
-\r
- bSnapShot=FALSE;\r
-\r
- SnapWidth = iResX;\r
- SnapHeigth = iResY;\r
-\r
- size=SnapWidth * SnapHeigth * 3 + 0x38;\r
-\r
- if((snapshotdumpmem=(unsigned char *)\r
- malloc(SnapWidth*SnapHeigth*3))==NULL)\r
- return;\r
- \r
- // fill in proper values for BMP\r
- for(i=0;i<0x36;i++) header[i]=0;\r
- header[0]='B';\r
- header[1]='M';\r
- header[2]=(unsigned char)(size&0xff);\r
- header[3]=(unsigned char)((size>>8)&0xff);\r
- header[4]=(unsigned char)((size>>16)&0xff);\r
- header[5]=(unsigned char)((size>>24)&0xff);\r
- header[0x0a]=0x36;\r
- header[0x0e]=0x28;\r
- header[0x12]=(unsigned char)(SnapWidth%256);\r
- header[0x13]=(unsigned char)(SnapWidth/256);\r
- header[0x16]=(unsigned char)(SnapHeigth%256);\r
- header[0x17]=(unsigned char)(SnapHeigth/256);\r
- header[0x1a]=0x01;\r
- header[0x1c]=0x18;\r
- header[0x26]=0x12;\r
- header[0x27]=0x0B;\r
- header[0x2A]=0x12;\r
- header[0x2B]=0x0B;\r
-\r
- // increment snapshot value\r
- // get filename\r
- do\r
- {\r
- snapshotnr++;\r
- sprintf(filename,"%s/pcsx%04d.bmp",getenv("HOME"),snapshotnr);\r
- bmpfile=fopen(filename,"rb");\r
- if(bmpfile==NULL)break;\r
- fclose(bmpfile);\r
- if(snapshotnr==9999) break;\r
- }\r
- while(TRUE);\r
-\r
- // try opening new snapshot file\r
- if((bmpfile=fopen(filename,"wb"))==NULL)\r
- {free(snapshotdumpmem);return;}\r
-\r
- fwrite(header,0x36,1,bmpfile);\r
-\r
- glReadPixels(0,0,SnapWidth,SnapHeigth,GL_RGB,\r
- GL_UNSIGNED_BYTE,snapshotdumpmem);\r
- p=snapshotdumpmem;\r
- size=SnapWidth * SnapHeigth;\r
-\r
- for(i=0;i<size;i++,p+=3)\r
- {c=*p;*p=*(p+2);*(p+2)=c;}\r
-\r
- fwrite(snapshotdumpmem,size*3,1,bmpfile);\r
- fwrite(empty,0x2,1,bmpfile);\r
- fclose(bmpfile); \r
- free(snapshotdumpmem);\r
-\r
- DoTextSnapShot(snapshotnr);\r
-} \r
-\r
-void CALLBACK GPUmakeSnapshot(void)\r
-{\r
- bSnapShot = TRUE;\r
-} \r
-\r
-////////////////////////////////////////////////////////////////////////\r
-// GPU INIT... here starts it all (first func called by emu)\r
-////////////////////////////////////////////////////////////////////////\r
-\r
-long CALLBACK GPUinit()\r
-{\r
- memset(ulStatusControl,0,256*sizeof(uint32_t));\r
-\r
- // different ways of accessing PSX VRAM\r
-\r
- psxVSecure=(unsigned char *)malloc((iGPUHeight*2)*1024 + (1024*1024)); // always alloc one extra MB for soft drawing funcs security\r
- if(!psxVSecure) return -1;\r
-\r
- psxVub=psxVSecure+512*1024; // security offset into double sized psx vram!\r
- psxVsb=(signed char *)psxVub;\r
- psxVsw=(signed short *)psxVub;\r
- psxVsl=(signed int *)psxVub;\r
- psxVuw=(unsigned short *)psxVub;\r
- psxVul=(uint32_t *)psxVub;\r
-\r
- psxVuw_eom=psxVuw+1024*iGPUHeight; // pre-calc of end of vram\r
-\r
- memset(psxVSecure,0x00,(iGPUHeight*2)*1024 + (1024*1024));\r
- memset(ulGPUInfoVals,0x00,16*sizeof(uint32_t));\r
-\r
- InitFrameCap(); // init frame rate stuff\r
-\r
- PSXDisplay.RGB24 = 0; // init vars\r
- PreviousPSXDisplay.RGB24= 0;\r
- PSXDisplay.Interlaced = 0;\r
- PSXDisplay.InterlacedTest=0;\r
- PSXDisplay.DrawOffset.x = 0;\r
- PSXDisplay.DrawOffset.y = 0;\r
- PSXDisplay.DrawArea.x0 = 0;\r
- PSXDisplay.DrawArea.y0 = 0;\r
- PSXDisplay.DrawArea.x1 = 320;\r
- PSXDisplay.DrawArea.y1 = 240;\r
- PSXDisplay.DisplayMode.x= 320;\r
- PSXDisplay.DisplayMode.y= 240;\r
- PSXDisplay.Disabled = FALSE;\r
- PreviousPSXDisplay.Range.x0 =0;\r
- PreviousPSXDisplay.Range.x1 =0;\r
- PreviousPSXDisplay.Range.y0 =0;\r
- PreviousPSXDisplay.Range.y1 =0;\r
- PSXDisplay.Range.x0=0;\r
- PSXDisplay.Range.x1=0;\r
- PSXDisplay.Range.y0=0;\r
- PSXDisplay.Range.y1=0;\r
- PreviousPSXDisplay.DisplayPosition.x = 1;\r
- PreviousPSXDisplay.DisplayPosition.y = 1;\r
- PSXDisplay.DisplayPosition.x = 1;\r
- PSXDisplay.DisplayPosition.y = 1;\r
- PreviousPSXDisplay.DisplayModeNew.y=0;\r
- PSXDisplay.Double=1;\r
- GPUdataRet=0x400;\r
-\r
- PSXDisplay.DisplayModeNew.x=0;\r
- PSXDisplay.DisplayModeNew.y=0;\r
-\r
- //PreviousPSXDisplay.Height = PSXDisplay.Height = 239;\r
- \r
- iDataWriteMode = DR_NORMAL;\r
-\r
- // Reset transfer values, to prevent mis-transfer of data\r
- memset(&VRAMWrite,0,sizeof(VRAMLoad_t));\r
- memset(&VRAMRead,0,sizeof(VRAMLoad_t));\r
- \r
- // device initialised already !\r
- //lGPUstatusRet = 0x74000000;\r
-\r
- STATUSREG = 0x14802000;\r
- GPUIsIdle;\r
- GPUIsReadyForCommands;\r
-\r
- return 0;\r
-} \r
-\r
-////////////////////////////////////////////////////////////////////////\r
-// GPU OPEN: funcs to open up the gpu display (Windows)\r
-////////////////////////////////////////////////////////////////////////\r
-\r
-////////////////////////////////////////////////////////////////////////\r
-// LINUX GPU OPEN: func to open up the gpu display (X stuff)\r
-// please note: in linux we are creating our own display, and we return\r
-// the display ID to the main emu... that's cleaner\r
-////////////////////////////////////////////////////////////////////////\r
-\r
-char * pCaptionText=0;\r
-int bFullScreen=0;\r
-Display *display;\r
-\r
-static Cursor cursor;\r
-static XVisualInfo *myvisual;\r
-static Colormap colormap;\r
-static Window window;\r
-\r
-static int bModeChanged=0;\r
-\r
-typedef struct\r
-{\r
-#define MWM_HINTS_DECORATIONS 2\r
- long flags;\r
- long functions;\r
- long decorations;\r
- long input_mode;\r
-} MotifWmHints;\r
-\r
-static int dbdepat[]={GLX_RGBA,GLX_DOUBLEBUFFER,GLX_DEPTH_SIZE,16,None};\r
-static int dbnodepat[]={GLX_RGBA,GLX_DOUBLEBUFFER,None};\r
-static GLXContext cx;\r
-\r
-static int fx=0;\r
-\r
-////////////////////////////////////////////////////////////////////////\r
-\r
-void osd_close_display (void) // close display\r
-{\r
- if(display) // display exists?\r
- {\r
- glXDestroyContext(display,cx); // -> kill context\r
- XFreeColormap(display, colormap); // -> kill colormap\r
- XSync(display,False); // -> sync events\r
-\r
-#ifndef NOVMODE\r
- if(bModeChanged) // -> repair screen mode\r
- {\r
- int myscreen=DefaultScreen(display);\r
- XF86VidModeSwitchToMode(display,myscreen, // --> switch mode back\r
- modes[iOldMode]);\r
- XF86VidModeSetViewPort(display,myscreen,0,0); // --> set viewport upperleft\r
- free(modes); // --> finally kill mode infos\r
- bModeChanged=0; // --> done\r
- }\r
-#endif\r
-\r
- XCloseDisplay(display); // -> close display\r
- }\r
-}\r
-\r
-////////////////////////////////////////////////////////////////////////\r
-\r
-void sysdep_create_display(void) // create display\r
-{\r
- XSetWindowAttributes winattr;float fxgamma=2;\r
- int myscreen;char gammastr[14];\r
- Screen * screen;XEvent event;\r
- XSizeHints hints;XWMHints wm_hints;\r
- MotifWmHints mwmhints;Atom mwmatom;Atom delwindow;\r
- char *glxfx;\r
-\r
- glxfx=getenv("MESA_GLX_FX"); // 3dfx mesa fullscreen flag\r
- if(glxfx)\r
- {\r
- if(glxfx[0]=='f') // -> yup, fullscreen needed\r
- {\r
- fx=1; // -> raise flag\r
- putenv("FX_GLIDE_NO_SPLASH=");\r
- sprintf(gammastr,"SST_GAMMA=%2.1f",fxgamma); // -> set gamma\r
- putenv(gammastr);\r
- }\r
- }\r
-\r
- display=XOpenDisplay(NULL); // open display\r
- if(!display) // no display?\r
- {\r
- fprintf (stderr,"Failed to open display!!!\n");\r
- osd_close_display();\r
- return; // -> bye\r
- }\r
-\r
- myscreen=DefaultScreen(display); // get screen id\r
-\r
-#ifdef NOVMODE\r
- if(bFullScreen) {fx=1;bModeChanged=0;}\r
-#else\r
- if(bFullScreen)\r
- {\r
- XF86VidModeModeLine mode;\r
- int nmodes,iC;\r
- fx=1; // raise flag\r
- XF86VidModeGetModeLine(display,myscreen,&iC,&mode); // get actual mode info\r
- if(mode.privsize) XFree(mode.private); // no need for private stuff\r
- bModeChanged=0; // init mode change flag\r
- if(iResX!=mode.hdisplay || iResY!=mode.vdisplay) // wanted mode is different?\r
- {\r
- XF86VidModeGetAllModeLines(display,myscreen, // -> enum all mode infos\r
- &nmodes,&modes);\r
- if(modes) // -> infos got?\r
- {\r
- for(iC=0;iC<nmodes;++iC) // -> loop modes\r
- {\r
- if(mode.hdisplay==modes[iC]->hdisplay && // -> act mode found?\r
- mode.vdisplay==modes[iC]->vdisplay) // if yes: store mode id\r
- iOldMode=iC;\r
-\r
- if(iResX==modes[iC]->hdisplay && // -> wanted mode found?\r
- iResY==modes[iC]->vdisplay)\r
- {\r
- XF86VidModeSwitchToMode(display,myscreen, // --> switch to mode\r
- modes[iC]);\r
- XF86VidModeSetViewPort(display,myscreen,0,0);\r
- bModeChanged=1; // --> raise flag for repairing mode on close\r
- }\r
- }\r
-\r
- if(bModeChanged==0) // -> no mode found?\r
- {\r
- free(modes); // --> free infos\r
- printf("No proper fullscreen mode found!\n"); // --> some info output\r
- }\r
- }\r
- }\r
- }\r
-#endif\r
-\r
- screen=DefaultScreenOfDisplay(display);\r
-\r
- if(iZBufferDepth) // visual (with or without zbuffer)\r
- myvisual=glXChooseVisual(display,myscreen,dbdepat);\r
- else myvisual=glXChooseVisual(display,myscreen,dbnodepat);\r
-\r
- if(!myvisual) // no visual?\r
- {\r
- fprintf(stderr,"Failed to obtain visual!!!\n"); // -> bye\r
- osd_close_display();\r
- return;\r
- }\r
-\r
- cx=glXCreateContext(display,myvisual,0,GL_TRUE); // create rendering context\r
-\r
- if(!cx) // no context?\r
- {\r
- fprintf(stderr,"Failed to create OpenGL context!!!\n");\r
- osd_close_display(); // -> bxe\r
- return;\r
- }\r
-\r
- // pffff... much work for a simple blank cursor... oh, well...\r
- if(!bFullScreen) cursor=XCreateFontCursor(display,XC_trek);\r
- else\r
- {\r
- Pixmap p1,p2;XImage * img;\r
- XColor b,w;unsigned char * idata;\r
- XGCValues GCv;\r
- GC GCc;\r
-\r
- memset(&b,0,sizeof(XColor));\r
- memset(&w,0,sizeof(XColor));\r
- idata=(unsigned char *)malloc(8);\r
- memset(idata,0,8);\r
-\r
- p1=XCreatePixmap(display,RootWindow(display,myvisual->screen),8,8,1);\r
- p2=XCreatePixmap(display,RootWindow(display,myvisual->screen),8,8,1);\r
-\r
- img = XCreateImage(display,myvisual->visual,\r
- 1,XYBitmap,0,idata,8,8,8,1);\r
-\r
- GCv.function = GXcopy;\r
- GCv.foreground = ~0;\r
- GCv.background = 0;\r
- GCv.plane_mask = AllPlanes;\r
- GCc = XCreateGC(display,p1,\r
- (GCFunction|GCForeground|GCBackground|GCPlaneMask),&GCv);\r
-\r
- XPutImage(display, p1,GCc,img,0,0,0,0,8,8);\r
- XPutImage(display, p2,GCc,img,0,0,0,0,8,8);\r
- XFreeGC(display, GCc);\r
-\r
- cursor = XCreatePixmapCursor(display,p1,p2,&b,&w,0,0);\r
-\r
- XFreePixmap(display,p1);\r
- XFreePixmap(display,p2);\r
- XDestroyImage(img); // will free idata as well\r
- }\r
-\r
- colormap=XCreateColormap(display, // create colormap\r
- RootWindow(display,myvisual->screen),\r
- myvisual->visual,AllocNone);\r
-\r
- winattr.background_pixel=0;\r
- winattr.border_pixel=WhitePixelOfScreen(screen);\r
- winattr.bit_gravity=ForgetGravity;\r
- winattr.win_gravity=NorthWestGravity;\r
- winattr.backing_store=NotUseful;\r
- winattr.override_redirect=False;\r
- winattr.save_under=False;\r
- winattr.event_mask=0;\r
- winattr.do_not_propagate_mask=0;\r
- winattr.colormap=colormap;\r
- winattr.cursor=None;\r
-\r
- window=XCreateWindow(display, // create own window\r
- RootWindow(display,DefaultScreen(display)),\r
- 0,0,iResX,iResY,\r
- 0,myvisual->depth,\r
- InputOutput,myvisual->visual,\r
- CWBorderPixel | CWBackPixel |\r
- CWEventMask | CWDontPropagate |\r
- CWColormap | CWCursor,\r
- &winattr);\r
-\r
- if(!window) // no window?\r
- {\r
- fprintf(stderr,"Failed in XCreateWindow()!!!\n");\r
- osd_close_display(); // -> bye\r
- return;\r
- }\r
-\r
- delwindow = XInternAtom(display,"WM_DELETE_WINDOW",0);\r
- XSetWMProtocols(display, window, &delwindow, 1);\r
-\r
- hints.flags=PMinSize|PMaxSize; // hints\r
- if(fx) hints.flags|=USPosition|USSize;\r
- else hints.flags|=PSize;\r
-\r
- hints.min_width = hints.max_width = hints.base_width = iResX;\r
- hints.min_height = hints.max_height = hints.base_height = iResY;\r
-\r
- wm_hints.input=1;\r
- wm_hints.flags=InputHint;\r
-\r
- XSetWMHints(display,window,&wm_hints);\r
- XSetWMNormalHints(display,window,&hints);\r
- if(pCaptionText) // caption\r
- XStoreName(display,window,pCaptionText);\r
- else XStoreName(display,window,"Pete MesaGL PSX Gpu");\r
-\r
- XDefineCursor(display,window,cursor); // cursor\r
-\r
- if(fx) // window title bar hack\r
- {\r
- mwmhints.flags=MWM_HINTS_DECORATIONS;\r
- mwmhints.decorations=0;\r
- mwmatom=XInternAtom(display,"_MOTIF_WM_HINTS",0);\r
- XChangeProperty(display,window,mwmatom,mwmatom,32,\r
- PropModeReplace,(unsigned char *)&mwmhints,4);\r
- }\r
-\r
- XSelectInput(display,window, // input setup\r
- FocusChangeMask | ExposureMask |\r
- KeyPressMask | KeyReleaseMask);\r
-\r
- XMapRaised(display,window);\r
- XClearWindow(display,window);\r
- XWindowEvent(display,window,ExposureMask,&event);\r
- glXMakeCurrent(display,window,cx);\r
-\r
-/* \r
- printf(glGetString(GL_VENDOR));\r
- printf("\n");\r
- printf(glGetString(GL_RENDERER));\r
- printf("\n");\r
-*/\r
-\r
- if (fx) // after make current: fullscreen resize\r
- {\r
- XResizeWindow(display,window,screen->width,screen->height);\r
- hints.min_width = hints.max_width = hints.base_width = screen->width;\r
- hints.min_height= hints.max_height = hints.base_height = screen->height;\r
- XSetWMNormalHints(display,window,&hints);
-
- // set the window layer for GNOME
- {
- XEvent xev;
-
- memset(&xev, 0, sizeof(xev));
- xev.xclient.type = ClientMessage;
- xev.xclient.serial = 0;
- xev.xclient.send_event = 1;
- xev.xclient.message_type = XInternAtom(display, "_NET_WM_STATE", 0);
- xev.xclient.window = window;
- xev.xclient.format = 32;
- xev.xclient.data.l[0] = 1;
- xev.xclient.data.l[1] = XInternAtom(display, "_NET_WM_STATE_FULLSCREEN", 0);
- xev.xclient.data.l[2] = 0;
- xev.xclient.data.l[3] = 0;
- xev.xclient.data.l[4] = 0;
-
- XSendEvent(display, RootWindow(display, DefaultScreen(display)), 0,
- SubstructureRedirectMask | SubstructureNotifyMask, &xev);
- }
- }\r
-}\r
-\r
-////////////////////////////////////////////////////////////////////////\r
-\r
-long GPUopen(unsigned long * disp,char * CapText,char * CfgFile)\r
-{\r
- pCaptionText=CapText;\r
- pConfigFile=CfgFile;\r
-\r
- ReadConfig(); // read text file for config\r
-\r
- SetFrameRateConfig(); // setup frame rate stuff\r
-\r
- bIsFirstFrame = TRUE; // we have to init later (well, no really... in Linux we do all in GPUopen)\r
-\r
- sysdep_create_display(); // create display\r
-\r
- InitializeTextureStore(); // init texture mem\r
-\r
- rRatioRect.left = rRatioRect.top=0;\r
- rRatioRect.right = iResX;\r
- rRatioRect.bottom = iResY;\r
-\r
- GLinitialize(); // init opengl\r
-\r
- if(disp)\r
- {\r
- *disp=(unsigned long *)display; // return display ID to main emu\r
- }\r
-\r
- if(display) return 0;\r
- return -1;\r
-}\r
-\r
-////////////////////////////////////////////////////////////////////////\r
-// close\r
-////////////////////////////////////////////////////////////////////////\r
-\r
-long GPUclose() // LINUX CLOSE\r
-{\r
- GLcleanup(); // close OGL\r
-\r
- if(pGfxCardScreen) free(pGfxCardScreen); // free helper memory\r
- pGfxCardScreen=0;\r
-\r
- osd_close_display(); // destroy display\r
-\r
- return 0;\r
-}\r
-\r
-////////////////////////////////////////////////////////////////////////\r
-// I shot the sheriff... last function called from emu \r
-////////////////////////////////////////////////////////////////////////\r
-\r
-long CALLBACK GPUshutdown()\r
-{\r
- if(psxVSecure) free(psxVSecure); // kill emulated vram memory\r
- psxVSecure=0;\r
-\r
- return 0;\r
-}\r
-\r
-////////////////////////////////////////////////////////////////////////\r
-// paint it black: simple func to clean up optical border garbage\r
-////////////////////////////////////////////////////////////////////////\r
-\r
-void PaintBlackBorders(void)\r
-{\r
- short s;\r
-\r
- glDisable(GL_SCISSOR_TEST);\r
- if(bTexEnabled) {glDisable(GL_TEXTURE_2D);bTexEnabled=FALSE;}\r
- if(bOldSmoothShaded) {glShadeModel(GL_FLAT);bOldSmoothShaded=FALSE;}\r
- if(bBlendEnable) {glDisable(GL_BLEND);bBlendEnable=FALSE;}\r
- glDisable(GL_ALPHA_TEST);\r
-\r
- glBegin(GL_QUADS);\r
-\r
- vertex[0].c.lcol=0xff000000;\r
- SETCOL(vertex[0]); \r
-\r
- if(PreviousPSXDisplay.Range.x0)\r
- {\r
- s=PreviousPSXDisplay.Range.x0+1;\r
- glVertex3f(0,0,0.99996f);\r
- glVertex3f(0,PSXDisplay.DisplayMode.y,0.99996f);\r
- glVertex3f(s,PSXDisplay.DisplayMode.y,0.99996f);\r
- glVertex3f(s,0,0.99996f);\r
-\r
- s+=PreviousPSXDisplay.Range.x1-2;\r
-\r
- glVertex3f(s,0,0.99996f);\r
- glVertex3f(s,PSXDisplay.DisplayMode.y,0.99996f);\r
- glVertex3f(PSXDisplay.DisplayMode.x,PSXDisplay.DisplayMode.y,0.99996f);\r
- glVertex3f(PSXDisplay.DisplayMode.x,0,0.99996f);\r
- }\r
-\r
- if(PreviousPSXDisplay.Range.y0)\r
- {\r
- s=PreviousPSXDisplay.Range.y0+1;\r
- glVertex3f(0,0,0.99996f);\r
- glVertex3f(0,s,0.99996f);\r
- glVertex3f(PSXDisplay.DisplayMode.x,s,0.99996f);\r
- glVertex3f(PSXDisplay.DisplayMode.x,0,0.99996f);\r
- }\r
-\r
- glEnd();\r
-\r
- glEnable(GL_ALPHA_TEST);\r
- glEnable(GL_SCISSOR_TEST);\r
-}\r
-\r
-////////////////////////////////////////////////////////////////////////\r
-// helper to draw scanlines\r
-////////////////////////////////////////////////////////////////////////\r
-\r
-__inline void XPRIMdrawTexturedQuad(OGLVertex* vertex1, OGLVertex* vertex2, \r
- OGLVertex* vertex3, OGLVertex* vertex4) \r
-{\r
-\r
- glBegin(GL_QUAD_STRIP);\r
- glTexCoord2fv(&vertex1->sow);\r
- glVertex3fv(&vertex1->x);\r
- \r
- glTexCoord2fv(&vertex2->sow);\r
- glVertex3fv(&vertex2->x);\r
- \r
- glTexCoord2fv(&vertex4->sow);\r
- glVertex3fv(&vertex4->x);\r
- \r
- glTexCoord2fv(&vertex3->sow);\r
- glVertex3fv(&vertex3->x);\r
- glEnd();\r
-}\r
-\r
-////////////////////////////////////////////////////////////////////////\r
-// scanlines\r
-////////////////////////////////////////////////////////////////////////\r
-\r
-void SetScanLines(void)\r
-{\r
- glLoadIdentity();\r
- glOrtho(0,iResX,iResY, 0, -1, 1);\r
-\r
- if(bKeepRatio)\r
- glViewport(0,0,iResX,iResY);\r
-\r
- glDisable(GL_SCISSOR_TEST); \r
- glDisable(GL_ALPHA_TEST);\r
- if(bOldSmoothShaded) {glShadeModel(GL_FLAT);bOldSmoothShaded=FALSE;}\r
-\r
- if(iScanBlend<0) // special texture mask scanline mode\r
- {\r
- if(!bTexEnabled) {glEnable(GL_TEXTURE_2D);bTexEnabled=TRUE;}\r
- gTexName=gTexScanName;\r
- glBindTexture(GL_TEXTURE_2D, gTexName);\r
- if(bGLBlend) glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE); \r
- if(!bBlendEnable) {glEnable(GL_BLEND);bBlendEnable=TRUE;}\r
- SetScanTexTrans();\r
-\r
- vertex[0].x=0;\r
- vertex[0].y=iResY;\r
- vertex[0].z=0.99996f;\r
-\r
- vertex[1].x=iResX;\r
- vertex[1].y=iResY;\r
- vertex[1].z=0.99996f;\r
-\r
- vertex[2].x=iResX;\r
- vertex[2].y=0;\r
- vertex[2].z=0.99996f;\r
-\r
- vertex[3].x=0;\r
- vertex[3].y=0;\r
- vertex[3].z=0.99996f;\r
-\r
- vertex[0].sow=0;\r
- vertex[0].tow=0;\r
- vertex[1].sow=(float)iResX/4.0f;\r
- vertex[1].tow=0;\r
- vertex[2].sow=vertex[1].sow;\r
- vertex[2].tow=(float)iResY/4.0f;\r
- vertex[3].sow=0;\r
- vertex[3].tow=vertex[2].tow;\r
-\r
- vertex[0].c.lcol=0xffffffff;\r
- SETCOL(vertex[0]); \r
-\r
- XPRIMdrawTexturedQuad(&vertex[0], &vertex[1], &vertex[2], &vertex[3]);\r
-\r
- if(bGLBlend) glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, COMBINE_EXT); \r
- }\r
- else // typical line mode\r
- {\r
- if(bTexEnabled) {glDisable(GL_TEXTURE_2D);bTexEnabled=FALSE;}\r
-\r
- if(iScanBlend==0)\r
- {\r
- if(bBlendEnable) {glDisable(GL_BLEND);bBlendEnable=FALSE;}\r
- vertex[0].c.lcol=0xff000000;\r
- }\r
- else\r
- {\r
- if(!bBlendEnable) {glEnable(GL_BLEND);bBlendEnable=TRUE;}\r
- SetScanTrans();\r
- vertex[0].c.lcol=iScanBlend<<24;\r
- }\r
-\r
- SETCOL(vertex[0]); \r
-\r
- glCallList(uiScanLine);\r
- }\r
-\r
- glLoadIdentity();\r
- glOrtho(0,PSXDisplay.DisplayMode.x,\r
- PSXDisplay.DisplayMode.y, 0, -1, 1);\r
-\r
- if(bKeepRatio)\r
- glViewport(rRatioRect.left,\r
- iResY-(rRatioRect.top+rRatioRect.bottom),\r
- rRatioRect.right, \r
- rRatioRect.bottom); // init viewport\r
-\r
- glEnable(GL_ALPHA_TEST);\r
- glEnable(GL_SCISSOR_TEST); \r
-}\r
-\r
-////////////////////////////////////////////////////////////////////////\r
-// blur, babe, blur (heavy performance hit for a so-so fullscreen effect)\r
-////////////////////////////////////////////////////////////////////////\r
-\r
-void BlurBackBuffer(void)\r
-{\r
- if(!gTexBlurName) return;\r
-\r
- if(bKeepRatio) glViewport(0,0,iResX,iResY);\r
-\r
- glDisable(GL_SCISSOR_TEST);\r
- glDisable(GL_ALPHA_TEST);\r
- if(bOldSmoothShaded) {glShadeModel(GL_FLAT);bOldSmoothShaded=FALSE;}\r
- if(bBlendEnable) {glDisable(GL_BLEND);bBlendEnable=FALSE;}\r
- if(!bTexEnabled) {glEnable(GL_TEXTURE_2D);bTexEnabled=TRUE;}\r
- if(iZBufferDepth) glDisable(GL_DEPTH_TEST); \r
- if(bDrawDither) glDisable(GL_DITHER); \r
-\r
- gTexName=gTexBlurName;\r
- glBindTexture(GL_TEXTURE_2D, gTexName);\r
-\r
- glCopyTexSubImage2D( GL_TEXTURE_2D, 0, // get back buffer in texture\r
- 0,\r
- 0,\r
- 0,\r
- 0,\r
- iResX,iResY);\r
-\r
- vertex[0].x=0;\r
- vertex[0].y=PSXDisplay.DisplayMode.y;\r
- vertex[1].x=PSXDisplay.DisplayMode.x;\r
- vertex[1].y=PSXDisplay.DisplayMode.y;\r
- vertex[2].x=PSXDisplay.DisplayMode.x;\r
- vertex[2].y=0;\r
- vertex[3].x=0;\r
- vertex[3].y=0;\r
- vertex[0].sow=0;\r
- vertex[0].tow=0;\r
-\r
-#ifdef OWNSCALE\r
- vertex[1].sow=((GLfloat)iFTexA)/256.0f;\r
- vertex[2].tow=((GLfloat)iFTexB)/256.0f;\r
-#else\r
- vertex[1].sow=iFTexA;\r
- vertex[2].tow=iFTexB;\r
-#endif\r
- vertex[1].tow=0;\r
- vertex[2].sow=vertex[1].sow;\r
- vertex[3].sow=0;\r
- vertex[3].tow=vertex[2].tow;\r
- \r
- if(bGLBlend) glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE); \r
- vertex[0].c.lcol=0x7fffffff;\r
- SETCOL(vertex[0]); \r
-\r
- DrawMultiBlur(); // draw the backbuffer texture to create blur effect\r
-\r
- glEnable(GL_ALPHA_TEST);\r
- glEnable(GL_SCISSOR_TEST);\r
- if(iZBufferDepth) glEnable(GL_DEPTH_TEST); \r
- if(bDrawDither) glEnable(GL_DITHER); \r
- if(bGLBlend) glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, COMBINE_EXT); \r
-\r
- if(bKeepRatio)\r
- glViewport(rRatioRect.left, // re-init viewport\r
- iResY-(rRatioRect.top+rRatioRect.bottom),\r
- rRatioRect.right, \r
- rRatioRect.bottom); \r
-}\r
-\r
-////////////////////////////////////////////////////////////////////////\r
-// "unblur" repairs the backbuffer after a blur\r
-\r
-void UnBlurBackBuffer(void)\r
-{\r
- if(!gTexBlurName) return;\r
-\r
- if(bKeepRatio) glViewport(0,0,iResX,iResY);\r
-\r
- glDisable(GL_SCISSOR_TEST);\r
- glDisable(GL_ALPHA_TEST);\r
- if(bBlendEnable) {glDisable(GL_BLEND);bBlendEnable=FALSE;}\r
- if(!bTexEnabled) {glEnable(GL_TEXTURE_2D);bTexEnabled=TRUE;}\r
- if(iZBufferDepth) glDisable(GL_DEPTH_TEST); \r
- if(bDrawDither) glDisable(GL_DITHER); \r
-\r
- gTexName=gTexBlurName;\r
- glBindTexture(GL_TEXTURE_2D, gTexName);\r
-\r
- vertex[0].x=0;\r
- vertex[0].y=PSXDisplay.DisplayMode.y;\r
- vertex[1].x=PSXDisplay.DisplayMode.x;\r
- vertex[1].y=PSXDisplay.DisplayMode.y;\r
- vertex[2].x=PSXDisplay.DisplayMode.x;\r
- vertex[2].y=0;\r
- vertex[3].x=0;\r
- vertex[3].y=0;\r
- vertex[0].sow=0;\r
- vertex[0].tow=0;\r
-#ifdef OWNSCALE\r
- vertex[1].sow=((GLfloat)iFTexA)/256.0f;\r
- vertex[2].tow=((GLfloat)iFTexB)/256.0f;\r
-#else\r
- vertex[1].sow=iFTexA;\r
- vertex[2].tow=iFTexB;\r
-#endif\r
- vertex[1].tow=0;\r
- vertex[2].sow=vertex[1].sow;\r
- vertex[3].sow=0;\r
- vertex[3].tow=vertex[2].tow;\r
- if(bGLBlend) glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE); \r
- vertex[0].c.lcol=0xffffffff;\r
- SETCOL(vertex[0]); \r
-\r
- // simply draw the backbuffer texture (without blur)\r
- XPRIMdrawTexturedQuad(&vertex[0], &vertex[1], &vertex[2], &vertex[3]);\r
-\r
- glEnable(GL_ALPHA_TEST);\r
- glEnable(GL_SCISSOR_TEST);\r
- if(iZBufferDepth) glEnable(GL_DEPTH_TEST); \r
- if(bDrawDither) glEnable(GL_DITHER); // dither mode\r
- if(bGLBlend) glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, COMBINE_EXT); \r
-\r
- if(bKeepRatio)\r
- glViewport(rRatioRect.left,\r
- iResY-(rRatioRect.top+rRatioRect.bottom),\r
- rRatioRect.right, \r
- rRatioRect.bottom); // init viewport\r
-}\r
-\r
-////////////////////////////////////////////////////////////////////////\r
-// Update display (swap buffers)... called in interlaced mode on \r
-// every emulated vsync, otherwise whenever the displayed screen region\r
-// has been changed\r
-////////////////////////////////////////////////////////////////////////\r
-\r
-int iLastRGB24=0; // special vars for checking when to skip two display updates\r
-int iSkipTwo=0;\r
-\r
-void updateDisplay(void) // UPDATE DISPLAY\r
-{\r
- BOOL bBlur=FALSE;\r
-\r
- bFakeFrontBuffer=FALSE;\r
- bRenderFrontBuffer=FALSE;\r
-\r
- if(iRenderFVR) // frame buffer read fix mode still active?\r
- {\r
- iRenderFVR--; // -> if some frames in a row without read access: turn off mode\r
- if(!iRenderFVR) bFullVRam=FALSE;\r
- }\r
-\r
- if(iLastRGB24 && iLastRGB24!=PSXDisplay.RGB24+1) // (mdec) garbage check\r
- {\r
- iSkipTwo=2; // -> skip two frames to avoid garbage if color mode changes\r
- }\r
- iLastRGB24=0;\r
-\r
- if(PSXDisplay.RGB24)// && !bNeedUploadAfter) // (mdec) upload wanted?\r
- {\r
- PrepareFullScreenUpload(-1);\r
- UploadScreen(PSXDisplay.Interlaced); // -> upload whole screen from psx vram\r
- bNeedUploadTest=FALSE;\r
- bNeedInterlaceUpdate=FALSE;\r
- bNeedUploadAfter=FALSE;\r
- bNeedRGB24Update=FALSE;\r
- }\r
- else\r
- if(bNeedInterlaceUpdate) // smaller upload?\r
- {\r
- bNeedInterlaceUpdate=FALSE;\r
- xrUploadArea=xrUploadAreaIL; // -> upload this rect\r
- UploadScreen(TRUE);\r
- }\r
-\r
- if(dwActFixes&512) bCheckFF9G4(NULL); // special game fix for FF9 \r
-\r
- if(PreviousPSXDisplay.Range.x0|| // paint black borders around display area, if needed\r
- PreviousPSXDisplay.Range.y0)\r
- PaintBlackBorders();\r
-\r
- if(PSXDisplay.Disabled) // display disabled?\r
- {\r
- // moved here\r
- glDisable(GL_SCISSOR_TEST); \r
- glClearColor(0,0,0,128); // -> clear whole backbuffer\r
- glClear(uiBufferBits);\r
- glEnable(GL_SCISSOR_TEST); \r
- gl_z=0.0f;\r
- bDisplayNotSet = TRUE;\r
- }\r
-\r
- if(iSkipTwo) // we are in skipping mood?\r
- {\r
- iSkipTwo--;\r
- iDrawnSomething=0; // -> simply lie about something drawn\r
- }\r
-\r
- if(iBlurBuffer && !bSkipNextFrame) // "blur display" activated?\r
- {BlurBackBuffer();bBlur=TRUE;} // -> blur it\r
-\r
- if(iUseScanLines) SetScanLines(); // "scan lines" activated? do it\r
-\r
- if(usCursorActive) ShowGunCursor(); // "gun cursor" wanted? show 'em\r
-\r
- if(dwActFixes&128) // special FPS limitation mode?\r
- {\r
- if(bUseFrameLimit) PCFrameCap(); // -> ok, do it\r
- if(bUseFrameSkip || ulKeybits&KEY_SHOWFPS) \r
- PCcalcfps(); \r
- }\r
-\r
- if(gTexPicName) DisplayPic(); // some gpu info picture active? display it\r
-\r
- if(bSnapShot) DoSnapShot(); // snapshot key pressed? cheeeese :)\r
-\r
- if(ulKeybits&KEY_SHOWFPS) // wanna see FPS?\r
- {\r
- sprintf(szDispBuf,"%06.1f",fps_cur);\r
- DisplayText(); // -> show it\r
- }\r
-\r
- //----------------------------------------------------//\r
- // main buffer swapping (well, or skip it)\r
-\r
- if(bUseFrameSkip) // frame skipping active ?\r
- {\r
- if(!bSkipNextFrame) \r
- {\r
- if(iDrawnSomething)\r
- glXSwapBuffers(display,window);\r
- }\r
- if(dwActFixes&0x180) // -> special old frame skipping: skip max one in a row\r
- {\r
- if((fps_skip < fFrameRateHz) && !(bSkipNextFrame)) \r
- {bSkipNextFrame = TRUE; fps_skip=fFrameRateHz;}\r
- else bSkipNextFrame = FALSE;\r
- }\r
- else FrameSkip();\r
- }\r
- else // no skip ?\r
- {\r
- if(iDrawnSomething)\r
- glXSwapBuffers(display,window);\r
- }\r
-\r
- iDrawnSomething=0;\r
-\r
- //----------------------------------------------------//\r
-\r
- if(lClearOnSwap) // clear buffer after swap?\r
- {\r
- GLclampf g,b,r;\r
-\r
- if(bDisplayNotSet) // -> set new vals\r
- SetOGLDisplaySettings(1);\r
-\r
- g=((GLclampf)GREEN(lClearOnSwapColor))/255.0f; // -> get col\r
- b=((GLclampf)BLUE(lClearOnSwapColor))/255.0f;\r
- r=((GLclampf)RED(lClearOnSwapColor))/255.0f;\r
- \r
- glDisable(GL_SCISSOR_TEST); \r
- glClearColor(r,g,b,128); // -> clear \r
- glClear(uiBufferBits);\r
- glEnable(GL_SCISSOR_TEST); \r
- lClearOnSwap=0; // -> done\r
- }\r
- else \r
- {\r
- if(bBlur) UnBlurBackBuffer(); // unblur buff, if blurred before\r
-\r
- if(iZBufferDepth) // clear zbuffer as well (if activated)\r
- {\r
- glDisable(GL_SCISSOR_TEST); \r
- glClear(GL_DEPTH_BUFFER_BIT);\r
- glEnable(GL_SCISSOR_TEST); \r
- }\r
- }\r
- gl_z=0.0f;\r
-\r
- //----------------------------------------------------//\r
- // additional uploads immediatly after swapping\r
-\r
- if(bNeedUploadAfter) // upload wanted?\r
- {\r
- bNeedUploadAfter=FALSE; \r
- bNeedUploadTest=FALSE;\r
- UploadScreen(-1); // -> upload\r
- }\r
- \r
- if(bNeedUploadTest)\r
- {\r
- bNeedUploadTest=FALSE;\r
- if(PSXDisplay.InterlacedTest &&\r
- //iOffscreenDrawing>2 &&\r
- PreviousPSXDisplay.DisplayPosition.x==PSXDisplay.DisplayPosition.x &&\r
- PreviousPSXDisplay.DisplayEnd.x==PSXDisplay.DisplayEnd.x &&\r
- PreviousPSXDisplay.DisplayPosition.y==PSXDisplay.DisplayPosition.y &&\r
- PreviousPSXDisplay.DisplayEnd.y==PSXDisplay.DisplayEnd.y)\r
- {\r
- PrepareFullScreenUpload(TRUE);\r
- UploadScreen(TRUE);\r
- }\r
- }\r
-\r
- //----------------------------------------------------//\r
- // rumbling (main emu pad effect)\r
-\r
- if(iRumbleTime) // shake screen by modifying view port\r
- {\r
- int i1=0,i2=0,i3=0,i4=0;\r
-\r
- iRumbleTime--;\r
- if(iRumbleTime) \r
- {\r
- i1=((rand()*iRumbleVal)/RAND_MAX)-(iRumbleVal/2); \r
- i2=((rand()*iRumbleVal)/RAND_MAX)-(iRumbleVal/2); \r
- i3=((rand()*iRumbleVal)/RAND_MAX)-(iRumbleVal/2); \r
- i4=((rand()*iRumbleVal)/RAND_MAX)-(iRumbleVal/2); \r
- }\r
-\r
- glViewport(rRatioRect.left+i1, \r
- iResY-(rRatioRect.top+rRatioRect.bottom)+i2,\r
- rRatioRect.right+i3, \r
- rRatioRect.bottom+i4); \r
- }\r
-\r
- if(ulKeybits&KEY_RESETTEXSTORE) ResetStuff(); // reset on gpu mode changes? do it before next frame is filled\r
-}\r
-\r
-////////////////////////////////////////////////////////////////////////\r
-// update front display: smaller update func, if something has changed \r
-// in the frontbuffer... dirty, but hey... real men know no pain\r
-////////////////////////////////////////////////////////////////////////\r
-\r
-void updateFrontDisplay(void)\r
-{\r
- if(PreviousPSXDisplay.Range.x0||\r
- PreviousPSXDisplay.Range.y0)\r
- PaintBlackBorders();\r
-\r
- if(iBlurBuffer) BlurBackBuffer();\r
-\r
- if(iUseScanLines) SetScanLines();\r
-\r
- if(usCursorActive) ShowGunCursor();\r
-\r
- bFakeFrontBuffer=FALSE;\r
- bRenderFrontBuffer=FALSE;\r
-\r
- if(gTexPicName) DisplayPic();\r
- if(ulKeybits&KEY_SHOWFPS) DisplayText();\r
-\r
- if(iDrawnSomething) // linux:\r
- glXSwapBuffers(display,window);\r
-\r
- if(iBlurBuffer) UnBlurBackBuffer();\r
-}\r
- \r
-////////////////////////////////////////////////////////////////////////\r
-// check if update needed\r
-////////////////////////////////////////////////////////////////////////\r
-\r
-void ChangeDispOffsetsX(void) // CENTER X\r
-{\r
- int lx,l;short sO;\r
-\r
- if(!PSXDisplay.Range.x1) return; // some range given?\r
-\r
- l=PSXDisplay.DisplayMode.x;\r
-\r
- l*=(int)PSXDisplay.Range.x1; // some funky calculation\r
- l/=2560;lx=l;l&=0xfffffff8;\r
- \r
- if(l==PreviousPSXDisplay.Range.x1) return; // some change?\r
-\r
- sO=PreviousPSXDisplay.Range.x0; // store old\r
-\r
- if(lx>=PSXDisplay.DisplayMode.x) // range bigger?\r
- {\r
- PreviousPSXDisplay.Range.x1= // -> take display width\r
- PSXDisplay.DisplayMode.x;\r
- PreviousPSXDisplay.Range.x0=0; // -> start pos is 0\r
- }\r
- else // range smaller? center it\r
- {\r
- PreviousPSXDisplay.Range.x1=l; // -> store width (8 pixel aligned)\r
- PreviousPSXDisplay.Range.x0= // -> calc start pos\r
- (PSXDisplay.Range.x0-500)/8;\r
- if(PreviousPSXDisplay.Range.x0<0) // -> we don't support neg. values yet\r
- PreviousPSXDisplay.Range.x0=0;\r
-\r
- if((PreviousPSXDisplay.Range.x0+lx)> // -> uhuu... that's too much\r
- PSXDisplay.DisplayMode.x)\r
- {\r
- PreviousPSXDisplay.Range.x0= // -> adjust start\r
- PSXDisplay.DisplayMode.x-lx;\r
- PreviousPSXDisplay.Range.x1+=lx-l; // -> adjust width\r
- } \r
- }\r
-\r
- if(sO!=PreviousPSXDisplay.Range.x0) // something changed?\r
- {\r
- bDisplayNotSet=TRUE; // -> recalc display stuff\r
- }\r
-}\r
-\r
-////////////////////////////////////////////////////////////////////////\r
-\r
-void ChangeDispOffsetsY(void) // CENTER Y\r
-{\r
- int iT;short sO; // store previous y size\r
-\r
- if(PSXDisplay.PAL) iT=48; else iT=28; // different offsets on PAL/NTSC\r
-\r
- if(PSXDisplay.Range.y0>=iT) // crossed the security line? :)\r
- {\r
- PreviousPSXDisplay.Range.y1= // -> store width\r
- PSXDisplay.DisplayModeNew.y;\r
- \r
- sO=(PSXDisplay.Range.y0-iT-4)*PSXDisplay.Double; // -> calc offset\r
- if(sO<0) sO=0;\r
-\r
- PSXDisplay.DisplayModeNew.y+=sO; // -> add offset to y size, too\r
- }\r
- else sO=0; // else no offset\r
-\r
- if(sO!=PreviousPSXDisplay.Range.y0) // something changed?\r
- {\r
- PreviousPSXDisplay.Range.y0=sO;\r
- bDisplayNotSet=TRUE; // -> recalc display stuff\r
- }\r
-}\r
-\r
-////////////////////////////////////////////////////////////////////////\r
-// Aspect ratio of ogl screen: simply adjusting ogl view port\r
-////////////////////////////////////////////////////////////////////////\r
-\r
-void SetAspectRatio(void)\r
-{\r
- float xs,ys,s;RECT r;\r
-\r
- if(!PSXDisplay.DisplayModeNew.x) return;\r
- if(!PSXDisplay.DisplayModeNew.y) return;\r
-\r
- xs=(float)iResX/(float)PSXDisplay.DisplayModeNew.x;\r
- ys=(float)iResY/(float)PSXDisplay.DisplayModeNew.y;\r
-\r
- s=min(xs,ys);\r
- r.right =(int)((float)PSXDisplay.DisplayModeNew.x*s);\r
- r.bottom=(int)((float)PSXDisplay.DisplayModeNew.y*s);\r
- if(r.right > iResX) r.right = iResX;\r
- if(r.bottom > iResY) r.bottom = iResY;\r
- if(r.right < 1) r.right = 1;\r
- if(r.bottom < 1) r.bottom = 1;\r
-\r
- r.left = (iResX-r.right)/2;\r
- r.top = (iResY-r.bottom)/2;\r
-\r
- if(r.bottom<rRatioRect.bottom ||\r
- r.right <rRatioRect.right)\r
- {\r
- RECT rC;\r
- glClearColor(0,0,0,128); \r
-\r
- if(r.right <rRatioRect.right)\r
- {\r
- rC.left=0;\r
- rC.top=0;\r
- rC.right=r.left;\r
- rC.bottom=iResY;\r
- glScissor(rC.left,rC.top,rC.right,rC.bottom);\r
- glClear(uiBufferBits);\r
- rC.left=iResX-rC.right;\r
- glScissor(rC.left,rC.top,rC.right,rC.bottom);\r
- glClear(uiBufferBits);\r
- }\r
-\r
- if(r.bottom <rRatioRect.bottom)\r
- {\r
- rC.left=0;\r
- rC.top=0;\r
- rC.right=iResX;\r
- rC.bottom=r.top;\r
- glScissor(rC.left,rC.top,rC.right,rC.bottom);\r
- glClear(uiBufferBits);\r
- rC.top=iResY-rC.bottom;\r
- glScissor(rC.left,rC.top,rC.right,rC.bottom);\r
- glClear(uiBufferBits);\r
- }\r
- \r
- bSetClip=TRUE;\r
- bDisplayNotSet=TRUE;\r
- }\r
-\r
- rRatioRect=r;\r
-\r
-\r
- glViewport(rRatioRect.left,\r
- iResY-(rRatioRect.top+rRatioRect.bottom),\r
- rRatioRect.right,\r
- rRatioRect.bottom); // init viewport\r
-}\r
-\r
-////////////////////////////////////////////////////////////////////////\r
-// big ass check, if an ogl swap buffer is needed\r
-////////////////////////////////////////////////////////////////////////\r
-\r
-void updateDisplayIfChanged(void)\r
-{\r
- BOOL bUp;\r
-\r
- if ((PSXDisplay.DisplayMode.y == PSXDisplay.DisplayModeNew.y) && \r
- (PSXDisplay.DisplayMode.x == PSXDisplay.DisplayModeNew.x))\r
- {\r
- if((PSXDisplay.RGB24 == PSXDisplay.RGB24New) && \r
- (PSXDisplay.Interlaced == PSXDisplay.InterlacedNew)) \r
- return; // nothing has changed? fine, no swap buffer needed\r
- }\r
- else // some res change?\r
- {\r
- glLoadIdentity();\r
- glOrtho(0,PSXDisplay.DisplayModeNew.x, // -> new psx resolution\r
- PSXDisplay.DisplayModeNew.y, 0, -1, 1);\r
- if(bKeepRatio) SetAspectRatio();\r
- }\r
-\r
- bDisplayNotSet = TRUE; // re-calc offsets/display area\r
- \r
- bUp=FALSE;\r
- if(PSXDisplay.RGB24!=PSXDisplay.RGB24New) // clean up textures, if rgb mode change (usually mdec on/off)\r
- {\r
- PreviousPSXDisplay.RGB24=0; // no full 24 frame uploaded yet\r
- ResetTextureArea(FALSE);\r
- bUp=TRUE;\r
- }\r
-\r
- PSXDisplay.RGB24 = PSXDisplay.RGB24New; // get new infos\r
- PSXDisplay.DisplayMode.y = PSXDisplay.DisplayModeNew.y;\r
- PSXDisplay.DisplayMode.x = PSXDisplay.DisplayModeNew.x;\r
- PSXDisplay.Interlaced = PSXDisplay.InterlacedNew;\r
- \r
- PSXDisplay.DisplayEnd.x= // calc new ends\r
- PSXDisplay.DisplayPosition.x+ PSXDisplay.DisplayMode.x;\r
- PSXDisplay.DisplayEnd.y=\r
- PSXDisplay.DisplayPosition.y+ PSXDisplay.DisplayMode.y+PreviousPSXDisplay.DisplayModeNew.y;\r
- PreviousPSXDisplay.DisplayEnd.x=\r
- PreviousPSXDisplay.DisplayPosition.x+ PSXDisplay.DisplayMode.x;\r
- PreviousPSXDisplay.DisplayEnd.y=\r
- PreviousPSXDisplay.DisplayPosition.y+ PSXDisplay.DisplayMode.y+PreviousPSXDisplay.DisplayModeNew.y;\r
-\r
- ChangeDispOffsetsX();\r
-\r
- if(iFrameLimit==2) SetAutoFrameCap(); // set new fps limit vals (depends on interlace)\r
-\r
- if(bUp) updateDisplay(); // yeah, real update (swap buffer)\r
-}\r
-\r
-////////////////////////////////////////////////////////////////////////\r
-// swap update check (called by psx vsync function)\r
-////////////////////////////////////////////////////////////////////////\r
-\r
-BOOL bSwapCheck(void)\r
-{\r
- static int iPosCheck=0;\r
- static PSXPoint_t pO;\r
- static PSXPoint_t pD;\r
- static int iDoAgain=0;\r
-\r
- if(PSXDisplay.DisplayPosition.x==pO.x &&\r
- PSXDisplay.DisplayPosition.y==pO.y &&\r
- PSXDisplay.DisplayEnd.x==pD.x &&\r
- PSXDisplay.DisplayEnd.y==pD.y)\r
- iPosCheck++;\r
- else iPosCheck=0;\r
-\r
- pO=PSXDisplay.DisplayPosition;\r
- pD=PSXDisplay.DisplayEnd;\r
-\r
- if(iPosCheck<=4) return FALSE;\r
-\r
- iPosCheck=4;\r
-\r
- if(PSXDisplay.Interlaced) return FALSE;\r
-\r
- if (bNeedInterlaceUpdate||\r
- bNeedRGB24Update ||\r
- bNeedUploadAfter|| \r
- bNeedUploadTest || \r
- iDoAgain\r
- )\r
- {\r
- iDoAgain=0;\r
- if(bNeedUploadAfter) \r
- iDoAgain=1;\r
- if(bNeedUploadTest && PSXDisplay.InterlacedTest)\r
- iDoAgain=1;\r
-\r
- bDisplayNotSet = TRUE;\r
- updateDisplay();\r
-\r
- PreviousPSXDisplay.DisplayPosition.x=PSXDisplay.DisplayPosition.x;\r
- PreviousPSXDisplay.DisplayPosition.y=PSXDisplay.DisplayPosition.y;\r
- PreviousPSXDisplay.DisplayEnd.x=PSXDisplay.DisplayEnd.x;\r
- PreviousPSXDisplay.DisplayEnd.y=PSXDisplay.DisplayEnd.y;\r
- pO=PSXDisplay.DisplayPosition;\r
- pD=PSXDisplay.DisplayEnd;\r
-\r
- return TRUE;\r
- }\r
-\r
- return FALSE;\r
-} \r
-\r
-////////////////////////////////////////////////////////////////////////\r
-// gun cursor func: player=0-7, x=0-511, y=0-255\r
-////////////////////////////////////////////////////////////////////////\r
-\r
-void CALLBACK GPUcursor(int iPlayer,int x,int y)\r
-{\r
- if(iPlayer<0) return;\r
- if(iPlayer>7) return;\r
-\r
- usCursorActive|=(1<<iPlayer);\r
-\r
- if(x<0) x=0;\r
- if(x>iGPUHeightMask) x=iGPUHeightMask;\r
- if(y<0) y=0;\r
- if(y>255) y=255;\r
-\r
- ptCursorPoint[iPlayer].x=x;\r
- ptCursorPoint[iPlayer].y=y;\r
-}\r
-\r
-////////////////////////////////////////////////////////////////////////\r
-// update lace is called every VSync. Basically we limit frame rate \r
-// here, and in interlaced mode we swap ogl display buffers.\r
-////////////////////////////////////////////////////////////////////////\r
-\r
-static unsigned short usFirstPos=2;\r
-\r
-void CALLBACK GPUupdateLace(void)\r
-{\r
- if(!(dwActFixes&0x1000)) \r
- STATUSREG^=0x80000000; // interlaced bit toggle, if the CC game fix is not active (see gpuReadStatus)\r
-\r
- if(!(dwActFixes&128)) // normal frame limit func\r
- CheckFrameRate();\r
-\r
- if(iOffscreenDrawing==4) // special check if high offscreen drawing is on\r
- {\r
- if(bSwapCheck()) return;\r
- }\r
-\r
- if(PSXDisplay.Interlaced) // interlaced mode?\r
- {\r
- if(PSXDisplay.DisplayMode.x>0 && PSXDisplay.DisplayMode.y>0)\r
- {\r
- updateDisplay(); // -> swap buffers (new frame)\r
- }\r
- }\r
- else if(bRenderFrontBuffer) // no interlace mode? and some stuff in front has changed?\r
- {\r
- updateFrontDisplay(); // -> update front buffer\r
- }\r
- else if(usFirstPos==1) // initial updates (after startup)\r
- {\r
- updateDisplay();\r
- }\r
-}\r
-\r
-////////////////////////////////////////////////////////////////////////\r
-// process read request from GPU status register\r
-////////////////////////////////////////////////////////////////////////\r
-\r
-uint32_t CALLBACK GPUreadStatus(void)\r
-{\r
- if(dwActFixes&0x1000) // CC game fix\r
- {\r
- static int iNumRead=0;\r
- if((iNumRead++)==2)\r
- {\r
- iNumRead=0;\r
- STATUSREG^=0x80000000; // interlaced bit toggle... we do it on every second read status... needed by some games (like ChronoCross)\r
- }\r
- }\r
-\r
- if(iFakePrimBusy) // 27.10.2007 - emulating some 'busy' while drawing... pfff... not perfect, but since our emulated dma is not done in an extra thread...\r
- {\r
- iFakePrimBusy--;\r
-\r
- if(iFakePrimBusy&1) // we do a busy-idle-busy-idle sequence after/while drawing prims\r
- {\r
- GPUIsBusy;\r
- GPUIsNotReadyForCommands;\r
- }\r
- else\r
- {\r
- GPUIsIdle;\r
- GPUIsReadyForCommands;\r
- }\r
- }\r
-\r
- return STATUSREG;\r
-}\r
-\r
-////////////////////////////////////////////////////////////////////////\r
-// processes data send to GPU status register\r
-// these are always single packet commands.\r
-////////////////////////////////////////////////////////////////////////\r
-\r
-void CALLBACK GPUwriteStatus(uint32_t gdata)\r
-{\r
- uint32_t lCommand=(gdata>>24)&0xff;\r
- \r
- ulStatusControl[lCommand]=gdata;\r
-\r
- switch(lCommand)\r
- {\r
- //--------------------------------------------------//\r
- // reset gpu\r
- case 0x00:\r
- memset(ulGPUInfoVals, 0x00, 16 * sizeof(uint32_t));\r
- lGPUstatusRet = 0x14802000;\r
- PSXDisplay.Disabled=1;\r
- iDataWriteMode=iDataReadMode=DR_NORMAL;\r
- PSXDisplay.DrawOffset.x=PSXDisplay.DrawOffset.y=0;\r
- drawX=drawY=0;drawW=drawH=0;\r
- sSetMask=0;lSetMask=0;bCheckMask=FALSE;iSetMask=0;\r
- usMirror=0;\r
- GlobalTextAddrX=0;GlobalTextAddrY=0;\r
- GlobalTextTP=0;GlobalTextABR=0;\r
- PSXDisplay.RGB24=FALSE;\r
- PSXDisplay.Interlaced=FALSE;\r
- bUsingTWin = FALSE;\r
- return;\r
-\r
- // dis/enable display\r
- case 0x03: \r
- PreviousPSXDisplay.Disabled = PSXDisplay.Disabled;\r
- PSXDisplay.Disabled = (gdata & 1);\r
-\r
- if(PSXDisplay.Disabled) \r
- STATUSREG|=GPUSTATUS_DISPLAYDISABLED;\r
- else STATUSREG&=~GPUSTATUS_DISPLAYDISABLED;\r
-\r
- if (iOffscreenDrawing==4 &&\r
- PreviousPSXDisplay.Disabled && \r
- !(PSXDisplay.Disabled))\r
- {\r
-\r
- if(!PSXDisplay.RGB24)\r
- {\r
- PrepareFullScreenUpload(TRUE);\r
- UploadScreen(TRUE); \r
- updateDisplay();\r
- }\r
- }\r
-\r
- return;\r
-\r
- // setting transfer mode\r
- case 0x04:\r
- gdata &= 0x03; // only want the lower two bits\r
-\r
- iDataWriteMode=iDataReadMode=DR_NORMAL;\r
- if(gdata==0x02) iDataWriteMode=DR_VRAMTRANSFER;\r
- if(gdata==0x03) iDataReadMode =DR_VRAMTRANSFER;\r
-\r
- STATUSREG&=~GPUSTATUS_DMABITS; // clear the current settings of the DMA bits\r
- STATUSREG|=(gdata << 29); // set the DMA bits according to the received data\r
-\r
- return;\r
-\r
- // setting display position\r
- case 0x05: \r
- {\r
- short sx=(short)(gdata & 0x3ff);\r
- short sy;\r
-\r
- if(iGPUHeight==1024)\r
- {\r
- if(dwGPUVersion==2) \r
- sy = (short)((gdata>>12)&0x3ff);\r
- else sy = (short)((gdata>>10)&0x3ff);\r
- }\r
- else sy = (short)((gdata>>10)&0x3ff); // really: 0x1ff, but we adjust it later\r
-\r
- if (sy & 0x200) \r
- {\r
- sy|=0xfc00;\r
- PreviousPSXDisplay.DisplayModeNew.y=sy/PSXDisplay.Double;\r
- sy=0;\r
- }\r
- else PreviousPSXDisplay.DisplayModeNew.y=0;\r
-\r
- if(sx>1000) sx=0;\r
-\r
- if(usFirstPos)\r
- {\r
- usFirstPos--;\r
- if(usFirstPos)\r
- {\r
- PreviousPSXDisplay.DisplayPosition.x = sx;\r
- PreviousPSXDisplay.DisplayPosition.y = sy;\r
- PSXDisplay.DisplayPosition.x = sx;\r
- PSXDisplay.DisplayPosition.y = sy;\r
- }\r
- }\r
-\r
- if(dwActFixes&8) \r
- {\r
- if((!PSXDisplay.Interlaced) &&\r
- PreviousPSXDisplay.DisplayPosition.x == sx &&\r
- PreviousPSXDisplay.DisplayPosition.y == sy)\r
- return;\r
-\r
- PSXDisplay.DisplayPosition.x = PreviousPSXDisplay.DisplayPosition.x;\r
- PSXDisplay.DisplayPosition.y = PreviousPSXDisplay.DisplayPosition.y;\r
- PreviousPSXDisplay.DisplayPosition.x = sx;\r
- PreviousPSXDisplay.DisplayPosition.y = sy;\r
- }\r
- else\r
- {\r
- if((!PSXDisplay.Interlaced) &&\r
- PSXDisplay.DisplayPosition.x == sx &&\r
- PSXDisplay.DisplayPosition.y == sy)\r
- return;\r
- PreviousPSXDisplay.DisplayPosition.x = PSXDisplay.DisplayPosition.x;\r
- PreviousPSXDisplay.DisplayPosition.y = PSXDisplay.DisplayPosition.y;\r
- PSXDisplay.DisplayPosition.x = sx;\r
- PSXDisplay.DisplayPosition.y = sy;\r
- }\r
-\r
- PSXDisplay.DisplayEnd.x=\r
- PSXDisplay.DisplayPosition.x+ PSXDisplay.DisplayMode.x;\r
- PSXDisplay.DisplayEnd.y=\r
- PSXDisplay.DisplayPosition.y+ PSXDisplay.DisplayMode.y+PreviousPSXDisplay.DisplayModeNew.y;\r
-\r
- PreviousPSXDisplay.DisplayEnd.x=\r
- PreviousPSXDisplay.DisplayPosition.x+ PSXDisplay.DisplayMode.x;\r
- PreviousPSXDisplay.DisplayEnd.y=\r
- PreviousPSXDisplay.DisplayPosition.y+ PSXDisplay.DisplayMode.y+PreviousPSXDisplay.DisplayModeNew.y;\r
-\r
- bDisplayNotSet = TRUE;\r
-\r
- if (!(PSXDisplay.Interlaced))\r
- {\r
- updateDisplay();\r
- }\r
- else\r
- if(PSXDisplay.InterlacedTest && \r
- ((PreviousPSXDisplay.DisplayPosition.x != PSXDisplay.DisplayPosition.x)||\r
- (PreviousPSXDisplay.DisplayPosition.y != PSXDisplay.DisplayPosition.y)))\r
- PSXDisplay.InterlacedTest--;\r
- \r
- return;\r
- }\r
-\r
- // setting width\r
- case 0x06:\r
-\r
- PSXDisplay.Range.x0=gdata & 0x7ff; //0x3ff;\r
- PSXDisplay.Range.x1=(gdata>>12) & 0xfff;//0x7ff;\r
-\r
- PSXDisplay.Range.x1-=PSXDisplay.Range.x0;\r
-\r
- ChangeDispOffsetsX();\r
-\r
- return;\r
-\r
- // setting height\r
- case 0x07:\r
-\r
- PreviousPSXDisplay.Height = PSXDisplay.Height;\r
-\r
- PSXDisplay.Range.y0=gdata & 0x3ff;\r
- PSXDisplay.Range.y1=(gdata>>10) & 0x3ff;\r
-\r
- PSXDisplay.Height = PSXDisplay.Range.y1 - \r
- PSXDisplay.Range.y0 +\r
- PreviousPSXDisplay.DisplayModeNew.y;\r
-\r
- if (PreviousPSXDisplay.Height != PSXDisplay.Height)\r
- {\r
- PSXDisplay.DisplayModeNew.y=PSXDisplay.Height*PSXDisplay.Double;\r
- ChangeDispOffsetsY();\r
- updateDisplayIfChanged();\r
- }\r
- return;\r
- \r
- // setting display infos\r
- case 0x08:\r
-\r
- PSXDisplay.DisplayModeNew.x = dispWidths[(gdata & 0x03) | ((gdata & 0x40) >> 4)];\r
-\r
- if (gdata&0x04) PSXDisplay.Double=2;\r
- else PSXDisplay.Double=1;\r
- PSXDisplay.DisplayModeNew.y = PSXDisplay.Height*PSXDisplay.Double;\r
-\r
- ChangeDispOffsetsY();\r
- \r
- PSXDisplay.PAL = (gdata & 0x08)?TRUE:FALSE; // if 1 - PAL mode, else NTSC\r
- PSXDisplay.RGB24New = (gdata & 0x10)?TRUE:FALSE; // if 1 - TrueColor\r
- PSXDisplay.InterlacedNew = (gdata & 0x20)?TRUE:FALSE; // if 1 - Interlace\r
-\r
- STATUSREG&=~GPUSTATUS_WIDTHBITS; // clear the width bits\r
-\r
- STATUSREG|=\r
- (((gdata & 0x03) << 17) | \r
- ((gdata & 0x40) << 10)); // set the width bits\r
-\r
- PreviousPSXDisplay.InterlacedNew=FALSE;\r
- if (PSXDisplay.InterlacedNew)\r
- {\r
- if(!PSXDisplay.Interlaced)\r
- {\r
- PSXDisplay.InterlacedTest=2;\r
- PreviousPSXDisplay.DisplayPosition.x = PSXDisplay.DisplayPosition.x;\r
- PreviousPSXDisplay.DisplayPosition.y = PSXDisplay.DisplayPosition.y;\r
- PreviousPSXDisplay.InterlacedNew=TRUE;\r
- }\r
-\r
- STATUSREG|=GPUSTATUS_INTERLACED;\r
- }\r
- else \r
- {\r
- PSXDisplay.InterlacedTest=0;\r
- STATUSREG&=~GPUSTATUS_INTERLACED;\r
- }\r
-\r
- if (PSXDisplay.PAL)\r
- STATUSREG|=GPUSTATUS_PAL;\r
- else STATUSREG&=~GPUSTATUS_PAL;\r
-\r
- if (PSXDisplay.Double==2)\r
- STATUSREG|=GPUSTATUS_DOUBLEHEIGHT;\r
- else STATUSREG&=~GPUSTATUS_DOUBLEHEIGHT;\r
-\r
- if (PSXDisplay.RGB24New)\r
- STATUSREG|=GPUSTATUS_RGB24;\r
- else STATUSREG&=~GPUSTATUS_RGB24;\r
-\r
- updateDisplayIfChanged();\r
-\r
- return;\r
-\r
- //--------------------------------------------------//\r
- // ask about GPU version and other stuff\r
- case 0x10: \r
-\r
- gdata&=0xff;\r
-\r
- switch(gdata) \r
- {\r
- case 0x02:\r
- GPUdataRet=ulGPUInfoVals[INFO_TW]; // tw infos\r
- return;\r
- case 0x03:\r
- GPUdataRet=ulGPUInfoVals[INFO_DRAWSTART]; // draw start\r
- return;\r
- case 0x04:\r
- GPUdataRet=ulGPUInfoVals[INFO_DRAWEND]; // draw end\r
- return;\r
- case 0x05:\r
- case 0x06:\r
- GPUdataRet=ulGPUInfoVals[INFO_DRAWOFF]; // draw offset\r
- return;\r
- case 0x07:\r
- if(dwGPUVersion==2)\r
- GPUdataRet=0x01;\r
- else GPUdataRet=0x02; // gpu type\r
- return;\r
- case 0x08:\r
- case 0x0F: // some bios addr?\r
- GPUdataRet=0xBFC03720;\r
- return;\r
- }\r
- return;\r
- //--------------------------------------------------//\r
- }\r
-}\r
-\r
-////////////////////////////////////////////////////////////////////////\r
-// vram read/write helpers\r
-////////////////////////////////////////////////////////////////////////\r
-\r
-BOOL bNeedWriteUpload=FALSE;\r
-\r
-__inline void FinishedVRAMWrite(void)\r
-{\r
- if(bNeedWriteUpload)\r
- {\r
- bNeedWriteUpload=FALSE;\r
- CheckWriteUpdate();\r
- }\r
-\r
- // set register to NORMAL operation\r
- iDataWriteMode = DR_NORMAL;\r
-\r
- // reset transfer values, to prevent mis-transfer of data\r
- VRAMWrite.ColsRemaining = 0;\r
- VRAMWrite.RowsRemaining = 0;\r
-}\r
-\r
-__inline void FinishedVRAMRead(void)\r
-{\r
- // set register to NORMAL operation\r
- iDataReadMode = DR_NORMAL;\r
- // reset transfer values, to prevent mis-transfer of data\r
- VRAMRead.x = 0;\r
- VRAMRead.y = 0;\r
- VRAMRead.Width = 0;\r
- VRAMRead.Height = 0;\r
- VRAMRead.ColsRemaining = 0;\r
- VRAMRead.RowsRemaining = 0;\r
-\r
- // indicate GPU is no longer ready for VRAM data in the STATUS REGISTER\r
- STATUSREG&=~GPUSTATUS_READYFORVRAM;\r
-}\r
-\r
-////////////////////////////////////////////////////////////////////////\r
-// vram read check ex (reading from card's back/frontbuffer if needed...\r
-// slow!)\r
-////////////////////////////////////////////////////////////////////////\r
-\r
-void CheckVRamReadEx(int x, int y, int dx, int dy)\r
-{\r
- unsigned short sArea;\r
- int ux,uy,udx,udy,wx,wy;\r
- unsigned short * p1, *p2;\r
- float XS,YS;\r
- unsigned char * ps;\r
- unsigned char * px;\r
- unsigned short s,sx;\r
-\r
- if(STATUSREG&GPUSTATUS_RGB24) return;\r
-\r
- if(((dx > PSXDisplay.DisplayPosition.x) &&\r
- (x < PSXDisplay.DisplayEnd.x) &&\r
- (dy > PSXDisplay.DisplayPosition.y) &&\r
- (y < PSXDisplay.DisplayEnd.y)))\r
- sArea=0;\r
- else\r
- if((!(PSXDisplay.InterlacedTest) &&\r
- (dx > PreviousPSXDisplay.DisplayPosition.x) &&\r
- (x < PreviousPSXDisplay.DisplayEnd.x) &&\r
- (dy > PreviousPSXDisplay.DisplayPosition.y) &&\r
- (y < PreviousPSXDisplay.DisplayEnd.y)))\r
- sArea=1;\r
- else \r
- {\r
- return;\r
- }\r
-\r
- //////////////\r
-\r
- if(iRenderFVR)\r
- {\r
- bFullVRam=TRUE;iRenderFVR=2;return;\r
- }\r
- bFullVRam=TRUE;iRenderFVR=2;\r
-\r
- //////////////\r
-\r
- p2=0;\r
-\r
- if(sArea==0)\r
- {\r
- ux=PSXDisplay.DisplayPosition.x;\r
- uy=PSXDisplay.DisplayPosition.y;\r
- udx=PSXDisplay.DisplayEnd.x-ux;\r
- udy=PSXDisplay.DisplayEnd.y-uy;\r
- if((PreviousPSXDisplay.DisplayEnd.x-\r
- PreviousPSXDisplay.DisplayPosition.x)==udx &&\r
- (PreviousPSXDisplay.DisplayEnd.y-\r
- PreviousPSXDisplay.DisplayPosition.y)==udy)\r
- p2=(psxVuw + (1024*PreviousPSXDisplay.DisplayPosition.y) + \r
- PreviousPSXDisplay.DisplayPosition.x);\r
- }\r
- else\r
- {\r
- ux=PreviousPSXDisplay.DisplayPosition.x;\r
- uy=PreviousPSXDisplay.DisplayPosition.y;\r
- udx=PreviousPSXDisplay.DisplayEnd.x-ux;\r
- udy=PreviousPSXDisplay.DisplayEnd.y-uy;\r
- if((PSXDisplay.DisplayEnd.x-\r
- PSXDisplay.DisplayPosition.x)==udx &&\r
- (PSXDisplay.DisplayEnd.y-\r
- PSXDisplay.DisplayPosition.y)==udy)\r
- p2=(psxVuw + (1024*PSXDisplay.DisplayPosition.y) + \r
- PSXDisplay.DisplayPosition.x);\r
- }\r
-\r
- p1=(psxVuw + (1024*uy) + ux);\r
- if(p1==p2) p2=0;\r
-\r
- x=0;y=0;\r
- wx=dx=udx;wy=dy=udy;\r
-\r
- if(udx<=0) return;\r
- if(udy<=0) return;\r
- if(dx<=0) return;\r
- if(dy<=0) return;\r
- if(wx<=0) return;\r
- if(wy<=0) return;\r
-\r
- XS=(float)rRatioRect.right/(float)wx;\r
- YS=(float)rRatioRect.bottom/(float)wy;\r
-\r
- dx=(int)((float)(dx)*XS);\r
- dy=(int)((float)(dy)*YS);\r
-\r
- if(dx>iResX) dx=iResX;\r
- if(dy>iResY) dy=iResY;\r
-\r
- if(dx<=0) return;\r
- if(dy<=0) return;\r
-\r
- // ogl y adjust\r
- y=iResY-y-dy;\r
-\r
- x+=rRatioRect.left;\r
- y-=rRatioRect.top;\r
-\r
- if(y<0) y=0; if((y+dy)>iResY) dy=iResY-y;\r
-\r
- if(!pGfxCardScreen)\r
- {\r
- glPixelStorei(GL_PACK_ALIGNMENT,1);\r
- pGfxCardScreen=(unsigned char *)malloc(iResX*iResY*4);\r
- }\r
-\r
- ps=pGfxCardScreen;\r
- \r
- if(!sArea) glReadBuffer(GL_FRONT);\r
-\r
- glReadPixels(x,y,dx,dy,GL_RGB,GL_UNSIGNED_BYTE,ps);\r
- \r
- if(!sArea) glReadBuffer(GL_BACK);\r
-\r
- s=0;\r
-\r
- XS=(float)dx/(float)(udx);\r
- YS=(float)dy/(float)(udy+1);\r
- \r
- for(y=udy;y>0;y--)\r
- {\r
- for(x=0;x<udx;x++)\r
- {\r
- if(p1>=psxVuw && p1<psxVuw_eom)\r
- {\r
- px=ps+(3*((int)((float)x * XS))+\r
- (3*dx)*((int)((float)y*YS)));\r
- sx=(*px)>>3;px++;\r
- s=sx;\r
- sx=(*px)>>3;px++;\r
- s|=sx<<5;\r
- sx=(*px)>>3;\r
- s|=sx<<10;\r
- s&=~0x8000;\r
- *p1=s;\r
- }\r
- if(p2>=psxVuw && p2<psxVuw_eom) *p2=s;\r
-\r
- p1++;\r
- if(p2) p2++;\r
- }\r
-\r
- p1 += 1024 - udx;\r
- if(p2) p2 += 1024 - udx;\r
- }\r
-}\r
-\r
-////////////////////////////////////////////////////////////////////////\r
-// vram read check (reading from card's back/frontbuffer if needed... \r
-// slow!)\r
-////////////////////////////////////////////////////////////////////////\r
-\r
-void CheckVRamRead(int x, int y, int dx, int dy,BOOL bFront)\r
-{\r
- unsigned short sArea;unsigned short * p;\r
- int ux,uy,udx,udy,wx,wy;float XS,YS;\r
- unsigned char * ps, * px;\r
- unsigned short s=0,sx;\r
-\r
- if(STATUSREG&GPUSTATUS_RGB24) return;\r
-\r
- if(((dx > PSXDisplay.DisplayPosition.x) &&\r
- (x < PSXDisplay.DisplayEnd.x) &&\r
- (dy > PSXDisplay.DisplayPosition.y) &&\r
- (y < PSXDisplay.DisplayEnd.y)))\r
- sArea=0;\r
- else\r
- if((!(PSXDisplay.InterlacedTest) &&\r
- (dx > PreviousPSXDisplay.DisplayPosition.x) &&\r
- (x < PreviousPSXDisplay.DisplayEnd.x) &&\r
- (dy > PreviousPSXDisplay.DisplayPosition.y) &&\r
- (y < PreviousPSXDisplay.DisplayEnd.y)))\r
- sArea=1;\r
- else \r
- {\r
- return;\r
- }\r
-\r
- if(dwActFixes&0x40)\r
- {\r
- if(iRenderFVR)\r
- {\r
- bFullVRam=TRUE;iRenderFVR=2;return;\r
- }\r
- bFullVRam=TRUE;iRenderFVR=2;\r
- }\r
-\r
- ux=x;uy=y;udx=dx;udy=dy;\r
-\r
- if(sArea==0)\r
- {\r
- x -=PSXDisplay.DisplayPosition.x;\r
- dx-=PSXDisplay.DisplayPosition.x;\r
- y -=PSXDisplay.DisplayPosition.y;\r
- dy-=PSXDisplay.DisplayPosition.y;\r
- wx=PSXDisplay.DisplayEnd.x-PSXDisplay.DisplayPosition.x;\r
- wy=PSXDisplay.DisplayEnd.y-PSXDisplay.DisplayPosition.y;\r
- }\r
- else\r
- {\r
- x -=PreviousPSXDisplay.DisplayPosition.x;\r
- dx-=PreviousPSXDisplay.DisplayPosition.x;\r
- y -=PreviousPSXDisplay.DisplayPosition.y;\r
- dy-=PreviousPSXDisplay.DisplayPosition.y;\r
- wx=PreviousPSXDisplay.DisplayEnd.x-PreviousPSXDisplay.DisplayPosition.x;\r
- wy=PreviousPSXDisplay.DisplayEnd.y-PreviousPSXDisplay.DisplayPosition.y;\r
- }\r
- if(x<0) {ux-=x;x=0;}\r
- if(y<0) {uy-=y;y=0;}\r
- if(dx>wx) {udx-=(dx-wx);dx=wx;}\r
- if(dy>wy) {udy-=(dy-wy);dy=wy;}\r
- udx-=ux;\r
- udy-=uy;\r
- \r
- p=(psxVuw + (1024*uy) + ux);\r
-\r
- if(udx<=0) return;\r
- if(udy<=0) return;\r
- if(dx<=0) return;\r
- if(dy<=0) return;\r
- if(wx<=0) return;\r
- if(wy<=0) return;\r
-\r
- XS=(float)rRatioRect.right/(float)wx;\r
- YS=(float)rRatioRect.bottom/(float)wy;\r
-\r
- dx=(int)((float)(dx)*XS);\r
- dy=(int)((float)(dy)*YS);\r
- x=(int)((float)x*XS);\r
- y=(int)((float)y*YS);\r
-\r
- dx-=x;\r
- dy-=y;\r
-\r
- if(dx>iResX) dx=iResX;\r
- if(dy>iResY) dy=iResY;\r
-\r
- if(dx<=0) return;\r
- if(dy<=0) return;\r
-\r
- // ogl y adjust\r
- y=iResY-y-dy;\r
-\r
- x+=rRatioRect.left;\r
- y-=rRatioRect.top;\r
-\r
- if(y<0) y=0; if((y+dy)>iResY) dy=iResY-y;\r
-\r
- if(!pGfxCardScreen)\r
- {\r
- glPixelStorei(GL_PACK_ALIGNMENT,1);\r
- pGfxCardScreen=(unsigned char *)malloc(iResX*iResY*4);\r
- }\r
-\r
- ps=pGfxCardScreen;\r
- \r
- if(bFront) glReadBuffer(GL_FRONT);\r
-\r
- glReadPixels(x,y,dx,dy,GL_RGB,GL_UNSIGNED_BYTE,ps);\r
- \r
- if(bFront) glReadBuffer(GL_BACK);\r
-\r
- XS=(float)dx/(float)(udx);\r
- YS=(float)dy/(float)(udy+1);\r
- \r
- for(y=udy;y>0;y--)\r
- {\r
- for(x=0;x<udx;x++)\r
- {\r
- if(p>=psxVuw && p<psxVuw_eom)\r
- {\r
- px=ps+(3*((int)((float)x * XS))+\r
- (3*dx)*((int)((float)y*YS)));\r
- sx=(*px)>>3;px++;\r
- s=sx;\r
- sx=(*px)>>3;px++;\r
- s|=sx<<5;\r
- sx=(*px)>>3;\r
- s|=sx<<10;\r
- s&=~0x8000;\r
- *p=s;\r
- }\r
- p++;\r
- }\r
- p += 1024 - udx;\r
- }\r
-}\r
-\r
-////////////////////////////////////////////////////////////////////////\r
-// core read from vram\r
-////////////////////////////////////////////////////////////////////////\r
-\r
-void CALLBACK GPUreadDataMem(uint32_t *pMem, int iSize)\r
-{\r
- int i;\r
-\r
- if(iDataReadMode!=DR_VRAMTRANSFER) return;\r
-\r
- GPUIsBusy;\r
-\r
- // adjust read ptr, if necessary\r
- while(VRAMRead.ImagePtr>=psxVuw_eom)\r
- VRAMRead.ImagePtr-=iGPUHeight*1024;\r
- while(VRAMRead.ImagePtr<psxVuw)\r
- VRAMRead.ImagePtr+=iGPUHeight*1024;\r
-\r
- if((iFrameReadType&1 && iSize>1) &&\r
- !(iDrawnSomething==2 &&\r
- VRAMRead.x == VRAMWrite.x &&\r
- VRAMRead.y == VRAMWrite.y &&\r
- VRAMRead.Width == VRAMWrite.Width &&\r
- VRAMRead.Height == VRAMWrite.Height))\r
- CheckVRamRead(VRAMRead.x,VRAMRead.y,\r
- VRAMRead.x+VRAMRead.RowsRemaining,\r
- VRAMRead.y+VRAMRead.ColsRemaining,\r
- TRUE);\r
-\r
- for(i=0;i<iSize;i++)\r
- {\r
- // do 2 seperate 16bit reads for compatibility (wrap issues)\r
- if ((VRAMRead.ColsRemaining > 0) && (VRAMRead.RowsRemaining > 0))\r
- {\r
- // lower 16 bit\r
- GPUdataRet=(uint32_t)*VRAMRead.ImagePtr;\r
-\r
- VRAMRead.ImagePtr++;\r
- if(VRAMRead.ImagePtr>=psxVuw_eom) VRAMRead.ImagePtr-=iGPUHeight*1024;\r
- VRAMRead.RowsRemaining --;\r
-\r
- if(VRAMRead.RowsRemaining<=0)\r
- {\r
- VRAMRead.RowsRemaining = VRAMRead.Width;\r
- VRAMRead.ColsRemaining--;\r
- VRAMRead.ImagePtr += 1024 - VRAMRead.Width;\r
- if(VRAMRead.ImagePtr>=psxVuw_eom) VRAMRead.ImagePtr-=iGPUHeight*1024;\r
- }\r
-\r
- // higher 16 bit (always, even if it's an odd width)\r
- GPUdataRet|=(uint32_t)(*VRAMRead.ImagePtr)<<16;\r
- *pMem++=GPUdataRet;\r
-\r
- if(VRAMRead.ColsRemaining <= 0)\r
- {FinishedVRAMRead();goto ENDREAD;}\r
-\r
- VRAMRead.ImagePtr++;\r
- if(VRAMRead.ImagePtr>=psxVuw_eom) VRAMRead.ImagePtr-=iGPUHeight*1024;\r
- VRAMRead.RowsRemaining--;\r
- if(VRAMRead.RowsRemaining<=0)\r
- {\r
- VRAMRead.RowsRemaining = VRAMRead.Width;\r
- VRAMRead.ColsRemaining--;\r
- VRAMRead.ImagePtr += 1024 - VRAMRead.Width;\r
- if(VRAMRead.ImagePtr>=psxVuw_eom) VRAMRead.ImagePtr-=iGPUHeight*1024;\r
- }\r
- if(VRAMRead.ColsRemaining <= 0)\r
- {FinishedVRAMRead();goto ENDREAD;}\r
- }\r
- else {FinishedVRAMRead();goto ENDREAD;}\r
- }\r
-\r
-ENDREAD:\r
- GPUIsIdle;\r
-}\r
-\r
-uint32_t CALLBACK GPUreadData(void)\r
-{\r
- uint32_t l;\r
- GPUreadDataMem(&l,1);\r
- return GPUdataRet;\r
-}\r
-\r
-////////////////////////////////////////////////////////////////////////\r
-// helper table to know how much data is used by drawing commands\r
-////////////////////////////////////////////////////////////////////////\r
-\r
-const unsigned char primTableCX[256] =\r
-{\r
- // 00\r
- 0,0,3,0,0,0,0,0,\r
- // 08\r
- 0,0,0,0,0,0,0,0,\r
- // 10\r
- 0,0,0,0,0,0,0,0,\r
- // 18\r
- 0,0,0,0,0,0,0,0,\r
- // 20\r
- 4,4,4,4,7,7,7,7,\r
- // 28\r
- 5,5,5,5,9,9,9,9,\r
- // 30\r
- 6,6,6,6,9,9,9,9,\r
- // 38\r
- 8,8,8,8,12,12,12,12,\r
- // 40\r
- 3,3,3,3,0,0,0,0,\r
- // 48\r
-// 5,5,5,5,6,6,6,6, //FLINE\r
- 254,254,254,254,254,254,254,254,\r
- // 50\r
- 4,4,4,4,0,0,0,0,\r
- // 58\r
-// 7,7,7,7,9,9,9,9, // LINEG3 LINEG4\r
- 255,255,255,255,255,255,255,255,\r
- // 60\r
- 3,3,3,3,4,4,4,4, // TILE SPRT\r
- // 68\r
- 2,2,2,2,3,3,3,3, // TILE1\r
- // 70\r
- 2,2,2,2,3,3,3,3,\r
- // 78\r
- 2,2,2,2,3,3,3,3,\r
- // 80\r
- 4,0,0,0,0,0,0,0,\r
- // 88\r
- 0,0,0,0,0,0,0,0,\r
- // 90\r
- 0,0,0,0,0,0,0,0,\r
- // 98\r
- 0,0,0,0,0,0,0,0,\r
- // a0\r
- 3,0,0,0,0,0,0,0,\r
- // a8\r
- 0,0,0,0,0,0,0,0,\r
- // b0\r
- 0,0,0,0,0,0,0,0,\r
- // b8\r
- 0,0,0,0,0,0,0,0,\r
- // c0\r
- 3,0,0,0,0,0,0,0,\r
- // c8\r
- 0,0,0,0,0,0,0,0,\r
- // d0\r
- 0,0,0,0,0,0,0,0,\r
- // d8\r
- 0,0,0,0,0,0,0,0,\r
- // e0\r
- 0,1,1,1,1,1,1,0,\r
- // e8\r
- 0,0,0,0,0,0,0,0,\r
- // f0\r
- 0,0,0,0,0,0,0,0,\r
- // f8\r
- 0,0,0,0,0,0,0,0\r
-};\r
-\r
-////////////////////////////////////////////////////////////////////////\r
-// processes data send to GPU data register\r
-////////////////////////////////////////////////////////////////////////\r
-\r
-void CALLBACK GPUwriteDataMem(uint32_t *pMem, int iSize)\r
-{\r
- unsigned char command;\r
- uint32_t gdata=0;\r
- int i=0;\r
- GPUIsBusy;\r
- GPUIsNotReadyForCommands;\r
-\r
-STARTVRAM:\r
-\r
- if(iDataWriteMode==DR_VRAMTRANSFER)\r
- {\r
- // make sure we are in vram\r
- while(VRAMWrite.ImagePtr>=psxVuw_eom)\r
- VRAMWrite.ImagePtr-=iGPUHeight*1024;\r
- while(VRAMWrite.ImagePtr<psxVuw)\r
- VRAMWrite.ImagePtr+=iGPUHeight*1024;\r
-\r
- // now do the loop\r
- while(VRAMWrite.ColsRemaining>0)\r
- {\r
- while(VRAMWrite.RowsRemaining>0)\r
- {\r
- if(i>=iSize) {goto ENDVRAM;}\r
- i++;\r
-\r
- gdata=*pMem++;\r
-\r
- *VRAMWrite.ImagePtr++ = (unsigned short)gdata;\r
- if(VRAMWrite.ImagePtr>=psxVuw_eom) VRAMWrite.ImagePtr-=iGPUHeight*1024;\r
- VRAMWrite.RowsRemaining --;\r
-\r
- if(VRAMWrite.RowsRemaining <= 0)\r
- {\r
- VRAMWrite.ColsRemaining--;\r
- if (VRAMWrite.ColsRemaining <= 0) // last pixel is odd width\r
- {\r
- gdata=(gdata&0xFFFF)|(((uint32_t)(*VRAMWrite.ImagePtr))<<16);\r
- FinishedVRAMWrite();\r
- goto ENDVRAM;\r
- }\r
- VRAMWrite.RowsRemaining = VRAMWrite.Width;\r
- VRAMWrite.ImagePtr += 1024 - VRAMWrite.Width;\r
- }\r
-\r
- *VRAMWrite.ImagePtr++ = (unsigned short)(gdata>>16);\r
- if(VRAMWrite.ImagePtr>=psxVuw_eom) VRAMWrite.ImagePtr-=iGPUHeight*1024;\r
- VRAMWrite.RowsRemaining --;\r
- }\r
-\r
- VRAMWrite.RowsRemaining = VRAMWrite.Width;\r
- VRAMWrite.ColsRemaining--;\r
- VRAMWrite.ImagePtr += 1024 - VRAMWrite.Width;\r
- }\r
-\r
- FinishedVRAMWrite();\r
- }\r
-\r
-ENDVRAM:\r
-\r
- if(iDataWriteMode==DR_NORMAL)\r
- {\r
- void (* *primFunc)(unsigned char *);\r
- if(bSkipNextFrame) primFunc=primTableSkip;\r
- else primFunc=primTableJ;\r
-\r
- for(;i<iSize;)\r
- {\r
- if(iDataWriteMode==DR_VRAMTRANSFER) goto STARTVRAM;\r
-\r
- gdata=*pMem++;i++;\r
- \r
- if(gpuDataC == 0)\r
- {\r
- command = (unsigned char)((gdata>>24) & 0xff);\r
- \r
- if(primTableCX[command])\r
- {\r
- gpuDataC = primTableCX[command];\r
- gpuCommand = command;\r
- gpuDataM[0] = gdata;\r
- gpuDataP = 1;\r
- }\r
- else continue;\r
- }\r
- else\r
- {\r
- gpuDataM[gpuDataP] = gdata;\r
- if(gpuDataC>128)\r
- {\r
- if((gpuDataC==254 && gpuDataP>=3) ||\r
- (gpuDataC==255 && gpuDataP>=4 && !(gpuDataP&1)))\r
- {\r
- if((gpuDataM[gpuDataP] & 0xF000F000) == 0x50005000)\r
- gpuDataP=gpuDataC-1;\r
- }\r
- }\r
- gpuDataP++;\r
- }\r
- \r
- if(gpuDataP == gpuDataC)\r
- {\r
- gpuDataC=gpuDataP=0;\r
- primFunc[gpuCommand]((unsigned char *)gpuDataM);\r
-\r
- if(dwEmuFixes&0x0001 || dwActFixes&0x20000) // hack for emulating "gpu busy" in some games\r
- iFakePrimBusy=4;\r
- }\r
- } \r
- }\r
-\r
- GPUdataRet=gdata;\r
-\r
- GPUIsReadyForCommands;\r
- GPUIsIdle; \r
-}\r
-\r
-////////////////////////////////////////////////////////////////////////\r
-\r
-void CALLBACK GPUwriteData(uint32_t gdata)\r
-{\r
- GPUwriteDataMem(&gdata,1);\r
-}\r
-\r
-////////////////////////////////////////////////////////////////////////\r
-// call config dlg\r
-////////////////////////////////////////////////////////////////////////\r
-\r
-void StartCfgTool(char *arg) // linux: start external cfg tool\r
-{\r
- char cfg[256];\r
- struct stat buf;\r
-\r
- strcpy(cfg, "./cfgpeopsxgl");\r
- if (stat(cfg, &buf) != -1) {\r
- if (fork() == 0) {\r
- execl(cfg, "cfgpeopsxgl", arg, NULL);\r
- exit(0);\r
- }\r
- return;\r
- }\r
-\r
- strcpy(cfg, "./cfg/cfgpeopsxgl");\r
- if (stat(cfg, &buf) != -1) {\r
- if (fork() == 0) {\r
- execl(cfg, "cfgpeopsxgl", arg, NULL);\r
- exit(0);\r
- }\r
- return;\r
- }\r
-\r
- sprintf(cfg, "%s/.pcsx/plugins/cfg/cfgpeopsxgl", getenv("HOME"));\r
- if (stat(cfg, &buf) != -1) {\r
- if (fork() == 0) {\r
- execl(cfg, "cfgpeopsxgl", arg, NULL);\r
- exit(0);\r
- }\r
- return;\r
- }\r
-\r
- printf("ERROR: cfgpeopsxgl file not found!\n");\r
-}\r
-\r
-long CALLBACK GPUconfigure(void)\r
-{\r
- StartCfgTool("CFG");\r
- return 0;\r
-}\r
-\r
-////////////////////////////////////////////////////////////////////////\r
-// sets all kind of act fixes\r
-////////////////////////////////////////////////////////////////////////\r
-\r
-void SetFixes(void)\r
-{\r
- ReInitFrameCap();\r
-\r
- if(dwActFixes & 0x2000) \r
- dispWidths[4]=384;\r
- else dispWidths[4]=368;\r
-}\r
-\r
-////////////////////////////////////////////////////////////////////////\r
-// Pete Special: make an 'intelligent' dma chain check (<-Tekken3)\r
-////////////////////////////////////////////////////////////////////////\r
-\r
-uint32_t lUsedAddr[3];\r
-\r
-__inline BOOL CheckForEndlessLoop(uint32_t laddr)\r
-{\r
- if(laddr==lUsedAddr[1]) return TRUE;\r
- if(laddr==lUsedAddr[2]) return TRUE;\r
-\r
- if(laddr<lUsedAddr[0]) lUsedAddr[1]=laddr;\r
- else lUsedAddr[2]=laddr;\r
- lUsedAddr[0]=laddr;\r
- return FALSE;\r
-}\r
-\r
-////////////////////////////////////////////////////////////////////////\r
-// core gives a dma chain to gpu: same as the gpuwrite interface funcs\r
-////////////////////////////////////////////////////////////////////////\r
-\r
-long CALLBACK GPUdmaChain(uint32_t *baseAddrL, uint32_t addr)\r
-{\r
- uint32_t dmaMem;\r
- unsigned char * baseAddrB;\r
- short count;unsigned int DMACommandCounter = 0;\r
-\r
- if(bIsFirstFrame) GLinitialize();\r
-\r
- GPUIsBusy;\r
-\r
- lUsedAddr[0]=lUsedAddr[1]=lUsedAddr[2]=0xffffff;\r
-\r
- baseAddrB = (unsigned char*) baseAddrL;\r
-\r
- do\r
- {\r
- if(iGPUHeight==512) addr&=0x1FFFFC;\r
-\r
- if(DMACommandCounter++ > 2000000) break;\r
- if(CheckForEndlessLoop(addr)) break;\r
-\r
- count = baseAddrB[addr+3];\r
-\r
- dmaMem=addr+4;\r
-\r
- if(count>0) GPUwriteDataMem(&baseAddrL[dmaMem>>2],count);\r
-\r
- addr = baseAddrL[addr>>2]&0xffffff;\r
- }\r
- while (addr != 0xffffff);\r
-\r
- GPUIsIdle;\r
-\r
- return 0;\r
-}\r
- \r
-////////////////////////////////////////////////////////////////////////\r
-// show about dlg\r
-////////////////////////////////////////////////////////////////////////\r
-\r
-void CALLBACK GPUabout(void)\r
-{\r
- StartCfgTool("ABOUT");\r
-}\r
-\r
-////////////////////////////////////////////////////////////////////////\r
-// We are ever fine ;)\r
-////////////////////////////////////////////////////////////////////////\r
-\r
-long CALLBACK GPUtest(void)\r
-{\r
- // if test fails this function should return negative value for error (unable to continue)\r
- // and positive value for warning (can continue but output might be crappy)\r
-\r
- return 0;\r
-}\r
-\r
-////////////////////////////////////////////////////////////////////////\r
-// save state funcs\r
-////////////////////////////////////////////////////////////////////////\r
-\r
-typedef struct GPUFREEZETAG\r
-{\r
- uint32_t ulFreezeVersion; // should be always 1 for now (set by main emu)\r
- uint32_t ulStatus; // current gpu status\r
- uint32_t ulControl[256]; // latest control register values\r
- unsigned char psxVRam[1024*1024*2]; // current VRam image (full 2 MB for ZN)\r
-} GPUFreeze_t;\r
-\r
-////////////////////////////////////////////////////////////////////////\r
-\r
-long CALLBACK GPUfreeze(uint32_t ulGetFreezeData,GPUFreeze_t * pF)\r
-{\r
- if(ulGetFreezeData==2) \r
- {\r
- int lSlotNum=*((int *)pF);\r
- if(lSlotNum<0) return 0;\r
- if(lSlotNum>8) return 0;\r
- lSelectedSlot=lSlotNum+1;\r
- return 1;\r
- }\r
-\r
- if(!pF) return 0; \r
- if(pF->ulFreezeVersion!=1) return 0;\r
-\r
- if(ulGetFreezeData==1)\r
- {\r
- pF->ulStatus=STATUSREG;\r
- memcpy(pF->ulControl,ulStatusControl,256*sizeof(uint32_t));\r
- memcpy(pF->psxVRam, psxVub, 1024*iGPUHeight*2);\r
-\r
- return 1;\r
- }\r
-\r
- if(ulGetFreezeData!=0) return 0;\r
-\r
- STATUSREG=pF->ulStatus;\r
- memcpy(ulStatusControl,pF->ulControl,256*sizeof(uint32_t));\r
- memcpy(psxVub, pF->psxVRam, 1024*iGPUHeight*2);\r
-\r
- ResetTextureArea(TRUE);\r
-\r
- GPUwriteStatus(ulStatusControl[0]);\r
- GPUwriteStatus(ulStatusControl[1]);\r
- GPUwriteStatus(ulStatusControl[2]);\r
- GPUwriteStatus(ulStatusControl[3]);\r
- GPUwriteStatus(ulStatusControl[8]);\r
- GPUwriteStatus(ulStatusControl[6]);\r
- GPUwriteStatus(ulStatusControl[7]);\r
- GPUwriteStatus(ulStatusControl[5]);\r
- GPUwriteStatus(ulStatusControl[4]);\r
-\r
- return 1;\r
-}\r
-\r
-////////////////////////////////////////////////////////////////////////\r
-// special "emu infos" / "emu effects" functions\r
-////////////////////////////////////////////////////////////////////////\r
-\r
-//00 = black\r
-//01 = white\r
-//10 = red\r
-//11 = transparent\r
-\r
-unsigned char cFont[10][120]=\r
-{\r
-// 0\r
-{0xaa,0xaa,0xaa,0xaa,0xaa,0xaa,\r
- 0x80,0x00,0x00,0x00,0x00,0x00,\r
- 0x80,0x00,0x00,0x00,0x00,0x00,\r
- 0x80,0x00,0x00,0x00,0x00,0x00,\r
- 0x80,0x00,0x00,0x00,0x00,0x00,\r
- 0x80,0x00,0x05,0x54,0x00,0x00,\r
- 0x80,0x00,0x14,0x05,0x00,0x00,\r
- 0x80,0x00,0x14,0x05,0x00,0x00,\r
- 0x80,0x00,0x14,0x05,0x00,0x00,\r
- 0x80,0x00,0x14,0x05,0x00,0x00,\r
- 0x80,0x00,0x14,0x05,0x00,0x00,\r
- 0x80,0x00,0x14,0x05,0x00,0x00,\r
- 0x80,0x00,0x14,0x05,0x00,0x00,\r
- 0x80,0x00,0x14,0x05,0x00,0x00,\r
- 0x80,0x00,0x05,0x54,0x00,0x00,\r
- 0x80,0x00,0x00,0x00,0x00,0x00,\r
- 0x80,0x00,0x00,0x00,0x00,0x00,\r
- 0x80,0x00,0x00,0x00,0x00,0x00,\r
- 0x80,0x00,0x00,0x00,0x00,0x00,\r
- 0xaa,0xaa,0xaa,0xaa,0xaa,0xaa\r
-},\r
-// 1\r
-{0xaa,0xaa,0xaa,0xaa,0xaa,0xaa,\r
- 0x80,0x00,0x00,0x00,0x00,0x00,\r
- 0x80,0x00,0x00,0x00,0x00,0x00,\r
- 0x80,0x00,0x00,0x00,0x00,0x00,\r
- 0x80,0x00,0x00,0x00,0x00,0x00,\r
- 0x80,0x00,0x00,0x50,0x00,0x00,\r
- 0x80,0x00,0x05,0x50,0x00,0x00,\r
- 0x80,0x00,0x00,0x50,0x00,0x00,\r
- 0x80,0x00,0x00,0x50,0x00,0x00,\r
- 0x80,0x00,0x00,0x50,0x00,0x00,\r
- 0x80,0x00,0x00,0x50,0x00,0x00,\r
- 0x80,0x00,0x00,0x50,0x00,0x00,\r
- 0x80,0x00,0x00,0x50,0x00,0x00,\r
- 0x80,0x00,0x00,0x50,0x00,0x00,\r
- 0x80,0x00,0x05,0x55,0x00,0x00,\r
- 0x80,0x00,0x00,0x00,0x00,0x00,\r
- 0x80,0x00,0x00,0x00,0x00,0x00,\r
- 0x80,0x00,0x00,0x00,0x00,0x00,\r
- 0x80,0x00,0x00,0x00,0x00,0x00,\r
- 0xaa,0xaa,0xaa,0xaa,0xaa,0xaa\r
-},\r
-// 2\r
-{0xaa,0xaa,0xaa,0xaa,0xaa,0xaa,\r
- 0x80,0x00,0x00,0x00,0x00,0x00,\r
- 0x80,0x00,0x00,0x00,0x00,0x00,\r
- 0x80,0x00,0x00,0x00,0x00,0x00,\r
- 0x80,0x00,0x00,0x00,0x00,0x00,\r
- 0x80,0x00,0x05,0x54,0x00,0x00,\r
- 0x80,0x00,0x14,0x05,0x00,0x00,\r
- 0x80,0x00,0x00,0x05,0x00,0x00,\r
- 0x80,0x00,0x00,0x05,0x00,0x00,\r
- 0x80,0x00,0x00,0x14,0x00,0x00,\r
- 0x80,0x00,0x00,0x50,0x00,0x00,\r
- 0x80,0x00,0x01,0x40,0x00,0x00,\r
- 0x80,0x00,0x05,0x00,0x00,0x00,\r
- 0x80,0x00,0x14,0x00,0x00,0x00,\r
- 0x80,0x00,0x15,0x55,0x00,0x00,\r
- 0x80,0x00,0x00,0x00,0x00,0x00,\r
- 0x80,0x00,0x00,0x00,0x00,0x00,\r
- 0x80,0x00,0x00,0x00,0x00,0x00,\r
- 0x80,0x00,0x00,0x00,0x00,0x00,\r
- 0xaa,0xaa,0xaa,0xaa,0xaa,0xaa\r
-},\r
-// 3\r
-{0xaa,0xaa,0xaa,0xaa,0xaa,0xaa,\r
- 0x80,0x00,0x00,0x00,0x00,0x00,\r
- 0x80,0x00,0x00,0x00,0x00,0x00,\r
- 0x80,0x00,0x00,0x00,0x00,0x00,\r
- 0x80,0x00,0x00,0x00,0x00,0x00,\r
- 0x80,0x00,0x05,0x54,0x00,0x00,\r
- 0x80,0x00,0x14,0x05,0x00,0x00,\r
- 0x80,0x00,0x00,0x05,0x00,0x00,\r
- 0x80,0x00,0x00,0x05,0x00,0x00,\r
- 0x80,0x00,0x01,0x54,0x00,0x00,\r
- 0x80,0x00,0x00,0x05,0x00,0x00,\r
- 0x80,0x00,0x00,0x05,0x00,0x00,\r
- 0x80,0x00,0x00,0x05,0x00,0x00,\r
- 0x80,0x00,0x14,0x05,0x00,0x00,\r
- 0x80,0x00,0x05,0x54,0x00,0x00,\r
- 0x80,0x00,0x00,0x00,0x00,0x00,\r
- 0x80,0x00,0x00,0x00,0x00,0x00,\r
- 0x80,0x00,0x00,0x00,0x00,0x00,\r
- 0x80,0x00,0x00,0x00,0x00,0x00,\r
- 0xaa,0xaa,0xaa,0xaa,0xaa,0xaa\r
-},\r
-// 4\r
-{0xaa,0xaa,0xaa,0xaa,0xaa,0xaa,\r
- 0x80,0x00,0x00,0x00,0x00,0x00,\r
- 0x80,0x00,0x00,0x00,0x00,0x00,\r
- 0x80,0x00,0x00,0x00,0x00,0x00,\r
- 0x80,0x00,0x00,0x00,0x00,0x00,\r
- 0x80,0x00,0x00,0x14,0x00,0x00,\r
- 0x80,0x00,0x00,0x54,0x00,0x00,\r
- 0x80,0x00,0x01,0x54,0x00,0x00,\r
- 0x80,0x00,0x01,0x54,0x00,0x00,\r
- 0x80,0x00,0x05,0x14,0x00,0x00,\r
- 0x80,0x00,0x14,0x14,0x00,0x00,\r
- 0x80,0x00,0x15,0x55,0x00,0x00,\r
- 0x80,0x00,0x00,0x14,0x00,0x00,\r
- 0x80,0x00,0x00,0x14,0x00,0x00,\r
- 0x80,0x00,0x00,0x55,0x00,0x00,\r
- 0x80,0x00,0x00,0x00,0x00,0x00,\r
- 0x80,0x00,0x00,0x00,0x00,0x00,\r
- 0x80,0x00,0x00,0x00,0x00,0x00,\r
- 0x80,0x00,0x00,0x00,0x00,0x00,\r
- 0xaa,0xaa,0xaa,0xaa,0xaa,0xaa\r
-},\r
-// 5\r
-{0xaa,0xaa,0xaa,0xaa,0xaa,0xaa,\r
- 0x80,0x00,0x00,0x00,0x00,0x00,\r
- 0x80,0x00,0x00,0x00,0x00,0x00,\r
- 0x80,0x00,0x00,0x00,0x00,0x00,\r
- 0x80,0x00,0x00,0x00,0x00,0x00,\r
- 0x80,0x00,0x15,0x55,0x00,0x00,\r
- 0x80,0x00,0x14,0x00,0x00,0x00,\r
- 0x80,0x00,0x14,0x00,0x00,0x00,\r
- 0x80,0x00,0x14,0x00,0x00,0x00,\r
- 0x80,0x00,0x15,0x54,0x00,0x00,\r
- 0x80,0x00,0x00,0x05,0x00,0x00,\r
- 0x80,0x00,0x00,0x05,0x00,0x00,\r
- 0x80,0x00,0x00,0x05,0x00,0x00,\r
- 0x80,0x00,0x14,0x05,0x00,0x00,\r
- 0x80,0x00,0x05,0x54,0x00,0x00,\r
- 0x80,0x00,0x00,0x00,0x00,0x00,\r
- 0x80,0x00,0x00,0x00,0x00,0x00,\r
- 0x80,0x00,0x00,0x00,0x00,0x00,\r
- 0x80,0x00,0x00,0x00,0x00,0x00,\r
- 0xaa,0xaa,0xaa,0xaa,0xaa,0xaa\r
-},\r
-// 6\r
-{0xaa,0xaa,0xaa,0xaa,0xaa,0xaa,\r
- 0x80,0x00,0x00,0x00,0x00,0x00,\r
- 0x80,0x00,0x00,0x00,0x00,0x00,\r
- 0x80,0x00,0x00,0x00,0x00,0x00,\r
- 0x80,0x00,0x00,0x00,0x00,0x00,\r
- 0x80,0x00,0x01,0x54,0x00,0x00,\r
- 0x80,0x00,0x05,0x00,0x00,0x00,\r
- 0x80,0x00,0x14,0x00,0x00,0x00,\r
- 0x80,0x00,0x14,0x00,0x00,0x00,\r
- 0x80,0x00,0x15,0x54,0x00,0x00,\r
- 0x80,0x00,0x15,0x05,0x00,0x00,\r
- 0x80,0x00,0x14,0x05,0x00,0x00,\r
- 0x80,0x00,0x14,0x05,0x00,0x00,\r
- 0x80,0x00,0x14,0x05,0x00,0x00,\r
- 0x80,0x00,0x05,0x54,0x00,0x00,\r
- 0x80,0x00,0x00,0x00,0x00,0x00,\r
- 0x80,0x00,0x00,0x00,0x00,0x00,\r
- 0x80,0x00,0x00,0x00,0x00,0x00,\r
- 0x80,0x00,0x00,0x00,0x00,0x00,\r
- 0xaa,0xaa,0xaa,0xaa,0xaa,0xaa\r
-},\r
-// 7\r
-{0xaa,0xaa,0xaa,0xaa,0xaa,0xaa,\r
- 0x80,0x00,0x00,0x00,0x00,0x00,\r
- 0x80,0x00,0x00,0x00,0x00,0x00,\r
- 0x80,0x00,0x00,0x00,0x00,0x00,\r
- 0x80,0x00,0x00,0x00,0x00,0x00,\r
- 0x80,0x00,0x15,0x55,0x00,0x00,\r
- 0x80,0x00,0x14,0x05,0x00,0x00,\r
- 0x80,0x00,0x00,0x14,0x00,0x00,\r
- 0x80,0x00,0x00,0x14,0x00,0x00,\r
- 0x80,0x00,0x00,0x50,0x00,0x00,\r
- 0x80,0x00,0x00,0x50,0x00,0x00,\r
- 0x80,0x00,0x01,0x40,0x00,0x00,\r
- 0x80,0x00,0x01,0x40,0x00,0x00,\r
- 0x80,0x00,0x05,0x00,0x00,0x00,\r
- 0x80,0x00,0x05,0x00,0x00,0x00,\r
- 0x80,0x00,0x00,0x00,0x00,0x00,\r
- 0x80,0x00,0x00,0x00,0x00,0x00,\r
- 0x80,0x00,0x00,0x00,0x00,0x00,\r
- 0x80,0x00,0x00,0x00,0x00,0x00,\r
- 0xaa,0xaa,0xaa,0xaa,0xaa,0xaa\r
-},\r
-// 8\r
-{0xaa,0xaa,0xaa,0xaa,0xaa,0xaa,\r
- 0x80,0x00,0x00,0x00,0x00,0x00,\r
- 0x80,0x00,0x00,0x00,0x00,0x00,\r
- 0x80,0x00,0x00,0x00,0x00,0x00,\r
- 0x80,0x00,0x00,0x00,0x00,0x00,\r
- 0x80,0x00,0x05,0x54,0x00,0x00,\r
- 0x80,0x00,0x14,0x05,0x00,0x00,\r
- 0x80,0x00,0x14,0x05,0x00,0x00,\r
- 0x80,0x00,0x14,0x05,0x00,0x00,\r
- 0x80,0x00,0x05,0x54,0x00,0x00,\r
- 0x80,0x00,0x14,0x05,0x00,0x00,\r
- 0x80,0x00,0x14,0x05,0x00,0x00,\r
- 0x80,0x00,0x14,0x05,0x00,0x00,\r
- 0x80,0x00,0x14,0x05,0x00,0x00,\r
- 0x80,0x00,0x05,0x54,0x00,0x00,\r
- 0x80,0x00,0x00,0x00,0x00,0x00,\r
- 0x80,0x00,0x00,0x00,0x00,0x00,\r
- 0x80,0x00,0x00,0x00,0x00,0x00,\r
- 0x80,0x00,0x00,0x00,0x00,0x00,\r
- 0xaa,0xaa,0xaa,0xaa,0xaa,0xaa\r
-},\r
-// 9\r
-{0xaa,0xaa,0xaa,0xaa,0xaa,0xaa,\r
- 0x80,0x00,0x00,0x00,0x00,0x00,\r
- 0x80,0x00,0x00,0x00,0x00,0x00,\r
- 0x80,0x00,0x00,0x00,0x00,0x00,\r
- 0x80,0x00,0x00,0x00,0x00,0x00,\r
- 0x80,0x00,0x05,0x54,0x00,0x00,\r
- 0x80,0x00,0x14,0x05,0x00,0x00,\r
- 0x80,0x00,0x14,0x05,0x00,0x00,\r
- 0x80,0x00,0x14,0x05,0x00,0x00,\r
- 0x80,0x00,0x14,0x15,0x00,0x00,\r
- 0x80,0x00,0x05,0x55,0x00,0x00,\r
- 0x80,0x00,0x00,0x05,0x00,0x00,\r
- 0x80,0x00,0x00,0x05,0x00,0x00,\r
- 0x80,0x00,0x00,0x14,0x00,0x00,\r
- 0x80,0x00,0x05,0x50,0x00,0x00,\r
- 0x80,0x00,0x00,0x00,0x00,0x00,\r
- 0x80,0x00,0x00,0x00,0x00,0x00,\r
- 0x80,0x00,0x00,0x00,0x00,0x00,\r
- 0x80,0x00,0x00,0x00,0x00,0x00,\r
- 0xaa,0xaa,0xaa,0xaa,0xaa,0xaa\r
-}\r
-};\r
-\r
-////////////////////////////////////////////////////////////////////////\r
-\r
-void PaintPicDot(unsigned char * p,unsigned char c)\r
-{\r
- if(c==0) {*p++=0x00;*p++=0x00;*p=0x00;return;}\r
- if(c==1) {*p++=0xff;*p++=0xff;*p=0xff;return;}\r
- if(c==2) {*p++=0x00;*p++=0x00;*p=0xff;return;}\r
-}\r
-\r
-////////////////////////////////////////////////////////////////////////\r
-\r
-void CALLBACK GPUgetScreenPic(unsigned char * pMem)\r
-{\r
- float XS,YS;int x,y,v;\r
- unsigned char * ps, * px, * pf;\r
- unsigned char c;\r
-\r
- if(!pGfxCardScreen)\r
- {\r
- glPixelStorei(GL_PACK_ALIGNMENT,1);\r
- pGfxCardScreen=(unsigned char *)malloc(iResX*iResY*4);\r
- }\r
-\r
- ps=pGfxCardScreen;\r
-\r
- glReadBuffer(GL_FRONT);\r
-\r
- glReadPixels(0,0,iResX,iResY,GL_RGB,GL_UNSIGNED_BYTE,ps);\r
- \r
- glReadBuffer(GL_BACK);\r
-\r
- XS=(float)iResX/128;\r
- YS=(float)iResY/96;\r
- pf=pMem;\r
-\r
- for(y=96;y>0;y--)\r
- {\r
- for(x=0;x<128;x++)\r
- {\r
- px=ps+(3*((int)((float)x * XS))+\r
- (3*iResX)*((int)((float)y*YS)));\r
- *(pf+0)=*(px+2);\r
- *(pf+1)=*(px+1);\r
- *(pf+2)=*(px+0);\r
- pf+=3;\r
- }\r
- }\r
-\r
- /////////////////////////////////////////////////////////////////////\r
- // generic number/border painter\r
-\r
- pf=pMem+(103*3);\r
-\r
- for(y=0;y<20;y++)\r
- {\r
- for(x=0;x<6;x++)\r
- {\r
- c=cFont[lSelectedSlot][x+y*6];\r
- v=(c&0xc0)>>6;\r
- PaintPicDot(pf,(unsigned char)v);pf+=3; // paint the dots into the rect\r
- v=(c&0x30)>>4;\r
- PaintPicDot(pf,(unsigned char)v);pf+=3;\r
- v=(c&0x0c)>>2;\r
- PaintPicDot(pf,(unsigned char)v);pf+=3;\r
- v=c&0x03;\r
- PaintPicDot(pf,(unsigned char)v);pf+=3;\r
- }\r
- pf+=104*3;\r
- }\r
-\r
- pf=pMem;\r
- for(x=0;x<128;x++)\r
- {\r
- *(pf+(95*128*3))=0x00;*pf++=0x00;\r
- *(pf+(95*128*3))=0x00;*pf++=0x00;\r
- *(pf+(95*128*3))=0xff;*pf++=0xff;\r
- }\r
- pf=pMem;\r
- for(y=0;y<96;y++)\r
- {\r
- *(pf+(127*3))=0x00;*pf++=0x00;\r
- *(pf+(127*3))=0x00;*pf++=0x00;\r
- *(pf+(127*3))=0xff;*pf++=0xff;\r
- pf+=127*3;\r
- }\r
-\r
-}\r
-\r
-////////////////////////////////////////////////////////////////////////\r
-\r
-void CALLBACK GPUshowScreenPic(unsigned char * pMem)\r
-{\r
- DestroyPic();\r
- if(pMem==0) return;\r
- CreatePic(pMem);\r
-}\r
-\r
-////////////////////////////////////////////////////////////////////////\r
-\r
-void CALLBACK GPUsetfix(uint32_t dwFixBits)\r
-{\r
- dwEmuFixes=dwFixBits;\r
-}\r
-\r
-////////////////////////////////////////////////////////////////////////\r
- \r
-void CALLBACK GPUvisualVibration(uint32_t iSmall, uint32_t iBig)\r
-{\r
- int iVibVal;\r
-\r
- if(PSXDisplay.DisplayModeNew.x) // calc min "shake pixel" from screen width\r
- iVibVal=max(1,iResX/PSXDisplay.DisplayModeNew.x);\r
- else iVibVal=1;\r
- // big rumble: 4...15 sp ; small rumble 1...3 sp\r
- if(iBig) iRumbleVal=max(4*iVibVal,min(15*iVibVal,((int)iBig *iVibVal)/10));\r
- else iRumbleVal=max(1*iVibVal,min( 3*iVibVal,((int)iSmall*iVibVal)/10));\r
-\r
- srand(timeGetTime()); // init rand (will be used in BufferSwap)\r
-\r
- iRumbleTime=15; // let the rumble last 16 buffer swaps\r
-}\r
- \r
-////////////////////////////////////////////////////////////////////////\r
-// main emu can set display infos (A/M/G/D) \r
-////////////////////////////////////////////////////////////////////////\r
-\r
-void CALLBACK GPUdisplayFlags(uint32_t dwFlags)\r
-{\r
- dwCoreFlags=dwFlags;\r
-}\r
notaz.gp2x.de / pcsx_rearmed.git / blobdiff