[pcsx_rearmed.git] / plugins / gpu_neon / peops_if.c

/***************************************************************************
    copyright            : (C) 2001 by Pete Bernert, 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. See also the license.txt file for *
 *   additional informations.                                              *
 *                                                                         *
 ***************************************************************************/

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

#define u32 uint32_t

#define INFO_TW        0
#define INFO_DRAWSTART 1
#define INFO_DRAWEND   2
#define INFO_DRAWOFF   3

#define SHADETEXBIT(x) ((x>>24) & 0x1)
#define SEMITRANSBIT(x) ((x>>25) & 0x1)
#define PSXRGB(r,g,b) ((g<<10)|(b<<5)|r)

#define DATAREGISTERMODES unsigned short

#define DR_NORMAL        0
#define DR_VRAMTRANSFER  1

#define GPUSTATUS_READYFORVRAM        0x08000000

// byteswappings

#define SWAP16(x) ({ uint16_t y=(x); (((y)>>8 & 0xff) | ((y)<<8 & 0xff00)); })
#define SWAP32(x) ({ uint32_t y=(x); (((y)>>24 & 0xfful) | ((y)>>8 & 0xff00ul) | ((y)<<8 & 0xff0000ul) | ((y)<<24 & 0xff000000ul)); })

#ifdef __BIG_ENDIAN__

// big endian config
#define HOST2LE32(x) SWAP32(x)
#define HOST2BE32(x) (x)
#define LE2HOST32(x) SWAP32(x)
#define BE2HOST32(x) (x)

#define HOST2LE16(x) SWAP16(x)
#define HOST2BE16(x) (x)
#define LE2HOST16(x) SWAP16(x)
#define BE2HOST16(x) (x)

#else

// little endian config
#define HOST2LE32(x) (x)
#define HOST2BE32(x) SWAP32(x)
#define LE2HOST32(x) (x)
#define BE2HOST32(x) SWAP32(x)

#define HOST2LE16(x) (x)
#define HOST2BE16(x) SWAP16(x)
#define LE2HOST16(x) (x)
#define BE2HOST16(x) SWAP16(x)

#endif

#define GETLEs16(X) ((int16_t)GETLE16((uint16_t *)X))
#define GETLEs32(X) ((int16_t)GETLE32((uint16_t *)X))

#define GETLE16(X) LE2HOST16(*(uint16_t *)X)
#define GETLE32_(X) LE2HOST32(*(uint32_t *)X)
#define GETLE16D(X) ({uint32_t val = GETLE32(X); (val<<16 | val >> 16);})
#define PUTLE16(X, Y) do{*((uint16_t *)X)=HOST2LE16((uint16_t)Y);}while(0)
#define PUTLE32_(X, Y) do{*((uint32_t *)X)=HOST2LE16((uint32_t)Y);}while(0)
#ifdef __arm__
#define GETLE32(X) (*(uint16_t *)(X)|(((uint16_t *)(X))[1]<<16))
#define PUTLE32(X, Y) do{uint16_t *p_=(uint16_t *)(X);uint32_t y_=Y;p_[0]=y_;p_[1]=y_>>16;}while(0)
#else
#define GETLE32 GETLE32_
#define PUTLE32 PUTLE32_
#endif

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

typedef struct VRAMLOADTTAG
{
 short x;
 short y;
 short Width;
 short Height;
 short RowsRemaining;
 short ColsRemaining;
 unsigned short *ImagePtr;
} VRAMLoad_t;

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

typedef struct PSXPOINTTAG
{
 int32_t x;
 int32_t y;
} PSXPoint_t;

typedef struct PSXSPOINTTAG
{
 short x;
 short y;
} PSXSPoint_t;

typedef struct PSXRECTTAG
{
 short x0;
 short x1;
 short y0;
 short y1;
} PSXRect_t;

// linux defines for some windows stuff

