Integrated P.E.Op.S OpenGL plugin into the build tree (still does NOT work on x86_64)

git-svn-id: https://pcsxr.svn.codeplex.com/svn/pcsxr@23342 e17a0e51-4ae3-4d35-97c3-1a29b211df97

1 files changed, 3187 insertions, 0 deletions

diff --git a/plugins/peopsxgl/gpu.c b/plugins/peopsxgl/gpu.c
new file mode 100644
index 00000000..3e424f80
--- /dev/null
+++ b/plugins/peopsxgl/gpu.c
@@ -0,0 +1,3187 @@
+/***************************************************************************

+                           gpu.c  -  description

+                             -------------------

+    begin                : Sun Mar 08 2009

+    copyright            : (C) 1999-2009 by Pete Bernert

+    email                : BlackDove@addcom.de

+ ***************************************************************************/

+

+/***************************************************************************

+ *                                                                         *

+ *   This program is free software; you can redistribute it and/or modify  *

+ *   it under the terms of the GNU General Public License as published by  *

+ *   the Free Software Foundation; either version 2 of the License, or     *

+ *   (at your option) any later version. See also the license.txt file for *

+ *   additional informations.                                              *

+ *                                                                         *

+ ***************************************************************************/

+

+// !!! enable this, if Linux XF86VidMode is not supported: 

+//#define NOVMODE

+
+#include "stdafx.h"

+
+#ifndef NOVMODE

+#include <X11/extensions/xf86vmode.h>

+static XF86VidModeModeInfo **modes=0;

+static int iOldMode=0;

+#endif

+

+#define _IN_GPU

+

+#include "externals.h"

+#include "gpu.h"

+#include "draw.h"

+#include "cfg.h"

+#include "prim.h"

+#include "psemu_plugin_defs.h"

+#include "texture.h"

+#include "menu.h"

+#include "fps.h"

+#include "key.h"

+

+                               

+////////////////////////////////////////////////////////////////////////

+// PPDK developer must change libraryName field and can change revision and build

+////////////////////////////////////////////////////////////////////////

+

+const  unsigned char version  = 1;    // do not touch - library for PSEmu 1.x

+const  unsigned char revision = 1;

+const  unsigned char build    = 78;

+

+static char *libraryName     = "OpenGL Driver";

+

+static char *PluginAuthor    = "Pete Bernert";

+static char *libraryInfo     = "Based on P.E.Op.S. MesaGL Driver V1.78\nCoded by Pete Bernert\n";

+

+////////////////////////////////////////////////////////////////////////

+// memory image of the PSX vram

+////////////////////////////////////////////////////////////////////////

+

+unsigned char  *psxVSecure;

+unsigned char  *psxVub;

+signed   char  *psxVsb;

+unsigned short *psxVuw;

+unsigned short *psxVuw_eom;

+signed   short *psxVsw;

+unsigned long  *psxVul;

+signed   long  *psxVsl;

+

+// macro for easy access to packet information

+#define GPUCOMMAND(x) ((x>>24) & 0xff)

+

+GLfloat         gl_z=0.0f;

+BOOL            bNeedInterlaceUpdate=FALSE;

+BOOL            bNeedRGB24Update=FALSE;

+BOOL            bChangeWinMode=FALSE;

+

+unsigned long   ulStatusControl[256];

+

+////////////////////////////////////////////////////////////////////////

+// global GPU vars

+////////////////////////////////////////////////////////////////////////

+

+static long     GPUdataRet;

+long            lGPUstatusRet;

+char            szDispBuf[64];
+

+uint32_t        dwGPUVersion = 0;

+int             iGPUHeight = 512;

+int             iGPUHeightMask = 511;

+int             GlobalTextIL = 0;

+int             iTileCheat = 0;
+

+static unsigned long gpuDataM[256];

+static unsigned char gpuCommand = 0;

+static long          gpuDataC = 0;

+static long          gpuDataP = 0;

+

+VRAMLoad_t      VRAMWrite;

+VRAMLoad_t      VRAMRead;

+int             iDataWriteMode;

+int             iDataReadMode;

+

+long            lClearOnSwap;

+long            lClearOnSwapColor;

+BOOL            bSkipNextFrame = FALSE;

+int             iColDepth;

+BOOL            bChangeRes;

+BOOL            bWindowMode;

+int             iWinSize;

+

+// possible psx display widths

+short dispWidths[8] = {256,320,512,640,368,384,512,640};

+

+PSXDisplay_t    PSXDisplay;

+PSXDisplay_t    PreviousPSXDisplay;

+TWin_t          TWin;

+short           imageX0,imageX1;

+short           imageY0,imageY1;

+BOOL            bDisplayNotSet = TRUE;

+GLuint          uiScanLine=0;

+int             iUseScanLines=0;

+long            lSelectedSlot=0;

+unsigned char * pGfxCardScreen=0;

+int             iBlurBuffer=0;

+int             iScanBlend=0;

+int             iRenderFVR=0;

+int             iNoScreenSaver=0;

+unsigned long   ulGPUInfoVals[16];

+int             iFakePrimBusy = 0;

+int             iRumbleVal    = 0;

+int             iRumbleTime   = 0;

+

+////////////////////////////////////////////////////////////////////////

+// stuff to make this a true PDK module

+////////////////////////////////////////////////////////////////////////

+

+char * CALLBACK PSEgetLibName(void)

+{

+ return libraryName;

+}

+

+unsigned long CALLBACK PSEgetLibType(void)

+{

+ return  PSE_LT_GPU;

+}

+

+unsigned long CALLBACK PSEgetLibVersion(void)

+{

+ return version<<16|revision<<8|build;

+}

+

+char * GPUgetLibInfos(void)

+{

+ return libraryInfo;

+}

+

+////////////////////////////////////////////////////////////////////////

+// snapshot funcs (saves screen to bitmap / text infos into file)

+////////////////////////////////////////////////////////////////////////

+

+char * GetConfigInfos(int hW)

+{

+ char szO[2][4]={"off","on "};

+ char szTxt[256];

+ char * pB=(char *)malloc(32767);

+

+ if(!pB) return NULL;

+ *pB=0;

+ //----------------------------------------------------//

+ sprintf(szTxt,"Plugin: %s %d.%d.%d\r\n",libraryName,version,revision,build);

+ strcat(pB,szTxt);

+ sprintf(szTxt,"Author: %s\r\n",PluginAuthor);

+ strcat(pB,szTxt);

+

+ sprintf(szTxt,"Card vendor: %s\r\n",(char *)glGetString(GL_VENDOR));

+ strcat(pB,szTxt);

+ sprintf(szTxt,"GFX card: %s\r\n",(char *)glGetString(GL_RENDERER));

+ strcat(pB,szTxt);

+ sprintf(szTxt,"OGL version: %s\r\n\r\n",(char *)glGetString(GL_VERSION));

+ strcat(pB,szTxt);

+ //strcat(pB,(char *)glGetString(GL_EXTENSIONS));

+ //strcat(pB,"\r\n\r\n");

+

+ if(hW && bWindowMode)

+  sprintf(szTxt,"Resolution/Color:\r\n- %dx%d ",LOWORD(iWinSize),HIWORD(iWinSize));

+ else

+  sprintf(szTxt,"Resolution/Color:\r\n- %dx%d ",iResX,iResY);

+ strcat(pB,szTxt);

+ if(bWindowMode) sprintf(szTxt,"Window mode\r\n");

+ else

+  {

+   sprintf(szTxt,"Fullscreen ");

+   strcat(pB,szTxt);

+   if(bChangeRes) sprintf(szTxt,"- Desktop changing [%d Bit]\r\n",iColDepth);

+   else           sprintf(szTxt,"- NO desktop changing\r\n");

+  }                                                                                   

+ strcat(pB,szTxt);

+

+ if(iForceVSync>=0) sprintf(szTxt,"- V-Sync: %s\r\n",szO[iForceVSync]);

+ else               strcpy(szTxt,"- V-Sync: Driver\r\n");

+ strcat(pB,szTxt); 

+ sprintf(szTxt,"- Keep psx aspect ratio: %s\r\n\r\n",szO[bKeepRatio]);

+ strcat(pB,szTxt);

+ //----------------------------------------------------//

+ strcpy(szTxt,"Textures:\r\n- ");

+ if(iTexQuality==0)      strcat(szTxt,"Default");

+ else if(iTexQuality==1) strcat(szTxt,"R4G4B4A4");

+ else if(iTexQuality==2) strcat(szTxt,"R5G5B5A1");

+ else if(iTexQuality==3) strcat(szTxt,"R8G8A8A8");

+ else if(iTexQuality==4) strcat(szTxt,"B8G8R8A8");

+ if(!hW && bGLExt) strcat(szTxt," (packed pixels)\r\n");

+ else              strcat(szTxt,"\r\n");

+ strcat(pB,szTxt);

+ if(!hW)

+  {

+   sprintf(szTxt,"- Filtering: %d - edge clamping ",iFilterType);

+   if(iClampType==GL_TO_EDGE_CLAMP) strcat(szTxt,"supported\r\n");

+   else                             strcat(szTxt,"NOT supported\r\n");

+  }

+ else sprintf(szTxt,"- iFiltering: %d\r\n",iFilterType);

+ strcat(pB,szTxt);

+ sprintf(szTxt,"- Hi-Res textures: %d\r\n",iHiResTextures);

+ strcat(pB,szTxt); 

+ if(!hW)

+  {

+   sprintf(szTxt,"- Palettized tex windows: %s\r\n",szO[iUsePalTextures]);

+   strcat(pB,szTxt); 

+  }

+ sprintf(szTxt,"- VRam size: %d MBytes",iVRamSize);

+ if(!hW)

+      sprintf(szTxt+strlen(szTxt)," - %d textures usable\r\n\r\n",iSortTexCnt);

+ else strcat(szTxt,"\r\n\r\n");

+ strcat(pB,szTxt);

+ //----------------------------------------------------//

+ sprintf(szTxt,"Framerate:\r\n- FPS limitation: %s\r\n",szO[bUseFrameLimit]);

+ strcat(pB,szTxt);

+ sprintf(szTxt,"- Frame skipping: %s\r\n",szO[bUseFrameSkip]);

+ strcat(pB,szTxt);

+ if(iFrameLimit==2)

+      strcpy(szTxt,"- FPS limit: Auto\r\n\r\n");

+ else sprintf(szTxt,"- FPS limit: %.1f\r\n\r\n",fFrameRate);

+ strcat(pB,szTxt);

+ //----------------------------------------------------//

+ sprintf(szTxt,"Compatibility:\r\n- Offscreen drawing: %d\r\n",iOffscreenDrawing);

+ strcat(pB,szTxt);

+ sprintf(szTxt,"- Framebuffer texture: %d",iFrameTexType);

+ if(!hW && iFrameTexType==2)

+  {

+   if(gTexFrameName) strcat(szTxt," - texture created\r\n");

+   else              strcat(szTxt," - not used yet\r\n");

+  }

+ else strcat(szTxt,"\r\n");

+ strcat(pB,szTxt);

+ sprintf(szTxt,"- Framebuffer access: %d\r\n",iFrameReadType);

+ strcat(pB,szTxt);

+ sprintf(szTxt,"- Alpha multipass: %s\r\n",szO[bOpaquePass]);

+ strcat(pB,szTxt);

+ sprintf(szTxt,"- Mask bit: %s\r\n",szO[iUseMask]);

+ strcat(pB,szTxt);

+ sprintf(szTxt,"- Advanced blending: %s",szO[bAdvancedBlend]);

+ if(!hW && bAdvancedBlend)

+  {

+   if(bGLBlend) strcat(szTxt," (hardware)\r\n");

+   else         strcat(szTxt," (software)\r\n");

+  }

+ else strcat(szTxt,"\r\n");

+ strcat(pB,szTxt);

+

+ if(!hW)

+  {

+   strcpy(szTxt,"- Subtractive blending: ");

+   if(glBlendEquationEXTEx)

+    {

+     if(bUseMultiPass) strcat(szTxt,"supported, but not used!");

+     else              strcat(szTxt,"activated");

+    }

+   else strcat(szTxt," NOT supported!");

+   strcat(szTxt,"\r\n\r\n");

+  }

+ else strcpy(szTxt,"\r\n");

+ 

+ strcat(pB,szTxt);             

+ //----------------------------------------------------//

+ sprintf(szTxt,"Misc:\r\n- Scanlines: %s",szO[iUseScanLines]);

+ strcat(pB,szTxt);

+ if(iUseScanLines) sprintf(szTxt," [%d]\r\n",iScanBlend);

+ else strcpy(szTxt,"\r\n");

+ strcat(pB,szTxt);

+ sprintf(szTxt,"- Line mode: %s\r\n",szO[bUseLines]);

+ strcat(pB,szTxt);

+// sprintf(szTxt,"- Line AA: %s\r\n",szO[bUseAntiAlias]);

+// fwrite(szTxt,lstrlen(szTxt),1,txtfile);

+ sprintf(szTxt,"- Unfiltered FB: %s\r\n",szO[bUseFastMdec]);

+ strcat(pB,szTxt);

+ sprintf(szTxt,"- 15 bit FB: %s\r\n",szO[bUse15bitMdec]);

+ strcat(pB,szTxt);

+ sprintf(szTxt,"- Dithering: %s\r\n",szO[bDrawDither]);

+ strcat(pB,szTxt);

+ sprintf(szTxt,"- Screen smoothing: %s",szO[iBlurBuffer]);

+ strcat(pB,szTxt);

+ if(!hW && iBlurBuffer) 

+  {

+   if(gTexBlurName) strcat(pB," - supported\r\n");

+   else             strcat(pB," - not supported\r\n");

+  }

+ else strcat(pB,"\r\n");

+ sprintf(szTxt,"- Game fixes: %s [%08lx]\r\n",szO[bUseFixes],dwCfgFixes);

+ strcat(pB,szTxt);

+ //----------------------------------------------------//

+ return pB;

+}

+

+////////////////////////////////////////////////////////////////////////

+// save text infos to file

+////////////////////////////////////////////////////////////////////////

+

+void DoTextSnapShot(int iNum)

+{

+ FILE *txtfile;char szTxt[256];char * pB;

+

+ sprintf(szTxt,"%s/pcsx%04d.txt",getenv("HOME"),iNum);

+

+ if((txtfile=fopen(szTxt,"wb"))==NULL)

+  return;                                              

+

+ pB=GetConfigInfos(0);

+ if(pB)

+  {

+   fwrite(pB,strlen(pB),1,txtfile);

+   free(pB);

+  }

+ fclose(txtfile); 

+}

+

+////////////////////////////////////////////////////////////////////////

+// saves screen bitmap to file

+////////////////////////////////////////////////////////////////////////

+

+void DoSnapShot(void)

