[pcsx_rearmed.git] / plugins / gpu-gles / gpulib_if.c

/***************************************************************************
    begin                : Sun Mar 08 2009
    copyright            : (C) 1999-2009 by Pete Bernert
    email                : BlackDove@addcom.de

    PCSX rearmed rework (C) notaz, 2012
 ***************************************************************************/

/***************************************************************************
 *                                                                         *
 *   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.                                              *
 *                                                                         *
 ***************************************************************************/

#include "gpuDraw.c"
#include "gpuTexture.c"
#include "gpuPrim.c"
#include "hud.c"

static const short dispWidths[8] = {256,320,512,640,368,384,512,640};
short g_m1,g_m2,g_m3;
short DrawSemiTrans;

short          ly0,lx0,ly1,lx1,ly2,lx2,ly3,lx3;        // global psx vertex coords
long           GlobalTextAddrX,GlobalTextAddrY,GlobalTextTP;
long           GlobalTextREST,GlobalTextABR,GlobalTextPAGE;

unsigned long dwGPUVersion;
int           iGPUHeight=512;
int           iGPUHeightMask=511;
int           GlobalTextIL;

unsigned char  *psxVub;
unsigned short *psxVuw;

GLfloat         gl_z=0.0f;
BOOL            bNeedInterlaceUpdate;
BOOL            bNeedRGB24Update;
BOOL            bChangeWinMode;
long            lGPUstatusRet;
unsigned long   ulGPUInfoVals[16];
VRAMLoad_t      VRAMWrite;
VRAMLoad_t      VRAMRead;
int             iDataWriteMode;
int             iDataReadMode;

long            lClearOnSwap;
long            lClearOnSwapColor;
BOOL            bSkipNextFrame;

PSXDisplay_t    PSXDisplay;
PSXDisplay_t    PreviousPSXDisplay;
TWin_t          TWin;
BOOL            bDisplayNotSet;
BOOL            bNeedWriteUpload;
int             iLastRGB24;

// don't do GL vram read
void CheckVRamRead(int x, int y, int dx, int dy, bool bFront)
{
}

void CheckVRamReadEx(int x, int y, int dx, int dy)
{
}

void SetFixes(void)
{
}

static void PaintBlackBorders(void)
{
 short s;
 glDisable(GL_SCISSOR_TEST); glError();
 if(bTexEnabled) {glDisable(GL_TEXTURE_2D);bTexEnabled=FALSE;} glError();
 if(bOldSmoothShaded) {glShadeModel(GL_FLAT);bOldSmoothShaded=FALSE;} glError();
 if(bBlendEnable)     {glDisable(GL_BLEND);bBlendEnable=FALSE;} glError();
 glDisable(GL_ALPHA_TEST); glError();

 glEnable(GL_ALPHA_TEST); glError();
 glEnable(GL_SCISSOR_TEST); glError();
}

static void fps_update(void);

void updateDisplay(void)
{
 bFakeFrontBuffer=FALSE;
 bRenderFrontBuffer=FALSE;

 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(PSXDisplay.Disabled)                              // display disabled?
 {
  // moved here
  glDisable(GL_SCISSOR_TEST); glError();                       
  glClearColor(0,0,0,128); glError();                 // -> clear whole backbuffer
  glClear(uiBufferBits); glError();
  glEnable(GL_SCISSOR_TEST); glError();                       
  gl_z=0.0f;
  bDisplayNotSet = TRUE;
 }

 if(iDrawnSomething)
 {
  fps_update();
  eglSwapBuffers(display, surface);
  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); glError();                       
  glClearColor(r,g,b,128); glError();                 // -> clear 
  glClear(uiBufferBits); glError();
  glEnable(GL_SCISSOR_TEST); glError();                       
  lClearOnSwap=0;                                     // -> done
 }
 else 
 {
  if(iZBufferDepth)                                   // clear zbuffer as well (if activated)
   {
    glDisable(GL_SCISSOR_TEST); glError();
    glClear(GL_DEPTH_BUFFER_BIT); glError();
    glEnable(GL_SCISSOR_TEST); glError();
   }
 }
 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);
   }
 }
}

void updateFrontDisplay(void)
{
 if(PreviousPSXDisplay.Range.x0||
    PreviousPSXDisplay.Range.y0)
  PaintBlackBorders();

 bFakeFrontBuffer=FALSE;
 bRenderFrontBuffer=FALSE;

 if(iDrawnSomething)                                  // linux:
  eglSwapBuffers(display, surface);
}

static 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
 }
}

