[pcsx_rearmed.git] / plugins / gpu_unai / gpulib_if.cpp

/***************************************************************************
*   Copyright (C) 2010 PCSX4ALL Team                                      *
*   Copyright (C) 2010 Unai                                               *
*   Copyright (C) 2011 notaz                                              *
*                                                                         *
*   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.                                   *
*                                                                         *
*   This program is distributed in the hope that it will be useful,       *
*   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
*   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
*   GNU General Public License for more details.                          *
*                                                                         *
*   You should have received a copy of the GNU General Public License     *
*   along with this program; if not, write to the                         *
*   Free Software Foundation, Inc.,                                       *
*   51 Franklin Street, Fifth Floor, Boston, MA 02111-1307 USA.           *
***************************************************************************/

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "../gpulib/gpu.h"

#define u8 uint8_t
#define s8 int8_t
#define u16 uint16_t
#define s16 int16_t
#define u32 uint32_t
#define s32 int32_t
#define s64 int64_t

#define INLINE static

#define	FRAME_BUFFER_SIZE  (1024*512*2)
#define	FRAME_WIDTH        1024
#define	FRAME_HEIGHT       512
#define	FRAME_OFFSET(x,y)  (((y)<<10)+(x))

#define isSkip 0 /* skip frame (info coming from GPU) */
#define alt_fps 0
static int linesInterlace;  /* internal lines interlace */
static int force_interlace;

static bool light = true; /* lighting */
static bool blend = true; /* blending */
static bool FrameToRead = false; /* load image in progress */
static bool FrameToWrite = false; /* store image in progress */

static bool enableAbbeyHack = false; /* Abe's Odyssey hack */

static u8 BLEND_MODE;
static u8 TEXT_MODE;
static u8 Masking;

static u16 PixelMSB;
static u16 PixelData;

///////////////////////////////////////////////////////////////////////////////
//  GPU Global data
///////////////////////////////////////////////////////////////////////////////

//  Dma Transfers info
static s32		px,py;
static s32		x_end,y_end;
static u16*  pvram;

static s32 PacketCount;
static s32 PacketIndex;

//  Rasterizer status
static u32 TextureWindow [4];
static u32 DrawingArea   [4];
static u32 DrawingOffset [2];

static u16* TBA;
static u16* CBA;

//  Inner Loops
static s32   u4, du4;
static s32   v4, dv4;
static s32   r4, dr4;
static s32   g4, dg4;
static s32   b4, db4;
static u32   lInc;
static u32   tInc, tMsk;

union GPUPacket
{
	u32 U4[16];
	s32 S4[16];
	u16 U2[32];
	s16 S2[32];
	u8  U1[64];
	s8  S1[64];
};

static GPUPacket PacketBuffer;
static u16  *GPU_FrameBuffer;
static u32   GPU_GP1;

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

#include "../gpu_unai/gpu_fixedpoint.h"

//  Inner loop driver instanciation file
#include "../gpu_unai/gpu_inner.h"

//  GPU Raster Macros
#define	GPU_RGB16(rgb)        ((((rgb)&0xF80000)>>9)|(((rgb)&0xF800)>>6)|(((rgb)&0xF8)>>3))

#define GPU_EXPANDSIGN(x)  (((s32)(x)<<21)>>21)

#define CHKMAX_X 1024
#define CHKMAX_Y 512

#define	GPU_SWAP(a,b,t)	{(t)=(a);(a)=(b);(b)=(t);}

// GPU internal image drawing functions
#include "../gpu_unai/gpu_raster_image.h"

// GPU internal line drawing functions
#include "../gpu_unai/gpu_raster_line.h"

// GPU internal polygon drawing functions
#include "../gpu_unai/gpu_raster_polygon.h"

// GPU internal sprite drawing functions
#include "../gpu_unai/gpu_raster_sprite.h"

// GPU command buffer execution/store
#include "../gpu_unai/gpu_command.h"

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

int renderer_init(void)
{
	GPU_FrameBuffer = (u16 *)gpu.vram;

	// s_invTable
	for(int i=1;i<=(1<<TABLE_BITS);++i)
	{
		double v = 1.0 / double(i);
		#ifdef GPU_TABLE_10_BITS
		v *= double(0xffffffff>>1);
		#else
		v *= double(0x80000000);
		#endif
		s_invTable[i-1]=s32(v);
	}

	return 0;
}

void renderer_finish(void)
{
}

void renderer_notify_res_change(void)
{
}

extern const unsigned char cmd_lengths[256];

