[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;

static void set_vram(void *vram)
{
 psxVub=vram;
 psxVuw=(unsigned short *)psxVub;
}

int renderer_init(void)
{
 set_vram(gpu.vram);

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

void renderer_finish(void)
{
}

void renderer_notify_res_change(void)
{
}

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 >= list_end) {
            cmd = -1;
            goto breakloop;
          }

          if((*list_position & 0xf000f000) == 0x50005000)
            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 >= list_end) {
            cmd = -1;
            goto breakloop;
          }

          if((*list_position & 0xf000f000) == 0x50005000)
            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
    }
  }

breakloop:
  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
 }
}

void vout_blank(void)
{
}

void vout_set_config(const struct rearmed_cbs *cbs)
{
}

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;
 if (cbs->pl_set_gpu_caps)
  cbs->pl_set_gpu_caps(GPU_CAP_OWNS_DISPLAY);

 set_vram(gpu.vram);
}

void SetAspectRatio(void)
{
 if (cbs->pl_get_layer_pos)
  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
9ee0fd5b	482	static void set_vram(void *vram)
7890a708	483	{
9ee0fd5b	484	psxVub=vram;
7890a708	485	psxVuw=(unsigned short *)psxVub;
9ee0fd5b	486	}
	487
	488	int renderer_init(void)
	489	{
	490	set_vram(gpu.vram);
7890a708	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
e929dec5	508	void renderer_finish(void)
	509	{
	510	}
	511
	512	void renderer_notify_res_change(void)
	513	{
	514	}
	515
7890a708	516	extern const unsigned char cmd_lengths[256];
7890a708	517
b243416b	518	// XXX: mostly dupe code from soft peops
b243416b	519	int do_cmd_list(unsigned int list, int list_len, int last_cmd)
7890a708	520	{
7890a708	521	unsigned int cmd, len;
b243416b	522	unsigned int *list_start = list;
7890a708	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];
b243416b	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
7890a708	540
	541	primTableJ[cmd]((void *)list);
	542
	543	switch(cmd)
	544	{
	545	case 0x48 ... 0x4F:
	546	{
b243416b	547	uint32_t num_vertexes = 2;
b243416b	548	uint32_t *list_position = &(list[3]);
7890a708	549
	550	while(1)
	551	{
804789d7	552	if(list_position >= list_end) {
	553	cmd = -1;
	554	goto breakloop;
	555	}
	556
	557	if((*list_position & 0xf000f000) == 0x50005000)
7890a708	558	break;
	559
	560	list_position++;
	561	num_vertexes++;
	562	}
	563
b243416b	564	len += (num_vertexes - 2);
7890a708	565	break;
	566	}
	567
	568	case 0x58 ... 0x5F:
	569	{
b243416b	570	uint32_t num_vertexes = 2;
b243416b	571	uint32_t *list_position = &(list[4]);
7890a708	572
	573	while(1)
	574	{
804789d7	575	if(list_position >= list_end) {
	576	cmd = -1;
	577	goto breakloop;
	578	}
	579
	580	if((*list_position & 0xf000f000) == 0x50005000)
7890a708	581	break;
	582
	583	list_position += 2;
	584	num_vertexes++;
	585	}
	586
b243416b	587	len += (num_vertexes - 2) * 2;
7890a708	588	break;
	589	}
	590
	591	#ifdef TEST
	592	case 0xA0: // sys -> vid
	593	{
	594	short slist = (void )list;
	595	uint32_t load_width = slist[4];
	596	uint32_t load_height = slist[5];
	597	uint32_t load_size = load_width * load_height;
	598
	599	len += load_size / 2;
	600	break;
	601	}
	602	#endif
	603	}
	604	}
b243416b	605
804789d7	606	breakloop:
b243416b	607	gpu.ex_regs[1] &= ~0x1ff;
	608	gpu.ex_regs[1] \|= lGPUstatusRet & 0x1ff;
	609
	610	*last_cmd = cmd;
	611	return list - list_start;
7890a708	612	}
	613
	614	void renderer_sync_ecmds(uint32_t *ecmds)
	615	{
	616	cmdTexturePage((unsigned char *)&ecmds[1]);
	617	cmdTextureWindow((unsigned char *)&ecmds[2]);
	618	cmdDrawAreaStart((unsigned char *)&ecmds[3]);
	619	cmdDrawAreaEnd((unsigned char *)&ecmds[4]);
	620	cmdDrawOffset((unsigned char *)&ecmds[5]);
	621	cmdSTP((unsigned char *)&ecmds[6]);
	622	}
	623
	624	void renderer_update_caches(int x, int y, int w, int h)
	625	{
	626	VRAMWrite.x = x;
	627	VRAMWrite.y = y;
	628	VRAMWrite.Width = w;
	629	VRAMWrite.Height = h;
	630	if(is_opened)
	631	CheckWriteUpdate();
	632	}
	633
	634	void renderer_flush_queues(void)
	635	{
	636	}
	637
	638	void renderer_set_interlace(int enable, int is_odd)
	639	{
	640	}
	641
	642	int vout_init(void)
	643	{
	644	return 0;
	645	}
	646
	647	int vout_finish(void)
	648	{
	649	return 0;
	650	}
	651
	652	void vout_update(void)
	653	{
	654	if(PSXDisplay.Interlaced) // interlaced mode?
	655	{
	656	if(PSXDisplay.DisplayMode.x>0 && PSXDisplay.DisplayMode.y>0)
	657	{
	658	updateDisplay(); // -> swap buffers (new frame)
	659	}
	660	}
	661	else if(bRenderFrontBuffer) // no interlace mode? and some stuff in front has changed?
	662	{
	663	updateFrontDisplay(); // -> update front buffer
	664	}
	665	}
	666