////////////////////////////////////////////////////////////////////////

static 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
 }
}

static 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(); glError();
  glOrtho(0,PSXDisplay.DisplayModeNew.x,              // -> new psx resolution
            PSXDisplay.DisplayModeNew.y, 0, -1, 1); glError();
  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(bUp) updateDisplay();                              // yeah, real update (swap buffer)
}

#define GPUwriteStatus_ext GPUwriteStatus_ext // for gpulib to see this
void GPUwriteStatus_ext(unsigned long gdata)
{
switch((gdata>>24)&0xff)
 {
  case 0x00:
   PSXDisplay.Disabled=1;
   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;

  case 0x03:  
   PreviousPSXDisplay.Disabled = PSXDisplay.Disabled;
   PSXDisplay.Disabled = (gdata & 1);

   if (iOffscreenDrawing==4 &&
        PreviousPSXDisplay.Disabled && 
       !(PSXDisplay.Disabled))
    {

     if(!PSXDisplay.RGB24)
      {
       PrepareFullScreenUpload(TRUE);
       UploadScreen(TRUE); 
       updateDisplay();
      }
    }
   return;

  case 0x05: 
   {
    short sx=(short)(gdata & 0x3ff);
    short sy;

    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(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;
   }

  case 0x06:
   PSXDisplay.Range.x0=gdata & 0x7ff;      //0x3ff;
   PSXDisplay.Range.x1=(gdata>>12) & 0xfff;//0x7ff;

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

   ChangeDispOffsetsX();
   return;

  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;

  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

   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;
      }
    }
   else 
    {
     PSXDisplay.InterlacedTest=0;
    }
   updateDisplayIfChanged();
   return;
 }
}

/////////////////////////////////////////////////////////////////////////////

#include <stdint.h>

#include "../gpulib/gpu.c"

static int is_opened;

int renderer_init(void)
{
 psxVub=(void *)gpu.vram;
 psxVuw=(unsigned short *)psxVub;

 PSXDisplay.RGB24        = FALSE;                      // init some stuff
 PSXDisplay.Interlaced   = FALSE;
 PSXDisplay.DrawOffset.x = 0;
 PSXDisplay.DrawOffset.y = 0;
 PSXDisplay.DisplayMode.x= 320;
 PSXDisplay.DisplayMode.y= 240;
 PSXDisplay.Disabled     = FALSE;
 PSXDisplay.Range.x0=0;
 PSXDisplay.Range.x1=0;
 PSXDisplay.Double = 1;

 lGPUstatusRet = 0x14802000;

 return 0;
}

extern const unsigned char cmd_lengths[256];

// XXX: mostly dupe code from soft peops
int do_cmd_list(unsigned int *list, int list_len, int *last_cmd)
{
  unsigned int cmd, len;
  unsigned int *list_start = list;
  unsigned int *list_end = list + list_len;

  for (; list < list_end; list += 1 + len)
  {
    cmd = *list >> 24;
    len = cmd_lengths[cmd];
    if (list + 1 + len > list_end) {
      cmd = -1;
      break;
    }

#ifndef TEST
    if (cmd == 0xa0 || cmd == 0xc0)
      break; // image i/o, forward to upper layer
    else if ((cmd & 0xf8) == 0xe0)
      gpu.ex_regs[cmd & 7] = list[0];
#endif

    primTableJ[cmd]((void *)list);

    switch(cmd)
    {
      case 0x48 ... 0x4F:
      {
        uint32_t num_vertexes = 2;
        uint32_t *list_position = &(list[3]);

        while(1)
        {
          if((*list_position & 0xf000f000) == 0x50005000 || list_position >= list_end)
            break;

          list_position++;
          num_vertexes++;
        }

        len += (num_vertexes - 2);
        break;
      }

      case 0x58 ... 0x5F:
      {
        uint32_t num_vertexes = 2;
        uint32_t *list_position = &(list[4]);

        while(1)
        {
          if((*list_position & 0xf000f000) == 0x50005000 || list_position >= list_end)
            break;

          list_position += 2;
          num_vertexes++;
        }

        len += (num_vertexes - 2) * 2;
        break;
      }

#ifdef TEST
      case 0xA0:          //  sys -> vid
      {
        short *slist = (void *)list;
        uint32_t load_width = slist[4];
        uint32_t load_height = slist[5];
        uint32_t load_size = load_width * load_height;

        len += load_size / 2;
        break;
      }
#endif
    }
  }

  gpu.ex_regs[1] &= ~0x1ff;
  gpu.ex_regs[1] |= lGPUstatusRet & 0x1ff;

  *last_cmd = cmd;
  return list - list_start;
}

