plugins/gpu-gles/gpulib_if.c

   1 /***************************************************************************
   2     begin                : Sun Mar 08 2009
   3     copyright            : (C) 1999-2009 by Pete Bernert
   4     email                : BlackDove@addcom.de
   5
   6     PCSX rearmed rework (C) notaz, 2012
   7  ***************************************************************************/
   8
   9 /***************************************************************************
  10  *                                                                         *
  11  *   This program is free software; you can redistribute it and/or modify  *
  12  *   it under the terms of the GNU General Public License as published by  *
  13  *   the Free Software Foundation; either version 2 of the License, or     *
  14  *   (at your option) any later version. See also the license.txt file for *
  15  *   additional informations.                                              *
  16  *                                                                         *
  17  ***************************************************************************/
  18
  19 #include "gpuDraw.c"
  20 #include "gpuTexture.c"
  21 #include "gpuPrim.c"
  22 #include "hud.c"
  23
  24 static const short dispWidths[8] = {256,320,512,640,368,384,512,640};
  25 short g_m1,g_m2,g_m3;
  26 short DrawSemiTrans;
  27
  28 short          ly0,lx0,ly1,lx1,ly2,lx2,ly3,lx3;        // global psx vertex coords
  29 long           GlobalTextAddrX,GlobalTextAddrY,GlobalTextTP;
  30 long           GlobalTextREST,GlobalTextABR,GlobalTextPAGE;
  31
  32 unsigned long dwGPUVersion;
  33 int           iGPUHeight=512;
  34 int           iGPUHeightMask=511;
  35 int           GlobalTextIL;
  36
  37 unsigned char  *psxVub;
  38 unsigned short *psxVuw;
  39
  40 GLfloat         gl_z=0.0f;
  41 BOOL            bNeedInterlaceUpdate;
  42 BOOL            bNeedRGB24Update;
  43 BOOL            bChangeWinMode;
  44 long            lGPUstatusRet;
  45 unsigned long   ulGPUInfoVals[16];
  46 VRAMLoad_t      VRAMWrite;
  47 VRAMLoad_t      VRAMRead;
  48 int             iDataWriteMode;
  49 int             iDataReadMode;
  50
  51 long            lClearOnSwap;
  52 long            lClearOnSwapColor;
  53 BOOL            bSkipNextFrame;
  54
  55 PSXDisplay_t    PSXDisplay;
  56 PSXDisplay_t    PreviousPSXDisplay;
  57 TWin_t          TWin;
  58 BOOL            bDisplayNotSet;
  59 BOOL            bNeedWriteUpload;
  60 int             iLastRGB24;
  61
  62 // don't do GL vram read
  63 void CheckVRamRead(int x, int y, int dx, int dy, bool bFront)
  64 {
  65 }
  66
  67 void CheckVRamReadEx(int x, int y, int dx, int dy)
  68 {
  69 }
  70
  71 void SetFixes(void)
  72 {
  73 }
  74
  75 static void PaintBlackBorders(void)
  76 {
  77  short s;
  78  glDisable(GL_SCISSOR_TEST); glError();
  79  if(bTexEnabled) {glDisable(GL_TEXTURE_2D);bTexEnabled=FALSE;} glError();
  80  if(bOldSmoothShaded) {glShadeModel(GL_FLAT);bOldSmoothShaded=FALSE;} glError();
  81  if(bBlendEnable)     {glDisable(GL_BLEND);bBlendEnable=FALSE;} glError();
  82  glDisable(GL_ALPHA_TEST); glError();
  83
  84  glEnable(GL_ALPHA_TEST); glError();
  85  glEnable(GL_SCISSOR_TEST); glError();
  86 }
  87
  88 static void fps_update(void);
  89
  90 void updateDisplay(void)
  91 {
  92  bFakeFrontBuffer=FALSE;
  93  bRenderFrontBuffer=FALSE;
  94
  95  if(PSXDisplay.RGB24)// && !bNeedUploadAfter)         // (mdec) upload wanted?
  96  {
  97   PrepareFullScreenUpload(-1);
  98   UploadScreen(PSXDisplay.Interlaced);                // -> upload whole screen from psx vram
  99   bNeedUploadTest=FALSE;
 100   bNeedInterlaceUpdate=FALSE;
 101   bNeedUploadAfter=FALSE;
 102   bNeedRGB24Update=FALSE;
 103  }
 104  else
 105  if(bNeedInterlaceUpdate)                             // smaller upload?
 106  {
 107   bNeedInterlaceUpdate=FALSE;
 108   xrUploadArea=xrUploadAreaIL;                        // -> upload this rect
 109   UploadScreen(TRUE);
 110  }
 111
 112  if(dwActFixes&512) bCheckFF9G4(NULL);                // special game fix for FF9
 113
 114  if(PSXDisplay.Disabled)                              // display disabled?
 115  {
 116   // moved here
 117   glDisable(GL_SCISSOR_TEST); glError();
 118   glClearColor(0,0,0,128); glError();                 // -> clear whole backbuffer
 119   glClear(uiBufferBits); glError();
 120   glEnable(GL_SCISSOR_TEST); glError();
 121   gl_z=0.0f;
 122   bDisplayNotSet = TRUE;
 123  }
 124
 125  if(iDrawnSomething)
 126  {
 127   fps_update();
 128   eglSwapBuffers(display, surface);
 129   iDrawnSomething=0;
 130  }
 131
 132  if(lClearOnSwap)                                     // clear buffer after swap?
 133  {
 134   GLclampf g,b,r;
 135
 136   if(bDisplayNotSet)                                  // -> set new vals
 137    SetOGLDisplaySettings(1);
 138
 139   g=((GLclampf)GREEN(lClearOnSwapColor))/255.0f;      // -> get col
 140   b=((GLclampf)BLUE(lClearOnSwapColor))/255.0f;
 141   r=((GLclampf)RED(lClearOnSwapColor))/255.0f;
 142   glDisable(GL_SCISSOR_TEST); glError();
 143   glClearColor(r,g,b,128); glError();                 // -> clear
 144   glClear(uiBufferBits); glError();
 145   glEnable(GL_SCISSOR_TEST); glError();
 146   lClearOnSwap=0;                                     // -> done
 147  }
 148  else
 149  {
 150   if(iZBufferDepth)                                   // clear zbuffer as well (if activated)
 151    {
 152     glDisable(GL_SCISSOR_TEST); glError();
 153     glClear(GL_DEPTH_BUFFER_BIT); glError();
 154     glEnable(GL_SCISSOR_TEST); glError();
 155    }
 156  }
 157  gl_z=0.0f;
 158
 159  // additional uploads immediatly after swapping
 160  if(bNeedUploadAfter)                                 // upload wanted?
 161  {
 162   bNeedUploadAfter=FALSE;
 163   bNeedUploadTest=FALSE;
 164   UploadScreen(-1);                                   // -> upload
 165  }
 166
 167  if(bNeedUploadTest)
 168  {
 169   bNeedUploadTest=FALSE;
 170   if(PSXDisplay.InterlacedTest &&
 171      //iOffscreenDrawing>2 &&
 172      PreviousPSXDisplay.DisplayPosition.x==PSXDisplay.DisplayPosition.x &&
 173      PreviousPSXDisplay.DisplayEnd.x==PSXDisplay.DisplayEnd.x &&
 174      PreviousPSXDisplay.DisplayPosition.y==PSXDisplay.DisplayPosition.y &&
 175      PreviousPSXDisplay.DisplayEnd.y==PSXDisplay.DisplayEnd.y)
 176    {
 177     PrepareFullScreenUpload(TRUE);
 178     UploadScreen(TRUE);
 179    }
 180  }
 181 }
 182
 183 void updateFrontDisplay(void)
 184 {
 185  if(PreviousPSXDisplay.Range.x0||
 186     PreviousPSXDisplay.Range.y0)
 187   PaintBlackBorders();
 188
 189  bFakeFrontBuffer=FALSE;
 190  bRenderFrontBuffer=FALSE;
 191
 192  if(iDrawnSomething)                                  // linux:
 193   eglSwapBuffers(display, surface);
 194 }
 195
 196 static void ChangeDispOffsetsX(void)                  // CENTER X
 197 {
 198 long lx,l;short sO;
 199
 200 if(!PSXDisplay.Range.x1) return;                      // some range given?
 201
 202 l=PSXDisplay.DisplayMode.x;
 203
 204 l*=(long)PSXDisplay.Range.x1;                         // some funky calculation
 205 l/=2560;lx=l;l&=0xfffffff8;
 206
 207 if(l==PreviousPSXDisplay.Range.x1) return;            // some change?
 208
 209 sO=PreviousPSXDisplay.Range.x0;                       // store old
 210
 211 if(lx>=PSXDisplay.DisplayMode.x)                      // range bigger?
 212  {
 213   PreviousPSXDisplay.Range.x1=                        // -> take display width
 214    PSXDisplay.DisplayMode.x;
 215   PreviousPSXDisplay.Range.x0=0;                      // -> start pos is 0
 216  }
 217 else                                                  // range smaller? center it
 218  {
 219   PreviousPSXDisplay.Range.x1=l;                      // -> store width (8 pixel aligned)
 220    PreviousPSXDisplay.Range.x0=                       // -> calc start pos
 221    (PSXDisplay.Range.x0-500)/8;
 222   if(PreviousPSXDisplay.Range.x0<0)                   // -> we don't support neg. values yet
 223    PreviousPSXDisplay.Range.x0=0;
 224
 225   if((PreviousPSXDisplay.Range.x0+lx)>                // -> uhuu... that's too much
 226      PSXDisplay.DisplayMode.x)
 227    {
 228     PreviousPSXDisplay.Range.x0=                      // -> adjust start
 229      PSXDisplay.DisplayMode.x-lx;
 230     PreviousPSXDisplay.Range.x1+=lx-l;                // -> adjust width
 231    }
 232  }
 233
 234 if(sO!=PreviousPSXDisplay.Range.x0)                   // something changed?
 235  {
 236   bDisplayNotSet=TRUE;                                // -> recalc display stuff
 237  }
 238 }
 239
 240 ////////////////////////////////////////////////////////////////////////
 241
 242 static void ChangeDispOffsetsY(void)                  // CENTER Y
 243 {
 244 int iT;short sO;                                      // store previous y size
 245
 246 if(PSXDisplay.PAL) iT=48; else iT=28;                 // different offsets on PAL/NTSC
 247
 248 if(PSXDisplay.Range.y0>=iT)                           // crossed the security line? :)
 249  {
 250   PreviousPSXDisplay.Range.y1=                        // -> store width
 251    PSXDisplay.DisplayModeNew.y;
 252
 253   sO=(PSXDisplay.Range.y0-iT-4)*PSXDisplay.Double;    // -> calc offset
 254   if(sO<0) sO=0;
 255
 256   PSXDisplay.DisplayModeNew.y+=sO;                    // -> add offset to y size, too
 257  }
 258 else sO=0;                                            // else no offset
 259
 260 if(sO!=PreviousPSXDisplay.Range.y0)                   // something changed?
 261  {
 262   PreviousPSXDisplay.Range.y0=sO;
 263   bDisplayNotSet=TRUE;                                // -> recalc display stuff
 264  }
 265 }
 266
 267 static void updateDisplayIfChanged(void)
 268 {
 269 BOOL bUp;
 270
 271 if ((PSXDisplay.DisplayMode.y == PSXDisplay.DisplayModeNew.y) &&
 272     (PSXDisplay.DisplayMode.x == PSXDisplay.DisplayModeNew.x))
 273  {
 274   if((PSXDisplay.RGB24      == PSXDisplay.RGB24New) &&
 275      (PSXDisplay.Interlaced == PSXDisplay.InterlacedNew))
 276      return;                                          // nothing has changed? fine, no swap buffer needed
 277  }
 278 else                                                  // some res change?
 279  {
 280   glLoadIdentity(); glError();
 281   glOrtho(0,PSXDisplay.DisplayModeNew.x,              // -> new psx resolution
 282             PSXDisplay.DisplayModeNew.y, 0, -1, 1); glError();
 283   if(bKeepRatio) SetAspectRatio();
 284  }
 285
 286 bDisplayNotSet = TRUE;                                // re-calc offsets/display area
 287
 288 bUp=FALSE;
 289 if(PSXDisplay.RGB24!=PSXDisplay.RGB24New)             // clean up textures, if rgb mode change (usually mdec on/off)
 290  {
 291   PreviousPSXDisplay.RGB24=0;                         // no full 24 frame uploaded yet
 292   ResetTextureArea(FALSE);
 293   bUp=TRUE;
 294  }
 295
 296 PSXDisplay.RGB24         = PSXDisplay.RGB24New;       // get new infos
 297 PSXDisplay.DisplayMode.y = PSXDisplay.DisplayModeNew.y;
 298 PSXDisplay.DisplayMode.x = PSXDisplay.DisplayModeNew.x;
 299 PSXDisplay.Interlaced    = PSXDisplay.InterlacedNew;
 300
 301 PSXDisplay.DisplayEnd.x=                              // calc new ends
 302  PSXDisplay.DisplayPosition.x+ PSXDisplay.DisplayMode.x;
 303 PSXDisplay.DisplayEnd.y=
 304  PSXDisplay.DisplayPosition.y+ PSXDisplay.DisplayMode.y+PreviousPSXDisplay.DisplayModeNew.y;
 305 PreviousPSXDisplay.DisplayEnd.x=
 306  PreviousPSXDisplay.DisplayPosition.x+ PSXDisplay.DisplayMode.x;
 307 PreviousPSXDisplay.DisplayEnd.y=
 308  PreviousPSXDisplay.DisplayPosition.y+ PSXDisplay.DisplayMode.y+PreviousPSXDisplay.DisplayModeNew.y;
 309
 310 ChangeDispOffsetsX();
 311 if(bUp) updateDisplay();                              // yeah, real update (swap buffer)
 312 }
 313
 314 #define GPUwriteStatus_ext GPUwriteStatus_ext // for gpulib to see this
 315 void GPUwriteStatus_ext(unsigned long gdata)
 316 {
 317 switch((gdata>>24)&0xff)
 318  {
 319   case 0x00:
 320    PSXDisplay.Disabled=1;
 321    PSXDisplay.DrawOffset.x=PSXDisplay.DrawOffset.y=0;
 322    drawX=drawY=0;drawW=drawH=0;
 323    sSetMask=0;lSetMask=0;bCheckMask=FALSE;iSetMask=0;
 324    usMirror=0;
 325    GlobalTextAddrX=0;GlobalTextAddrY=0;
 326    GlobalTextTP=0;GlobalTextABR=0;
 327    PSXDisplay.RGB24=FALSE;
 328    PSXDisplay.Interlaced=FALSE;
 329    bUsingTWin = FALSE;
 330    return;
 331
 332   case 0x03:
 333    PreviousPSXDisplay.Disabled = PSXDisplay.Disabled;
 334    PSXDisplay.Disabled = (gdata & 1);
 335
 336    if (iOffscreenDrawing==4 &&
 337         PreviousPSXDisplay.Disabled &&
 338        !(PSXDisplay.Disabled))
 339     {
 340
 341      if(!PSXDisplay.RGB24)
 342       {
 343        PrepareFullScreenUpload(TRUE);
 344        UploadScreen(TRUE);
 345        updateDisplay();
 346       }
 347     }
 348    return;
 349
 350   case 0x05:
 351    {
 352     short sx=(short)(gdata & 0x3ff);
 353     short sy;
 354
 355     sy = (short)((gdata>>10)&0x3ff);             // really: 0x1ff, but we adjust it later
 356     if (sy & 0x200)
 357      {
 358       sy|=0xfc00;
 359       PreviousPSXDisplay.DisplayModeNew.y=sy/PSXDisplay.Double;
 360       sy=0;
 361      }
 362     else PreviousPSXDisplay.DisplayModeNew.y=0;
 363
 364     if(sx>1000) sx=0;
 365
 366     if(dwActFixes&8)
 367      {
 368       if((!PSXDisplay.Interlaced) &&
 369          PreviousPSXDisplay.DisplayPosition.x == sx  &&
 370          PreviousPSXDisplay.DisplayPosition.y == sy)
 371        return;
 372
 373       PSXDisplay.DisplayPosition.x = PreviousPSXDisplay.DisplayPosition.x;
 374       PSXDisplay.DisplayPosition.y = PreviousPSXDisplay.DisplayPosition.y;
 375       PreviousPSXDisplay.DisplayPosition.x = sx;
 376       PreviousPSXDisplay.DisplayPosition.y = sy;
 377      }
 378     else
 379      {
 380       if((!PSXDisplay.Interlaced) &&
 381          PSXDisplay.DisplayPosition.x == sx  &&
 382          PSXDisplay.DisplayPosition.y == sy)
 383        return;
 384       PreviousPSXDisplay.DisplayPosition.x = PSXDisplay.DisplayPosition.x;
 385       PreviousPSXDisplay.DisplayPosition.y = PSXDisplay.DisplayPosition.y;
 386       PSXDisplay.DisplayPosition.x = sx;
 387       PSXDisplay.DisplayPosition.y = sy;
 388      }
 389
 390     PSXDisplay.DisplayEnd.x=
 391      PSXDisplay.DisplayPosition.x+ PSXDisplay.DisplayMode.x;
 392     PSXDisplay.DisplayEnd.y=
 393      PSXDisplay.DisplayPosition.y+ PSXDisplay.DisplayMode.y+PreviousPSXDisplay.DisplayModeNew.y;
 394
 395     PreviousPSXDisplay.DisplayEnd.x=
 396      PreviousPSXDisplay.DisplayPosition.x+ PSXDisplay.DisplayMode.x;
 397     PreviousPSXDisplay.DisplayEnd.y=
 398      PreviousPSXDisplay.DisplayPosition.y+ PSXDisplay.DisplayMode.y+PreviousPSXDisplay.DisplayModeNew.y;
 399
 400     bDisplayNotSet = TRUE;
 401
 402     if (!(PSXDisplay.Interlaced))
 403      {
 404       updateDisplay();
 405      }
 406     else
 407     if(PSXDisplay.InterlacedTest &&
 408        ((PreviousPSXDisplay.DisplayPosition.x != PSXDisplay.DisplayPosition.x)||
 409         (PreviousPSXDisplay.DisplayPosition.y != PSXDisplay.DisplayPosition.y)))
 410      PSXDisplay.InterlacedTest--;
 411     return;
 412    }
 413
 414   case 0x06:
 415    PSXDisplay.Range.x0=gdata & 0x7ff;      //0x3ff;
 416    PSXDisplay.Range.x1=(gdata>>12) & 0xfff;//0x7ff;
 417
 418    PSXDisplay.Range.x1-=PSXDisplay.Range.x0;
 419
 420    ChangeDispOffsetsX();
 421    return;
 422
 423   case 0x07:
 424    PreviousPSXDisplay.Height = PSXDisplay.Height;
 425
 426    PSXDisplay.Range.y0=gdata & 0x3ff;
 427    PSXDisplay.Range.y1=(gdata>>10) & 0x3ff;
 428
 429    PSXDisplay.Height = PSXDisplay.Range.y1 -
 430                        PSXDisplay.Range.y0 +
 431                        PreviousPSXDisplay.DisplayModeNew.y;
 432
 433    if (PreviousPSXDisplay.Height != PSXDisplay.Height)
 434     {
 435      PSXDisplay.DisplayModeNew.y=PSXDisplay.Height*PSXDisplay.Double;
 436      ChangeDispOffsetsY();
 437      updateDisplayIfChanged();
 438     }
 439    return;
 440
 441   case 0x08:
 442    PSXDisplay.DisplayModeNew.x = dispWidths[(gdata & 0x03) | ((gdata & 0x40) >> 4)];
 443
 444    if (gdata&0x04) PSXDisplay.Double=2;
 445    else            PSXDisplay.Double=1;
 446    PSXDisplay.DisplayModeNew.y = PSXDisplay.Height*PSXDisplay.Double;
 447
 448    ChangeDispOffsetsY();
 449
 450    PSXDisplay.PAL           = (gdata & 0x08)?TRUE:FALSE; // if 1 - PAL mode, else NTSC
 451    PSXDisplay.RGB24New      = (gdata & 0x10)?TRUE:FALSE; // if 1 - TrueColor
 452    PSXDisplay.InterlacedNew = (gdata & 0x20)?TRUE:FALSE; // if 1 - Interlace
 453
 454    PreviousPSXDisplay.InterlacedNew=FALSE;
 455    if (PSXDisplay.InterlacedNew)
 456     {
 457      if(!PSXDisplay.Interlaced)
 458       {
 459        PSXDisplay.InterlacedTest=2;
 460        PreviousPSXDisplay.DisplayPosition.x = PSXDisplay.DisplayPosition.x;
 461        PreviousPSXDisplay.DisplayPosition.y = PSXDisplay.DisplayPosition.y;
 462        PreviousPSXDisplay.InterlacedNew=TRUE;
 463       }
 464     }
 465    else
 466     {
 467      PSXDisplay.InterlacedTest=0;
 468     }
 469    updateDisplayIfChanged();
 470    return;
 471  }
 472 }
 473
 474 /////////////////////////////////////////////////////////////////////////////
 475
 476 #include <stdint.h>
 477
 478 #include "../gpulib/gpu.c"
 479
 480 static int is_opened;
 481
 482 static void set_vram(void *vram)
 483 {
 484  psxVub=vram;
 485  psxVuw=(unsigned short *)psxVub;
 486 }
 487
 488 int renderer_init(void)
 489 {
 490  set_vram(gpu.vram);
 491
 492  PSXDisplay.RGB24        = FALSE;                      // init some stuff
 493  PSXDisplay.Interlaced   = FALSE;
 494  PSXDisplay.DrawOffset.x = 0;
 495  PSXDisplay.DrawOffset.y = 0;
 496  PSXDisplay.DisplayMode.x= 320;
 497  PSXDisplay.DisplayMode.y= 240;
 498  PSXDisplay.Disabled     = FALSE;
 499  PSXDisplay.Range.x0=0;
 500  PSXDisplay.Range.x1=0;
 501  PSXDisplay.Double = 1;
 502
 503  lGPUstatusRet = 0x14802000;
 504
 505  return 0;
 506 }
 507
 508 void renderer_finish(void)
 509 {
 510 }
 511
 512 void renderer_notify_res_change(void)
 513 {
 514 }
 515
 516 extern const unsigned char cmd_lengths[256];
 517
 518 // XXX: mostly dupe code from soft peops
 519 int do_cmd_list(unsigned int *list, int list_len, int *last_cmd)
 520 {
 521   unsigned int cmd, len;
 522   unsigned int *list_start = list;
 523   unsigned int *list_end = list + list_len;
 524
 525   for (; list < list_end; list += 1 + len)
 526   {
 527     cmd = *list >> 24;
 528     len = cmd_lengths[cmd];
 529     if (list + 1 + len > list_end) {
 530       cmd = -1;
 531       break;
 532     }
 533
 534 #ifndef TEST
 535     if (cmd == 0xa0 || cmd == 0xc0)
 536       break; // image i/o, forward to upper layer
 537     else if ((cmd & 0xf8) == 0xe0)
 538       gpu.ex_regs[cmd & 7] = list[0];
 539 #endif
 540
 541     primTableJ[cmd]((void *)list);
 542
 543     switch(cmd)
 544     {
 545       case 0x48 ... 0x4F:
 546       {
 547         uint32_t num_vertexes = 2;
 548         uint32_t *list_position = &(list[3]);
 549
 550         while(1)
 551         {
 552           if((*list_position & 0xf000f000) == 0x50005000 || list_position >= list_end)
 553             break;
 554
 555           list_position++;
 556           num_vertexes++;
 557         }
 558
 559         len += (num_vertexes - 2);
 560         break;
 561       }
 562
 563       case 0x58 ... 0x5F:
 564       {
 565         uint32_t num_vertexes = 2;
 566         uint32_t *list_position = &(list[4]);
 567
 568         while(1)
 569         {
 570           if((*list_position & 0xf000f000) == 0x50005000 || list_position >= list_end)
 571             break;
 572
 573           list_position += 2;
 574           num_vertexes++;
 575         }
 576
 577         len += (num_vertexes - 2) * 2;
 578         break;
 579       }
 580
 581 #ifdef TEST
 582       case 0xA0:          //  sys -> vid
 583       {
 584         short *slist = (void *)list;
 585         uint32_t load_width = slist[4];
 586         uint32_t load_height = slist[5];
 587         uint32_t load_size = load_width * load_height;
 588
 589         len += load_size / 2;
 590         break;
 591       }
 592 #endif
 593     }
 594   }
 595
 596   gpu.ex_regs[1] &= ~0x1ff;
 597   gpu.ex_regs[1] |= lGPUstatusRet & 0x1ff;
 598
 599   *last_cmd = cmd;
 600   return list - list_start;
 601 }
 602
 603 void renderer_sync_ecmds(uint32_t *ecmds)
 604 {
 605   cmdTexturePage((unsigned char *)&ecmds[1]);
 606   cmdTextureWindow((unsigned char *)&ecmds[2]);
 607   cmdDrawAreaStart((unsigned char *)&ecmds[3]);
 608   cmdDrawAreaEnd((unsigned char *)&ecmds[4]);
 609   cmdDrawOffset((unsigned char *)&ecmds[5]);
 610   cmdSTP((unsigned char *)&ecmds[6]);
 611 }
 612
 613 void renderer_update_caches(int x, int y, int w, int h)
 614 {
 615  VRAMWrite.x = x;
 616  VRAMWrite.y = y;
 617  VRAMWrite.Width = w;
 618  VRAMWrite.Height = h;
 619  if(is_opened)
 620   CheckWriteUpdate();
 621 }
 622
 623 void renderer_flush_queues(void)
 624 {
 625 }
 626
 627 void renderer_set_interlace(int enable, int is_odd)
 628 {
 629 }
 630
 631 int vout_init(void)
 632 {
 633   return 0;
 634 }
 635
 636 int vout_finish(void)
 637 {
 638   return 0;
 639 }
 640
 641 void vout_update(void)
 642 {
 643  if(PSXDisplay.Interlaced)                            // interlaced mode?
 644  {
 645   if(PSXDisplay.DisplayMode.x>0 && PSXDisplay.DisplayMode.y>0)
 646    {
 647     updateDisplay();                                  // -> swap buffers (new frame)
 648    }
 649  }
 650  else if(bRenderFrontBuffer)                          // no interlace mode? and some stuff in front has changed?
 651  {
 652   updateFrontDisplay();                               // -> update front buffer
 653  }
 654 }
 655
 656 void vout_blank(void)
 657 {
 658 }
 659
 660 void vout_set_config(const struct rearmed_cbs *cbs)
 661 {
 662 }
 663
 664 static struct rearmed_cbs *cbs;
 665
 666 long GPUopen(void **dpy)
 667 {
 668  int ret;
 669
 670  iResX = cbs->screen_w;
 671  iResY = cbs->screen_h;
 672  rRatioRect.left   = rRatioRect.top=0;
 673  rRatioRect.right  = iResX;
 674  rRatioRect.bottom = iResY;
 675
 676  bDisplayNotSet = TRUE;
 677  bSetClip = TRUE;
 678  CSTEXTURE = CSVERTEX = CSCOLOR = 0;
 679
 680  InitializeTextureStore();                             // init texture mem
 681
 682  ret = GLinitialize();
 683  MakeDisplayLists();
 684
 685  is_opened = 1;
 686  return ret;
 687 }
 688
 689 long GPUclose(void)
 690 {
 691  is_opened = 0;
 692
 693  KillDisplayLists();
 694  GLcleanup();                                          // close OGL
 695  return 0;
 696 }
 697
 698 /* acting as both renderer and vout handler here .. */
 699 void renderer_set_config(const struct rearmed_cbs *cbs_)
 700 {
 701  cbs = (void *)cbs_; // ugh..
 702
 703  iOffscreenDrawing = 0;
 704  iZBufferDepth = 0;
 705  iFrameReadType = 0;
 706  bKeepRatio = TRUE;
 707
 708  dwActFixes = cbs->gpu_peopsgl.dwActFixes;
 709  bDrawDither = cbs->gpu_peopsgl.bDrawDither;
 710  iFilterType = cbs->gpu_peopsgl.iFilterType;
 711  iFrameTexType = cbs->gpu_peopsgl.iFrameTexType;
 712  iUseMask = cbs->gpu_peopsgl.iUseMask;
 713  bOpaquePass = cbs->gpu_peopsgl.bOpaquePass;
 714  bAdvancedBlend = cbs->gpu_peopsgl.bAdvancedBlend;
 715  bUseFastMdec = cbs->gpu_peopsgl.bUseFastMdec;
 716  iTexGarbageCollection = cbs->gpu_peopsgl.iTexGarbageCollection;
 717  iVRamSize = cbs->gpu_peopsgl.iVRamSize;
 718
 719  set_vram(gpu.vram);
 720 }
 721
 722 void SetAspectRatio(void)
 723 {
 724  if (cbs->pl_get_layer_pos)
 725   cbs->pl_get_layer_pos(&rRatioRect.left, &rRatioRect.top, &rRatioRect.right, &rRatioRect.bottom);
 726
 727  glScissor(rRatioRect.left,
 728            iResY-(rRatioRect.top+rRatioRect.bottom),
 729            rRatioRect.right,rRatioRect.bottom);
 730  glViewport(rRatioRect.left,
 731            iResY-(rRatioRect.top+rRatioRect.bottom),
 732            rRatioRect.right,rRatioRect.bottom);
 733  glError();
 734 }
 735
 736 static void fps_update(void)
 737 {
 738  char buf[16];
 739
 740  cbs->flip_cnt++;
 741  if(cbs->flips_per_sec != 0)
 742  {
 743   snprintf(buf,sizeof(buf),"%2d %4.1f",cbs->flips_per_sec,cbs->vsps_cur);
 744   DisplayText(buf, 0);
 745  }
 746  if(cbs->cpu_usage != 0)
 747  {
 748   snprintf(buf,sizeof(buf),"%3d",cbs->cpu_usage);
 749   DisplayText(buf, 1);
 750  }
 751 }