int do_cmd_list(unsigned int *list, int list_len, int *last_cmd)
{
  unsigned int cmd = 0, len, i;
  unsigned int *list_start = list;
  unsigned int *list_end = list + list_len;

  linesInterlace = force_interlace;
#ifndef __ARM_ARCH_7A__ /* XXX */
  linesInterlace |= gpu.status.interlace;
#endif

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

    #define PRIM cmd
    PacketBuffer.U4[0] = list[0];
    for (i = 1; i <= len; i++)
      PacketBuffer.U4[i] = list[i];

    switch (cmd)
    {
      case 0x02:
        gpuClearImage();
        break;

      case 0x20:
      case 0x21:
      case 0x22:
      case 0x23:
        gpuDrawF3(gpuPolySpanDrivers [Blending_Mode | Masking | Blending | PixelMSB]);
        break;

      case 0x24:
      case 0x25:
      case 0x26:
      case 0x27:
        gpuSetCLUT   (PacketBuffer.U4[2] >> 16);
        gpuSetTexture(PacketBuffer.U4[4] >> 16);
        if ((PacketBuffer.U1[0]>0x5F) && (PacketBuffer.U1[1]>0x5F) && (PacketBuffer.U1[2]>0x5F))
          gpuDrawFT3(gpuPolySpanDrivers [Blending_Mode | TEXT_MODE | Masking | Blending | PixelMSB]);
        else
          gpuDrawFT3(gpuPolySpanDrivers [Blending_Mode | TEXT_MODE | Masking | Blending | Lighting | PixelMSB]);
        break;

      case 0x28:
      case 0x29:
      case 0x2A:
      case 0x2B: {
        const PP gpuPolySpanDriver = gpuPolySpanDrivers [Blending_Mode | Masking | Blending | PixelMSB];
        gpuDrawF3(gpuPolySpanDriver);
        PacketBuffer.U4[1] = PacketBuffer.U4[4];
        gpuDrawF3(gpuPolySpanDriver);
        break;
      }

      case 0x2C:
      case 0x2D:
      case 0x2E:
      case 0x2F: {
        gpuSetCLUT   (PacketBuffer.U4[2] >> 16);
        gpuSetTexture(PacketBuffer.U4[4] >> 16);
        PP gpuPolySpanDriver;
        if ((PacketBuffer.U1[0]>0x5F) && (PacketBuffer.U1[1]>0x5F) && (PacketBuffer.U1[2]>0x5F))
          gpuPolySpanDriver = gpuPolySpanDrivers [Blending_Mode | TEXT_MODE | Masking | Blending | PixelMSB];
        else
          gpuPolySpanDriver = gpuPolySpanDrivers [Blending_Mode | TEXT_MODE | Masking | Blending | Lighting | PixelMSB];
        gpuDrawFT3(gpuPolySpanDriver);
        PacketBuffer.U4[1] = PacketBuffer.U4[7];
        PacketBuffer.U4[2] = PacketBuffer.U4[8];
        gpuDrawFT3(gpuPolySpanDriver);
        break;
      }

      case 0x30:
      case 0x31:
      case 0x32:
      case 0x33:
        gpuDrawG3(gpuPolySpanDrivers [Blending_Mode | Masking | Blending | 129 | PixelMSB]);
        break;

      case 0x34:
      case 0x35:
      case 0x36:
      case 0x37:
        gpuSetCLUT    (PacketBuffer.U4[2] >> 16);
        gpuSetTexture (PacketBuffer.U4[5] >> 16);
        gpuDrawGT3(gpuPolySpanDrivers [Blending_Mode | TEXT_MODE | Masking | Blending | ((Lighting)?129:0) | PixelMSB]);
        break;

      case 0x38:
      case 0x39:
      case 0x3A:
      case 0x3B: {
        const PP gpuPolySpanDriver  = gpuPolySpanDrivers [Blending_Mode | Masking | Blending | 129 | PixelMSB];
        gpuDrawG3(gpuPolySpanDriver);
        PacketBuffer.U4[0] = PacketBuffer.U4[6];
        PacketBuffer.U4[1] = PacketBuffer.U4[7];
        gpuDrawG3(gpuPolySpanDriver);
        break;
      }

      case 0x3C:
      case 0x3D:
      case 0x3E:
      case 0x3F: {
        gpuSetCLUT    (PacketBuffer.U4[2] >> 16);
        gpuSetTexture (PacketBuffer.U4[5] >> 16);
        const PP gpuPolySpanDriver  = gpuPolySpanDrivers [Blending_Mode | TEXT_MODE | Masking | Blending | ((Lighting)?129:0) | PixelMSB];
        gpuDrawGT3(gpuPolySpanDriver);
        PacketBuffer.U4[0] = PacketBuffer.U4[9];
        PacketBuffer.U4[1] = PacketBuffer.U4[10];
        PacketBuffer.U4[2] = PacketBuffer.U4[11];
        gpuDrawGT3(gpuPolySpanDriver);
        break;
      }

      case 0x40:
      case 0x41:
      case 0x42:
      case 0x43:
        gpuDrawLF(gpuPixelDrivers [ (Blending_Mode | Masking | Blending | (PixelMSB>>3)) >> 1]);
        break;

      case 0x48 ... 0x4F:
      {
        u32 num_vertexes = 1;
        u32 *list_position = &(list[2]);

        gpuDrawLF(gpuPixelDrivers [ (Blending_Mode | Masking | Blending | (PixelMSB>>3)) >> 1]);

        while(1)
        {
          PacketBuffer.U4[1] = PacketBuffer.U4[2];
          PacketBuffer.U4[2] = *list_position++;
          gpuDrawLF(gpuPixelDrivers [ (Blending_Mode | Masking | Blending | (PixelMSB>>3)) >> 1]);

          num_vertexes++;
          if(list_position >= list_end) {
            cmd = -1;
            goto breakloop;
          }
          if((*list_position & 0xf000f000) == 0x50005000)
            break;
        }

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

      case 0x50:
      case 0x51:
      case 0x52:
      case 0x53:
        gpuDrawLG(gpuPixelDrivers [ (Blending_Mode | Masking | Blending | (PixelMSB>>3)) >> 1]);
        break;

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

        gpuDrawLG(gpuPixelDrivers [ (Blending_Mode | Masking | Blending | (PixelMSB>>3)) >> 1]);

        while(1)
        {
          PacketBuffer.U4[0] = PacketBuffer.U4[2];
          PacketBuffer.U4[1] = PacketBuffer.U4[3];
          PacketBuffer.U4[2] = *list_position++;
          PacketBuffer.U4[3] = *list_position++;
          gpuDrawLG(gpuPixelDrivers [ (Blending_Mode | Masking | Blending | (PixelMSB>>3)) >> 1]);

          num_vertexes++;
          if(list_position >= list_end) {
            cmd = -1;
            goto breakloop;
          }
          if((*list_position & 0xf000f000) == 0x50005000)
            break;
        }

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

      case 0x60:
      case 0x61:
      case 0x62:
      case 0x63:
        gpuDrawT(gpuTileSpanDrivers [Blending_Mode | Masking | Blending | (PixelMSB>>3)]);
        break;

      case 0x64:
      case 0x65:
      case 0x66:
      case 0x67:
        gpuSetCLUT    (PacketBuffer.U4[2] >> 16);
        gpuSetTexture (GPU_GP1);
        if ((PacketBuffer.U1[0]>0x5F) && (PacketBuffer.U1[1]>0x5F) && (PacketBuffer.U1[2]>0x5F))
          gpuDrawS(gpuSpriteSpanDrivers [Blending_Mode | TEXT_MODE | Masking | Blending | (enableAbbeyHack<<7)  | PixelMSB]);
        else
          gpuDrawS(gpuSpriteSpanDrivers [Blending_Mode | TEXT_MODE | Masking | Blending | Lighting | (enableAbbeyHack<<7)  | PixelMSB]);
        break;

      case 0x68:
      case 0x69:
      case 0x6A:
      case 0x6B:
        PacketBuffer.U4[2] = 0x00010001;
        gpuDrawT(gpuTileSpanDrivers [Blending_Mode | Masking | Blending | (PixelMSB>>3)]);
        break;

      case 0x70:
      case 0x71:
      case 0x72:
      case 0x73:
        PacketBuffer.U4[2] = 0x00080008;
        gpuDrawT(gpuTileSpanDrivers [Blending_Mode | Masking | Blending | (PixelMSB>>3)]);
        break;

      case 0x74:
      case 0x75:
      case 0x76:
      case 0x77:
        PacketBuffer.U4[3] = 0x00080008;
        gpuSetCLUT    (PacketBuffer.U4[2] >> 16);
        gpuSetTexture (GPU_GP1);
        if ((PacketBuffer.U1[0]>0x5F) && (PacketBuffer.U1[1]>0x5F) && (PacketBuffer.U1[2]>0x5F))
          gpuDrawS(gpuSpriteSpanDrivers [Blending_Mode | TEXT_MODE | Masking | Blending | (enableAbbeyHack<<7)  | PixelMSB]);
        else
          gpuDrawS(gpuSpriteSpanDrivers [Blending_Mode | TEXT_MODE | Masking | Blending | Lighting | (enableAbbeyHack<<7)  | PixelMSB]);
        break;

      case 0x78:
      case 0x79:
      case 0x7A:
      case 0x7B:
        PacketBuffer.U4[2] = 0x00100010;
        gpuDrawT(gpuTileSpanDrivers [Blending_Mode | Masking | Blending | (PixelMSB>>3)]);
        break;

      case 0x7C:
      case 0x7D:
#ifdef __arm__
        if ((GPU_GP1 & 0x180) == 0 && (Masking | PixelMSB) == 0)
        {
          gpuSetCLUT    (PacketBuffer.U4[2] >> 16);
          gpuSetTexture (GPU_GP1);
          gpuDrawS16();
          break;
        }
        // fallthrough
#endif
      case 0x7E:
      case 0x7F:
        PacketBuffer.U4[3] = 0x00100010;
        gpuSetCLUT    (PacketBuffer.U4[2] >> 16);
        gpuSetTexture (GPU_GP1);
        if ((PacketBuffer.U1[0]>0x5F) && (PacketBuffer.U1[1]>0x5F) && (PacketBuffer.U1[2]>0x5F))
          gpuDrawS(gpuSpriteSpanDrivers [Blending_Mode | TEXT_MODE | Masking | Blending | (enableAbbeyHack<<7)  | PixelMSB]);
        else
          gpuDrawS(gpuSpriteSpanDrivers [Blending_Mode | TEXT_MODE | Masking | Blending | Lighting | (enableAbbeyHack<<7)  | PixelMSB]);
        break;

      case 0x80:          //  vid -> vid
        gpuMoveImage();   //  prim handles updateLace && skip
        break;
#ifdef TEST
      case 0xA0:          //  sys -> vid
      {
        u32 load_width = list[2] & 0xffff;
        u32 load_height = list[2] >> 16;
        u32 load_size = load_width * load_height;

        len += load_size / 2;
        break;
      }
      case 0xC0:
        break;
#else
      case 0xA0:          //  sys ->vid
      case 0xC0:          //  vid -> sys
        goto breakloop;
#endif
      case 0xE1: {
        const u32 temp = PacketBuffer.U4[0];
        GPU_GP1 = (GPU_GP1 & ~0x000007FF) | (temp & 0x000007FF);
        gpuSetTexture(temp);
        gpu.ex_regs[1] = temp;
        break;
      }
      case 0xE2: {
        static const u8  TextureMask[32] = {
          255, 7, 15, 7, 31, 7, 15, 7, 63, 7, 15, 7, 31, 7, 15, 7,
          127, 7, 15, 7, 31, 7, 15, 7, 63, 7, 15, 7, 31, 7, 15, 7
        };
        const u32 temp = PacketBuffer.U4[0];
        TextureWindow[0] = ((temp >> 10) & 0x1F) << 3;
        TextureWindow[1] = ((temp >> 15) & 0x1F) << 3;
        TextureWindow[2] = TextureMask[(temp >> 0) & 0x1F];
        TextureWindow[3] = TextureMask[(temp >> 5) & 0x1F];
        gpuSetTexture(GPU_GP1);
        gpu.ex_regs[2] = temp;
        break;
      }
      case 0xE3: {
        const u32 temp = PacketBuffer.U4[0];
        DrawingArea[0] = temp         & 0x3FF;
        DrawingArea[1] = (temp >> 10) & 0x3FF;
        gpu.ex_regs[3] = temp;
        break;
      }
      case 0xE4: {
        const u32 temp = PacketBuffer.U4[0];
        DrawingArea[2] = (temp         & 0x3FF) + 1;
        DrawingArea[3] = ((temp >> 10) & 0x3FF) + 1;
        gpu.ex_regs[4] = temp;
        break;
      }
      case 0xE5: {
        const u32 temp = PacketBuffer.U4[0];
        DrawingOffset[0] = ((long)temp<<(32-11))>>(32-11);
        DrawingOffset[1] = ((long)temp<<(32-22))>>(32-11);
        gpu.ex_regs[5] = temp;
        break;
      }
      case 0xE6: {
        const u32 temp = PacketBuffer.U4[0];
        Masking = (temp & 0x2) <<  1;
        PixelMSB =(temp & 0x1) <<  8;
        gpu.ex_regs[6] = temp;
        break;
      }
    }
  }

breakloop:
  gpu.ex_regs[1] &= ~0x1ff;
  gpu.ex_regs[1] |= GPU_GP1 & 0x1ff;

  *last_cmd = cmd;
  return list - list_start;
}