void renderer_sync_ecmds(uint32_t *ecmds)
{
  cmdTexturePage((unsigned char *)&ecmds[1]);
  cmdTextureWindow((unsigned char *)&ecmds[2]);
  cmdDrawAreaStart((unsigned char *)&ecmds[3]);
  cmdDrawAreaEnd((unsigned char *)&ecmds[4]);
  cmdDrawOffset((unsigned char *)&ecmds[5]);
  cmdSTP((unsigned char *)&ecmds[6]);
}

void renderer_update_caches(int x, int y, int w, int h)
{
 VRAMWrite.x = x;
 VRAMWrite.y = y;
 VRAMWrite.Width = w;
 VRAMWrite.Height = h;
 if(is_opened)
  CheckWriteUpdate();
}

void renderer_flush_queues(void)
{
}

void renderer_set_interlace(int enable, int is_odd)
{
}

int vout_init(void)
{
  return 0;
}

int vout_finish(void)
{
  return 0;
}

void vout_update(void)
{
 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
 }
}

static struct rearmed_cbs *cbs;

long GPUopen(void **dpy)
{
 int ret;

 iResX = cbs->screen_w;
 iResY = cbs->screen_h;
 rRatioRect.left   = rRatioRect.top=0;
 rRatioRect.right  = iResX;
 rRatioRect.bottom = iResY;

 bDisplayNotSet = TRUE; 
 bSetClip = TRUE;
 CSTEXTURE = CSVERTEX = CSCOLOR = 0;

 InitializeTextureStore();                             // init texture mem

 ret = GLinitialize();
 MakeDisplayLists();

 is_opened = 1;
 return ret;
}

long GPUclose(void)
{
 is_opened = 0;

 KillDisplayLists();
 GLcleanup();                                          // close OGL
 return 0;
}

/* acting as both renderer and vout handler here .. */
void renderer_set_config(const struct rearmed_cbs *cbs_)
{
 cbs = (void *)cbs_; // ugh..

 iOffscreenDrawing = 0;
 iZBufferDepth = 0;
 iFrameReadType = 0;
 bKeepRatio = TRUE;

 dwActFixes = cbs->gpu_peopsgl.dwActFixes;
 bDrawDither = cbs->gpu_peopsgl.bDrawDither;
 iFilterType = cbs->gpu_peopsgl.iFilterType;
 iFrameTexType = cbs->gpu_peopsgl.iFrameTexType;
 iUseMask = cbs->gpu_peopsgl.iUseMask;
 bOpaquePass = cbs->gpu_peopsgl.bOpaquePass;
 bAdvancedBlend = cbs->gpu_peopsgl.bAdvancedBlend;
 bUseFastMdec = cbs->gpu_peopsgl.bUseFastMdec;
 iTexGarbageCollection = cbs->gpu_peopsgl.iTexGarbageCollection;
 iVRamSize = cbs->gpu_peopsgl.iVRamSize;
}

void vout_set_config(const struct rearmed_cbs *cbs)
{
}

void SetAspectRatio(void)
{
 cbs->pl_get_layer_pos(&rRatioRect.left, &rRatioRect.top, &rRatioRect.right, &rRatioRect.bottom);

 glScissor(rRatioRect.left,
           iResY-(rRatioRect.top+rRatioRect.bottom),
	   rRatioRect.right,rRatioRect.bottom);
 glViewport(rRatioRect.left,
           iResY-(rRatioRect.top+rRatioRect.bottom),
           rRatioRect.right,rRatioRect.bottom);
 glError();
}