#define FALSE 0
#define TRUE 1
#define BOOL unsigned short
#define LOWORD(l)           ((unsigned short)(l))
#define HIWORD(l)           ((unsigned short)(((uint32_t)(l) >> 16) & 0xFFFF))
#define max(a,b)            (((a) > (b)) ? (a) : (b))
#define min(a,b)            (((a) < (b)) ? (a) : (b))
#define DWORD uint32_t
#ifndef __int64
#define __int64 long long int
#endif

typedef struct RECTTAG
{
 int left;
 int top;
 int right;
 int bottom;
}RECT;

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

typedef struct TWINTAG
{
 PSXRect_t  Position;
 int xmask, ymask;
} TWin_t;

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

typedef struct PSXDISPLAYTAG
{
 PSXPoint_t  DisplayModeNew;
 PSXPoint_t  DisplayMode;
 PSXPoint_t  DisplayPosition;
 PSXPoint_t  DisplayEnd;

 int32_t        Double;
 int32_t        Height;
 int32_t        PAL;
 int32_t        InterlacedNew;
 int32_t        Interlaced;
 int32_t        RGB24New;
 int32_t        RGB24;
 PSXSPoint_t DrawOffset;
 int32_t        Disabled;
 PSXRect_t   Range;

} PSXDisplay_t;

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

// draw.c

extern int32_t           GlobalTextAddrX,GlobalTextAddrY,GlobalTextTP;
extern int32_t           GlobalTextABR,GlobalTextPAGE;
extern short          ly0,lx0,ly1,lx1,ly2,lx2,ly3,lx3;
extern long           lLowerpart;
extern BOOL           bCheckMask;
extern unsigned short sSetMask;
extern unsigned long  lSetMask;
extern short          g_m1;
extern short          g_m2;
extern short          g_m3;
extern short          DrawSemiTrans;

// prim.c

extern BOOL           bUsingTWin;
extern TWin_t         TWin;
extern void (*primTableJ[256])(unsigned char *);
extern void (*primTableSkip[256])(unsigned char *);
extern unsigned short  usMirror;
extern int            iDither;
extern uint32_t  dwCfgFixes;
extern uint32_t  dwActFixes;
extern int            iUseFixes;
extern int            iUseDither;
extern BOOL           bDoVSyncUpdate;
extern int32_t           drawX;
extern int32_t           drawY;
extern int32_t           drawW;
extern int32_t           drawH;

// gpu.h

#define OPAQUEON   10
#define OPAQUEOFF  11

#define KEY_RESETTEXSTORE 1
#define KEY_SHOWFPS       2
#define KEY_RESETOPAQUE   4
#define KEY_RESETDITHER   8
#define KEY_RESETFILTER   16
#define KEY_RESETADVBLEND 32
#define KEY_BADTEXTURES   128
#define KEY_CHECKTHISOUT  256

#if !defined(__BIG_ENDIAN__) || defined(__x86_64__) || defined(__i386__)
#ifndef __LITTLE_ENDIAN__
#define __LITTLE_ENDIAN__
#endif
#endif

#ifdef __LITTLE_ENDIAN__
#define RED(x) (x & 0xff)
#define BLUE(x) ((x>>16) & 0xff)
#define GREEN(x) ((x>>8) & 0xff)
#define COLOR(x) (x & 0xffffff)
#elif defined __BIG_ENDIAN__
#define RED(x) ((x>>24) & 0xff)
#define BLUE(x) ((x>>8) & 0xff)
#define GREEN(x) ((x>>16) & 0xff)
#define COLOR(x) SWAP32(x & 0xffffff)
#endif

PSXDisplay_t      PSXDisplay;
unsigned char  *psxVub;
signed   char  *psxVsb;
unsigned short *psxVuw;
unsigned short *psxVuw_eom;
signed   short *psxVsw;
uint32_t *psxVul;
int32_t  *psxVsl;

long              lGPUstatusRet;
uint32_t          lGPUInfoVals[16];

VRAMLoad_t        VRAMWrite;
VRAMLoad_t        VRAMRead;

DATAREGISTERMODES DataWriteMode;
DATAREGISTERMODES DataReadMode;