+{

+ unsigned char * snapshotdumpmem=NULL,* p,c;

+ FILE *bmpfile;char filename[256];

+ unsigned char header[0x36];long size;

+ unsigned char empty[2]={0,0};int i;

+ unsigned long snapshotnr = 0;

+ short SnapWidth;

+ short SnapHeigth;

+

+ bSnapShot=FALSE;

+

+ SnapWidth  = iResX;

+ SnapHeigth = iResY;

+

+ size=SnapWidth * SnapHeigth * 3 + 0x38;

+

+ if((snapshotdumpmem=(unsigned char *)

+   malloc(SnapWidth*SnapHeigth*3))==NULL)

+  return;

+    

+  // fill in proper values for BMP

+ for(i=0;i<0x36;i++) header[i]=0;

+ header[0]='B';

+ header[1]='M';

+ header[2]=(unsigned char)(size&0xff);

+ header[3]=(unsigned char)((size>>8)&0xff);

+ header[4]=(unsigned char)((size>>16)&0xff);

+ header[5]=(unsigned char)((size>>24)&0xff);

+ header[0x0a]=0x36;

+ header[0x0e]=0x28;

+ header[0x12]=(unsigned char)(SnapWidth%256);

+ header[0x13]=(unsigned char)(SnapWidth/256);

+ header[0x16]=(unsigned char)(SnapHeigth%256);

+ header[0x17]=(unsigned char)(SnapHeigth/256);

+ header[0x1a]=0x01;

+ header[0x1c]=0x18;

+ header[0x26]=0x12;

+ header[0x27]=0x0B;

+ header[0x2A]=0x12;

+ header[0x2B]=0x0B;

+

+ // increment snapshot value

+ // get filename

+ do

+  {

+   snapshotnr++;

+   sprintf(filename,"%s/pcsx%04d.bmp",getenv("HOME"),snapshotnr);

+   bmpfile=fopen(filename,"rb");

+   if(bmpfile==NULL)break;

+   fclose(bmpfile);

+   if(snapshotnr==9999) break;

+  }

+ while(TRUE);

+

+ // try opening new snapshot file

+ if((bmpfile=fopen(filename,"wb"))==NULL)

+  {free(snapshotdumpmem);return;}

+

+ fwrite(header,0x36,1,bmpfile);

+

+ glReadPixels(0,0,SnapWidth,SnapHeigth,GL_RGB,

+               GL_UNSIGNED_BYTE,snapshotdumpmem);

+ p=snapshotdumpmem;

+ size=SnapWidth * SnapHeigth;

+

+ for(i=0;i<size;i++,p+=3)

+  {c=*p;*p=*(p+2);*(p+2)=c;}

+

+ fwrite(snapshotdumpmem,size*3,1,bmpfile);

+ fwrite(empty,0x2,1,bmpfile);

+ fclose(bmpfile); 

+ free(snapshotdumpmem);

+

+ DoTextSnapShot(snapshotnr);

+}       

+

+void CALLBACK GPUmakeSnapshot(void)

+{

+ bSnapShot = TRUE;

+}        

+

+////////////////////////////////////////////////////////////////////////

+// GPU INIT... here starts it all (first func called by emu)

+////////////////////////////////////////////////////////////////////////

+

+long CALLBACK GPUinit()

+{

+ memset(ulStatusControl,0,256*sizeof(unsigned long));

+

+ // different ways of accessing PSX VRAM

+

+ psxVSecure=(unsigned char *)malloc((iGPUHeight*2)*1024 + (1024*1024)); // always alloc one extra MB for soft drawing funcs security

+ if(!psxVSecure) return -1;

+

+ psxVub=psxVSecure+512*1024;                           // security offset into double sized psx vram!

+ psxVsb=(signed char *)psxVub;

+ psxVsw=(signed short *)psxVub;

+ psxVsl=(signed long *)psxVub;

+ psxVuw=(unsigned short *)psxVub;

+ psxVul=(unsigned long *)psxVub;

+

+ psxVuw_eom=psxVuw+1024*iGPUHeight;                    // pre-calc of end of vram

+

+ memset(psxVSecure,0x00,(iGPUHeight*2)*1024 + (1024*1024));

+ memset(ulGPUInfoVals,0x00,16*sizeof(unsigned long));

+

+ InitFrameCap();                                       // init frame rate stuff

+

+ PSXDisplay.RGB24        = 0;                          // init vars

+ PreviousPSXDisplay.RGB24= 0;

+ PSXDisplay.Interlaced   = 0;

+ PSXDisplay.InterlacedTest=0;

+ PSXDisplay.DrawOffset.x = 0;

+ PSXDisplay.DrawOffset.y = 0;

+ PSXDisplay.DrawArea.x0  = 0;

+ PSXDisplay.DrawArea.y0  = 0;

+ PSXDisplay.DrawArea.x1  = 320;

+ PSXDisplay.DrawArea.y1  = 240;

+ PSXDisplay.DisplayMode.x= 320;

+ PSXDisplay.DisplayMode.y= 240;

+ PSXDisplay.Disabled     = FALSE;

+ PreviousPSXDisplay.Range.x0 =0;

+ PreviousPSXDisplay.Range.x1 =0;

+ PreviousPSXDisplay.Range.y0 =0;

+ PreviousPSXDisplay.Range.y1 =0;

+ PSXDisplay.Range.x0=0;

+ PSXDisplay.Range.x1=0;

+ PSXDisplay.Range.y0=0;

+ PSXDisplay.Range.y1=0;

+ PreviousPSXDisplay.DisplayPosition.x = 1;

+ PreviousPSXDisplay.DisplayPosition.y = 1;

+ PSXDisplay.DisplayPosition.x = 1;

+ PSXDisplay.DisplayPosition.y = 1;

+ PreviousPSXDisplay.DisplayModeNew.y=0;

+ PSXDisplay.Double=1;

+ GPUdataRet=0x400;

+

+ PSXDisplay.DisplayModeNew.x=0;

+ PSXDisplay.DisplayModeNew.y=0;

+

+ //PreviousPSXDisplay.Height = PSXDisplay.Height = 239;

+ 

+ iDataWriteMode = DR_NORMAL;

+

+ // Reset transfer values, to prevent mis-transfer of data

+ memset(&VRAMWrite,0,sizeof(VRAMLoad_t));

+ memset(&VRAMRead,0,sizeof(VRAMLoad_t));

+ 

+ // device initialised already !

+ //lGPUstatusRet = 0x74000000;

+

+ STATUSREG = 0x14802000;

+ GPUIsIdle;

+ GPUIsReadyForCommands;

+

+ return 0;

+}                             

+

+////////////////////////////////////////////////////////////////////////

+// GPU OPEN: funcs to open up the gpu display (Windows)

+////////////////////////////////////////////////////////////////////////

+

+////////////////////////////////////////////////////////////////////////

+// LINUX GPU OPEN: func to open up the gpu display (X stuff)

+// please note: in linux we are creating our own display, and we return

+// the display ID to the main emu... that's cleaner

+////////////////////////////////////////////////////////////////////////

+

+char * pCaptionText=0;

+int    bFullScreen=0;

+Display              *display;

+

+static Cursor        cursor;

+static XVisualInfo   *myvisual;

+static Colormap      colormap;

+static Window        window;

+

+static int bModeChanged=0;

+

+typedef struct

+{

+#define MWM_HINTS_DECORATIONS   2

+  long flags;

+  long functions;

+  long decorations;

+  long input_mode;

+} MotifWmHints;

+

+static int dbdepat[]={GLX_RGBA,GLX_DOUBLEBUFFER,GLX_DEPTH_SIZE,16,None};

+static int dbnodepat[]={GLX_RGBA,GLX_DOUBLEBUFFER,None};

+static GLXContext cx;

+

+static int fx=0;

+

+////////////////////////////////////////////////////////////////////////

+

+void osd_close_display (void)                          // close display

+{

+ if(display)                                           // display exists?

+  {

+   glXDestroyContext(display,cx);                      // -> kill context

+   XFreeColormap(display, colormap);                   // -> kill colormap

+   XSync(display,False);                               // -> sync events

+

+#ifndef NOVMODE

+   if(bModeChanged)                                    // -> repair screen mode

+    {

+     int myscreen=DefaultScreen(display);

+     XF86VidModeSwitchToMode(display,myscreen,         // --> switch mode back

+                             modes[iOldMode]);

+     XF86VidModeSetViewPort(display,myscreen,0,0);     // --> set viewport upperleft

+     free(modes);                                      // --> finally kill mode infos

+     bModeChanged=0;                                   // --> done

+    }

+#endif

+

+   XCloseDisplay(display);                             // -> close display

+  }

+}

+

+////////////////////////////////////////////////////////////////////////

+

+void sysdep_create_display(void)                       // create display

+{

+ XSetWindowAttributes winattr;float fxgamma=2;

+ int myscreen;char gammastr[14];

+ Screen * screen;XEvent event;

+ XSizeHints hints;XWMHints wm_hints;

+ MotifWmHints mwmhints;Atom mwmatom;

+ char *glxfx;

+

+ glxfx=getenv("MESA_GLX_FX");                          // 3dfx mesa fullscreen flag

+ if(glxfx)

+  {

+   if(glxfx[0]=='f')                                   // -> yup, fullscreen needed

+    {

+     fx=1;                                             // -> raise flag

+     putenv("FX_GLIDE_NO_SPLASH=");

+     sprintf(gammastr,"SST_GAMMA=%2.1f",fxgamma);      // -> set gamma

+     putenv(gammastr);

+    }

+  }

+

+ display=XOpenDisplay(NULL);                           // open display

+ if(!display)                                          // no display?

+  {

+   fprintf (stderr,"Failed to open display!!!\n");

+   osd_close_display();

+   return;                                             // -> bye

+  }

+

+ myscreen=DefaultScreen(display);                      // get screen id

+

+#ifdef NOVMODE

+ if(bFullScreen) {fx=1;bModeChanged=0;}

+#else

+ if(bFullScreen)

+  {

+   XF86VidModeModeLine mode;

+   int nmodes,iC;

+   fx=1;                                               // raise flag

+   XF86VidModeGetModeLine(display,myscreen,&iC,&mode); // get actual mode info

+   if(mode.privsize) XFree(mode.private);              // no need for private stuff

+   bModeChanged=0;                                     // init mode change flag

+   if(iResX!=mode.hdisplay || iResY!=mode.vdisplay)    // wanted mode is different?

+    {

+     XF86VidModeGetAllModeLines(display,myscreen,      // -> enum all mode infos

+                                &nmodes,&modes);

+     if(modes)                                         // -> infos got?

+      {

+       for(iC=0;iC<nmodes;++iC)                        // -> loop modes

+        {

+         if(mode.hdisplay==modes[iC]->hdisplay &&      // -> act mode found?

+            mode.vdisplay==modes[iC]->vdisplay)        //    if yes: store mode id

+          iOldMode=iC;

+

+         if(iResX==modes[iC]->hdisplay &&              // -> wanted mode found?

+            iResY==modes[iC]->vdisplay)

+          {

+           XF86VidModeSwitchToMode(display,myscreen,   // --> switch to mode

+                                   modes[iC]);

+           XF86VidModeSetViewPort(display,myscreen,0,0);

+           bModeChanged=1;                             // --> raise flag for repairing mode on close

+          }

+        }

+

+       if(bModeChanged==0)                             // -> no mode found?

+        {

+         free(modes);                                  // --> free infos

+         printf("No proper fullscreen mode found!\n"); // --> some info output

+        }

+      }

+    }

+  }

+#endif

+

+ screen=DefaultScreenOfDisplay(display);

+

+ if(iZBufferDepth)                                      // visual (with or without zbuffer)

+      myvisual=glXChooseVisual(display,myscreen,dbdepat);

+ else myvisual=glXChooseVisual(display,myscreen,dbnodepat);

+

+ if(!myvisual)                                         // no visual?

+  {

+   fprintf(stderr,"Failed to obtain visual!!!\n");     // -> bye

+   osd_close_display();

+   return;

+  }

+

+ cx=glXCreateContext(display,myvisual,0,GL_TRUE);      // create rendering context

+

+ if(!cx)                                               // no context?

+  {

+   fprintf(stderr,"Failed to create OpenGL context!!!\n");

+   osd_close_display();                                // -> bxe

+   return;

+  }

+

+ // pffff... much work for a simple blank cursor... oh, well...

+ if(!bFullScreen) cursor=XCreateFontCursor(display,XC_trek);

+ else

+  {

+   Pixmap p1,p2;XImage * img;

+   XColor b,w;unsigned char * idata;

+   XGCValues GCv;

+   GC        GCc;

+

+   memset(&b,0,sizeof(XColor));

+   memset(&w,0,sizeof(XColor));

+   idata=(unsigned char *)malloc(8);

+   memset(idata,0,8);

+

+   p1=XCreatePixmap(display,RootWindow(display,myvisual->screen),8,8,1);

+   p2=XCreatePixmap(display,RootWindow(display,myvisual->screen),8,8,1);

+

+   img = XCreateImage(display,myvisual->visual,

+                      1,XYBitmap,0,idata,8,8,8,1);

+

+   GCv.function   = GXcopy;

+   GCv.foreground = ~0;

+   GCv.background =  0;

+   GCv.plane_mask = AllPlanes;

+   GCc = XCreateGC(display,p1,

+                   (GCFunction|GCForeground|GCBackground|GCPlaneMask),&GCv);

+

+   XPutImage(display, p1,GCc,img,0,0,0,0,8,8);

+   XPutImage(display, p2,GCc,img,0,0,0,0,8,8);

+   XFreeGC(display, GCc);

+

+   cursor = XCreatePixmapCursor(display,p1,p2,&b,&w,0,0);

+

+   XFreePixmap(display,p1);

+   XFreePixmap(display,p2);

+   XDestroyImage(img);                                 // will free idata as well

+  }

+

+ colormap=XCreateColormap(display,                     // create colormap

+                          RootWindow(display,myvisual->screen),

+                          myvisual->visual,AllocNone);

+

+ winattr.background_pixel=0;

+ winattr.border_pixel=WhitePixelOfScreen(screen);

+ winattr.bit_gravity=ForgetGravity;

+ winattr.win_gravity=NorthWestGravity;

+ winattr.backing_store=NotUseful;

+ winattr.override_redirect=False;

+ winattr.save_under=False;

+ winattr.event_mask=0;

+ winattr.do_not_propagate_mask=0;

+ winattr.colormap=colormap;

+ winattr.cursor=None;

+

+ window=XCreateWindow(display,                         // create own window

+             RootWindow(display,DefaultScreen(display)),

+             0,0,iResX,iResY,

+             0,myvisual->depth,

+             InputOutput,myvisual->visual,

+             CWBorderPixel | CWBackPixel |

+             CWEventMask | CWDontPropagate |

+             CWColormap | CWCursor,

+             &winattr);

+

+ if(!window)                                           // no window?

+  {

+   fprintf(stderr,"Failed in XCreateWindow()!!!\n");

+   osd_close_display();                                // -> bye

+   return;

+  }

+

+ hints.flags=PMinSize|PMaxSize;                        // hints

+ if(fx) hints.flags|=USPosition|USSize;

+ else   hints.flags|=PSize;

+

+ hints.min_width   = hints.max_width  = hints.base_width  = iResX;

+ hints.min_height  = hints.max_height = hints.base_height = iResY;

+

+ wm_hints.input=1;

+ wm_hints.flags=InputHint;

+

+ XSetWMHints(display,window,&wm_hints);

+ XSetWMNormalHints(display,window,&hints);

+ if(pCaptionText)                                      // caption

+      XStoreName(display,window,pCaptionText);

+ else XStoreName(display,window,"Pete MesaGL PSX Gpu");

+

+ XDefineCursor(display,window,cursor);                 // cursor

+

+ if(fx)                                                // window title bar hack

+  {

+   mwmhints.flags=MWM_HINTS_DECORATIONS;

+   mwmhints.decorations=0;

+   mwmatom=XInternAtom(display,"_MOTIF_WM_HINTS",0);

+   XChangeProperty(display,window,mwmatom,mwmatom,32,

+                   PropModeReplace,(unsigned char *)&mwmhints,4);

+  }

+

+ XSelectInput(display,window,                          // input setup

+              FocusChangeMask | ExposureMask |

+              KeyPressMask | KeyReleaseMask);

+

+ XMapRaised(display,window);

+ XClearWindow(display,window);

+ XWindowEvent(display,window,ExposureMask,&event);

+ glXMakeCurrent(display,window,cx);

+

+/* 

+ printf(glGetString(GL_VENDOR));

+ printf("\n");

+ printf(glGetString(GL_RENDERER));

+ printf("\n");

+*/

+

+ if(fx)                                                // after make current: fullscreen resize

+  {

+   XResizeWindow(display,window,screen->width,screen->height);

+   hints.min_width   = hints.max_width = hints.base_width = screen->width;

+   hints.min_height= hints.max_height = hints.base_height = screen->height;

+   XSetWMNormalHints(display,window,&hints);

+  }

+}

+

+////////////////////////////////////////////////////////////////////////

+

+long GPUopen(unsigned long * disp,char * CapText,char * CfgFile)