static void fps_update(void)
{
 char buf[16];

 cbs->flip_cnt++;
 if(cbs->flips_per_sec != 0)
 {
  snprintf(buf,sizeof(buf),"%2d %4.1f",cbs->flips_per_sec,cbs->vsps_cur);
  DisplayText(buf, 0);
 }
 if(cbs->cpu_usage != 0)
 {
  snprintf(buf,sizeof(buf),"%3d",cbs->cpu_usage);
  DisplayText(buf, 1);
 }
}
Commit	Line	Data
7890a708	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"
0cc470cd	22	#include "hud.c"
7890a708	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
0cc470cd	88	static void fps_update(void);
0cc470cd	89
7890a708	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)
0cc470cd	126	{
0cc470cd	127	fps_update();
7890a708	128	eglSwapBuffers(display, surface);
0cc470cd	129	iDrawnSomething=0;
0cc470cd	130	}
7890a708	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	int renderer_init(void)
483	{
484	psxVub=(void *)gpu.vram;
485	psxVuw=(unsigned short *)psxVub;
486
487	PSXDisplay.RGB24 = FALSE; // init some stuff
488	PSXDisplay.Interlaced = FALSE;
489	PSXDisplay.DrawOffset.x = 0;
490	PSXDisplay.DrawOffset.y = 0;
491	PSXDisplay.DisplayMode.x= 320;
492	PSXDisplay.DisplayMode.y= 240;
493	PSXDisplay.Disabled = FALSE;
494	PSXDisplay.Range.x0=0;
495	PSXDisplay.Range.x1=0;
496	PSXDisplay.Double = 1;
497
498	lGPUstatusRet = 0x14802000;
499
500	return 0;
501	}
502
503	extern const unsigned char cmd_lengths[256];
504
b243416b	505	// XXX: mostly dupe code from soft peops
b243416b	506	int do_cmd_list(unsigned int list, int list_len, int last_cmd)
7890a708	507	{
7890a708	508	unsigned int cmd, len;
b243416b	509	unsigned int *list_start = list;
7890a708	510	unsigned int *list_end = list + list_len;
	511
	512	for (; list < list_end; list += 1 + len)
	513	{
	514	cmd = *list >> 24;
	515	len = cmd_lengths[cmd];
b243416b	516	if (list + 1 + len > list_end) {
	517	cmd = -1;
	518	break;
	519	}
	520
	521	#ifndef TEST
	522	if (cmd == 0xa0 \|\| cmd == 0xc0)
	523	break; // image i/o, forward to upper layer
	524	else if ((cmd & 0xf8) == 0xe0)
	525	gpu.ex_regs[cmd & 7] = list[0];
	526	#endif
7890a708	527
	528	primTableJ[cmd]((void *)list);
	529
	530	switch(cmd)
	531	{
	532	case 0x48 ... 0x4F:
	533	{
b243416b	534	uint32_t num_vertexes = 2;
b243416b	535	uint32_t *list_position = &(list[3]);
7890a708	536
	537	while(1)
	538	{
	539	if((*list_position & 0xf000f000) == 0x50005000 \|\| list_position >= list_end)
	540	break;
	541
	542	list_position++;
	543	num_vertexes++;
	544	}
	545
b243416b	546	len += (num_vertexes - 2);
7890a708	547	break;
	548	}
	549
	550	case 0x58 ... 0x5F:
	551	{
b243416b	552	uint32_t num_vertexes = 2;
b243416b	553	uint32_t *list_position = &(list[4]);
7890a708	554
	555	while(1)
	556	{
	557	if((*list_position & 0xf000f000) == 0x50005000 \|\| list_position >= list_end)
	558	break;
	559
	560	list_position += 2;
	561	num_vertexes++;
	562	}
	563
b243416b	564	len += (num_vertexes - 2) * 2;
7890a708	565	break;
	566	}
	567
	568	#ifdef TEST
	569	case 0xA0: // sys -> vid
	570	{
	571	short slist = (void )list;
	572	uint32_t load_width = slist[4];
	573	uint32_t load_height = slist[5];
	574	uint32_t load_size = load_width * load_height;
	575
	576	len += load_size / 2;
	577	break;
	578	}
	579	#endif
	580	}
	581	}
b243416b	582
	583	gpu.ex_regs[1] &= ~0x1ff;
	584	gpu.ex_regs[1] \|= lGPUstatusRet & 0x1ff;
	585
	586	*last_cmd = cmd;
	587	return list - list_start;
7890a708	588	}
	589
	590	void renderer_sync_ecmds(uint32_t *ecmds)
	591	{
	592	cmdTexturePage((unsigned char *)&ecmds[1]);
	593	cmdTextureWindow((unsigned char *)&ecmds[2]);
	594	cmdDrawAreaStart((unsigned char *)&ecmds[3]);
	595	cmdDrawAreaEnd((unsigned char *)&ecmds[4]);
	596	cmdDrawOffset((unsigned char *)&ecmds[5]);
	597	cmdSTP((unsigned char *)&ecmds[6]);
	598	}
	599
	600	void renderer_update_caches(int x, int y, int w, int h)
	601	{
	602	VRAMWrite.x = x;
	603	VRAMWrite.y = y;
	604	VRAMWrite.Width = w;
	605	VRAMWrite.Height = h;
	606	if(is_opened)
	607	CheckWriteUpdate();
	608	}
	609
	610	void renderer_flush_queues(void)
	611	{
	612	}
	613
	614	void renderer_set_interlace(int enable, int is_odd)
	615	{
	616	}
	617
	618	int vout_init(void)
	619	{
	620	return 0;
	621	}
	622
	623	int vout_finish(void)
	624	{
	625	return 0;
	626	}
	627
	628	void vout_update(void)
	629	{
	630	if(PSXDisplay.Interlaced) // interlaced mode?
	631	{
	632	if(PSXDisplay.DisplayMode.x>0 && PSXDisplay.DisplayMode.y>0)
	633	{
	634	updateDisplay(); // -> swap buffers (new frame)
	635	}
	636	}
	637	else if(bRenderFrontBuffer) // no interlace mode? and some stuff in front has changed?
	638	{
	639	updateFrontDisplay(); // -> update front buffer
	640	}
	641	}
	642