4ea086f6	667	void vout_blank(void)
	668	{
	669	}
	670
	671	void vout_set_config(const struct rearmed_cbs *cbs)
	672	{
	673	}
	674
bb88ec28	675	static struct rearmed_cbs *cbs;
bb88ec28	676
7890a708	677	long GPUopen(void **dpy)
7890a708	678	{
0cc470cd	679	int ret;
0cc470cd	680
bb88ec28	681	iResX = cbs->screen_w;
bb88ec28	682	iResY = cbs->screen_h;
7890a708	683	rRatioRect.left = rRatioRect.top=0;
	684	rRatioRect.right = iResX;
	685	rRatioRect.bottom = iResY;
	686
	687	bDisplayNotSet = TRUE;
	688	bSetClip = TRUE;
	689	CSTEXTURE = CSVERTEX = CSCOLOR = 0;
	690
	691	InitializeTextureStore(); // init texture mem
7890a708	692
0cc470cd	693	ret = GLinitialize();
	694	MakeDisplayLists();
	695
	696	is_opened = 1;
	697	return ret;
7890a708	698	}
	699
	700	long GPUclose(void)
	701	{
	702	is_opened = 0;
	703
0cc470cd	704	KillDisplayLists();
7890a708	705	GLcleanup(); // close OGL
	706	return 0;
	707	}
	708
7890a708	709	/* acting as both renderer and vout handler here .. */
	710	void renderer_set_config(const struct rearmed_cbs *cbs_)
	711	{
0cc470cd	712	cbs = (void *)cbs_; // ugh..
7890a708	713
	714	iOffscreenDrawing = 0;
	715	iZBufferDepth = 0;
	716	iFrameReadType = 0;
	717	bKeepRatio = TRUE;
	718
	719	dwActFixes = cbs->gpu_peopsgl.dwActFixes;
	720	bDrawDither = cbs->gpu_peopsgl.bDrawDither;
	721	iFilterType = cbs->gpu_peopsgl.iFilterType;
	722	iFrameTexType = cbs->gpu_peopsgl.iFrameTexType;
	723	iUseMask = cbs->gpu_peopsgl.iUseMask;
	724	bOpaquePass = cbs->gpu_peopsgl.bOpaquePass;
	725	bAdvancedBlend = cbs->gpu_peopsgl.bAdvancedBlend;
	726	bUseFastMdec = cbs->gpu_peopsgl.bUseFastMdec;
	727	iTexGarbageCollection = cbs->gpu_peopsgl.iTexGarbageCollection;
	728	iVRamSize = cbs->gpu_peopsgl.iVRamSize;
fa56d360	729	if (cbs->pl_set_gpu_caps)
fa56d360	730	cbs->pl_set_gpu_caps(GPU_CAP_OWNS_DISPLAY);
9ee0fd5b	731
9ee0fd5b	732	set_vram(gpu.vram);
7890a708	733	}
7890a708	734
7890a708	735	void SetAspectRatio(void)
7890a708	736	{
38c2028e	737	if (cbs->pl_get_layer_pos)
38c2028e	738	cbs->pl_get_layer_pos(&rRatioRect.left, &rRatioRect.top, &rRatioRect.right, &rRatioRect.bottom);
7890a708	739
	740	glScissor(rRatioRect.left,
	741	iResY-(rRatioRect.top+rRatioRect.bottom),
	742	rRatioRect.right,rRatioRect.bottom);
	743	glViewport(rRatioRect.left,
	744	iResY-(rRatioRect.top+rRatioRect.bottom),
	745	rRatioRect.right,rRatioRect.bottom);
	746	glError();
	747	}
0cc470cd	748
	749	static void fps_update(void)
	750	{
	751	char buf[16];
	752
	753	cbs->flip_cnt++;
	754	if(cbs->flips_per_sec != 0)
	755	{
	756	snprintf(buf,sizeof(buf),"%2d %4.1f",cbs->flips_per_sec,cbs->vsps_cur);
	757	DisplayText(buf, 0);
	758	}
	759	if(cbs->cpu_usage != 0)
	760	{
	761	snprintf(buf,sizeof(buf),"%3d",cbs->cpu_usage);
	762	DisplayText(buf, 1);
	763	}
	764	}