+{

+ pCaptionText=CapText;

+ pConfigFile=CfgFile;

+

+ ReadConfig();                                         // read text file for config

+

+ SetFrameRateConfig();                                 // setup frame rate stuff

+

+ bIsFirstFrame = TRUE;                                 // we have to init later (well, no really... in Linux we do all in GPUopen)

+

+ sysdep_create_display();                              // create display

+

+ InitializeTextureStore();                             // init texture mem

+

+ rRatioRect.left   = rRatioRect.top=0;

+ rRatioRect.right  = iResX;

+ rRatioRect.bottom = iResY;

+

+ GLinitialize();                                       // init opengl

+

+ if(disp)

+  {

+   *disp=(unsigned long)display;                       // return display ID to main emu

+  }

+

+ if(display) return 0;

+ return -1;

+}

+

+////////////////////////////////////////////////////////////////////////

+// close

+////////////////////////////////////////////////////////////////////////

+
+long GPUclose()                                        // LINUX CLOSE

+{

+ GLcleanup();                                          // close OGL

+

+ if(pGfxCardScreen) free(pGfxCardScreen);              // free helper memory

+ pGfxCardScreen=0;

+

+ osd_close_display();                                  // destroy display

+

+ return 0;

+}

+

+////////////////////////////////////////////////////////////////////////

+// I shot the sheriff... last function called from emu 

+////////////////////////////////////////////////////////////////////////

+

+long CALLBACK GPUshutdown()

+{

+ if(psxVSecure) free(psxVSecure);                      // kill emulated vram memory

+ psxVSecure=0;

+

+ return 0;

+}

+

+////////////////////////////////////////////////////////////////////////

+// paint it black: simple func to clean up optical border garbage

+////////////////////////////////////////////////////////////////////////

+

+void PaintBlackBorders(void)

+{

+ short s;

+

+ glDisable(GL_SCISSOR_TEST);

+ if(bTexEnabled) {glDisable(GL_TEXTURE_2D);bTexEnabled=FALSE;}

+ if(bOldSmoothShaded) {glShadeModel(GL_FLAT);bOldSmoothShaded=FALSE;}

+ if(bBlendEnable)     {glDisable(GL_BLEND);bBlendEnable=FALSE;}

+ glDisable(GL_ALPHA_TEST);

+

+ glBegin(GL_QUADS);

+

+ vertex[0].c.lcol=0xff000000;

+ SETCOL(vertex[0]); 

+

+ if(PreviousPSXDisplay.Range.x0)

+  {

+   s=PreviousPSXDisplay.Range.x0+1;

+   glVertex3f(0,0,0.99996f);

+   glVertex3f(0,PSXDisplay.DisplayMode.y,0.99996f);

+   glVertex3f(s,PSXDisplay.DisplayMode.y,0.99996f);

+   glVertex3f(s,0,0.99996f);

+

+   s+=PreviousPSXDisplay.Range.x1-2;

+

+   glVertex3f(s,0,0.99996f);

+   glVertex3f(s,PSXDisplay.DisplayMode.y,0.99996f);

+   glVertex3f(PSXDisplay.DisplayMode.x,PSXDisplay.DisplayMode.y,0.99996f);

+   glVertex3f(PSXDisplay.DisplayMode.x,0,0.99996f);

+  }

+

+ if(PreviousPSXDisplay.Range.y0)

+  {

+   s=PreviousPSXDisplay.Range.y0+1;

+   glVertex3f(0,0,0.99996f);

+   glVertex3f(0,s,0.99996f);

+   glVertex3f(PSXDisplay.DisplayMode.x,s,0.99996f);

+   glVertex3f(PSXDisplay.DisplayMode.x,0,0.99996f);

+  }

+

+ glEnd();

+

+ glEnable(GL_ALPHA_TEST);

+ glEnable(GL_SCISSOR_TEST);

+}

+

+////////////////////////////////////////////////////////////////////////

+// helper to draw scanlines

+////////////////////////////////////////////////////////////////////////

+

+__inline void XPRIMdrawTexturedQuad(OGLVertex* vertex1, OGLVertex* vertex2, 

+                                    OGLVertex* vertex3, OGLVertex* vertex4) 

+{

+

+ glBegin(GL_QUAD_STRIP);

+  glTexCoord2fv(&vertex1->sow);

+  glVertex3fv(&vertex1->x);

+  

+  glTexCoord2fv(&vertex2->sow);

+  glVertex3fv(&vertex2->x);

+  

+  glTexCoord2fv(&vertex4->sow);

+  glVertex3fv(&vertex4->x);

+  

+  glTexCoord2fv(&vertex3->sow);

+  glVertex3fv(&vertex3->x);

+ glEnd();

+}

+

+////////////////////////////////////////////////////////////////////////

+// scanlines

+////////////////////////////////////////////////////////////////////////

+

+void SetScanLines(void)

+{

+ glLoadIdentity();

+ glOrtho(0,iResX,iResY, 0, -1, 1);

+

+ if(bKeepRatio)

+  glViewport(0,0,iResX,iResY);

+

+ glDisable(GL_SCISSOR_TEST);                       

+ glDisable(GL_ALPHA_TEST);

+ if(bOldSmoothShaded) {glShadeModel(GL_FLAT);bOldSmoothShaded=FALSE;}

+

+ if(iScanBlend<0)                                      // special texture mask scanline mode

+  {

+   if(!bTexEnabled)    {glEnable(GL_TEXTURE_2D);bTexEnabled=TRUE;}

+   gTexName=gTexScanName;

+   glBindTexture(GL_TEXTURE_2D, gTexName);

+   if(bGLBlend) glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);    

+   if(!bBlendEnable)   {glEnable(GL_BLEND);bBlendEnable=TRUE;}

+   SetScanTexTrans();

+

+   vertex[0].x=0;

+   vertex[0].y=iResY;

+   vertex[0].z=0.99996f;

+

+   vertex[1].x=iResX;

+   vertex[1].y=iResY;

+   vertex[1].z=0.99996f;

+

+   vertex[2].x=iResX;

+   vertex[2].y=0;

+   vertex[2].z=0.99996f;

+

+   vertex[3].x=0;

+   vertex[3].y=0;

+   vertex[3].z=0.99996f;

+

+   vertex[0].sow=0;

+   vertex[0].tow=0;

+   vertex[1].sow=(float)iResX/4.0f;

+   vertex[1].tow=0;

+   vertex[2].sow=vertex[1].sow;

+   vertex[2].tow=(float)iResY/4.0f;

+   vertex[3].sow=0;

+   vertex[3].tow=vertex[2].tow;

+

+   vertex[0].c.lcol=0xffffffff;

+   SETCOL(vertex[0]); 

+

+   XPRIMdrawTexturedQuad(&vertex[0], &vertex[1], &vertex[2], &vertex[3]);

+

+   if(bGLBlend) glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, COMBINE_EXT);    

+  }

+ else                                                  // typical line mode

+  {

+   if(bTexEnabled)     {glDisable(GL_TEXTURE_2D);bTexEnabled=FALSE;}

+

+   if(iScanBlend==0)

+    {

+     if(bBlendEnable)    {glDisable(GL_BLEND);bBlendEnable=FALSE;}

+     vertex[0].c.lcol=0xff000000;

+    }

+   else

+    {

+     if(!bBlendEnable)   {glEnable(GL_BLEND);bBlendEnable=TRUE;}

+     SetScanTrans();

+     vertex[0].c.lcol=iScanBlend<<24;

+    }

+

+   SETCOL(vertex[0]); 

+

+   glCallList(uiScanLine);

+  }

+

+ glLoadIdentity();

+ glOrtho(0,PSXDisplay.DisplayMode.x,

+         PSXDisplay.DisplayMode.y, 0, -1, 1);

+

+ if(bKeepRatio)

+  glViewport(rRatioRect.left,

+             iResY-(rRatioRect.top+rRatioRect.bottom),

+             rRatioRect.right, 

+             rRatioRect.bottom);                         // init viewport

+

+ glEnable(GL_ALPHA_TEST);

+ glEnable(GL_SCISSOR_TEST);                       

+}

+

+////////////////////////////////////////////////////////////////////////

+// blur, babe, blur (heavy performance hit for a so-so fullscreen effect)

+////////////////////////////////////////////////////////////////////////

+

+void BlurBackBuffer(void)

+{

+ if(!gTexBlurName) return;

+

+ if(bKeepRatio) glViewport(0,0,iResX,iResY);

+

+ glDisable(GL_SCISSOR_TEST);

+ glDisable(GL_ALPHA_TEST);

+ if(bOldSmoothShaded) {glShadeModel(GL_FLAT);bOldSmoothShaded=FALSE;}

+ if(bBlendEnable)     {glDisable(GL_BLEND);bBlendEnable=FALSE;}

+ if(!bTexEnabled)     {glEnable(GL_TEXTURE_2D);bTexEnabled=TRUE;}

+ if(iZBufferDepth)    glDisable(GL_DEPTH_TEST);    

+ if(bDrawDither)      glDisable(GL_DITHER); 

+

+ gTexName=gTexBlurName;

+ glBindTexture(GL_TEXTURE_2D, gTexName);

+

+ glCopyTexSubImage2D( GL_TEXTURE_2D, 0,                // get back buffer in texture

+                      0,

+                      0,

+                      0,

+                      0,

+                      iResX,iResY);

+

+ vertex[0].x=0;

+ vertex[0].y=PSXDisplay.DisplayMode.y;

+ vertex[1].x=PSXDisplay.DisplayMode.x;

+ vertex[1].y=PSXDisplay.DisplayMode.y;

+ vertex[2].x=PSXDisplay.DisplayMode.x;

+ vertex[2].y=0;

+ vertex[3].x=0;

+ vertex[3].y=0;

+ vertex[0].sow=0;

+ vertex[0].tow=0;

+

+#ifdef OWNSCALE

+ vertex[1].sow=((GLfloat)iFTexA)/256.0f;

+ vertex[2].tow=((GLfloat)iFTexB)/256.0f;

+#else

+ vertex[1].sow=iFTexA;

+ vertex[2].tow=iFTexB;

+#endif

+ vertex[1].tow=0;

+ vertex[2].sow=vertex[1].sow;

+ vertex[3].sow=0;

+ vertex[3].tow=vertex[2].tow;

+ 

+ if(bGLBlend) glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);    

+ vertex[0].c.lcol=0x7fffffff;

+ SETCOL(vertex[0]); 

+

+ DrawMultiBlur();                                      // draw the backbuffer texture to create blur effect

+

+ glEnable(GL_ALPHA_TEST);

+ glEnable(GL_SCISSOR_TEST);

+ if(iZBufferDepth)  glEnable(GL_DEPTH_TEST);    

+ if(bDrawDither)    glEnable(GL_DITHER);    

+ if(bGLBlend) glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, COMBINE_EXT);    

+

+ if(bKeepRatio)

+  glViewport(rRatioRect.left,                            // re-init viewport

+             iResY-(rRatioRect.top+rRatioRect.bottom),

+             rRatioRect.right, 

+             rRatioRect.bottom);            

+}

+

+////////////////////////////////////////////////////////////////////////

+// "unblur" repairs the backbuffer after a blur

+

+void UnBlurBackBuffer(void)

+{

+ if(!gTexBlurName) return;

+

+ if(bKeepRatio) glViewport(0,0,iResX,iResY);

+

+ glDisable(GL_SCISSOR_TEST);

+ glDisable(GL_ALPHA_TEST);

+ if(bBlendEnable)    {glDisable(GL_BLEND);bBlendEnable=FALSE;}

+ if(!bTexEnabled)    {glEnable(GL_TEXTURE_2D);bTexEnabled=TRUE;}

+ if(iZBufferDepth)    glDisable(GL_DEPTH_TEST);    

+ if(bDrawDither)      glDisable(GL_DITHER); 

+

+ gTexName=gTexBlurName;

+ glBindTexture(GL_TEXTURE_2D, gTexName);

+

+ vertex[0].x=0;

+ vertex[0].y=PSXDisplay.DisplayMode.y;

+ vertex[1].x=PSXDisplay.DisplayMode.x;

+ vertex[1].y=PSXDisplay.DisplayMode.y;

+ vertex[2].x=PSXDisplay.DisplayMode.x;

+ vertex[2].y=0;

+ vertex[3].x=0;

+ vertex[3].y=0;

+ vertex[0].sow=0;

+ vertex[0].tow=0;

+#ifdef OWNSCALE

+ vertex[1].sow=((GLfloat)iFTexA)/256.0f;

+ vertex[2].tow=((GLfloat)iFTexB)/256.0f;

+#else

+ vertex[1].sow=iFTexA;

+ vertex[2].tow=iFTexB;

+#endif

+ vertex[1].tow=0;

+ vertex[2].sow=vertex[1].sow;

+ vertex[3].sow=0;

+ vertex[3].tow=vertex[2].tow;

+ if(bGLBlend) glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);    

+ vertex[0].c.lcol=0xffffffff;

+ SETCOL(vertex[0]); 

+

+ // simply draw the backbuffer texture (without blur)

+ XPRIMdrawTexturedQuad(&vertex[0], &vertex[1], &vertex[2], &vertex[3]);

+

+ glEnable(GL_ALPHA_TEST);

+ glEnable(GL_SCISSOR_TEST);

+ if(iZBufferDepth)  glEnable(GL_DEPTH_TEST);    

+ if(bDrawDither)    glEnable(GL_DITHER);                  // dither mode

+ if(bGLBlend) glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, COMBINE_EXT);    

+

+ if(bKeepRatio)

+  glViewport(rRatioRect.left,

+             iResY-(rRatioRect.top+rRatioRect.bottom),

+             rRatioRect.right, 

+             rRatioRect.bottom);                         // init viewport

+}

+

+////////////////////////////////////////////////////////////////////////

+// Update display (swap buffers)... called in interlaced mode on 

+// every emulated vsync, otherwise whenever the displayed screen region

+// has been changed

+////////////////////////////////////////////////////////////////////////

+

+int iLastRGB24=0;                                      // special vars for checking when to skip two display updates

+int iSkipTwo=0;

+

+void updateDisplay(void)                               // UPDATE DISPLAY