void renderer_sync_ecmds(uint32_t *ecmds)
{
  int dummy;
  do_cmd_list(&ecmds[1], 6, &dummy);
}

void renderer_update_caches(int x, int y, int w, int h)
{
}

void renderer_flush_queues(void)
{
}

void renderer_set_interlace(int enable, int is_odd)
{
}

#ifndef TEST

#include "../../frontend/plugin_lib.h"

void renderer_set_config(const struct rearmed_cbs *cbs)
{
  force_interlace = cbs->gpu_unai.lineskip;
  enableAbbeyHack = cbs->gpu_unai.abe_hack;
  light = !cbs->gpu_unai.no_light;
  blend = !cbs->gpu_unai.no_blend;

  GPU_FrameBuffer = (u16 *)gpu.vram;
}

#endif

// vim:shiftwidth=2:expandtab
Commit	Line	Data
6f2ee2be	1	/***************************************************************************
	2	* Copyright (C) 2010 PCSX4ALL Team *
	3	* Copyright (C) 2010 Unai *
	4	* Copyright (C) 2011 notaz *
	5	* *
	6	* This program is free software; you can redistribute it and/or modify *
	7	* it under the terms of the GNU General Public License as published by *
	8	* the Free Software Foundation; either version 2 of the License, or *
	9	* (at your option) any later version. *
	10	* *
	11	* This program is distributed in the hope that it will be useful, *
	12	* but WITHOUT ANY WARRANTY; without even the implied warranty of *
	13	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
	14	* GNU General Public License for more details. *
	15	* *
	16	* You should have received a copy of the GNU General Public License *
	17	* along with this program; if not, write to the *
	18	* Free Software Foundation, Inc., *
	19	* 51 Franklin Street, Fifth Floor, Boston, MA 02111-1307 USA. *
	20	***************************************************************************/
	21
	22	#include <stdio.h>
	23	#include <stdlib.h>
	24	#include <string.h>