bb88ec28	643	static struct rearmed_cbs *cbs;
bb88ec28	644
7890a708	645	long GPUopen(void **dpy)
7890a708	646	{
0cc470cd	647	int ret;
0cc470cd	648
bb88ec28	649	iResX = cbs->screen_w;
bb88ec28	650	iResY = cbs->screen_h;
7890a708	651	rRatioRect.left = rRatioRect.top=0;
	652	rRatioRect.right = iResX;
	653	rRatioRect.bottom = iResY;
	654
	655	bDisplayNotSet = TRUE;
	656	bSetClip = TRUE;
	657	CSTEXTURE = CSVERTEX = CSCOLOR = 0;
	658
	659	InitializeTextureStore(); // init texture mem
7890a708	660
0cc470cd	661	ret = GLinitialize();
	662	MakeDisplayLists();
	663
	664	is_opened = 1;
	665	return ret;
7890a708	666	}
	667
	668	long GPUclose(void)
	669	{
	670	is_opened = 0;
	671
0cc470cd	672	KillDisplayLists();
7890a708	673	GLcleanup(); // close OGL
	674	return 0;
	675	}
	676
7890a708	677	/* acting as both renderer and vout handler here .. */
	678	void renderer_set_config(const struct rearmed_cbs *cbs_)
	679	{
0cc470cd	680	cbs = (void *)cbs_; // ugh..
7890a708	681
	682	iOffscreenDrawing = 0;
	683	iZBufferDepth = 0;
	684	iFrameReadType = 0;
	685	bKeepRatio = TRUE;
	686
	687	dwActFixes = cbs->gpu_peopsgl.dwActFixes;
	688	bDrawDither = cbs->gpu_peopsgl.bDrawDither;
	689	iFilterType = cbs->gpu_peopsgl.iFilterType;
	690	iFrameTexType = cbs->gpu_peopsgl.iFrameTexType;
	691	iUseMask = cbs->gpu_peopsgl.iUseMask;
	692	bOpaquePass = cbs->gpu_peopsgl.bOpaquePass;
	693	bAdvancedBlend = cbs->gpu_peopsgl.bAdvancedBlend;
	694	bUseFastMdec = cbs->gpu_peopsgl.bUseFastMdec;
	695	iTexGarbageCollection = cbs->gpu_peopsgl.iTexGarbageCollection;
	696	iVRamSize = cbs->gpu_peopsgl.iVRamSize;
	697	}
	698
	699	void vout_set_config(const struct rearmed_cbs *cbs)
	700	{
	701	}
	702
	703	void SetAspectRatio(void)
	704	{
	705	cbs->pl_get_layer_pos(&rRatioRect.left, &rRatioRect.top, &rRatioRect.right, &rRatioRect.bottom);
	706
	707	glScissor(rRatioRect.left,
	708	iResY-(rRatioRect.top+rRatioRect.bottom),
	709	rRatioRect.right,rRatioRect.bottom);
	710	glViewport(rRatioRect.left,
	711	iResY-(rRatioRect.top+rRatioRect.bottom),
	712	rRatioRect.right,rRatioRect.bottom);
	713	glError();
	714	}
0cc470cd	715
	716	static void fps_update(void)
	717	{
	718	char buf[16];
	719
	720	cbs->flip_cnt++;
	721	if(cbs->flips_per_sec != 0)
	722	{
	723	snprintf(buf,sizeof(buf),"%2d %4.1f",cbs->flips_per_sec,cbs->vsps_cur);
	724	DisplayText(buf, 0);
	725	}
	726	if(cbs->cpu_usage != 0)
	727	{
	728	snprintf(buf,sizeof(buf),"%3d",cbs->cpu_usage);
	729	DisplayText(buf, 1);
	730	}
	731	}