+{

+ BOOL bBlur=FALSE;

+

+ bFakeFrontBuffer=FALSE;

+ bRenderFrontBuffer=FALSE;

+

+ if(iRenderFVR)                                        // frame buffer read fix mode still active?

+  {

+   iRenderFVR--;                                       // -> if some frames in a row without read access: turn off mode

+   if(!iRenderFVR) bFullVRam=FALSE;

+  }

+

+ if(iLastRGB24 && iLastRGB24!=PSXDisplay.RGB24+1)      // (mdec) garbage check

+  {

+   iSkipTwo=2;                                         // -> skip two frames to avoid garbage if color mode changes

+  }

+ iLastRGB24=0;

+

+ if(PSXDisplay.RGB24)// && !bNeedUploadAfter)          // (mdec) upload wanted?

+  {

+   PrepareFullScreenUpload(-1);

+   UploadScreen(PSXDisplay.Interlaced);                // -> upload whole screen from psx vram

+   bNeedUploadTest=FALSE;

+   bNeedInterlaceUpdate=FALSE;

+   bNeedUploadAfter=FALSE;

+   bNeedRGB24Update=FALSE;

+  }

+ else

+ if(bNeedInterlaceUpdate)                              // smaller upload?

+  {

+   bNeedInterlaceUpdate=FALSE;

+   xrUploadArea=xrUploadAreaIL;                        // -> upload this rect

+   UploadScreen(TRUE);

+  }

+

+ if(dwActFixes&512) bCheckFF9G4(NULL);                 // special game fix for FF9 

+

+ if(PreviousPSXDisplay.Range.x0||                      // paint black borders around display area, if needed

+    PreviousPSXDisplay.Range.y0)

+  PaintBlackBorders();

+

+ if(PSXDisplay.Disabled)                               // display disabled?

+  {

+   // moved here

+   glDisable(GL_SCISSOR_TEST);                       

+   glClearColor(0,0,0,128);                            // -> clear whole backbuffer

+   glClear(uiBufferBits);

+   glEnable(GL_SCISSOR_TEST);                       

+   gl_z=0.0f;

+   bDisplayNotSet = TRUE;

+  }

+

+ if(iSkipTwo)                                          // we are in skipping mood?

+  {

+   iSkipTwo--;

+   iDrawnSomething=0;                                  // -> simply lie about something drawn

+  }

+

+ if(iBlurBuffer && !bSkipNextFrame)                    // "blur display" activated?

+  {BlurBackBuffer();bBlur=TRUE;}                       // -> blur it

+

+ if(iUseScanLines) SetScanLines();                     // "scan lines" activated? do it

+

+ if(usCursorActive) ShowGunCursor();                   // "gun cursor" wanted? show 'em

+

+ if(dwActFixes&128)                                    // special FPS limitation mode?

+  {

+   if(bUseFrameLimit) PCFrameCap();                    // -> ok, do it

+   if(bUseFrameSkip || ulKeybits&KEY_SHOWFPS)  

+    PCcalcfps();         

+  }

+

+ if(gTexPicName) DisplayPic();                         // some gpu info picture active? display it

+

+ if(bSnapShot) DoSnapShot();                           // snapshot key pressed? cheeeese :)

+

+ if(ulKeybits&KEY_SHOWFPS)                             // wanna see FPS?

+  {

+   sprintf(szDispBuf,"%06.1f",fps_cur);

+   DisplayText();                                      // -> show it

+  }

+

+ //----------------------------------------------------//

+ // main buffer swapping (well, or skip it)

+

+ if(bUseFrameSkip)                                     // frame skipping active ?

+  {

+   if(!bSkipNextFrame) 

+    {

+     if(iDrawnSomething)

+      glXSwapBuffers(display,window);

+    }

+   if(dwActFixes&0x180)                                // -> special old frame skipping: skip max one in a row

+    {

+     if((fps_skip < fFrameRateHz) && !(bSkipNextFrame)) 

+      {bSkipNextFrame = TRUE; fps_skip=fFrameRateHz;}

+     else bSkipNextFrame = FALSE;

+    }

+   else FrameSkip();

+  }

+ else                                                  // no skip ?

+  {

+   if(iDrawnSomething)

+    glXSwapBuffers(display,window);

+  }

+

+ iDrawnSomething=0;

+

+ //----------------------------------------------------//

+

+ if(lClearOnSwap)                                      // clear buffer after swap?

+  {

+   GLclampf g,b,r;

+

+   if(bDisplayNotSet)                                  // -> set new vals

+    SetOGLDisplaySettings(1);

+

+   g=((GLclampf)GREEN(lClearOnSwapColor))/255.0f;      // -> get col

+   b=((GLclampf)BLUE(lClearOnSwapColor))/255.0f;

+   r=((GLclampf)RED(lClearOnSwapColor))/255.0f;

+   

+   glDisable(GL_SCISSOR_TEST);                       

+   glClearColor(r,g,b,128);                            // -> clear 

+   glClear(uiBufferBits);

+   glEnable(GL_SCISSOR_TEST);                       

+   lClearOnSwap=0;                                     // -> done

+  }

+ else 

+  {

+   if(bBlur) UnBlurBackBuffer();                       // unblur buff, if blurred before

+

+   if(iZBufferDepth)                                   // clear zbuffer as well (if activated)

+    {

+     glDisable(GL_SCISSOR_TEST);                       

+     glClear(GL_DEPTH_BUFFER_BIT);

+     glEnable(GL_SCISSOR_TEST);                       

+    }

+  }

+ gl_z=0.0f;

+

+ //----------------------------------------------------//

+ // additional uploads immediatly after swapping

+

+ if(bNeedUploadAfter)                                  // upload wanted?

+  {

+   bNeedUploadAfter=FALSE;                           

+   bNeedUploadTest=FALSE;

+   UploadScreen(-1);                                   // -> upload

+  }

+ 

+ if(bNeedUploadTest)

+  {

+   bNeedUploadTest=FALSE;

+   if(PSXDisplay.InterlacedTest &&

+      //iOffscreenDrawing>2 &&

+      PreviousPSXDisplay.DisplayPosition.x==PSXDisplay.DisplayPosition.x &&

+      PreviousPSXDisplay.DisplayEnd.x==PSXDisplay.DisplayEnd.x &&

+      PreviousPSXDisplay.DisplayPosition.y==PSXDisplay.DisplayPosition.y &&

+      PreviousPSXDisplay.DisplayEnd.y==PSXDisplay.DisplayEnd.y)

+    {

+     PrepareFullScreenUpload(TRUE);

+     UploadScreen(TRUE);

+    }

+  }

+

+ //----------------------------------------------------//

+ // rumbling (main emu pad effect)

+

+ if(iRumbleTime)                                       // shake screen by modifying view port

+  {

+   int i1=0,i2=0,i3=0,i4=0;

+

+   iRumbleTime--;

+   if(iRumbleTime) 

+    {

+     i1=((rand()*iRumbleVal)/RAND_MAX)-(iRumbleVal/2); 

+     i2=((rand()*iRumbleVal)/RAND_MAX)-(iRumbleVal/2); 

+     i3=((rand()*iRumbleVal)/RAND_MAX)-(iRumbleVal/2); 

+     i4=((rand()*iRumbleVal)/RAND_MAX)-(iRumbleVal/2); 

+    }

+

+   glViewport(rRatioRect.left+i1,                      

+              iResY-(rRatioRect.top+rRatioRect.bottom)+i2,

+              rRatioRect.right+i3, 

+              rRatioRect.bottom+i4);            

+  }

+

+ if(ulKeybits&KEY_RESETTEXSTORE) ResetStuff();         // reset on gpu mode changes? do it before next frame is filled

+}

+

+////////////////////////////////////////////////////////////////////////

+// update front display: smaller update func, if something has changed 

+// in the frontbuffer... dirty, but hey... real men know no pain

+////////////////////////////////////////////////////////////////////////

+

+void updateFrontDisplay(void)

+{

+ if(PreviousPSXDisplay.Range.x0||

+    PreviousPSXDisplay.Range.y0)

+  PaintBlackBorders();

+

+ if(iBlurBuffer) BlurBackBuffer();

+

+ if(iUseScanLines) SetScanLines();

+

+ if(usCursorActive) ShowGunCursor();

+

+ bFakeFrontBuffer=FALSE;

+ bRenderFrontBuffer=FALSE;

+

+ if(gTexPicName) DisplayPic();

+ if(ulKeybits&KEY_SHOWFPS) DisplayText();

+

+ if(iDrawnSomething)                                   // linux:

+  glXSwapBuffers(display,window);

+

+ if(iBlurBuffer) UnBlurBackBuffer();

+}

+                                             

+////////////////////////////////////////////////////////////////////////

+// check if update needed

+////////////////////////////////////////////////////////////////////////

+

+void ChangeDispOffsetsX(void)                          // CENTER X

+{

+ long lx,l;short sO;

+

+ if(!PSXDisplay.Range.x1) return;                      // some range given?

+

+ l=PSXDisplay.DisplayMode.x;

+

+ l*=(long)PSXDisplay.Range.x1;                         // some funky calculation

+ l/=2560;lx=l;l&=0xfffffff8;

+ 

+ if(l==PreviousPSXDisplay.Range.x1) return;            // some change?

+

+ sO=PreviousPSXDisplay.Range.x0;                       // store old

+

+ if(lx>=PSXDisplay.DisplayMode.x)                      // range bigger?

+  {

+   PreviousPSXDisplay.Range.x1=                        // -> take display width

+    PSXDisplay.DisplayMode.x;

+   PreviousPSXDisplay.Range.x0=0;                      // -> start pos is 0

+  }

+ else                                                  // range smaller? center it

+  {

+   PreviousPSXDisplay.Range.x1=l;                      // -> store width (8 pixel aligned)

+    PreviousPSXDisplay.Range.x0=                       // -> calc start pos

+    (PSXDisplay.Range.x0-500)/8;

+   if(PreviousPSXDisplay.Range.x0<0)                   // -> we don't support neg. values yet

+    PreviousPSXDisplay.Range.x0=0;

+

+   if((PreviousPSXDisplay.Range.x0+lx)>                // -> uhuu... that's too much

+      PSXDisplay.DisplayMode.x)

+    {

+     PreviousPSXDisplay.Range.x0=                      // -> adjust start

+      PSXDisplay.DisplayMode.x-lx;

+     PreviousPSXDisplay.Range.x1+=lx-l;                // -> adjust width

+    }                   

+  }

+

+ if(sO!=PreviousPSXDisplay.Range.x0)                   // something changed?

+  {

+   bDisplayNotSet=TRUE;                                // -> recalc display stuff

+  }

+}

+

+////////////////////////////////////////////////////////////////////////

+

+void ChangeDispOffsetsY(void)                          // CENTER Y

+{

+ int iT;short sO;                                      // store previous y size

+

+ if(PSXDisplay.PAL) iT=48; else iT=28;                 // different offsets on PAL/NTSC

+

+ if(PSXDisplay.Range.y0>=iT)                           // crossed the security line? :)

+  {

+   PreviousPSXDisplay.Range.y1=                        // -> store width

+    PSXDisplay.DisplayModeNew.y;

+   

+   sO=(PSXDisplay.Range.y0-iT-4)*PSXDisplay.Double;    // -> calc offset

+   if(sO<0) sO=0;

+

+   PSXDisplay.DisplayModeNew.y+=sO;                    // -> add offset to y size, too

+  }

+ else sO=0;                                            // else no offset

+

+ if(sO!=PreviousPSXDisplay.Range.y0)                   // something changed?

+  {

+   PreviousPSXDisplay.Range.y0=sO;

+   bDisplayNotSet=TRUE;                                // -> recalc display stuff

+  }

+}

+

+////////////////////////////////////////////////////////////////////////

+// Aspect ratio of ogl screen: simply adjusting ogl view port

+////////////////////////////////////////////////////////////////////////

+

+void SetAspectRatio(void)

+{

+ float xs,ys,s;RECT r;

+

+ if(!PSXDisplay.DisplayModeNew.x) return;

+ if(!PSXDisplay.DisplayModeNew.y) return;

+

+ xs=(float)iResX/(float)PSXDisplay.DisplayModeNew.x;

+ ys=(float)iResY/(float)PSXDisplay.DisplayModeNew.y;

+

+ s=min(xs,ys);

+ r.right =(int)((float)PSXDisplay.DisplayModeNew.x*s);

+ r.bottom=(int)((float)PSXDisplay.DisplayModeNew.y*s);

+ if(r.right  > iResX) r.right  = iResX;

+ if(r.bottom > iResY) r.bottom = iResY;

+ if(r.right  < 1)     r.right  = 1;

+ if(r.bottom < 1)     r.bottom = 1;

+

+ r.left = (iResX-r.right)/2;

+ r.top  = (iResY-r.bottom)/2;

+

+ if(r.bottom<rRatioRect.bottom ||

+    r.right <rRatioRect.right)

+  {

+   RECT rC;

+   glClearColor(0,0,0,128);                         

+

+   if(r.right <rRatioRect.right)

+    {

+     rC.left=0;

+     rC.top=0;

+     rC.right=r.left;

+     rC.bottom=iResY;

+     glScissor(rC.left,rC.top,rC.right,rC.bottom);

+     glClear(uiBufferBits);

+     rC.left=iResX-rC.right;

+     glScissor(rC.left,rC.top,rC.right,rC.bottom);

+     glClear(uiBufferBits);

+    }

+

+   if(r.bottom <rRatioRect.bottom)

+    {

+     rC.left=0;

+     rC.top=0;

+     rC.right=iResX;

+     rC.bottom=r.top;

+     glScissor(rC.left,rC.top,rC.right,rC.bottom);

+     glClear(uiBufferBits);

+     rC.top=iResY-rC.bottom;

+     glScissor(rC.left,rC.top,rC.right,rC.bottom);

+     glClear(uiBufferBits);

+    }

+   

+   bSetClip=TRUE;

+   bDisplayNotSet=TRUE;

+  }

+

+ rRatioRect=r;

+

+

+ glViewport(rRatioRect.left,

+            iResY-(rRatioRect.top+rRatioRect.bottom),

+            rRatioRect.right,

+            rRatioRect.bottom);                         // init viewport

+}

+

+////////////////////////////////////////////////////////////////////////

+// big ass check, if an ogl swap buffer is needed

+////////////////////////////////////////////////////////////////////////

+

+void updateDisplayIfChanged(void)

+{

+ BOOL bUp;

+

+ if ((PSXDisplay.DisplayMode.y == PSXDisplay.DisplayModeNew.y) && 

+     (PSXDisplay.DisplayMode.x == PSXDisplay.DisplayModeNew.x))

+  {

+   if((PSXDisplay.RGB24      == PSXDisplay.RGB24New) && 

+      (PSXDisplay.Interlaced == PSXDisplay.InterlacedNew)) 

+      return;                                          // nothing has changed? fine, no swap buffer needed

+  }

+ else                                                  // some res change?

+  {

+   glLoadIdentity();

+   glOrtho(0,PSXDisplay.DisplayModeNew.x,              // -> new psx resolution

+             PSXDisplay.DisplayModeNew.y, 0, -1, 1);

+   if(bKeepRatio) SetAspectRatio();

+  }

+

+ bDisplayNotSet = TRUE;                                // re-calc offsets/display area

+ 

+ bUp=FALSE;

+ if(PSXDisplay.RGB24!=PSXDisplay.RGB24New)             // clean up textures, if rgb mode change (usually mdec on/off)

+  {

+   PreviousPSXDisplay.RGB24=0;                         // no full 24 frame uploaded yet

+   ResetTextureArea(FALSE);

+   bUp=TRUE;

+  }

+

+ PSXDisplay.RGB24         = PSXDisplay.RGB24New;       // get new infos

+ PSXDisplay.DisplayMode.y = PSXDisplay.DisplayModeNew.y;

+ PSXDisplay.DisplayMode.x = PSXDisplay.DisplayModeNew.x;

+ PSXDisplay.Interlaced    = PSXDisplay.InterlacedNew;

+    

+ PSXDisplay.DisplayEnd.x=                              // calc new ends

+  PSXDisplay.DisplayPosition.x+ PSXDisplay.DisplayMode.x;

+ PSXDisplay.DisplayEnd.y=

+  PSXDisplay.DisplayPosition.y+ PSXDisplay.DisplayMode.y+PreviousPSXDisplay.DisplayModeNew.y;

+ PreviousPSXDisplay.DisplayEnd.x=

+  PreviousPSXDisplay.DisplayPosition.x+ PSXDisplay.DisplayMode.x;

+ PreviousPSXDisplay.DisplayEnd.y=

+  PreviousPSXDisplay.DisplayPosition.y+ PSXDisplay.DisplayMode.y+PreviousPSXDisplay.DisplayModeNew.y;

+

+ ChangeDispOffsetsX();

+

+ if(iFrameLimit==2) SetAutoFrameCap();                 // set new fps limit vals (depends on interlace)

+

+ if(bUp) updateDisplay();                              // yeah, real update (swap buffer)

+}

+

+////////////////////////////////////////////////////////////////////////

+// swap update check (called by psx vsync function)

+////////////////////////////////////////////////////////////////////////

+

+BOOL bSwapCheck(void)