BOOL           bCheckMask = FALSE;
unsigned short sSetMask = 0;
unsigned long  lSetMask = 0;
long           lLowerpart;

#include "../dfxvideo/soft.c"
#include "../dfxvideo/prim.c"

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

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

 psxVsb=(signed char *)psxVub;                         // different ways of accessing PSX VRAM
 psxVsw=(signed short *)psxVub;
 psxVsl=(int32_t *)psxVub;
 psxVuw=(unsigned short *)psxVub;
 psxVul=(uint32_t *)psxVub;

 psxVuw_eom=psxVuw+1024*512;                           // pre-calc of end of 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;

 DataWriteMode = DR_NORMAL;
 lGPUstatusRet = 0x14802000;

 return 0;
}

extern const unsigned char cmd_lengths[256];

void do_cmd_list(unsigned int *list, int list_len)
{
  unsigned int cmd, len;

  unsigned int *list_end = list + list_len;

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

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

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

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

          list_position++;
          num_vertexes++;
        }

        if(num_vertexes > 2)
          len += (num_vertexes - 2);

        break;
      }

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

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

          list_position += 2;
          num_vertexes++;
        }

        if(num_vertexes > 2)
          len += (num_vertexes - 2) * 2;

        break;
      }

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

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

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)
{
}

void renderer_flush_queues(void)
{
}

void renderer_set_interlace(int enable, int is_odd)
{
}

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

void renderer_set_config(const struct rearmed_cbs *cbs)
{
 iUseDither = cbs->gpu_peops.iUseDither;
 dwActFixes = cbs->gpu_peops.dwActFixes;
}
Commit	Line	Data
b094071f	1	/***************************************************************************
	2	copyright : (C) 2001 by Pete Bernert, 2011 notaz
	3
	4	***************************************************************************/
	5	/***************************************************************************
	6	* *
	7	* This program is free software; you can redistribute it and/or modify *
	8	* it under the terms of the GNU General Public License as published by *
	9	* the Free Software Foundation; either version 2 of the License, or *
	10	* (at your option) any later version. See also the license.txt file for *
	11	* additional informations. *
	12	* *
	13	***************************************************************************/
	14
	15	#include <stdio.h>
	16	#include <stdlib.h>
	17	#include <string.h>
	18	#include "gpu.h"
	19
	20	#define u32 uint32_t
	21
	22	#define INFO_TW 0
	23	#define INFO_DRAWSTART 1
	24	#define INFO_DRAWEND 2
	25	#define INFO_DRAWOFF 3
	26
	27	#define SHADETEXBIT(x) ((x>>24) & 0x1)
	28	#define SEMITRANSBIT(x) ((x>>25) & 0x1)
	29	#define PSXRGB(r,g,b) ((g<<10)\|(b<<5)\|r)
	30
	31	#define DATAREGISTERMODES unsigned short
	32
	33	#define DR_NORMAL 0
	34	#define DR_VRAMTRANSFER 1
	35
	36	#define GPUSTATUS_READYFORVRAM 0x08000000
	37
	38	// byteswappings
	39
	40	#define SWAP16(x) ({ uint16_t y=(x); (((y)>>8 & 0xff) \| ((y)<<8 & 0xff00)); })
	41	#define SWAP32(x) ({ uint32_t y=(x); (((y)>>24 & 0xfful) \| ((y)>>8 & 0xff00ul) \| ((y)<<8 & 0xff0000ul) \| ((y)<<24 & 0xff000000ul)); })
	42
	43	#ifdef __BIG_ENDIAN__
	44
	45	// big endian config
	46	#define HOST2LE32(x) SWAP32(x)
	47	#define HOST2BE32(x) (x)
	48	#define LE2HOST32(x) SWAP32(x)
	49	#define BE2HOST32(x) (x)
	50
	51	#define HOST2LE16(x) SWAP16(x)
	52	#define HOST2BE16(x) (x)
	53	#define LE2HOST16(x) SWAP16(x)
	54	#define BE2HOST16(x) (x)
	55
	56	#else
	57
	58	// little endian config
	59	#define HOST2LE32(x) (x)
	60	#define HOST2BE32(x) SWAP32(x)
	61	#define LE2HOST32(x) (x)
	62	#define BE2HOST32(x) SWAP32(x)
	63
	64	#define HOST2LE16(x) (x)