62d7fa95	25	#include "../gpulib/gpu.h"
6f2ee2be	26
	27	#define u8 uint8_t
	28	#define s8 int8_t
	29	#define u16 uint16_t
	30	#define s16 int16_t
	31	#define u32 uint32_t
	32	#define s32 int32_t
	33	#define s64 int64_t
	34
8aea5f5a	35	#define INLINE static
6f2ee2be	36
	37	#define FRAME_BUFFER_SIZE (10245122)
	38	#define FRAME_WIDTH 1024
	39	#define FRAME_HEIGHT 512
	40	#define FRAME_OFFSET(x,y) (((y)<<10)+(x))
	41
89c0de42	42	#define isSkip 0 /* skip frame (info coming from GPU) */
6f2ee2be	43	#define alt_fps 0
89c0de42	44	static int linesInterlace; /* internal lines interlace */
89c0de42	45	static int force_interlace;
6f2ee2be	46
	47	static bool light = true; /* lighting */
	48	static bool blend = true; /* blending */
	49	static bool FrameToRead = false; /* load image in progress */
	50	static bool FrameToWrite = false; /* store image in progress */
	51
	52	static bool enableAbbeyHack = false; /* Abe's Odyssey hack */
	53
	54	static u8 BLEND_MODE;
	55	static u8 TEXT_MODE;
	56	static u8 Masking;
	57
	58	static u16 PixelMSB;
	59	static u16 PixelData;
	60
	61	///////////////////////////////////////////////////////////////////////////////
	62	// GPU Global data
	63	///////////////////////////////////////////////////////////////////////////////
	64
	65	// Dma Transfers info
	66	static s32 px,py;
	67	static s32 x_end,y_end;
	68	static u16* pvram;
	69
	70	static s32 PacketCount;
	71	static s32 PacketIndex;
	72
	73	// Rasterizer status
	74	static u32 TextureWindow [4];
	75	static u32 DrawingArea [4];
	76	static u32 DrawingOffset [2];
	77
	78	static u16* TBA;
	79	static u16* CBA;
	80
	81	// Inner Loops
	82	static s32 u4, du4;
	83	static s32 v4, dv4;
	84	static s32 r4, dr4;
	85	static s32 g4, dg4;
	86	static s32 b4, db4;
	87	static u32 lInc;
	88	static u32 tInc, tMsk;
	89
	90	union GPUPacket
	91	{
8aea5f5a	92	u32 U4[16];
	93	s32 S4[16];
	94	u16 U2[32];
	95	s16 S2[32];
	96	u8 U1[64];
	97	s8 S1[64];
6f2ee2be	98	};
	99
	100	static GPUPacket PacketBuffer;
	101	static u16 *GPU_FrameBuffer;
	102	static u32 GPU_GP1;
	103
	104	///////////////////////////////////////////////////////////////////////////////
	105
	106	#include "../gpu_unai/gpu_fixedpoint.h"
	107
	108	// Inner loop driver instanciation file
	109	#include "../gpu_unai/gpu_inner.h"
	110
	111	// GPU Raster Macros
	112	#define GPU_RGB16(rgb) ((((rgb)&0xF80000)>>9)\|(((rgb)&0xF800)>>6)\|(((rgb)&0xF8)>>3))
	113