+{

+ static int iPosCheck=0;

+ static PSXPoint_t pO;

+ static PSXPoint_t pD;

+ static int iDoAgain=0;

+

+ if(PSXDisplay.DisplayPosition.x==pO.x &&

+    PSXDisplay.DisplayPosition.y==pO.y &&

+    PSXDisplay.DisplayEnd.x==pD.x &&

+    PSXDisplay.DisplayEnd.y==pD.y)

+      iPosCheck++;

+ else iPosCheck=0;

+

+ pO=PSXDisplay.DisplayPosition;

+ pD=PSXDisplay.DisplayEnd;

+

+ if(iPosCheck<=4) return FALSE;

+

+ iPosCheck=4;

+

+ if(PSXDisplay.Interlaced) return FALSE;

+

+ if (bNeedInterlaceUpdate||

+     bNeedRGB24Update ||

+     bNeedUploadAfter|| 

+     bNeedUploadTest || 

+     iDoAgain

+    )

+  {

+   iDoAgain=0;

+   if(bNeedUploadAfter) 

+    iDoAgain=1;

+   if(bNeedUploadTest && PSXDisplay.InterlacedTest)

+    iDoAgain=1;

+

+   bDisplayNotSet = TRUE;

+   updateDisplay();

+

+   PreviousPSXDisplay.DisplayPosition.x=PSXDisplay.DisplayPosition.x;

+   PreviousPSXDisplay.DisplayPosition.y=PSXDisplay.DisplayPosition.y;

+   PreviousPSXDisplay.DisplayEnd.x=PSXDisplay.DisplayEnd.x;

+   PreviousPSXDisplay.DisplayEnd.y=PSXDisplay.DisplayEnd.y;

+   pO=PSXDisplay.DisplayPosition;

+   pD=PSXDisplay.DisplayEnd;

+

+   return TRUE;

+  }

+

+ return FALSE;

+} 

+

+////////////////////////////////////////////////////////////////////////

+// gun cursor func: player=0-7, x=0-511, y=0-255

+////////////////////////////////////////////////////////////////////////

+

+void CALLBACK GPUcursor(int iPlayer,int x,int y)

+{

+ if(iPlayer<0) return;

+ if(iPlayer>7) return;

+

+ usCursorActive|=(1<<iPlayer);

+

+ if(x<0)              x=0;

+ if(x>iGPUHeightMask) x=iGPUHeightMask;

+ if(y<0)              y=0;

+ if(y>255)            y=255;

+

+ ptCursorPoint[iPlayer].x=x;

+ ptCursorPoint[iPlayer].y=y;

+}

+

+////////////////////////////////////////////////////////////////////////

+// update lace is called every VSync. Basically we limit frame rate 

+// here, and in interlaced mode we swap ogl display buffers.

+////////////////////////////////////////////////////////////////////////

+

+static unsigned short usFirstPos=2;

+

+void CALLBACK GPUupdateLace(void)

+{

+ if(!(dwActFixes&0x1000))                               

+  STATUSREG^=0x80000000;                               // interlaced bit toggle, if the CC game fix is not active (see gpuReadStatus)

+

+ if(!(dwActFixes&128))                                 // normal frame limit func

+  CheckFrameRate();

+

+ if(iOffscreenDrawing==4)                              // special check if high offscreen drawing is on

+  {

+   if(bSwapCheck()) return;

+  }

+

+ if(PSXDisplay.Interlaced)                             // interlaced mode?

+  {

+   if(PSXDisplay.DisplayMode.x>0 && PSXDisplay.DisplayMode.y>0)

+    {

+     updateDisplay();                                  // -> swap buffers (new frame)

+    }

+  }

+ else if(bRenderFrontBuffer)                           // no interlace mode? and some stuff in front has changed?

+  {

+   updateFrontDisplay();                               // -> update front buffer

+  }

+ else if(usFirstPos==1)                                // initial updates (after startup)

+  {

+   updateDisplay();

+  }

+}

+

+////////////////////////////////////////////////////////////////////////

+// process read request from GPU status register

+////////////////////////////////////////////////////////////////////////

+

+unsigned long CALLBACK GPUreadStatus(void)

+{

+ if(dwActFixes&0x1000)                                 // CC game fix

+  {

+   static int iNumRead=0;

+   if((iNumRead++)==2)

+    {

+     iNumRead=0;

+     STATUSREG^=0x80000000;                            // interlaced bit toggle... we do it on every second read status... needed by some games (like ChronoCross)

+    }

+  }

+

+ 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...

+  {

+   iFakePrimBusy--;

+

+   if(iFakePrimBusy&1)                                 // we do a busy-idle-busy-idle sequence after/while drawing prims

+    {

+     GPUIsBusy;

+     GPUIsNotReadyForCommands;

+    }

+   else

+    {

+     GPUIsIdle;

+     GPUIsReadyForCommands;

+    }

+  }

+

+ return STATUSREG;

+}

+

+////////////////////////////////////////////////////////////////////////

+// processes data send to GPU status register

+// these are always single packet commands.

+////////////////////////////////////////////////////////////////////////

+

+void CALLBACK GPUwriteStatus(unsigned long gdata)

+{

+ unsigned long lCommand=(gdata>>24)&0xff;

+ 

+ ulStatusControl[lCommand]=gdata;

+

+ switch(lCommand)

+  {

+   //--------------------------------------------------//

+   // reset gpu

+   case 0x00:

+    memset(ulGPUInfoVals,0x00,16*sizeof(unsigned long));

+    lGPUstatusRet=0x14802000;

+    PSXDisplay.Disabled=1;

+    iDataWriteMode=iDataReadMode=DR_NORMAL;

+    PSXDisplay.DrawOffset.x=PSXDisplay.DrawOffset.y=0;

+    drawX=drawY=0;drawW=drawH=0;

+    sSetMask=0;lSetMask=0;bCheckMask=FALSE;iSetMask=0;

+    usMirror=0;

+    GlobalTextAddrX=0;GlobalTextAddrY=0;

+    GlobalTextTP=0;GlobalTextABR=0;

+    PSXDisplay.RGB24=FALSE;

+    PSXDisplay.Interlaced=FALSE;

+    bUsingTWin = FALSE;

+    return;

+

+   // dis/enable display

+   case 0x03:  

+    PreviousPSXDisplay.Disabled = PSXDisplay.Disabled;

+    PSXDisplay.Disabled = (gdata & 1);

+

+    if(PSXDisplay.Disabled) 

+         STATUSREG|=GPUSTATUS_DISPLAYDISABLED;

+    else STATUSREG&=~GPUSTATUS_DISPLAYDISABLED;

+

+    if (iOffscreenDrawing==4 &&

+         PreviousPSXDisplay.Disabled && 

+        !(PSXDisplay.Disabled))

+     {

+

+      if(!PSXDisplay.RGB24)

+       {

+        PrepareFullScreenUpload(TRUE);

+        UploadScreen(TRUE); 

+        updateDisplay();

+       }

+     }

+

+    return;

+

+   // setting transfer mode

+   case 0x04:

+    gdata &= 0x03;                                     // only want the lower two bits

+

+    iDataWriteMode=iDataReadMode=DR_NORMAL;

+    if(gdata==0x02) iDataWriteMode=DR_VRAMTRANSFER;

+    if(gdata==0x03) iDataReadMode =DR_VRAMTRANSFER;

+

+    STATUSREG&=~GPUSTATUS_DMABITS;                     // clear the current settings of the DMA bits

+    STATUSREG|=(gdata << 29);                          // set the DMA bits according to the received data

+

+    return;

+

+   // setting display position

+   case 0x05: 

+    {

+     short sx=(short)(gdata & 0x3ff);

+     short sy;

+

+     if(iGPUHeight==1024)

+      {

+       if(dwGPUVersion==2) 

+            sy = (short)((gdata>>12)&0x3ff);

+       else sy = (short)((gdata>>10)&0x3ff);

+      }

+     else sy = (short)((gdata>>10)&0x3ff);             // really: 0x1ff, but we adjust it later

+

+     if (sy & 0x200) 

+      {

+       sy|=0xfc00;

+       PreviousPSXDisplay.DisplayModeNew.y=sy/PSXDisplay.Double;

+       sy=0;

+      }

+     else PreviousPSXDisplay.DisplayModeNew.y=0;

+

+     if(sx>1000) sx=0;

+

+     if(usFirstPos)

+      {

+       usFirstPos--;

+       if(usFirstPos)

+        {

+         PreviousPSXDisplay.DisplayPosition.x = sx;

+         PreviousPSXDisplay.DisplayPosition.y = sy;

+         PSXDisplay.DisplayPosition.x = sx;

+         PSXDisplay.DisplayPosition.y = sy;

+        }

+      }

+

+     if(dwActFixes&8) 

+      {

+       if((!PSXDisplay.Interlaced) &&

+          PreviousPSXDisplay.DisplayPosition.x == sx  &&

+          PreviousPSXDisplay.DisplayPosition.y == sy)

+        return;

+

+       PSXDisplay.DisplayPosition.x = PreviousPSXDisplay.DisplayPosition.x;

+       PSXDisplay.DisplayPosition.y = PreviousPSXDisplay.DisplayPosition.y;

+       PreviousPSXDisplay.DisplayPosition.x = sx;

+       PreviousPSXDisplay.DisplayPosition.y = sy;

+      }

+     else

+      {

+       if((!PSXDisplay.Interlaced) &&

+          PSXDisplay.DisplayPosition.x == sx  &&

+          PSXDisplay.DisplayPosition.y == sy)

+        return;

+       PreviousPSXDisplay.DisplayPosition.x = PSXDisplay.DisplayPosition.x;

+       PreviousPSXDisplay.DisplayPosition.y = PSXDisplay.DisplayPosition.y;

+       PSXDisplay.DisplayPosition.x = sx;

+       PSXDisplay.DisplayPosition.y = sy;

+      }

+

+     PSXDisplay.DisplayEnd.x=

+      PSXDisplay.DisplayPosition.x+ PSXDisplay.DisplayMode.x;

+     PSXDisplay.DisplayEnd.y=

+      PSXDisplay.DisplayPosition.y+ PSXDisplay.DisplayMode.y+PreviousPSXDisplay.DisplayModeNew.y;

+

+     PreviousPSXDisplay.DisplayEnd.x=

+      PreviousPSXDisplay.DisplayPosition.x+ PSXDisplay.DisplayMode.x;

+     PreviousPSXDisplay.DisplayEnd.y=

+      PreviousPSXDisplay.DisplayPosition.y+ PSXDisplay.DisplayMode.y+PreviousPSXDisplay.DisplayModeNew.y;

+

+     bDisplayNotSet = TRUE;

+

+     if (!(PSXDisplay.Interlaced))

+      {

+       updateDisplay();

+      }

+     else

+     if(PSXDisplay.InterlacedTest && 

+        ((PreviousPSXDisplay.DisplayPosition.x != PSXDisplay.DisplayPosition.x)||

+         (PreviousPSXDisplay.DisplayPosition.y != PSXDisplay.DisplayPosition.y)))

+      PSXDisplay.InterlacedTest--;

+ 

+     return;

+    }

+

+   // setting width

+   case 0x06:

+

+    PSXDisplay.Range.x0=gdata & 0x7ff;      //0x3ff;

+    PSXDisplay.Range.x1=(gdata>>12) & 0xfff;//0x7ff;

+

+    PSXDisplay.Range.x1-=PSXDisplay.Range.x0;

+

+    ChangeDispOffsetsX();

+

+    return;

+

+   // setting height

+   case 0x07:

+

+    PreviousPSXDisplay.Height = PSXDisplay.Height;

+

+    PSXDisplay.Range.y0=gdata & 0x3ff;

+    PSXDisplay.Range.y1=(gdata>>10) & 0x3ff;

+

+    PSXDisplay.Height = PSXDisplay.Range.y1 - 

+                        PSXDisplay.Range.y0 +

+                        PreviousPSXDisplay.DisplayModeNew.y;

+

+    if (PreviousPSXDisplay.Height != PSXDisplay.Height)

+     {

+      PSXDisplay.DisplayModeNew.y=PSXDisplay.Height*PSXDisplay.Double;

+      ChangeDispOffsetsY();

+      updateDisplayIfChanged();

+     }

+    return;

+ 

+   // setting display infos

+   case 0x08:

+

+    PSXDisplay.DisplayModeNew.x = dispWidths[(gdata & 0x03) | ((gdata & 0x40) >> 4)];

+

+    if (gdata&0x04) PSXDisplay.Double=2;

+    else            PSXDisplay.Double=1;

+    PSXDisplay.DisplayModeNew.y = PSXDisplay.Height*PSXDisplay.Double;

+

+    ChangeDispOffsetsY();

+  

+    PSXDisplay.PAL           = (gdata & 0x08)?TRUE:FALSE; // if 1 - PAL mode, else NTSC

+    PSXDisplay.RGB24New      = (gdata & 0x10)?TRUE:FALSE; // if 1 - TrueColor

+    PSXDisplay.InterlacedNew = (gdata & 0x20)?TRUE:FALSE; // if 1 - Interlace

+

+    STATUSREG&=~GPUSTATUS_WIDTHBITS;                   // clear the width bits

+

+    STATUSREG|=

+               (((gdata & 0x03) << 17) | 

+               ((gdata & 0x40) << 10));                // set the width bits

+

+    PreviousPSXDisplay.InterlacedNew=FALSE;

+    if (PSXDisplay.InterlacedNew)

+     {

+      if(!PSXDisplay.Interlaced)

+       {

+        PSXDisplay.InterlacedTest=2;

+        PreviousPSXDisplay.DisplayPosition.x = PSXDisplay.DisplayPosition.x;

+        PreviousPSXDisplay.DisplayPosition.y = PSXDisplay.DisplayPosition.y;

+        PreviousPSXDisplay.InterlacedNew=TRUE;

+       }

+

+      STATUSREG|=GPUSTATUS_INTERLACED;

+     }

+    else 

+     {

+      PSXDisplay.InterlacedTest=0;

+      STATUSREG&=~GPUSTATUS_INTERLACED;

+     }

+

+    if (PSXDisplay.PAL)

+         STATUSREG|=GPUSTATUS_PAL;

+    else STATUSREG&=~GPUSTATUS_PAL;

+

+    if (PSXDisplay.Double==2)

+         STATUSREG|=GPUSTATUS_DOUBLEHEIGHT;

+    else STATUSREG&=~GPUSTATUS_DOUBLEHEIGHT;

+

+    if (PSXDisplay.RGB24New)

+         STATUSREG|=GPUSTATUS_RGB24;

+    else STATUSREG&=~GPUSTATUS_RGB24;

+

+    updateDisplayIfChanged();

+

+    return;

+

+   //--------------------------------------------------//

+   // ask about GPU version and other stuff

+   case 0x10: 

+

+    gdata&=0xff;

+

+    switch(gdata) 

+     {

+      case 0x02:

+       GPUdataRet=ulGPUInfoVals[INFO_TW];              // tw infos

+       return;

+      case 0x03:

+       GPUdataRet=ulGPUInfoVals[INFO_DRAWSTART];       // draw start

+       return;

+      case 0x04:

+       GPUdataRet=ulGPUInfoVals[INFO_DRAWEND];         // draw end

+       return;

+      case 0x05:

+      case 0x06:

+       GPUdataRet=ulGPUInfoVals[INFO_DRAWOFF];         // draw offset

+       return;

+      case 0x07:

+       if(dwGPUVersion==2)

+            GPUdataRet=0x01;

+       else GPUdataRet=0x02;                           // gpu type

+       return;

+      case 0x08:

+      case 0x0F:                                       // some bios addr?

+       GPUdataRet=0xBFC03720;

+       return;

+     }

+    return;

+   //--------------------------------------------------//

+  }

+}

+

+////////////////////////////////////////////////////////////////////////

+// vram read/write helpers

+////////////////////////////////////////////////////////////////////////

+

+BOOL bNeedWriteUpload=FALSE;

+

+__inline void FinishedVRAMWrite(void)

+{

+ if(bNeedWriteUpload)

+  {

+   bNeedWriteUpload=FALSE;

+   CheckWriteUpdate();

+  }

+

+ // set register to NORMAL operation

+ iDataWriteMode = DR_NORMAL;

+

+ // reset transfer values, to prevent mis-transfer of data

+ VRAMWrite.ColsRemaining = 0;

+ VRAMWrite.RowsRemaining = 0;

+}

+

+__inline void FinishedVRAMRead(void)