65	#define HOST2BE16(x) SWAP16(x)
66	#define LE2HOST16(x) (x)
67	#define BE2HOST16(x) SWAP16(x)
68
69	#endif
70
71	#define GETLEs16(X) ((int16_t)GETLE16((uint16_t *)X))
72	#define GETLEs32(X) ((int16_t)GETLE32((uint16_t *)X))
73
74	#define GETLE16(X) LE2HOST16((uint16_t )X)
75	#define GETLE32_(X) LE2HOST32((uint32_t )X)
76	#define GETLE16D(X) ({uint32_t val = GETLE32(X); (val<<16 \| val >> 16);})
77	#define PUTLE16(X, Y) do{((uint16_t )X)=HOST2LE16((uint16_t)Y);}while(0)
78	#define PUTLE32_(X, Y) do{((uint32_t )X)=HOST2LE16((uint32_t)Y);}while(0)
79	#ifdef __arm__
80	#define GETLE32(X) ((uint16_t )(X)\|(((uint16_t *)(X))[1]<<16))
81	#define PUTLE32(X, Y) do{uint16_t p_=(uint16_t )(X);uint32_t y_=Y;p_[0]=y_;p_[1]=y_>>16;}while(0)
82	#else
83	#define GETLE32 GETLE32_
84	#define PUTLE32 PUTLE32_
85	#endif
86
87	/////////////////////////////////////////////////////////////////////////////
88
89	typedef struct VRAMLOADTTAG
90	{
91	short x;
92	short y;
93	short Width;
94	short Height;
95	short RowsRemaining;
96	short ColsRemaining;
97	unsigned short *ImagePtr;
98	} VRAMLoad_t;
99
100	/////////////////////////////////////////////////////////////////////////////
101
102	typedef struct PSXPOINTTAG
103	{
104	int32_t x;
105	int32_t y;
106	} PSXPoint_t;
107
108	typedef struct PSXSPOINTTAG
109	{
110	short x;
111	short y;
112	} PSXSPoint_t;
113
114	typedef struct PSXRECTTAG
115	{
116	short x0;
117	short x1;
118	short y0;
119	short y1;
120	} PSXRect_t;
121
122	// linux defines for some windows stuff
123
124	#define FALSE 0
125	#define TRUE 1
126	#define BOOL unsigned short
127	#define LOWORD(l) ((unsigned short)(l))
128	#define HIWORD(l) ((unsigned short)(((uint32_t)(l) >> 16) & 0xFFFF))
129	#define max(a,b) (((a) > (b)) ? (a) : (b))
130	#define min(a,b) (((a) < (b)) ? (a) : (b))
131	#define DWORD uint32_t
132	#ifndef __int64
133	#define __int64 long long int
134	#endif
135
136	typedef struct RECTTAG
137	{
138	int left;
139	int top;
140	int right;
141	int bottom;
142	}RECT;
143
144	/////////////////////////////////////////////////////////////////////////////
145
146	typedef struct TWINTAG
147	{
148	PSXRect_t Position;
149	int xmask, ymask;
150	} TWin_t;
151
152	/////////////////////////////////////////////////////////////////////////////
153
154	typedef struct PSXDISPLAYTAG
155	{
156	PSXPoint_t DisplayModeNew;
157	PSXPoint_t DisplayMode;
158	PSXPoint_t DisplayPosition;
159	PSXPoint_t DisplayEnd;
160
161	int32_t Double;
162	int32_t Height;
163	int32_t PAL;
164	int32_t InterlacedNew;
165	int32_t Interlaced;
166	int32_t RGB24New;
167	int32_t RGB24;
168	PSXSPoint_t DrawOffset;
169	int32_t Disabled;
170	PSXRect_t Range;
171
172	} PSXDisplay_t;
173
174	/////////////////////////////////////////////////////////////////////////////
175
176	// draw.c
177
178	extern int32_t GlobalTextAddrX,GlobalTextAddrY,GlobalTextTP;
179	extern int32_t GlobalTextABR,GlobalTextPAGE;
180	extern short ly0,lx0,ly1,lx1,ly2,lx2,ly3,lx3;
181	extern long lLowerpart;
182	extern BOOL bCheckMask;
183	extern unsigned short sSetMask;
184	extern unsigned long lSetMask;
185	extern short g_m1;
186	extern short g_m2;
187	extern short g_m3;
188	extern short DrawSemiTrans;
189
190	// prim.c
191
192	extern BOOL bUsingTWin;
193	extern TWin_t TWin;
194	extern void (primTableJ[256])(unsigned char );
195	extern void (primTableSkip[256])(unsigned char );
196	extern unsigned short usMirror;
197	extern int iDither;
198	extern uint32_t dwCfgFixes;
199	extern uint32_t dwActFixes;
200	extern int iUseFixes;
201	extern int iUseDither;
202	extern BOOL bDoVSyncUpdate;
203	extern int32_t drawX;
204	extern int32_t drawY;
205	extern int32_t drawW;
206	extern int32_t drawH;
207
208	// gpu.h
209
210	#define OPAQUEON 10
211	#define OPAQUEOFF 11
212
213	#define KEY_RESETTEXSTORE 1
214	#define KEY_SHOWFPS 2
215	#define KEY_RESETOPAQUE 4
216	#define KEY_RESETDITHER 8
217	#define KEY_RESETFILTER 16
218	#define KEY_RESETADVBLEND 32
219	#define KEY_BADTEXTURES 128
220	#define KEY_CHECKTHISOUT 256
221
222	#if !defined(__BIG_ENDIAN__) \|\| defined(__x86_64__) \|\| defined(__i386__)
223	#ifndef __LITTLE_ENDIAN__
224	#define __LITTLE_ENDIAN__
225	#endif
226	#endif
227
228	#ifdef __LITTLE_ENDIAN__
229	#define RED(x) (x & 0xff)
230	#define BLUE(x) ((x>>16) & 0xff)
231	#define GREEN(x) ((x>>8) & 0xff)
232	#define COLOR(x) (x & 0xffffff)
233	#elif defined __BIG_ENDIAN__
234	#define RED(x) ((x>>24) & 0xff)
235	#define BLUE(x) ((x>>8) & 0xff)
236	#define GREEN(x) ((x>>16) & 0xff)
237	#define COLOR(x) SWAP32(x & 0xffffff)
238	#endif
239
240	PSXDisplay_t PSXDisplay;
241	unsigned char *psxVub;
242	signed char *psxVsb;
243	unsigned short *psxVuw;
244	unsigned short *psxVuw_eom;
245	signed short *psxVsw;
246	uint32_t *psxVul;
247	int32_t *psxVsl;
248
249	long lGPUstatusRet;
250	uint32_t lGPUInfoVals[16];
251
252	VRAMLoad_t VRAMWrite;
253	VRAMLoad_t VRAMRead;
254
255	DATAREGISTERMODES DataWriteMode;
256	DATAREGISTERMODES DataReadMode;
257
258	BOOL bCheckMask = FALSE;
259	unsigned short sSetMask = 0;
260	unsigned long lSetMask = 0;
261	long lLowerpart;
262
263	#include "../dfxvideo/soft.c"
264	#include "../dfxvideo/prim.c"
265
266	/////////////////////////////////////////////////////////////////////////////
267
268	int renderer_init(void)
269	{
270	psxVub=(void *)gpu.vram;
271
272	psxVsb=(signed char *)psxVub; // different ways of accessing PSX VRAM
273	psxVsw=(signed short *)psxVub;
274	psxVsl=(int32_t *)psxVub;
275	psxVuw=(unsigned short *)psxVub;
276	psxVul=(uint32_t *)psxVub;
277
278	psxVuw_eom=psxVuw+1024*512; // pre-calc of end of vram
279
280	PSXDisplay.RGB24 = FALSE; // init some stuff
281	PSXDisplay.Interlaced = FALSE;
282	PSXDisplay.DrawOffset.x = 0;
283	PSXDisplay.DrawOffset.y = 0;
284	PSXDisplay.DisplayMode.x= 320;
285	PSXDisplay.DisplayMode.y= 240;
286	PSXDisplay.Disabled = FALSE;
287	PSXDisplay.Range.x0=0;
288	PSXDisplay.Range.x1=0;
289	PSXDisplay.Double = 1;
290
291	DataWriteMode = DR_NORMAL;
292	lGPUstatusRet = 0x14802000;
293
294	return 0;
295	}
296
297	extern const unsigned char cmd_lengths[256];
298
299	void do_cmd_list(unsigned int *list, int list_len)
300	{
301	unsigned int cmd, len;
302
303	unsigned int *list_end = list + list_len;
304
305	for (; list < list_end; list += 1 + len)
306	{
b094071f	307	cmd = *list >> 24;
	308	len = cmd_lengths[cmd];
	309
	310	primTableJ[cmd]((void *)list);
	311
	312	switch(cmd)
	313	{
	314	case 0x48 ... 0x4F:
	315	{
	316	u32 num_vertexes = 1;
	317	u32 *list_position = &(list[2]);
	318
	319	while(1)
	320	{
	321	if((*list_position & 0xf000f000) == 0x50005000 \|\| list_position >= list_end)
	322	break;
	323
	324	list_position++;
	325	num_vertexes++;
	326	}
	327
	328	if(num_vertexes > 2)
	329	len += (num_vertexes - 2);
	330
	331	break;
	332	}
	333
	334	case 0x58 ... 0x5F:
	335	{
	336	u32 num_vertexes = 1;
	337	u32 *list_position = &(list[2]);
	338
	339	while(1)
	340	{
	341	if((*list_position & 0xf000f000) == 0x50005000 \|\| list_position >= list_end)
	342	break;
	343
	344	list_position += 2;
	345	num_vertexes++;
	346	}
	347
	348	if(num_vertexes > 2)
8aea5f5a	349	len += (num_vertexes - 2) * 2;
b094071f	350
	351	break;
	352	}
	353
9a6e7816	354	#ifdef TEST
b094071f	355	case 0xA0: // sys -> vid
b094071f	356	{
9a6e7816	357	short slist = (void )list;
b094071f	358	u32 load_width = slist[4];
	359	u32 load_height = slist[5];
	360	u32 load_size = load_width * load_height;
	361
	362	len += load_size / 2;
	363	break;
	364	}
9a6e7816	365	#endif
b094071f	366	}
	367	}
	368	}
	369
5b745e5b	370	void renderer_sync_ecmds(uint32_t *ecmds)
	371	{
	372	cmdTexturePage((unsigned char *)&ecmds[1]);
	373	cmdTextureWindow((unsigned char *)&ecmds[2]);
	374	cmdDrawAreaStart((unsigned char *)&ecmds[3]);
	375	cmdDrawAreaEnd((unsigned char *)&ecmds[4]);
	376	cmdDrawOffset((unsigned char *)&ecmds[5]);
	377	cmdSTP((unsigned char *)&ecmds[6]);
	378	}
	379
05740673	380	void renderer_update_caches(int x, int y, int w, int h)
b094071f	381	{
	382	}
	383
	384	void renderer_flush_queues(void)
	385	{
	386	}
914455e6	387
5440b88e	388	void renderer_set_interlace(int enable, int is_odd)
	389	{
	390	}
	391
914455e6	392	#include "../../frontend/plugin_lib.h"
	393
	394	void renderer_set_config(const struct rearmed_cbs *cbs)
	395	{
	396	iUseDither = cbs->gpu_peops.iUseDither;
	397	dwActFixes = cbs->gpu_peops.dwActFixes;
	398	}