9ed4ca47	114	#define GPU_EXPANDSIGN(x) (((s32)(x)<<21)>>21)
6f2ee2be	115
9ed4ca47	116	#define CHKMAX_X 1024
9ed4ca47	117	#define CHKMAX_Y 512
6f2ee2be	118
	119	#define GPU_SWAP(a,b,t) {(t)=(a);(a)=(b);(b)=(t);}
	120
	121	// GPU internal image drawing functions
	122	#include "../gpu_unai/gpu_raster_image.h"
	123
	124	// GPU internal line drawing functions
	125	#include "../gpu_unai/gpu_raster_line.h"
	126
	127	// GPU internal polygon drawing functions
	128	#include "../gpu_unai/gpu_raster_polygon.h"
	129
	130	// GPU internal sprite drawing functions
	131	#include "../gpu_unai/gpu_raster_sprite.h"
	132
	133	// GPU command buffer execution/store
	134	#include "../gpu_unai/gpu_command.h"
	135
6f2ee2be	136	/////////////////////////////////////////////////////////////////////////////
	137
	138	int renderer_init(void)
	139	{
	140	GPU_FrameBuffer = (u16 *)gpu.vram;
	141
	142	// s_invTable
	143	for(int i=1;i<=(1<<TABLE_BITS);++i)
	144	{
	145	double v = 1.0 / double(i);
	146	#ifdef GPU_TABLE_10_BITS
	147	v *= double(0xffffffff>>1);
	148	#else
	149	v *= double(0x80000000);
	150	#endif
	151	s_invTable[i-1]=s32(v);
	152	}
	153
	154	return 0;
	155	}
	156
e929dec5	157	void renderer_finish(void)
	158	{
	159	}
	160
	161	void renderer_notify_res_change(void)
	162	{
	163	}
	164