+{

+ // set register to NORMAL operation

+ iDataReadMode = DR_NORMAL;

+ // reset transfer values, to prevent mis-transfer of data

+ VRAMRead.x = 0;

+ VRAMRead.y = 0;

+ VRAMRead.Width = 0;

+ VRAMRead.Height = 0;

+ VRAMRead.ColsRemaining = 0;

+ VRAMRead.RowsRemaining = 0;

+

+ // indicate GPU is no longer ready for VRAM data in the STATUS REGISTER

+ STATUSREG&=~GPUSTATUS_READYFORVRAM;

+}

+

+////////////////////////////////////////////////////////////////////////

+// vram read check ex (reading from card's back/frontbuffer if needed...

+// slow!)

+////////////////////////////////////////////////////////////////////////

+

+void CheckVRamReadEx(int x, int y, int dx, int dy)

+{

+ unsigned short sArea;

+ int ux,uy,udx,udy,wx,wy;

+ unsigned short * p1, *p2;

+ float XS,YS;

+ unsigned char * ps;

+ unsigned char * px;

+ unsigned short s,sx;

+

+ if(STATUSREG&GPUSTATUS_RGB24) return;

+

+ if(((dx  > PSXDisplay.DisplayPosition.x) &&

+     (x   < PSXDisplay.DisplayEnd.x) &&

+     (dy  > PSXDisplay.DisplayPosition.y) &&

+     (y   < PSXDisplay.DisplayEnd.y)))

+  sArea=0;

+ else

+ if((!(PSXDisplay.InterlacedTest) &&

+     (dx  > PreviousPSXDisplay.DisplayPosition.x) &&

+     (x   < PreviousPSXDisplay.DisplayEnd.x) &&

+     (dy  > PreviousPSXDisplay.DisplayPosition.y) &&

+     (y   < PreviousPSXDisplay.DisplayEnd.y)))

+  sArea=1;

+ else 

+  {

+   return;

+  }

+

+ //////////////

+

+ if(iRenderFVR)

+  {

+   bFullVRam=TRUE;iRenderFVR=2;return;

+  }

+ bFullVRam=TRUE;iRenderFVR=2;

+

+ //////////////

+

+ p2=0;

+

+ if(sArea==0)

+  {

+   ux=PSXDisplay.DisplayPosition.x;

+   uy=PSXDisplay.DisplayPosition.y;

+   udx=PSXDisplay.DisplayEnd.x-ux;

+   udy=PSXDisplay.DisplayEnd.y-uy;

+   if((PreviousPSXDisplay.DisplayEnd.x-

+       PreviousPSXDisplay.DisplayPosition.x)==udx &&

+      (PreviousPSXDisplay.DisplayEnd.y-

+       PreviousPSXDisplay.DisplayPosition.y)==udy)

+    p2=(psxVuw + (1024*PreviousPSXDisplay.DisplayPosition.y) + 

+        PreviousPSXDisplay.DisplayPosition.x);

+  }

+ else

+  {

+   ux=PreviousPSXDisplay.DisplayPosition.x;

+   uy=PreviousPSXDisplay.DisplayPosition.y;

+   udx=PreviousPSXDisplay.DisplayEnd.x-ux;

+   udy=PreviousPSXDisplay.DisplayEnd.y-uy;

+   if((PSXDisplay.DisplayEnd.x-

+       PSXDisplay.DisplayPosition.x)==udx &&

+      (PSXDisplay.DisplayEnd.y-

+       PSXDisplay.DisplayPosition.y)==udy)

+    p2=(psxVuw + (1024*PSXDisplay.DisplayPosition.y) + 

+        PSXDisplay.DisplayPosition.x);

+  }

+

+ p1=(psxVuw + (1024*uy) + ux);

+ if(p1==p2) p2=0;

+

+ x=0;y=0;

+ wx=dx=udx;wy=dy=udy;

+

+ if(udx<=0) return;

+ if(udy<=0) return;

+ if(dx<=0)  return;

+ if(dy<=0)  return;

+ if(wx<=0)  return;

+ if(wy<=0)  return;

+

+ XS=(float)rRatioRect.right/(float)wx;

+ YS=(float)rRatioRect.bottom/(float)wy;

+

+ dx=(int)((float)(dx)*XS);

+ dy=(int)((float)(dy)*YS);

+

+ if(dx>iResX) dx=iResX;

+ if(dy>iResY) dy=iResY;

+

+ if(dx<=0) return;

+ if(dy<=0) return;

+

+ // ogl y adjust

+ y=iResY-y-dy;

+

+ x+=rRatioRect.left;

+ y-=rRatioRect.top;

+

+ if(y<0) y=0; if((y+dy)>iResY) dy=iResY-y;

+

+ if(!pGfxCardScreen)

+  {

+   glPixelStorei(GL_PACK_ALIGNMENT,1);

+   pGfxCardScreen=(unsigned char *)malloc(iResX*iResY*4);

+  }

+

+ ps=pGfxCardScreen;

+ 

+ if(!sArea) glReadBuffer(GL_FRONT);

+

+ glReadPixels(x,y,dx,dy,GL_RGB,GL_UNSIGNED_BYTE,ps);

+               

+ if(!sArea) glReadBuffer(GL_BACK);

+

+ s=0;

+

+ XS=(float)dx/(float)(udx);

+ YS=(float)dy/(float)(udy+1);

+    

+ for(y=udy;y>0;y--)

+  {

+   for(x=0;x<udx;x++)

+    {

+     if(p1>=psxVuw && p1<psxVuw_eom)

+      {

+       px=ps+(3*((int)((float)x * XS))+

+             (3*dx)*((int)((float)y*YS)));

+       sx=(*px)>>3;px++;

+       s=sx;

+       sx=(*px)>>3;px++;

+       s|=sx<<5;

+       sx=(*px)>>3;

+       s|=sx<<10;

+       s&=~0x8000;

+       *p1=s;

+      }

+     if(p2>=psxVuw && p2<psxVuw_eom) *p2=s;

+

+     p1++;

+     if(p2) p2++;

+    }

+

+   p1 += 1024 - udx;

+   if(p2) p2 += 1024 - udx;

+  }

+}

+

+////////////////////////////////////////////////////////////////////////

+// vram read check (reading from card's back/frontbuffer if needed... 

+// slow!)

+////////////////////////////////////////////////////////////////////////

+

+void CheckVRamRead(int x, int y, int dx, int dy,BOOL bFront)

+{

+ unsigned short sArea;unsigned short * p;

+ int ux,uy,udx,udy,wx,wy;float XS,YS;

+ unsigned char * ps, * px;

+ unsigned short s=0,sx;

+

+ if(STATUSREG&GPUSTATUS_RGB24) return;

+

+ if(((dx  > PSXDisplay.DisplayPosition.x) &&

+     (x   < PSXDisplay.DisplayEnd.x) &&

+     (dy  > PSXDisplay.DisplayPosition.y) &&

+     (y   < PSXDisplay.DisplayEnd.y)))

+  sArea=0;

+ else

+ if((!(PSXDisplay.InterlacedTest) &&

+     (dx  > PreviousPSXDisplay.DisplayPosition.x) &&

+     (x   < PreviousPSXDisplay.DisplayEnd.x) &&

+     (dy  > PreviousPSXDisplay.DisplayPosition.y) &&

+     (y   < PreviousPSXDisplay.DisplayEnd.y)))

+  sArea=1;

+ else 

+  {

+   return;

+  }

+

+ if(dwActFixes&0x40)

+  {

+   if(iRenderFVR)

+    {

+     bFullVRam=TRUE;iRenderFVR=2;return;

+    }

+   bFullVRam=TRUE;iRenderFVR=2;

+  }

+

+ ux=x;uy=y;udx=dx;udy=dy;

+

+ if(sArea==0)

+  {

+   x -=PSXDisplay.DisplayPosition.x;

+   dx-=PSXDisplay.DisplayPosition.x;

+   y -=PSXDisplay.DisplayPosition.y;

+   dy-=PSXDisplay.DisplayPosition.y;

+   wx=PSXDisplay.DisplayEnd.x-PSXDisplay.DisplayPosition.x;

+   wy=PSXDisplay.DisplayEnd.y-PSXDisplay.DisplayPosition.y;

+  }

+ else

+  {

+   x -=PreviousPSXDisplay.DisplayPosition.x;

+   dx-=PreviousPSXDisplay.DisplayPosition.x;

+   y -=PreviousPSXDisplay.DisplayPosition.y;

+   dy-=PreviousPSXDisplay.DisplayPosition.y;

+   wx=PreviousPSXDisplay.DisplayEnd.x-PreviousPSXDisplay.DisplayPosition.x;

+   wy=PreviousPSXDisplay.DisplayEnd.y-PreviousPSXDisplay.DisplayPosition.y;

+  }

+ if(x<0) {ux-=x;x=0;}

+ if(y<0) {uy-=y;y=0;}

+ if(dx>wx) {udx-=(dx-wx);dx=wx;}

+ if(dy>wy) {udy-=(dy-wy);dy=wy;}

+ udx-=ux;

+ udy-=uy;

+  

+ p=(psxVuw + (1024*uy) + ux);

+

+ if(udx<=0) return;

+ if(udy<=0) return;

+ if(dx<=0)  return;

+ if(dy<=0)  return;

+ if(wx<=0)  return;

+ if(wy<=0)  return;

+

+ XS=(float)rRatioRect.right/(float)wx;

+ YS=(float)rRatioRect.bottom/(float)wy;

+

+ dx=(int)((float)(dx)*XS);

+ dy=(int)((float)(dy)*YS);

+ x=(int)((float)x*XS);

+ y=(int)((float)y*YS);

+

+ dx-=x;

+ dy-=y;

+

+ if(dx>iResX) dx=iResX;

+ if(dy>iResY) dy=iResY;

+

+ if(dx<=0) return;

+ if(dy<=0) return;

+

+ // ogl y adjust

+ y=iResY-y-dy;

+

+ x+=rRatioRect.left;

+ y-=rRatioRect.top;

+

+ if(y<0) y=0; if((y+dy)>iResY) dy=iResY-y;

+

+ if(!pGfxCardScreen)

+  {

+   glPixelStorei(GL_PACK_ALIGNMENT,1);

+   pGfxCardScreen=(unsigned char *)malloc(iResX*iResY*4);

+  }

+

+ ps=pGfxCardScreen;

+ 

+ if(bFront) glReadBuffer(GL_FRONT);

+

+ glReadPixels(x,y,dx,dy,GL_RGB,GL_UNSIGNED_BYTE,ps);

+               

+ if(bFront) glReadBuffer(GL_BACK);

+

+ XS=(float)dx/(float)(udx);

+ YS=(float)dy/(float)(udy+1);

+    

+ for(y=udy;y>0;y--)

+  {

+   for(x=0;x<udx;x++)

+    {

+     if(p>=psxVuw && p<psxVuw_eom)

+      {

+       px=ps+(3*((int)((float)x * XS))+

+             (3*dx)*((int)((float)y*YS)));

+       sx=(*px)>>3;px++;

+       s=sx;

+       sx=(*px)>>3;px++;

+       s|=sx<<5;

+       sx=(*px)>>3;

+       s|=sx<<10;

+       s&=~0x8000;

+       *p=s;

+      }

+     p++;

+    }

+   p += 1024 - udx;

+  }

+}

+

+////////////////////////////////////////////////////////////////////////

+// core read from vram

+////////////////////////////////////////////////////////////////////////

+

+void CALLBACK GPUreadDataMem(unsigned long * pMem, int iSize)

+{

+ int i;

+

+ if(iDataReadMode!=DR_VRAMTRANSFER) return;

+

+ GPUIsBusy;

+

+ // adjust read ptr, if necessary

+ while(VRAMRead.ImagePtr>=psxVuw_eom)

+  VRAMRead.ImagePtr-=iGPUHeight*1024;

+ while(VRAMRead.ImagePtr<psxVuw)

+  VRAMRead.ImagePtr+=iGPUHeight*1024;

+

+ if((iFrameReadType&1 && iSize>1) &&

+    !(iDrawnSomething==2 &&

+      VRAMRead.x      == VRAMWrite.x     &&

+      VRAMRead.y      == VRAMWrite.y     &&

+      VRAMRead.Width  == VRAMWrite.Width &&

+      VRAMRead.Height == VRAMWrite.Height))

+  CheckVRamRead(VRAMRead.x,VRAMRead.y,

+                VRAMRead.x+VRAMRead.RowsRemaining,

+                VRAMRead.y+VRAMRead.ColsRemaining,

+                TRUE);

+

+ for(i=0;i<iSize;i++)

+  {

+   // do 2 seperate 16bit reads for compatibility (wrap issues)

+   if ((VRAMRead.ColsRemaining > 0) && (VRAMRead.RowsRemaining > 0))

+    {

+     // lower 16 bit

+     GPUdataRet=(unsigned long)*VRAMRead.ImagePtr;

+

+     VRAMRead.ImagePtr++;

+     if(VRAMRead.ImagePtr>=psxVuw_eom) VRAMRead.ImagePtr-=iGPUHeight*1024;

+     VRAMRead.RowsRemaining --;

+

+     if(VRAMRead.RowsRemaining<=0)

+      {

+       VRAMRead.RowsRemaining = VRAMRead.Width;

+       VRAMRead.ColsRemaining--;

+       VRAMRead.ImagePtr += 1024 - VRAMRead.Width;

+       if(VRAMRead.ImagePtr>=psxVuw_eom) VRAMRead.ImagePtr-=iGPUHeight*1024;

+      }

+

+     // higher 16 bit (always, even if it's an odd width)

+     GPUdataRet|=(unsigned long)(*VRAMRead.ImagePtr)<<16;

+     *pMem++=GPUdataRet;

+

+     if(VRAMRead.ColsRemaining <= 0)

+      {FinishedVRAMRead();goto ENDREAD;}

+

+     VRAMRead.ImagePtr++;

+     if(VRAMRead.ImagePtr>=psxVuw_eom) VRAMRead.ImagePtr-=iGPUHeight*1024;

+     VRAMRead.RowsRemaining--;

+     if(VRAMRead.RowsRemaining<=0)

+      {

+       VRAMRead.RowsRemaining = VRAMRead.Width;

+       VRAMRead.ColsRemaining--;

+       VRAMRead.ImagePtr += 1024 - VRAMRead.Width;

+       if(VRAMRead.ImagePtr>=psxVuw_eom) VRAMRead.ImagePtr-=iGPUHeight*1024;

+      }

+     if(VRAMRead.ColsRemaining <= 0)

+      {FinishedVRAMRead();goto ENDREAD;}

+    }

+   else {FinishedVRAMRead();goto ENDREAD;}

+  }

+

+ENDREAD:

+ GPUIsIdle;

+}

+

+unsigned long CALLBACK GPUreadData(void)

+{

+ unsigned long l;

+ GPUreadDataMem(&l,1);

+ return GPUdataRet;

+}

+

+////////////////////////////////////////////////////////////////////////

+// helper table to know how much data is used by drawing commands

+////////////////////////////////////////////////////////////////////////

+

+const unsigned char primTableCX[256] =

+{

+    // 00

+    0,0,3,0,0,0,0,0,

+    // 08

+    0,0,0,0,0,0,0,0,

+    // 10

+    0,0,0,0,0,0,0,0,

+    // 18

+    0,0,0,0,0,0,0,0,

+    // 20

+    4,4,4,4,7,7,7,7,

+    // 28

+    5,5,5,5,9,9,9,9,

+    // 30

+    6,6,6,6,9,9,9,9,

+    // 38

+    8,8,8,8,12,12,12,12,

+    // 40

+    3,3,3,3,0,0,0,0,

+    // 48

+//    5,5,5,5,6,6,6,6,      //FLINE

+    254,254,254,254,254,254,254,254,

+    // 50

+    4,4,4,4,0,0,0,0,

+    // 58

+//    7,7,7,7,9,9,9,9,    //    LINEG3    LINEG4

+    255,255,255,255,255,255,255,255,

+    // 60

+    3,3,3,3,4,4,4,4,    //    TILE    SPRT

+    // 68

+    2,2,2,2,3,3,3,3,    //    TILE1

+    // 70

+    2,2,2,2,3,3,3,3,

+    // 78

+    2,2,2,2,3,3,3,3,

+    // 80

+    4,0,0,0,0,0,0,0,

+    // 88

+    0,0,0,0,0,0,0,0,

+    // 90

+    0,0,0,0,0,0,0,0,

+    // 98

+    0,0,0,0,0,0,0,0,

+    // a0

+    3,0,0,0,0,0,0,0,

+    // a8

+    0,0,0,0,0,0,0,0,

+    // b0

+    0,0,0,0,0,0,0,0,

+    // b8

+    0,0,0,0,0,0,0,0,

+    // c0

+    3,0,0,0,0,0,0,0,

+    // c8

+    0,0,0,0,0,0,0,0,

+    // d0

+    0,0,0,0,0,0,0,0,

+    // d8

+    0,0,0,0,0,0,0,0,

+    // e0

+    0,1,1,1,1,1,1,0,

+    // e8

+    0,0,0,0,0,0,0,0,

+    // f0

+    0,0,0,0,0,0,0,0,

+    // f8

+    0,0,0,0,0,0,0,0

+};

+

+////////////////////////////////////////////////////////////////////////

+// processes data send to GPU data register

+////////////////////////////////////////////////////////////////////////

+

+void CALLBACK GPUwriteDataMem(unsigned long * pMem, int iSize)

+{

+ unsigned char command;

+ unsigned long gdata=0;

+ int i=0;

+ GPUIsBusy;

+ GPUIsNotReadyForCommands;

+

+STARTVRAM:

+

+ if(iDataWriteMode==DR_VRAMTRANSFER)

+  {

+   // make sure we are in vram

+   while(VRAMWrite.ImagePtr>=psxVuw_eom)

+    VRAMWrite.ImagePtr-=iGPUHeight*1024;

+   while(VRAMWrite.ImagePtr<psxVuw)

+    VRAMWrite.ImagePtr+=iGPUHeight*1024;

+

+   // now do the loop

+   while(VRAMWrite.ColsRemaining>0)

+    {

+     while(VRAMWrite.RowsRemaining>0)

+      {

+       if(i>=iSize) {goto ENDVRAM;}

+       i++;

+

+       gdata=*pMem++;

+

+       *VRAMWrite.ImagePtr++ = (unsigned short)gdata;

+       if(VRAMWrite.ImagePtr>=psxVuw_eom) VRAMWrite.ImagePtr-=iGPUHeight*1024;

+       VRAMWrite.RowsRemaining --;

+

+       if(VRAMWrite.RowsRemaining <= 0)

+        {

+         VRAMWrite.ColsRemaining--;

+         if (VRAMWrite.ColsRemaining <= 0)             // last pixel is odd width

+          {

+           gdata=(gdata&0xFFFF)|(((unsigned long)(*VRAMWrite.ImagePtr))<<16);

+           FinishedVRAMWrite();

+           goto ENDVRAM;

+          }

+         VRAMWrite.RowsRemaining = VRAMWrite.Width;

+         VRAMWrite.ImagePtr += 1024 - VRAMWrite.Width;

+        }

+

+       *VRAMWrite.ImagePtr++ = (unsigned short)(gdata>>16);

+       if(VRAMWrite.ImagePtr>=psxVuw_eom) VRAMWrite.ImagePtr-=iGPUHeight*1024;

+       VRAMWrite.RowsRemaining --;

+      }

+

+     VRAMWrite.RowsRemaining = VRAMWrite.Width;

+     VRAMWrite.ColsRemaining--;

+     VRAMWrite.ImagePtr += 1024 - VRAMWrite.Width;

+    }

+

+   FinishedVRAMWrite();

+  }

+

+ENDVRAM:

+

+ if(iDataWriteMode==DR_NORMAL)

+  {

+   void (* *primFunc)(unsigned char *);

+   if(bSkipNextFrame) primFunc=primTableSkip;

+   else               primFunc=primTableJ;

+

+   for(;i<iSize;)

+    {

+     if(iDataWriteMode==DR_VRAMTRANSFER) goto STARTVRAM;

+

+     gdata=*pMem++;i++;

+ 

+     if(gpuDataC == 0)

+      {

+       command = (unsigned char)((gdata>>24) & 0xff);

+ 

+       if(primTableCX[command])

+        {

+         gpuDataC = primTableCX[command];

+         gpuCommand = command;

+         gpuDataM[0] = gdata;

+         gpuDataP = 1;

+        }

+       else continue;

+      }

+     else

+      {

+       gpuDataM[gpuDataP] = gdata;

+       if(gpuDataC>128)

+        {

+         if((gpuDataC==254 && gpuDataP>=3) ||

+            (gpuDataC==255 && gpuDataP>=4 && !(gpuDataP&1)))

+          {

+           if((gpuDataM[gpuDataP] & 0xF000F000) == 0x50005000)

+            gpuDataP=gpuDataC-1;

+          }

+        }

+       gpuDataP++;

+      }

+ 

+     if(gpuDataP == gpuDataC)

+      {

+       gpuDataC=gpuDataP=0;

+       primFunc[gpuCommand]((unsigned char *)gpuDataM);

+

+       if(dwEmuFixes&0x0001 || dwActFixes&0x20000)     // hack for emulating "gpu busy" in some games

+        iFakePrimBusy=4;

+      }

+    } 

+  }

+

+ GPUdataRet=gdata;

+

+ GPUIsReadyForCommands;

+ GPUIsIdle;                

+}

+

+////////////////////////////////////////////////////////////////////////

+

+void CALLBACK GPUwriteData(unsigned long gdata)

+{

+ GPUwriteDataMem(&gdata,1);

+}

+

+////////////////////////////////////////////////////////////////////////

+// this function will be removed soon (or 'soonish') (or never)

+////////////////////////////////////////////////////////////////////////

+

+void CALLBACK GPUsetMode(unsigned long gdata)

+{

+ // ignore old psemu setmode:

+

+ // imageTransfer = gdata;

+ // iDataWriteMode=(gdata&1)?DR_VRAMTRANSFER:DR_NORMAL;

+ // iDataReadMode =(gdata&2)?DR_VRAMTRANSFER:DR_NORMAL;

+}

+

+// and this function will be removed soon as well, hehehe...

+long CALLBACK GPUgetMode(void)

+{

+ // ignore old psemu setmode

+ // return imageTransfer;

+

+ long iT=0;

+

+ if(iDataWriteMode==DR_VRAMTRANSFER) iT|=0x1;

+ if(iDataReadMode ==DR_VRAMTRANSFER) iT|=0x2;

+

+ return iT;

+}

+

+////////////////////////////////////////////////////////////////////////

+// call config dlg

+////////////////////////////////////////////////////////////////////////

+

+void StartCfgTool(char *arg) // linux: start external cfg tool

+{
+	char cfg[256];
+	struct stat buf;
+
+	strcpy(cfg, "./cfgpeopsxgl");
+	if (stat(cfg, &buf) != -1) {
+		strcat(cfg, " ");
+		strcat(cfg, arg);
+		system(cfg);
+		return;
+	}
+
+	strcpy(cfg, "./cfg/cfgpeopsxgl");
+	if (stat(cfg, &buf) != -1) {
+		strcat(cfg, " ");
+		strcat(cfg, arg);
+		system(cfg);
+		return;
+	}
+
+	sprintf(cfg, "%s/.pcsx/plugins/cfg/cfgpeopsxgl", getenv("HOME"));
+	if (stat(cfg, &buf) != -1) {
+		strcat(cfg, " ");
+		strcat(cfg, arg);
+		system(cfg);
+		return;
+	}
+
+	printf("ERROR: cfgpeopsxgl file not found!\n");
+}

+

+long CALLBACK GPUconfigure(void)

+{

+ StartCfgTool("CFG");

+ return 0;

+}

+

+////////////////////////////////////////////////////////////////////////

+// sets all kind of act fixes

+////////////////////////////////////////////////////////////////////////

+

+void SetFixes(void)

+{

+ ReInitFrameCap();

+

+ if(dwActFixes & 0x2000) 

+      dispWidths[4]=384;

+ else dispWidths[4]=368;

+}

+

+////////////////////////////////////////////////////////////////////////

+// Pete Special: make an 'intelligent' dma chain check (<-Tekken3)

+////////////////////////////////////////////////////////////////////////

+

+unsigned long lUsedAddr[3];

+

+__inline BOOL CheckForEndlessLoop(unsigned long laddr)

+{

+ if(laddr==lUsedAddr[1]) return TRUE;

+ if(laddr==lUsedAddr[2]) return TRUE;

+

+ if(laddr<lUsedAddr[0]) lUsedAddr[1]=laddr;

+ else                   lUsedAddr[2]=laddr;

+ lUsedAddr[0]=laddr;

+ return FALSE;

+}

+

+////////////////////////////////////////////////////////////////////////

+// core gives a dma chain to gpu: same as the gpuwrite interface funcs

+////////////////////////////////////////////////////////////////////////

+

+long CALLBACK GPUdmaChain(unsigned long * baseAddrL, unsigned long addr)

+{

+ unsigned long dmaMem;

+ unsigned char * baseAddrB;

+ short count;unsigned int DMACommandCounter = 0;

+

+ if(bIsFirstFrame) GLinitialize();

+

+ GPUIsBusy;

+

+ lUsedAddr[0]=lUsedAddr[1]=lUsedAddr[2]=0xffffff;

+

+ baseAddrB = (unsigned char*) baseAddrL;

+

+ do

+  {

+   if(iGPUHeight==512) addr&=0x1FFFFC;

+

+   if(DMACommandCounter++ > 2000000) break;

+   if(CheckForEndlessLoop(addr)) break;

+

+   count = baseAddrB[addr+3];

+

+   dmaMem=addr+4;

+

+   if(count>0) GPUwriteDataMem(&baseAddrL[dmaMem>>2],count);

+

+   addr = baseAddrL[addr>>2]&0xffffff;

+  }

+ while (addr != 0xffffff);

+

+ GPUIsIdle;

+

+ return 0;

+}

+           

+////////////////////////////////////////////////////////////////////////

+// show about dlg

+////////////////////////////////////////////////////////////////////////

+

+void CALLBACK GPUabout(void)

+{

+ StartCfgTool("ABOUT");

+}

+

+////////////////////////////////////////////////////////////////////////

+// We are ever fine ;)

+////////////////////////////////////////////////////////////////////////

+

+long CALLBACK GPUtest(void)

+{

+ // if test fails this function should return negative value for error (unable to continue)

+ // and positive value for warning (can continue but output might be crappy)

+

+ return 0;

+}

+

+////////////////////////////////////////////////////////////////////////

+// save state funcs

+////////////////////////////////////////////////////////////////////////

+

+typedef struct

+{

+ unsigned long ulFreezeVersion;      // should be always 1 for now

+ unsigned long ulStatus;             // current gpu status

+ unsigned long ulControl[256];       // latest control register values

+ unsigned char psxVRam[1024*1024*2]; // current VRam image

+} GPUFreeze_t;

+

+////////////////////////////////////////////////////////////////////////

+

+long CALLBACK GPUfreeze(unsigned long ulGetFreezeData,GPUFreeze_t * pF)

+{

+ if(ulGetFreezeData==2) 

+  {

+   long lSlotNum=*((long *)pF);

+   if(lSlotNum<0) return 0;

+   if(lSlotNum>8) return 0;

+   lSelectedSlot=lSlotNum+1;

+   return 1;

+  }

+

+ if(!pF)                    return 0; 

+ if(pF->ulFreezeVersion!=1) return 0;

+

+ if(ulGetFreezeData==1)

+  {

+   pF->ulStatus=STATUSREG;

+   memcpy(pF->ulControl,ulStatusControl,256*sizeof(unsigned long));

+   memcpy(pF->psxVRam,  psxVub,         1024*iGPUHeight*2);

+

+   return 1;

+  }

+

+ if(ulGetFreezeData!=0) return 0;

+

+ STATUSREG=pF->ulStatus;

+ memcpy(ulStatusControl,pF->ulControl,256*sizeof(unsigned long));

+ memcpy(psxVub,         pF->psxVRam,  1024*iGPUHeight*2);

+

+ ResetTextureArea(TRUE);

+

+ GPUwriteStatus(ulStatusControl[0]);

+ GPUwriteStatus(ulStatusControl[1]);

+ GPUwriteStatus(ulStatusControl[2]);

+ GPUwriteStatus(ulStatusControl[3]);

+ GPUwriteStatus(ulStatusControl[8]);

+ GPUwriteStatus(ulStatusControl[6]);

+ GPUwriteStatus(ulStatusControl[7]);

+ GPUwriteStatus(ulStatusControl[5]);

+ GPUwriteStatus(ulStatusControl[4]);

+

+ return 1;

+}

+

+////////////////////////////////////////////////////////////////////////

+// special "emu infos" / "emu effects" functions

+////////////////////////////////////////////////////////////////////////

+

+//00 = black

+//01 = white

+//10 = red

+//11 = transparent

+

+unsigned char cFont[10][120]=