6f2ee2be	165	extern const unsigned char cmd_lengths[256];
6f2ee2be	166
b243416b	167	int do_cmd_list(unsigned int list, int list_len, int last_cmd)
6f2ee2be	168	{
42a261f1	169	unsigned int cmd = 0, len, i;
b243416b	170	unsigned int *list_start = list;
6f2ee2be	171	unsigned int *list_end = list + list_len;
6f2ee2be	172
89c0de42	173	linesInterlace = force_interlace;
	174	#ifndef __ARM_ARCH_7A__ /* XXX */
	175	linesInterlace \|= gpu.status.interlace;
	176	#endif
	177
6f2ee2be	178	for (; list < list_end; list += 1 + len)
6f2ee2be	179	{
6f2ee2be	180	cmd = *list >> 24;
6f2ee2be	181	len = cmd_lengths[cmd];
b243416b	182	if (list + 1 + len > list_end) {
	183	cmd = -1;
	184	break;
	185	}
	186
42a261f1	187	#define PRIM cmd
	188	PacketBuffer.U4[0] = list[0];
	189	for (i = 1; i <= len; i++)
	190	PacketBuffer.U4[i] = list[i];
6f2ee2be	191
42a261f1	192	switch (cmd)
6f2ee2be	193	{
42a261f1	194	case 0x02:
	195	gpuClearImage();
	196	break;
	197
	198	case 0x20:
	199	case 0x21:
	200	case 0x22:
	201	case 0x23:
	202	gpuDrawF3(gpuPolySpanDrivers [Blending_Mode \| Masking \| Blending \| PixelMSB]);
	203	break;
	204
	205	case 0x24:
	206	case 0x25:
	207	case 0x26:
	208	case 0x27:
	209	gpuSetCLUT (PacketBuffer.U4[2] >> 16);
	210	gpuSetTexture(PacketBuffer.U4[4] >> 16);
	211	if ((PacketBuffer.U1[0]>0x5F) && (PacketBuffer.U1[1]>0x5F) && (PacketBuffer.U1[2]>0x5F))
	212	gpuDrawFT3(gpuPolySpanDrivers [Blending_Mode \| TEXT_MODE \| Masking \| Blending \| PixelMSB]);
	213	else
	214	gpuDrawFT3(gpuPolySpanDrivers [Blending_Mode \| TEXT_MODE \| Masking \| Blending \| Lighting \| PixelMSB]);
	215	break;
	216
	217	case 0x28:
	218	case 0x29:
	219	case 0x2A:
	220	case 0x2B: {
	221	const PP gpuPolySpanDriver = gpuPolySpanDrivers [Blending_Mode \| Masking \| Blending \| PixelMSB];
	222	gpuDrawF3(gpuPolySpanDriver);
	223	PacketBuffer.U4[1] = PacketBuffer.U4[4];
	224	gpuDrawF3(gpuPolySpanDriver);
	225	break;
	226	}
	227
	228	case 0x2C:
	229	case 0x2D:
	230	case 0x2E:
	231	case 0x2F: {
	232	gpuSetCLUT (PacketBuffer.U4[2] >> 16);
	233	gpuSetTexture(PacketBuffer.U4[4] >> 16);
	234	PP gpuPolySpanDriver;
	235	if ((PacketBuffer.U1[0]>0x5F) && (PacketBuffer.U1[1]>0x5F) && (PacketBuffer.U1[2]>0x5F))
	236	gpuPolySpanDriver = gpuPolySpanDrivers [Blending_Mode \| TEXT_MODE \| Masking \| Blending \| PixelMSB];
	237	else
	238	gpuPolySpanDriver = gpuPolySpanDrivers [Blending_Mode \| TEXT_MODE \| Masking \| Blending \| Lighting \| PixelMSB];
	239	gpuDrawFT3(gpuPolySpanDriver);
	240	PacketBuffer.U4[1] = PacketBuffer.U4[7];
	241	PacketBuffer.U4[2] = PacketBuffer.U4[8];
	242	gpuDrawFT3(gpuPolySpanDriver);
	243	break;
	244	}
	245
	246	case 0x30:
	247	case 0x31:
	248	case 0x32:
	249	case 0x33:
	250	gpuDrawG3(gpuPolySpanDrivers [Blending_Mode \| Masking \| Blending \| 129 \| PixelMSB]);
	251	break;
	252
	253	case 0x34:
	254	case 0x35:
	255	case 0x36:
	256	case 0x37:
	257	gpuSetCLUT (PacketBuffer.U4[2] >> 16);
258	gpuSetTexture (PacketBuffer.U4[5] >> 16);
259	gpuDrawGT3(gpuPolySpanDrivers [Blending_Mode \| TEXT_MODE \| Masking \| Blending \| ((Lighting)?129:0) \| PixelMSB]);
260	break;
261
262	case 0x38:
263	case 0x39:
264	case 0x3A:
265	case 0x3B: {
266	const PP gpuPolySpanDriver = gpuPolySpanDrivers [Blending_Mode \| Masking \| Blending \| 129 \| PixelMSB];
267	gpuDrawG3(gpuPolySpanDriver);
268	PacketBuffer.U4[0] = PacketBuffer.U4[6];
269	PacketBuffer.U4[1] = PacketBuffer.U4[7];
270	gpuDrawG3(gpuPolySpanDriver);
271	break;
272	}
273
274	case 0x3C:
275	case 0x3D:
276	case 0x3E:
277	case 0x3F: {
278	gpuSetCLUT (PacketBuffer.U4[2] >> 16);
279	gpuSetTexture (PacketBuffer.U4[5] >> 16);
280	const PP gpuPolySpanDriver = gpuPolySpanDrivers [Blending_Mode \| TEXT_MODE \| Masking \| Blending \| ((Lighting)?129:0) \| PixelMSB];
281	gpuDrawGT3(gpuPolySpanDriver);
282	PacketBuffer.U4[0] = PacketBuffer.U4[9];
283	PacketBuffer.U4[1] = PacketBuffer.U4[10];
284	PacketBuffer.U4[2] = PacketBuffer.U4[11];
285	gpuDrawGT3(gpuPolySpanDriver);
286	break;
287	}
288
289	case 0x40:
290	case 0x41:
291	case 0x42:
292	case 0x43:
293	gpuDrawLF(gpuPixelDrivers [ (Blending_Mode \| Masking \| Blending \| (PixelMSB>>3)) >> 1]);
294	break;
295
6f2ee2be	296	case 0x48 ... 0x4F:
	297	{
	298	u32 num_vertexes = 1;
	299	u32 *list_position = &(list[2]);
8aea5f5a	300
8aea5f5a	301	gpuDrawLF(gpuPixelDrivers [ (Blending_Mode \| Masking \| Blending \| (PixelMSB>>3)) >> 1]);
6f2ee2be	302
	303	while(1)
	304	{
8aea5f5a	305	PacketBuffer.U4[1] = PacketBuffer.U4[2];
	306	PacketBuffer.U4[2] = *list_position++;
	307	gpuDrawLF(gpuPixelDrivers [ (Blending_Mode \| Masking \| Blending \| (PixelMSB>>3)) >> 1]);
	308
6f2ee2be	309	num_vertexes++;
804789d7	310	if(list_position >= list_end) {
	311	cmd = -1;
	312	goto breakloop;
	313	}
	314	if((*list_position & 0xf000f000) == 0x50005000)
b243416b	315	break;
6f2ee2be	316	}
6f2ee2be	317
b243416b	318	len += (num_vertexes - 2);
6f2ee2be	319	break;
	320	}
	321
42a261f1	322	case 0x50:
	323	case 0x51:
	324	case 0x52:
	325	case 0x53:
	326	gpuDrawLG(gpuPixelDrivers [ (Blending_Mode \| Masking \| Blending \| (PixelMSB>>3)) >> 1]);
	327	break;
	328
6f2ee2be	329	case 0x58 ... 0x5F:
	330	{
	331	u32 num_vertexes = 1;
	332	u32 *list_position = &(list[2]);
8aea5f5a	333
8aea5f5a	334	gpuDrawLG(gpuPixelDrivers [ (Blending_Mode \| Masking \| Blending \| (PixelMSB>>3)) >> 1]);
6f2ee2be	335
	336	while(1)
	337	{
8aea5f5a	338	PacketBuffer.U4[0] = PacketBuffer.U4[2];
	339	PacketBuffer.U4[1] = PacketBuffer.U4[3];
	340	PacketBuffer.U4[2] = *list_position++;
	341	PacketBuffer.U4[3] = *list_position++;
	342	gpuDrawLG(gpuPixelDrivers [ (Blending_Mode \| Masking \| Blending \| (PixelMSB>>3)) >> 1]);
	343
6f2ee2be	344	num_vertexes++;
804789d7	345	if(list_position >= list_end) {
	346	cmd = -1;
	347	goto breakloop;
	348	}
	349	if((*list_position & 0xf000f000) == 0x50005000)
b243416b	350	break;
6f2ee2be	351	}
6f2ee2be	352
b243416b	353	len += (num_vertexes - 2) * 2;
6f2ee2be	354	break;
	355	}
	356
42a261f1	357	case 0x60:
	358	case 0x61:
	359	case 0x62:
	360	case 0x63:
	361	gpuDrawT(gpuTileSpanDrivers [Blending_Mode \| Masking \| Blending \| (PixelMSB>>3)]);
	362	break;
	363
	364	case 0x64:
	365	case 0x65:
	366	case 0x66:
	367	case 0x67:
	368	gpuSetCLUT (PacketBuffer.U4[2] >> 16);
	369	gpuSetTexture (GPU_GP1);
	370	if ((PacketBuffer.U1[0]>0x5F) && (PacketBuffer.U1[1]>0x5F) && (PacketBuffer.U1[2]>0x5F))
	371	gpuDrawS(gpuSpriteSpanDrivers [Blending_Mode \| TEXT_MODE \| Masking \| Blending \| (enableAbbeyHack<<7) \| PixelMSB]);
	372	else
	373	gpuDrawS(gpuSpriteSpanDrivers [Blending_Mode \| TEXT_MODE \| Masking \| Blending \| Lighting \| (enableAbbeyHack<<7) \| PixelMSB]);
	374	break;
	375
	376	case 0x68:
	377	case 0x69:
	378	case 0x6A:
	379	case 0x6B:
	380	PacketBuffer.U4[2] = 0x00010001;
	381	gpuDrawT(gpuTileSpanDrivers [Blending_Mode \| Masking \| Blending \| (PixelMSB>>3)]);
	382	break;
	383
	384	case 0x70:
	385	case 0x71:
	386	case 0x72:
	387	case 0x73:
	388	PacketBuffer.U4[2] = 0x00080008;
	389	gpuDrawT(gpuTileSpanDrivers [Blending_Mode \| Masking \| Blending \| (PixelMSB>>3)]);
	390	break;
	391
	392	case 0x74:
	393	case 0x75:
	394	case 0x76:
	395	case 0x77:
	396	PacketBuffer.U4[3] = 0x00080008;
	397	gpuSetCLUT (PacketBuffer.U4[2] >> 16);
	398	gpuSetTexture (GPU_GP1);
	399	if ((PacketBuffer.U1[0]>0x5F) && (PacketBuffer.U1[1]>0x5F) && (PacketBuffer.U1[2]>0x5F))
	400	gpuDrawS(gpuSpriteSpanDrivers [Blending_Mode \| TEXT_MODE \| Masking \| Blending \| (enableAbbeyHack<<7) \| PixelMSB]);
	401	else
	402	gpuDrawS(gpuSpriteSpanDrivers [Blending_Mode \| TEXT_MODE \| Masking \| Blending \| Lighting \| (enableAbbeyHack<<7) \| PixelMSB]);
	403	break;
	404
	405	case 0x78:
	406	case 0x79:
	407	case 0x7A:
	408	case 0x7B:
	409	PacketBuffer.U4[2] = 0x00100010;
	410	gpuDrawT(gpuTileSpanDrivers [Blending_Mode \| Masking \| Blending \| (PixelMSB>>3)]);
	411	break;
	412
	413	case 0x7C:
	414	case 0x7D:
	415	#ifdef __arm__
	416	if ((GPU_GP1 & 0x180) == 0 && (Masking \| PixelMSB) == 0)
	417	{
	418	gpuSetCLUT (PacketBuffer.U4[2] >> 16);
	419	gpuSetTexture (GPU_GP1);
	420	gpuDrawS16();
421	break;
422	}
423	// fallthrough
424	#endif
425	case 0x7E:
426	case 0x7F:
427	PacketBuffer.U4[3] = 0x00100010;
428	gpuSetCLUT (PacketBuffer.U4[2] >> 16);
429	gpuSetTexture (GPU_GP1);
430	if ((PacketBuffer.U1[0]>0x5F) && (PacketBuffer.U1[1]>0x5F) && (PacketBuffer.U1[2]>0x5F))
431	gpuDrawS(gpuSpriteSpanDrivers [Blending_Mode \| TEXT_MODE \| Masking \| Blending \| (enableAbbeyHack<<7) \| PixelMSB]);
432	else
433	gpuDrawS(gpuSpriteSpanDrivers [Blending_Mode \| TEXT_MODE \| Masking \| Blending \| Lighting \| (enableAbbeyHack<<7) \| PixelMSB]);
434	break;
435
436	case 0x80: // vid -> vid
437	gpuMoveImage(); // prim handles updateLace && skip
438	break;
9a6e7816	439	#ifdef TEST
	440	case 0xA0: // sys -> vid
	441	{
	442	u32 load_width = list[2] & 0xffff;
	443	u32 load_height = list[2] >> 16;
	444	u32 load_size = load_width * load_height;
	445
	446	len += load_size / 2;
	447	break;
	448	}
42a261f1	449	case 0xC0:
	450	break;
	451	#else
	452	case 0xA0: // sys ->vid
	453	case 0xC0: // vid -> sys
	454	goto breakloop;
9a6e7816	455	#endif
42a261f1	456	case 0xE1: {
	457	const u32 temp = PacketBuffer.U4[0];
	458	GPU_GP1 = (GPU_GP1 & ~0x000007FF) \| (temp & 0x000007FF);
	459	gpuSetTexture(temp);
	460	gpu.ex_regs[1] = temp;
	461	break;
	462	}
	463	case 0xE2: {
	464	static const u8 TextureMask[32] = {
	465	255, 7, 15, 7, 31, 7, 15, 7, 63, 7, 15, 7, 31, 7, 15, 7,
	466	127, 7, 15, 7, 31, 7, 15, 7, 63, 7, 15, 7, 31, 7, 15, 7
	467	};
	468	const u32 temp = PacketBuffer.U4[0];
	469	TextureWindow[0] = ((temp >> 10) & 0x1F) << 3;
	470	TextureWindow[1] = ((temp >> 15) & 0x1F) << 3;
	471	TextureWindow[2] = TextureMask[(temp >> 0) & 0x1F];
	472	TextureWindow[3] = TextureMask[(temp >> 5) & 0x1F];
	473	gpuSetTexture(GPU_GP1);
	474	gpu.ex_regs[2] = temp;
	475	break;
	476	}
	477	case 0xE3: {
	478	const u32 temp = PacketBuffer.U4[0];
	479	DrawingArea[0] = temp & 0x3FF;
	480	DrawingArea[1] = (temp >> 10) & 0x3FF;
	481	gpu.ex_regs[3] = temp;
6f2ee2be	482	break;
42a261f1	483	}
	484	case 0xE4: {
	485	const u32 temp = PacketBuffer.U4[0];
	486	DrawingArea[2] = (temp & 0x3FF) + 1;
	487	DrawingArea[3] = ((temp >> 10) & 0x3FF) + 1;
	488	gpu.ex_regs[4] = temp;
	489	break;
	490	}
	491	case 0xE5: {
	492	const u32 temp = PacketBuffer.U4[0];
	493	DrawingOffset[0] = ((long)temp<<(32-11))>>(32-11);
	494	DrawingOffset[1] = ((long)temp<<(32-22))>>(32-11);
	495	gpu.ex_regs[5] = temp;
	496	break;
	497	}
	498	case 0xE6: {
	499	const u32 temp = PacketBuffer.U4[0];
	500	Masking = (temp & 0x2) << 1;
	501	PixelMSB =(temp & 0x1) << 8;
	502	gpu.ex_regs[6] = temp;
	503	break;
	504	}
6f2ee2be	505	}
6f2ee2be	506	}
b243416b	507
42a261f1	508	breakloop:
b243416b	509	gpu.ex_regs[1] &= ~0x1ff;
	510	gpu.ex_regs[1] \|= GPU_GP1 & 0x1ff;
	511
	512	*last_cmd = cmd;
	513	return list - list_start;
6f2ee2be	514	}
	515
	516	void renderer_sync_ecmds(uint32_t *ecmds)
	517	{
42a261f1	518	int dummy;
42a261f1	519	do_cmd_list(&ecmds[1], 6, &dummy);
6f2ee2be	520	}
6f2ee2be	521
05740673	522	void renderer_update_caches(int x, int y, int w, int h)
6f2ee2be	523	{
	524	}
	525
	526	void renderer_flush_queues(void)
	527	{
	528	}
914455e6	529
5440b88e	530	void renderer_set_interlace(int enable, int is_odd)
	531	{
	532	}
	533
9a6e7816	534	#ifndef TEST
9a6e7816	535
914455e6	536	#include "../../frontend/plugin_lib.h"
	537
	538	void renderer_set_config(const struct rearmed_cbs *cbs)
	539	{
89c0de42	540	force_interlace = cbs->gpu_unai.lineskip;
914455e6	541	enableAbbeyHack = cbs->gpu_unai.abe_hack;
	542	light = !cbs->gpu_unai.no_light;
	543	blend = !cbs->gpu_unai.no_blend;
9ee0fd5b	544
9ee0fd5b	545	GPU_FrameBuffer = (u16 *)gpu.vram;
914455e6	546	}
9a6e7816	547
9a6e7816	548	#endif
42a261f1	549
42a261f1	550	// vim:shiftwidth=2:expandtab