+{

+// 0

+{0xaa,0xaa,0xaa,0xaa,0xaa,0xaa,

+ 0x80,0x00,0x00,0x00,0x00,0x00,

+ 0x80,0x00,0x00,0x00,0x00,0x00,

+ 0x80,0x00,0x00,0x00,0x00,0x00,

+ 0x80,0x00,0x00,0x00,0x00,0x00,

+ 0x80,0x00,0x05,0x54,0x00,0x00,

+ 0x80,0x00,0x14,0x05,0x00,0x00,

+ 0x80,0x00,0x14,0x05,0x00,0x00,

+ 0x80,0x00,0x14,0x05,0x00,0x00,

+ 0x80,0x00,0x14,0x05,0x00,0x00,

+ 0x80,0x00,0x14,0x05,0x00,0x00,

+ 0x80,0x00,0x14,0x05,0x00,0x00,

+ 0x80,0x00,0x14,0x05,0x00,0x00,

+ 0x80,0x00,0x14,0x05,0x00,0x00,

+ 0x80,0x00,0x05,0x54,0x00,0x00,

+ 0x80,0x00,0x00,0x00,0x00,0x00,

+ 0x80,0x00,0x00,0x00,0x00,0x00,

+ 0x80,0x00,0x00,0x00,0x00,0x00,

+ 0x80,0x00,0x00,0x00,0x00,0x00,

+ 0xaa,0xaa,0xaa,0xaa,0xaa,0xaa

+},

+// 1

+{0xaa,0xaa,0xaa,0xaa,0xaa,0xaa,

+ 0x80,0x00,0x00,0x00,0x00,0x00,

+ 0x80,0x00,0x00,0x00,0x00,0x00,

+ 0x80,0x00,0x00,0x00,0x00,0x00,

+ 0x80,0x00,0x00,0x00,0x00,0x00,

+ 0x80,0x00,0x00,0x50,0x00,0x00,

+ 0x80,0x00,0x05,0x50,0x00,0x00,

+ 0x80,0x00,0x00,0x50,0x00,0x00,

+ 0x80,0x00,0x00,0x50,0x00,0x00,

+ 0x80,0x00,0x00,0x50,0x00,0x00,

+ 0x80,0x00,0x00,0x50,0x00,0x00,

+ 0x80,0x00,0x00,0x50,0x00,0x00,

+ 0x80,0x00,0x00,0x50,0x00,0x00,

+ 0x80,0x00,0x00,0x50,0x00,0x00,

+ 0x80,0x00,0x05,0x55,0x00,0x00,

+ 0x80,0x00,0x00,0x00,0x00,0x00,

+ 0x80,0x00,0x00,0x00,0x00,0x00,

+ 0x80,0x00,0x00,0x00,0x00,0x00,

+ 0x80,0x00,0x00,0x00,0x00,0x00,

+ 0xaa,0xaa,0xaa,0xaa,0xaa,0xaa

+},

+// 2

+{0xaa,0xaa,0xaa,0xaa,0xaa,0xaa,

+ 0x80,0x00,0x00,0x00,0x00,0x00,

+ 0x80,0x00,0x00,0x00,0x00,0x00,

+ 0x80,0x00,0x00,0x00,0x00,0x00,

+ 0x80,0x00,0x00,0x00,0x00,0x00,

+ 0x80,0x00,0x05,0x54,0x00,0x00,

+ 0x80,0x00,0x14,0x05,0x00,0x00,

+ 0x80,0x00,0x00,0x05,0x00,0x00,

+ 0x80,0x00,0x00,0x05,0x00,0x00,

+ 0x80,0x00,0x00,0x14,0x00,0x00,

+ 0x80,0x00,0x00,0x50,0x00,0x00,

+ 0x80,0x00,0x01,0x40,0x00,0x00,

+ 0x80,0x00,0x05,0x00,0x00,0x00,

+ 0x80,0x00,0x14,0x00,0x00,0x00,

+ 0x80,0x00,0x15,0x55,0x00,0x00,

+ 0x80,0x00,0x00,0x00,0x00,0x00,

+ 0x80,0x00,0x00,0x00,0x00,0x00,

+ 0x80,0x00,0x00,0x00,0x00,0x00,

+ 0x80,0x00,0x00,0x00,0x00,0x00,

+ 0xaa,0xaa,0xaa,0xaa,0xaa,0xaa

+},

+// 3

+{0xaa,0xaa,0xaa,0xaa,0xaa,0xaa,

+ 0x80,0x00,0x00,0x00,0x00,0x00,

+ 0x80,0x00,0x00,0x00,0x00,0x00,

+ 0x80,0x00,0x00,0x00,0x00,0x00,

+ 0x80,0x00,0x00,0x00,0x00,0x00,

+ 0x80,0x00,0x05,0x54,0x00,0x00,

+ 0x80,0x00,0x14,0x05,0x00,0x00,

+ 0x80,0x00,0x00,0x05,0x00,0x00,

+ 0x80,0x00,0x00,0x05,0x00,0x00,

+ 0x80,0x00,0x01,0x54,0x00,0x00,

+ 0x80,0x00,0x00,0x05,0x00,0x00,

+ 0x80,0x00,0x00,0x05,0x00,0x00,

+ 0x80,0x00,0x00,0x05,0x00,0x00,

+ 0x80,0x00,0x14,0x05,0x00,0x00,

+ 0x80,0x00,0x05,0x54,0x00,0x00,

+ 0x80,0x00,0x00,0x00,0x00,0x00,

+ 0x80,0x00,0x00,0x00,0x00,0x00,

+ 0x80,0x00,0x00,0x00,0x00,0x00,

+ 0x80,0x00,0x00,0x00,0x00,0x00,

+ 0xaa,0xaa,0xaa,0xaa,0xaa,0xaa

+},

+// 4

+{0xaa,0xaa,0xaa,0xaa,0xaa,0xaa,

+ 0x80,0x00,0x00,0x00,0x00,0x00,

+ 0x80,0x00,0x00,0x00,0x00,0x00,

+ 0x80,0x00,0x00,0x00,0x00,0x00,

+ 0x80,0x00,0x00,0x00,0x00,0x00,

+ 0x80,0x00,0x00,0x14,0x00,0x00,

+ 0x80,0x00,0x00,0x54,0x00,0x00,

+ 0x80,0x00,0x01,0x54,0x00,0x00,

+ 0x80,0x00,0x01,0x54,0x00,0x00,

+ 0x80,0x00,0x05,0x14,0x00,0x00,

+ 0x80,0x00,0x14,0x14,0x00,0x00,

+ 0x80,0x00,0x15,0x55,0x00,0x00,

+ 0x80,0x00,0x00,0x14,0x00,0x00,

+ 0x80,0x00,0x00,0x14,0x00,0x00,

+ 0x80,0x00,0x00,0x55,0x00,0x00,

+ 0x80,0x00,0x00,0x00,0x00,0x00,

+ 0x80,0x00,0x00,0x00,0x00,0x00,

+ 0x80,0x00,0x00,0x00,0x00,0x00,

+ 0x80,0x00,0x00,0x00,0x00,0x00,

+ 0xaa,0xaa,0xaa,0xaa,0xaa,0xaa

+},

+// 5

+{0xaa,0xaa,0xaa,0xaa,0xaa,0xaa,

+ 0x80,0x00,0x00,0x00,0x00,0x00,

+ 0x80,0x00,0x00,0x00,0x00,0x00,

+ 0x80,0x00,0x00,0x00,0x00,0x00,

+ 0x80,0x00,0x00,0x00,0x00,0x00,

+ 0x80,0x00,0x15,0x55,0x00,0x00,

+ 0x80,0x00,0x14,0x00,0x00,0x00,

+ 0x80,0x00,0x14,0x00,0x00,0x00,

+ 0x80,0x00,0x14,0x00,0x00,0x00,

+ 0x80,0x00,0x15,0x54,0x00,0x00,

+ 0x80,0x00,0x00,0x05,0x00,0x00,

+ 0x80,0x00,0x00,0x05,0x00,0x00,

+ 0x80,0x00,0x00,0x05,0x00,0x00,

+ 0x80,0x00,0x14,0x05,0x00,0x00,

+ 0x80,0x00,0x05,0x54,0x00,0x00,

+ 0x80,0x00,0x00,0x00,0x00,0x00,

+ 0x80,0x00,0x00,0x00,0x00,0x00,

+ 0x80,0x00,0x00,0x00,0x00,0x00,

+ 0x80,0x00,0x00,0x00,0x00,0x00,

+ 0xaa,0xaa,0xaa,0xaa,0xaa,0xaa

+},

+// 6

+{0xaa,0xaa,0xaa,0xaa,0xaa,0xaa,

+ 0x80,0x00,0x00,0x00,0x00,0x00,

+ 0x80,0x00,0x00,0x00,0x00,0x00,

+ 0x80,0x00,0x00,0x00,0x00,0x00,

+ 0x80,0x00,0x00,0x00,0x00,0x00,

+ 0x80,0x00,0x01,0x54,0x00,0x00,

+ 0x80,0x00,0x05,0x00,0x00,0x00,

+ 0x80,0x00,0x14,0x00,0x00,0x00,

+ 0x80,0x00,0x14,0x00,0x00,0x00,

+ 0x80,0x00,0x15,0x54,0x00,0x00,

+ 0x80,0x00,0x15,0x05,0x00,0x00,

+ 0x80,0x00,0x14,0x05,0x00,0x00,

+ 0x80,0x00,0x14,0x05,0x00,0x00,

+ 0x80,0x00,0x14,0x05,0x00,0x00,

+ 0x80,0x00,0x05,0x54,0x00,0x00,

+ 0x80,0x00,0x00,0x00,0x00,0x00,

+ 0x80,0x00,0x00,0x00,0x00,0x00,

+ 0x80,0x00,0x00,0x00,0x00,0x00,

+ 0x80,0x00,0x00,0x00,0x00,0x00,

+ 0xaa,0xaa,0xaa,0xaa,0xaa,0xaa

+},

+// 7

+{0xaa,0xaa,0xaa,0xaa,0xaa,0xaa,

+ 0x80,0x00,0x00,0x00,0x00,0x00,

+ 0x80,0x00,0x00,0x00,0x00,0x00,

+ 0x80,0x00,0x00,0x00,0x00,0x00,

+ 0x80,0x00,0x00,0x00,0x00,0x00,

+ 0x80,0x00,0x15,0x55,0x00,0x00,

+ 0x80,0x00,0x14,0x05,0x00,0x00,

+ 0x80,0x00,0x00,0x14,0x00,0x00,

+ 0x80,0x00,0x00,0x14,0x00,0x00,

+ 0x80,0x00,0x00,0x50,0x00,0x00,

+ 0x80,0x00,0x00,0x50,0x00,0x00,

+ 0x80,0x00,0x01,0x40,0x00,0x00,

+ 0x80,0x00,0x01,0x40,0x00,0x00,

+ 0x80,0x00,0x05,0x00,0x00,0x00,

+ 0x80,0x00,0x05,0x00,0x00,0x00,

+ 0x80,0x00,0x00,0x00,0x00,0x00,

+ 0x80,0x00,0x00,0x00,0x00,0x00,

+ 0x80,0x00,0x00,0x00,0x00,0x00,

+ 0x80,0x00,0x00,0x00,0x00,0x00,

+ 0xaa,0xaa,0xaa,0xaa,0xaa,0xaa

+},

+// 8

+{0xaa,0xaa,0xaa,0xaa,0xaa,0xaa,

+ 0x80,0x00,0x00,0x00,0x00,0x00,

+ 0x80,0x00,0x00,0x00,0x00,0x00,

+ 0x80,0x00,0x00,0x00,0x00,0x00,

+ 0x80,0x00,0x00,0x00,0x00,0x00,

+ 0x80,0x00,0x05,0x54,0x00,0x00,

+ 0x80,0x00,0x14,0x05,0x00,0x00,

+ 0x80,0x00,0x14,0x05,0x00,0x00,

+ 0x80,0x00,0x14,0x05,0x00,0x00,

+ 0x80,0x00,0x05,0x54,0x00,0x00,

+ 0x80,0x00,0x14,0x05,0x00,0x00,

+ 0x80,0x00,0x14,0x05,0x00,0x00,

+ 0x80,0x00,0x14,0x05,0x00,0x00,

+ 0x80,0x00,0x14,0x05,0x00,0x00,

+ 0x80,0x00,0x05,0x54,0x00,0x00,

+ 0x80,0x00,0x00,0x00,0x00,0x00,

+ 0x80,0x00,0x00,0x00,0x00,0x00,

+ 0x80,0x00,0x00,0x00,0x00,0x00,

+ 0x80,0x00,0x00,0x00,0x00,0x00,

+ 0xaa,0xaa,0xaa,0xaa,0xaa,0xaa

+},

+// 9

+{0xaa,0xaa,0xaa,0xaa,0xaa,0xaa,

+ 0x80,0x00,0x00,0x00,0x00,0x00,

+ 0x80,0x00,0x00,0x00,0x00,0x00,

+ 0x80,0x00,0x00,0x00,0x00,0x00,

+ 0x80,0x00,0x00,0x00,0x00,0x00,

+ 0x80,0x00,0x05,0x54,0x00,0x00,

+ 0x80,0x00,0x14,0x05,0x00,0x00,

+ 0x80,0x00,0x14,0x05,0x00,0x00,

+ 0x80,0x00,0x14,0x05,0x00,0x00,

+ 0x80,0x00,0x14,0x15,0x00,0x00,

+ 0x80,0x00,0x05,0x55,0x00,0x00,

+ 0x80,0x00,0x00,0x05,0x00,0x00,

+ 0x80,0x00,0x00,0x05,0x00,0x00,

+ 0x80,0x00,0x00,0x14,0x00,0x00,

+ 0x80,0x00,0x05,0x50,0x00,0x00,

+ 0x80,0x00,0x00,0x00,0x00,0x00,

+ 0x80,0x00,0x00,0x00,0x00,0x00,

+ 0x80,0x00,0x00,0x00,0x00,0x00,

+ 0x80,0x00,0x00,0x00,0x00,0x00,

+ 0xaa,0xaa,0xaa,0xaa,0xaa,0xaa

+}

+};

+

+////////////////////////////////////////////////////////////////////////

+

+void PaintPicDot(unsigned char * p,unsigned char c)

+{

+ if(c==0) {*p++=0x00;*p++=0x00;*p=0x00;return;}

+ if(c==1) {*p++=0xff;*p++=0xff;*p=0xff;return;}

+ if(c==2) {*p++=0x00;*p++=0x00;*p=0xff;return;}

+}

+

+////////////////////////////////////////////////////////////////////////

+

+void CALLBACK GPUgetScreenPic(unsigned char * pMem)

+{

+ float XS,YS;int x,y,v;

+ unsigned char * ps, * px, * pf;

+ unsigned char c;

+

+ if(!pGfxCardScreen)

+  {

+   glPixelStorei(GL_PACK_ALIGNMENT,1);

+   pGfxCardScreen=(unsigned char *)malloc(iResX*iResY*4);

+  }

+

+ ps=pGfxCardScreen;

+

+ glReadBuffer(GL_FRONT);

+

+ glReadPixels(0,0,iResX,iResY,GL_RGB,GL_UNSIGNED_BYTE,ps);

+               

+ glReadBuffer(GL_BACK);

+

+ XS=(float)iResX/128;

+ YS=(float)iResY/96;

+ pf=pMem;

+

+ for(y=96;y>0;y--)

+  {

+   for(x=0;x<128;x++)

+    {

+     px=ps+(3*((int)((float)x * XS))+

+           (3*iResX)*((int)((float)y*YS)));

+     *(pf+0)=*(px+2);

+     *(pf+1)=*(px+1);

+     *(pf+2)=*(px+0);

+     pf+=3;

+    }

+  }

+

+ /////////////////////////////////////////////////////////////////////

+ // generic number/border painter

+

+ pf=pMem+(103*3);

+

+ for(y=0;y<20;y++)

+  {

+   for(x=0;x<6;x++)

+    {

+     c=cFont[lSelectedSlot][x+y*6];

+     v=(c&0xc0)>>6;

+     PaintPicDot(pf,(unsigned char)v);pf+=3;                // paint the dots into the rect

+     v=(c&0x30)>>4;

+     PaintPicDot(pf,(unsigned char)v);pf+=3;

+     v=(c&0x0c)>>2;

+     PaintPicDot(pf,(unsigned char)v);pf+=3;

+     v=c&0x03;

+     PaintPicDot(pf,(unsigned char)v);pf+=3;

+    }

+   pf+=104*3;

+  }

+

+ pf=pMem;

+ for(x=0;x<128;x++)

+  {

+   *(pf+(95*128*3))=0x00;*pf++=0x00;

+   *(pf+(95*128*3))=0x00;*pf++=0x00;

+   *(pf+(95*128*3))=0xff;*pf++=0xff;

+  }

+ pf=pMem;

+ for(y=0;y<96;y++)

+  {

+   *(pf+(127*3))=0x00;*pf++=0x00;

+   *(pf+(127*3))=0x00;*pf++=0x00;

+   *(pf+(127*3))=0xff;*pf++=0xff;

+   pf+=127*3;

+  }

+

+}

+

+////////////////////////////////////////////////////////////////////////

+

+void CALLBACK GPUshowScreenPic(unsigned char * pMem)

+{

+ DestroyPic();

+ if(pMem==0) return;

+ CreatePic(pMem);

+}

+

+////////////////////////////////////////////////////////////////////////

+

+void CALLBACK GPUsetfix(unsigned long dwFixBits)

+{

+ dwEmuFixes=dwFixBits;

+}

+

+////////////////////////////////////////////////////////////////////////

+ 

+void CALLBACK GPUvisualVibration(unsigned long iSmall, unsigned long iBig)

+{

+ int iVibVal;

+

+ if(PSXDisplay.DisplayModeNew.x)                       // calc min "shake pixel" from screen width

+      iVibVal=max(1,iResX/PSXDisplay.DisplayModeNew.x);

+ else iVibVal=1;

+                                                       // big rumble: 4...15 sp ; small rumble 1...3 sp

+ if(iBig) iRumbleVal=max(4*iVibVal,min(15*iVibVal,((int)iBig  *iVibVal)/10));

+ else     iRumbleVal=max(1*iVibVal,min( 3*iVibVal,((int)iSmall*iVibVal)/10));

+

+ srand(timeGetTime());                                 // init rand (will be used in BufferSwap)

+

+ iRumbleTime=15;                                       // let the rumble last 16 buffer swaps

+}

+                                                       

+////////////////////////////////////////////////////////////////////////

+// main emu can set display infos (A/M/G/D) 

+////////////////////////////////////////////////////////////////////////

+

+void CALLBACK GPUdisplayFlags(unsigned long dwFlags)

+{

+ dwCoreFlags=dwFlags;

+}