notaz.gp2x.de / pcsx_rearmed.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
gpu-gles: schtruck/fpse merge: gl error checks
[pcsx_rearmed.git] / plugins / gpu-gles / gpuPrim.c
CommitLineData
ce879073 1/***************************************************************************\r
2 prim.c - description\r
3 -------------------\r
4 begin : Sun Mar 08 2009\r
5 copyright : (C) 1999-2009 by Pete Bernert\r
6 web : www.pbernert.com \r
7 ***************************************************************************/\r
8\r
9/***************************************************************************\r
10 * *\r
11 * This program is free software; you can redistribute it and/or modify *\r
12 * it under the terms of the GNU General Public License as published by *\r
13 * the Free Software Foundation; either version 2 of the License, or *\r
14 * (at your option) any later version. See also the license.txt file for *\r
15 * additional informations. *\r
16 * *\r
17 ***************************************************************************/\r
18\r
19//*************************************************************************// \r
20// History of changes:\r
21//\r
22// 2009/03/08 - Pete \r
23// - generic cleanup for the Peops release\r
24//\r
25//*************************************************************************// \r
26\r
27#define _IN_PRIMDRAW\r
28\r
ce879073 29#include "gpuStdafx.h"\r
30#include "gpuExternals.h"\r
31#include "gpuPlugin.h"\r
32#include "gpuDraw.h"\r
33#include "gpuTexture.h"\r
34#include "gpuPrim.h"\r
35\r
ce879073 36//////////////////////////////////////////////////////////////////////// \r
37// defines\r
38////////////////////////////////////////////////////////////////////////\r
39\r
40#define DEFOPAQUEON glAlphaFunc(GL_EQUAL,0.0f);bBlendEnable=FALSE;glDisable(GL_BLEND); \r
41#define DEFOPAQUEOFF glAlphaFunc(GL_GREATER,0.49f);\r
42#define fpoint(x) x\r
43//////////////////////////////////////////////////////////////////////// \r
44// globals\r
45////////////////////////////////////////////////////////////////////////\r
46\r
13326d3e 47EGLSurface surface;\r
48EGLDisplay display;\r
49\r
ce879073 50\r
51BOOL bDrawTextured; // current active drawing states\r
52BOOL bDrawSmoothShaded;\r
53BOOL bOldSmoothShaded;\r
54BOOL bDrawNonShaded;\r
55BOOL bDrawMultiPass;\r
56int iOffscreenDrawing;\r
57int iDrawnSomething=0;\r
58\r
59BOOL bRenderFrontBuffer=FALSE; // flag for front buffer rendering\r
60\r
61GLubyte ubGloAlpha; // texture alpha\r
62GLubyte ubGloColAlpha; // color alpha\r
63int iFilterType; // type of filter\r
64BOOL bFullVRam=FALSE; // sign for tex win\r
65BOOL bDrawDither; // sign for dither\r
66BOOL bUseMultiPass; // sign for multi pass\r
67GLuint gTexName; // binded texture\r
68BOOL bTexEnabled; // texture enable flag\r
69BOOL bBlendEnable; // blend enable flag\r
70PSXRect_t xrUploadArea; // rect to upload\r
71PSXRect_t xrUploadAreaIL; // rect to upload\r
72PSXRect_t xrUploadAreaRGB24; // rect to upload rgb24\r
73int iSpriteTex=0; // flag for "hey, it's a sprite"\r
74unsigned short usMirror; // mirror, mirror on the wall\r
75\r
76BOOL bNeedUploadAfter=FALSE; // sign for uploading in next frame\r
77BOOL bNeedUploadTest=FALSE; // sign for upload test\r
78BOOL bUsingTWin=FALSE; // tex win active flag\r
79BOOL bUsingMovie=FALSE; // movie active flag\r
80PSXRect_t xrMovieArea; // rect for movie upload\r
81short sSprite_ux2; // needed for sprire adjust\r
82short sSprite_vy2; // \r
83unsigned long ulOLDCOL=0; // active color\r
84unsigned long ulClutID; // clut\r
85\r
86unsigned long dwCfgFixes; // game fixes\r
87unsigned long dwActFixes=0;\r
88unsigned long dwEmuFixes=0;\r
89BOOL bUseFixes;\r
90\r
91long drawX,drawY,drawW,drawH; // offscreen drawing checkers\r
92short sxmin,sxmax,symin,symax;\r
93\r
94//////////////////////////////////////////////////////////////////////// \r
95// Update global TP infos\r
96////////////////////////////////////////////////////////////////////////\r
97\r
98void UpdateGlobalTP(unsigned short gdata)\r
99{\r
100 GlobalTextAddrX = (gdata << 6) & 0x3c0;\r
101\r
102 if(iGPUHeight==1024) // ZN mode\r
103 {\r
104 if(dwGPUVersion==2) // very special zn gpu\r
105 {\r
106 GlobalTextAddrY =((gdata & 0x60 ) << 3);\r
107 GlobalTextIL =(gdata & 0x2000) >> 13;\r
108 GlobalTextABR = (unsigned short)((gdata >> 7) & 0x3);\r
109 GlobalTextTP = (gdata >> 9) & 0x3;\r
110 if(GlobalTextTP==3) GlobalTextTP=2; \r
111 GlobalTexturePage = (GlobalTextAddrX>>6)+(GlobalTextAddrY>>4);\r
112 usMirror =0;\r
113 STATUSREG = (STATUSREG & 0xffffe000 ) | (gdata & 0x1fff );\r
114 return;\r
115 }\r
116 else // "enhanced" psx gpu\r
117 {\r
118 GlobalTextAddrY = (unsigned short)(((gdata << 4) & 0x100) | ((gdata >> 2) & 0x200));\r
119 }\r
120 }\r
121 else GlobalTextAddrY = (gdata << 4) & 0x100; // "normal" psx gpu\r
122\r
123 usMirror=gdata&0x3000;\r
124 \r
125 GlobalTextTP = (gdata >> 7) & 0x3; // tex mode (4,8,15)\r
126 if(GlobalTextTP==3) GlobalTextTP=2; // seen in Wild9 :(\r
127 GlobalTextABR = (gdata >> 5) & 0x3; // blend mode\r
128\r
129 GlobalTexturePage = (GlobalTextAddrX>>6)+(GlobalTextAddrY>>4);\r
130\r
131 STATUSREG&=~0x07ff; // Clear the necessary bits\r
132 STATUSREG|=(gdata & 0x07ff); // set the necessary bits\r
133}\r
134\r
135//////////////////////////////////////////////////////////////////////// \r
136// Some ASM color convertion... Lewpy's special...\r
137////////////////////////////////////////////////////////////////////////\r
138\r
ce879073 139\r
140unsigned long DoubleBGR2RGB (unsigned long BGR)\r
141{\r
142 unsigned long ebx,eax,edx;\r
143\r
144 ebx=(BGR&0x000000ff)<<1;\r
145 if(ebx&0x00000100) ebx=0x000000ff;\r
146\r
147 eax=(BGR&0x0000ff00)<<1;\r
148 if(eax&0x00010000) eax=0x0000ff00;\r
149\r
150 edx=(BGR&0x00ff0000)<<1;\r
151 if(edx&0x01000000) edx=0x00ff0000;\r
152\r
153 return (ebx|eax|edx);\r
154}\r
155\r
156unsigned short BGR24to16 (unsigned long BGR)\r
157{\r
158 return ((BGR>>3)&0x1f)|((BGR&0xf80000)>>9)|((BGR&0xf800)>>6);\r
159}\r
160\r
ce879073 161\r
162////////////////////////////////////////////////////////////////////////\r
163// OpenGL primitive drawing commands\r
164////////////////////////////////////////////////////////////////////////\r
165\r
13326d3e 166void PRIMdrawTexturedQuad(OGLVertex* vertex1, OGLVertex* vertex2,\r
ce879073 167 OGLVertex* vertex3, OGLVertex* vertex4) \r
168{\r
169\r
170\r
171Vertex v[4];\r
172\r
173v[0].xyz.x = fpoint(vertex1->x);\r
174v[0].xyz.y = fpoint(vertex1->y);\r
175v[0].xyz.z = fpoint(vertex1->z);\r
176v[0].st.x = fpoint(vertex1->sow);\r
177v[0].st.y = fpoint(vertex1->tow);\r
178\r
179v[1].xyz.x = fpoint(vertex2->x);\r
180v[1].xyz.y = fpoint(vertex2->y);\r
181v[1].xyz.z = fpoint(vertex2->z);\r
182v[1].st.x = fpoint(vertex2->sow);\r
183v[1].st.y = fpoint(vertex2->tow);\r
184\r
185v[2].xyz.x = fpoint(vertex4->x);\r
186v[2].xyz.y = fpoint(vertex4->y);\r
187v[2].xyz.z = fpoint(vertex4->z);\r
188v[2].st.x = fpoint(vertex4->sow);\r
189v[2].st.y = fpoint(vertex4->tow);\r
190\r
191v[3].xyz.x = fpoint(vertex3->x);\r
192v[3].xyz.y = fpoint(vertex3->y);\r
193v[3].xyz.z = fpoint(vertex3->z);\r
194v[3].st.x = fpoint(vertex3->sow);\r
195v[3].st.y = fpoint(vertex3->tow);\r
196\r
197glEnableClientState(GL_TEXTURE_COORD_ARRAY);\r
198glEnableClientState(GL_VERTEX_ARRAY);\r
199glTexCoordPointer(2, GL_FLOAT, sizeof(v[0]), &v[0].st);\r
200glVertexPointer(3, GL_FLOAT, sizeof(v[0]), &v[0].xyz);\r
201glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);\r
202glDisableClientState(GL_TEXTURE_COORD_ARRAY);\r
203glDisableClientState(GL_VERTEX_ARRAY); \r
204}\r
205\r
206///////////////////////////////////////////////////////// \r
207\r
208__inline void PRIMdrawTexturedTri(OGLVertex* vertex1, OGLVertex* vertex2, \r
209 OGLVertex* vertex3) \r
210{\r
211Vertex v[3];\r
212\r
213v[0].xyz.x = fpoint(vertex1->x);\r
214v[0].xyz.y = fpoint(vertex1->y);\r
215v[0].xyz.z = fpoint(vertex1->z);\r
216v[0].st.x = fpoint(vertex1->sow);\r
217v[0].st.y = fpoint(vertex1->tow);\r
218\r
219v[1].xyz.x = fpoint(vertex2->x);\r
220v[1].xyz.y = fpoint(vertex2->y);\r
221v[1].xyz.z = fpoint(vertex2->z);\r
222v[1].st.x = fpoint(vertex2->sow);\r
223v[1].st.y = fpoint(vertex2->tow);\r
224\r
225v[2].xyz.x = fpoint(vertex3->x);\r
226v[2].xyz.y = fpoint(vertex3->y);\r
227v[2].xyz.z = fpoint(vertex3->z);\r
228v[2].st.x = fpoint(vertex3->sow);\r
229v[2].st.y = fpoint(vertex3->tow);\r
230\r
231glEnableClientState(GL_TEXTURE_COORD_ARRAY);\r
232glEnableClientState(GL_VERTEX_ARRAY);\r
233glTexCoordPointer(2, GL_FLOAT, sizeof(v[0]), &v[0].st);\r
234glVertexPointer(3, GL_FLOAT, sizeof(v[0]), &v[0].xyz);\r
235glDrawArrays(GL_TRIANGLES, 0, 3);\r
236glDisableClientState(GL_TEXTURE_COORD_ARRAY);\r
237glDisableClientState(GL_VERTEX_ARRAY);\r
238\r
239}\r
240\r
241///////////////////////////////////////////////////////// \r
242\r
243__inline void PRIMdrawTexGouraudTriColor(OGLVertex* vertex1, OGLVertex* vertex2, \r
244 OGLVertex* vertex3) \r
245{\r
246\r
247Vertex2 v[3];\r
248\r
249v[0].xyz.x = fpoint(vertex1->x);\r
250v[0].xyz.y = fpoint(vertex1->y);\r
251v[0].xyz.z = fpoint(vertex1->z);\r
252v[0].st.x = fpoint(vertex1->sow);\r
253v[0].st.y = fpoint(vertex1->tow);\r
254v[0].rgba.r = vertex1->c.col[0];\r
255v[0].rgba.g = vertex1->c.col[1];\r
256v[0].rgba.b = vertex1->c.col[2];\r
257v[0].rgba.a = vertex1->c.col[3];\r
258\r
259v[1].xyz.x = fpoint(vertex2->x);\r
260v[1].xyz.y = fpoint(vertex2->y);\r
261v[1].xyz.z = fpoint(vertex2->z);\r
262v[1].st.x = fpoint(vertex2->sow);\r
263v[1].st.y = fpoint(vertex2->tow);\r
264v[1].rgba.r = vertex2->c.col[0];\r
265v[1].rgba.g = vertex2->c.col[1];\r
266v[1].rgba.b = vertex2->c.col[2];\r
267v[1].rgba.a = vertex2->c.col[3];\r
268\r
269v[2].xyz.x = fpoint(vertex3->x);\r
270v[2].xyz.y = fpoint(vertex3->y);\r
271v[2].xyz.z = fpoint(vertex3->z);\r
272v[2].st.x = fpoint(vertex3->sow);\r
273v[2].st.y = fpoint(vertex3->tow);\r
274v[2].rgba.r = vertex3->c.col[0];\r
275v[2].rgba.g = vertex3->c.col[1];\r
276v[2].rgba.b = vertex3->c.col[2];\r
277v[2].rgba.a = vertex3->c.col[3];\r
278\r
279glEnableClientState(GL_TEXTURE_COORD_ARRAY);\r
280glEnableClientState(GL_VERTEX_ARRAY);\r
281glEnableClientState(GL_COLOR_ARRAY);\r
282\r
283glTexCoordPointer(2, GL_FLOAT, sizeof(v[0]), &v[0].st);\r
284glVertexPointer(3, GL_FLOAT, sizeof(v[0]), &v[0].xyz);\r
285glColorPointer(4, GL_UNSIGNED_BYTE, sizeof(v[0]), &v[0].rgba);\r
286\r
287glDrawArrays(GL_TRIANGLES, 0, 3);\r
288glDisableClientState(GL_TEXTURE_COORD_ARRAY);\r
289glDisableClientState(GL_VERTEX_ARRAY);\r
290glDisableClientState(GL_COLOR_ARRAY);\r
291}\r
292\r
293///////////////////////////////////////////////////////// \r
294\r
295__inline void PRIMdrawTexGouraudTriColorQuad(OGLVertex* vertex1, OGLVertex* vertex2, \r
296 OGLVertex* vertex3, OGLVertex* vertex4) \r
297{\r
298Vertex2 v[4];\r
299\r
300v[0].xyz.x = fpoint(vertex1->x);\r
301v[0].xyz.y = fpoint(vertex1->y);\r
302v[0].xyz.z = fpoint(vertex1->z);\r
303v[0].st.x = fpoint(vertex1->sow);\r
304v[0].st.y = fpoint(vertex1->tow);\r
305v[0].rgba.r = vertex1->c.col[0];\r
306v[0].rgba.g = vertex1->c.col[1];\r
307v[0].rgba.b = vertex1->c.col[2];\r
308v[0].rgba.a = vertex1->c.col[3];\r
309\r
310v[1].xyz.x = fpoint(vertex2->x);\r
311v[1].xyz.y = fpoint(vertex2->y);\r
312v[1].xyz.z = fpoint(vertex2->z);\r
313v[1].st.x = fpoint(vertex2->sow);\r
314v[1].st.y = fpoint(vertex2->tow);\r
315v[1].rgba.r = vertex2->c.col[0];\r
316v[1].rgba.g = vertex2->c.col[1];\r
317v[1].rgba.b = vertex2->c.col[2];\r
318v[1].rgba.a = vertex2->c.col[3];\r
319\r
320v[2].xyz.x = fpoint(vertex4->x);\r
321v[2].xyz.y = fpoint(vertex4->y);\r
322v[2].xyz.z = fpoint(vertex4->z);\r
323v[2].st.x = fpoint(vertex4->sow);\r
324v[2].st.y = fpoint(vertex4->tow);\r
325v[2].rgba.r = vertex4->c.col[0];\r
326v[2].rgba.g = vertex4->c.col[1];\r
327v[2].rgba.b = vertex4->c.col[2];\r
328v[2].rgba.a = vertex4->c.col[3];\r
329\r
330v[3].xyz.x = fpoint(vertex3->x);\r
331v[3].xyz.y = fpoint(vertex3->y);\r
332v[3].xyz.z = fpoint(vertex3->z);\r
333v[3].st.x = fpoint(vertex3->sow);\r
334v[3].st.y = fpoint(vertex3->tow);\r
335v[3].rgba.r = vertex3->c.col[0];\r
336v[3].rgba.g = vertex3->c.col[1];\r
337v[3].rgba.b = vertex3->c.col[2];\r
338v[3].rgba.a = vertex3->c.col[3];\r
339\r
340glEnableClientState(GL_TEXTURE_COORD_ARRAY);\r
341glEnableClientState(GL_VERTEX_ARRAY);\r
342glEnableClientState(GL_COLOR_ARRAY);\r
343\r
344glTexCoordPointer(2, GL_FLOAT, sizeof(v[0]), &v[0].st);\r
345glVertexPointer(3, GL_FLOAT, sizeof(v[0]), &v[0].xyz);\r
346glColorPointer(4, GL_UNSIGNED_BYTE, sizeof(v[0]), &v[0].rgba);\r
347\r
348glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);\r
349glDisableClientState(GL_TEXTURE_COORD_ARRAY);\r
350glDisableClientState(GL_VERTEX_ARRAY);\r
351glDisableClientState(GL_COLOR_ARRAY);\r
352}\r
353\r
354///////////////////////////////////////////////////////// \r
355\r
356__inline void PRIMdrawTri(OGLVertex* vertex1, OGLVertex* vertex2, OGLVertex* vertex3) \r
357{\r
358Vec3f v[3];\r
359\r
360v[0].x = fpoint(vertex1->x);\r
361v[0].y = fpoint(vertex1->y);\r
362v[0].z = fpoint(vertex1->z);\r
363\r
364v[1].x = fpoint(vertex2->x);\r
365v[1].y = fpoint(vertex2->y);\r
366v[1].z = fpoint(vertex2->z);\r
367\r
368v[2].x = fpoint(vertex3->x);\r
369v[2].y = fpoint(vertex3->y);\r
370v[2].z = fpoint(vertex3->z);\r
371\r
372glEnableClientState(GL_VERTEX_ARRAY);\r
373glVertexPointer(3, GL_FLOAT, sizeof(v[0]), &v[0]);\r
374glDrawArrays(GL_TRIANGLES, 0, 3);\r
375glDisableClientState(GL_VERTEX_ARRAY);\r
376}\r
377\r
378///////////////////////////////////////////////////////// \r
379\r
380__inline void PRIMdrawTri2(OGLVertex* vertex1, OGLVertex* vertex2, \r
381 OGLVertex* vertex3, OGLVertex* vertex4) \r
382{\r
383Vec3f v[4];\r
384\r
385v[0].x = fpoint(vertex1->x);\r
386v[0].y = fpoint(vertex1->y);\r
387v[0].z = fpoint(vertex1->z);\r
388\r
389v[1].x = fpoint(vertex3->x);\r
390v[1].y = fpoint(vertex3->y);\r
391v[1].z = fpoint(vertex3->z);\r
392\r
393v[2].x = fpoint(vertex2->x);\r
394v[2].y = fpoint(vertex2->y);\r
395v[2].z = fpoint(vertex2->z);\r
396\r
397v[3].x = fpoint(vertex4->x);\r
398v[3].y = fpoint(vertex4->y);\r
399v[3].z = fpoint(vertex4->z);\r
400\r
401glEnableClientState(GL_VERTEX_ARRAY);\r
402glVertexPointer(3, GL_FLOAT, sizeof(v[0]), &v[0]);\r
403glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);\r
404glDisableClientState(GL_VERTEX_ARRAY);\r
405}\r
406\r
407///////////////////////////////////////////////////////// \r
408\r
409__inline void PRIMdrawGouraudTriColor(OGLVertex* vertex1, OGLVertex* vertex2, \r
410 OGLVertex* vertex3) \r
411{\r
412Vertex2 v[3];\r
413\r
414v[0].xyz.x = fpoint(vertex1->x);\r
415v[0].xyz.y = fpoint(vertex1->y);\r
416v[0].xyz.z = fpoint(vertex1->z);\r
417v[0].rgba.r = vertex1->c.col[0];\r
418v[0].rgba.g = vertex1->c.col[1];\r
419v[0].rgba.b = vertex1->c.col[2];\r
420v[0].rgba.a = vertex1->c.col[3];\r
421\r
422v[1].xyz.x = fpoint(vertex2->x);\r
423v[1].xyz.y = fpoint(vertex2->y);\r
424v[1].xyz.z = fpoint(vertex2->z);\r
425v[1].rgba.r = vertex2->c.col[0];\r
426v[1].rgba.g = vertex2->c.col[1];\r
427v[1].rgba.b = vertex2->c.col[2];\r
428v[1].rgba.a = vertex2->c.col[3];\r
429\r
430v[2].xyz.x = fpoint(vertex3->x);\r
431v[2].xyz.y = fpoint(vertex3->y);\r
432v[2].xyz.z = fpoint(vertex3->z);\r
433v[2].rgba.r = vertex3->c.col[0];\r
434v[2].rgba.g = vertex3->c.col[1];\r
435v[2].rgba.b = vertex3->c.col[2];\r
436v[2].rgba.a = vertex3->c.col[3];\r
437\r
438glEnableClientState(GL_VERTEX_ARRAY);\r
439glEnableClientState(GL_COLOR_ARRAY);\r
440\r
441glVertexPointer(3, GL_FLOAT, sizeof(v[0]), &v[0].xyz);\r
442glColorPointer(4, GL_UNSIGNED_BYTE, sizeof(v[0]), &v[0].rgba);\r
443\r
444glDrawArrays(GL_TRIANGLES, 0, 3);\r
445glDisableClientState(GL_VERTEX_ARRAY);\r
446glDisableClientState(GL_COLOR_ARRAY);\r
447}\r
448\r
449///////////////////////////////////////////////////////// \r
450\r
451__inline void PRIMdrawGouraudTri2Color(OGLVertex* vertex1, OGLVertex* vertex2, \r
452 OGLVertex* vertex3, OGLVertex* vertex4) \r
453{\r
454Vertex2 v[4];\r
455\r
456v[0].xyz.x = fpoint(vertex1->x);\r
457v[0].xyz.y = fpoint(vertex1->y);\r
458v[0].xyz.z = fpoint(vertex1->z);\r
459v[0].rgba.r = vertex1->c.col[0];\r
460v[0].rgba.g = vertex1->c.col[1];\r
461v[0].rgba.b = vertex1->c.col[2];\r
462v[0].rgba.a = vertex1->c.col[3];\r
463\r
464v[1].xyz.x = fpoint(vertex2->x);\r
465v[1].xyz.y = fpoint(vertex2->y);\r
466v[1].xyz.z = fpoint(vertex2->z);\r
467v[1].rgba.r = vertex2->c.col[0];\r
468v[1].rgba.g = vertex2->c.col[1];\r
469v[1].rgba.b = vertex2->c.col[2];\r
470v[1].rgba.a = vertex2->c.col[3];\r
471\r
472v[2].xyz.x = fpoint(vertex3->x);\r
473v[2].xyz.y = fpoint(vertex3->y);\r
474v[2].xyz.z = fpoint(vertex3->z);\r
475v[2].rgba.r = vertex3->c.col[0];\r
476v[2].rgba.g = vertex3->c.col[1];\r
477v[2].rgba.b = vertex3->c.col[2];\r
478v[2].rgba.a = vertex3->c.col[3];\r
479\r
480v[3].xyz.x = fpoint(vertex4->x);\r
481v[3].xyz.y = fpoint(vertex4->y);\r
482v[3].xyz.z = fpoint(vertex4->z);\r
483v[3].rgba.r = vertex4->c.col[0];\r
484v[3].rgba.g = vertex4->c.col[1];\r
485v[3].rgba.b = vertex4->c.col[2];\r
486v[3].rgba.a = vertex4->c.col[3];\r
487\r
488glEnableClientState(GL_VERTEX_ARRAY);\r
489glEnableClientState(GL_COLOR_ARRAY);\r
490\r
491glVertexPointer(3, GL_FLOAT, sizeof(v[0]), &v[0].xyz);\r
492glColorPointer(4, GL_UNSIGNED_BYTE, sizeof(v[0]), &v[0].rgba);\r
493\r
494glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);\r
495glDisableClientState(GL_VERTEX_ARRAY);\r
496glDisableClientState(GL_COLOR_ARRAY);\r
497}\r
498\r
499///////////////////////////////////////////////////////// \r
500\r
501__inline void PRIMdrawFlatLine(OGLVertex* vertex1, OGLVertex* vertex2,OGLVertex* vertex3, OGLVertex* vertex4)\r
502{\r
503Vertex2 v[4];\r
504\r
505v[0].xyz.x = fpoint(vertex1->x);\r
506v[0].xyz.y = fpoint(vertex1->y);\r
507v[0].xyz.z = fpoint(vertex1->z);\r
508v[0].rgba.r = vertex1->c.col[0];\r
509v[0].rgba.g = vertex1->c.col[1];\r
510v[0].rgba.b = vertex1->c.col[2];\r
511v[0].rgba.a = vertex1->c.col[3];\r
512\r
513v[1].xyz.x = fpoint(vertex2->x);\r
514v[1].xyz.y = fpoint(vertex2->y);\r
515v[1].xyz.z = fpoint(vertex2->z);\r
516v[1].rgba.r = vertex1->c.col[0];\r
517v[1].rgba.g = vertex1->c.col[1];\r
518v[1].rgba.b = vertex1->c.col[2];\r
519v[1].rgba.a = vertex1->c.col[3];\r
520\r
521v[2].xyz.x = fpoint(vertex4->x);\r
522v[2].xyz.y = fpoint(vertex4->y);\r
523v[2].xyz.z = fpoint(vertex4->z);\r
524v[2].rgba.r = vertex1->c.col[0];\r
525v[2].rgba.g = vertex1->c.col[1];\r
526v[2].rgba.b = vertex1->c.col[2];\r
527v[2].rgba.a = vertex1->c.col[3];\r
528\r
529v[3].xyz.x = fpoint(vertex3->x);\r
530v[3].xyz.y = fpoint(vertex3->y);\r
531v[3].xyz.z = fpoint(vertex3->z);\r
532v[3].rgba.r = vertex1->c.col[0];\r
533v[3].rgba.g = vertex1->c.col[1];\r
534v[3].rgba.b = vertex1->c.col[2];\r
535v[3].rgba.a = vertex1->c.col[3];\r
536\r
537glEnableClientState(GL_VERTEX_ARRAY);\r
538glEnableClientState(GL_COLOR_ARRAY);\r
539\r
540glVertexPointer(3, GL_FLOAT, sizeof(v[0]), &v[0].xyz);\r
541glColorPointer(4, GL_UNSIGNED_BYTE, sizeof(v[0]), &v[0].rgba);\r
542\r
543glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);\r
544glDisableClientState(GL_VERTEX_ARRAY);\r
545glDisableClientState(GL_COLOR_ARRAY);\r
546\r
547\r
548}\r
549\r
550///////////////////////////////////////////////////////// \r
551 \r
552__inline void PRIMdrawGouraudLine(OGLVertex* vertex1, OGLVertex* vertex2,OGLVertex* vertex3, OGLVertex* vertex4)\r
553{\r
554 Vertex2 v[4];\r
555\r
556v[0].xyz.x = fpoint(vertex1->x);\r
557v[0].xyz.y = fpoint(vertex1->y);\r
558v[0].xyz.z = fpoint(vertex1->z);\r
559v[0].rgba.r = vertex1->c.col[0];\r
560v[0].rgba.g = vertex1->c.col[1];\r
561v[0].rgba.b = vertex1->c.col[2];\r
562v[0].rgba.a = vertex1->c.col[3];\r
563\r
564v[1].xyz.x = fpoint(vertex2->x);\r
565v[1].xyz.y = fpoint(vertex2->y);\r
566v[1].xyz.z = fpoint(vertex2->z);\r
567v[1].rgba.r = vertex2->c.col[0];\r
568v[1].rgba.g = vertex2->c.col[1];\r
569v[1].rgba.b = vertex2->c.col[2];\r
570v[1].rgba.a = vertex2->c.col[3];\r
571\r
572v[3].xyz.x = fpoint(vertex3->x);\r
573v[3].xyz.y = fpoint(vertex3->y);\r
574v[3].xyz.z = fpoint(vertex3->z);\r
575v[3].rgba.r = vertex3->c.col[0];\r
576v[3].rgba.g = vertex3->c.col[1];\r
577v[3].rgba.b = vertex3->c.col[2];\r
578v[3].rgba.a = vertex3->c.col[3];\r
579\r
580v[2].xyz.x = fpoint(vertex4->x);\r
581v[2].xyz.y = fpoint(vertex4->y);\r
582v[2].xyz.z = fpoint(vertex4->z);\r
583v[2].rgba.r = vertex4->c.col[0];\r
584v[2].rgba.g = vertex4->c.col[1];\r
585v[2].rgba.b = vertex4->c.col[2];\r
586v[2].rgba.a = vertex4->c.col[3];\r
587\r
588glEnableClientState(GL_VERTEX_ARRAY);\r
589glEnableClientState(GL_COLOR_ARRAY);\r
590\r
591glVertexPointer(3, GL_FLOAT, sizeof(v[0]), &v[0].xyz);\r
592glColorPointer(4, GL_UNSIGNED_BYTE, sizeof(v[0]), &v[0].rgba);\r
593\r
594glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);\r
595glDisableClientState(GL_VERTEX_ARRAY);\r
596glDisableClientState(GL_COLOR_ARRAY);\r
597}\r
598\r
599///////////////////////////////////////////////////////// \r
600 \r
601__inline void PRIMdrawQuad(OGLVertex* vertex1, OGLVertex* vertex2, \r
602 OGLVertex* vertex3, OGLVertex* vertex4) \r
603{\r
604Vec3f v[4];\r
605\r
606v[0].x = fpoint(vertex1->x);\r
607v[0].y = fpoint(vertex1->y);\r
608v[0].z = fpoint(vertex1->z);\r
609\r
610v[1].x = fpoint(vertex2->x);\r
611v[1].y = fpoint(vertex2->y);\r
612v[1].z = fpoint(vertex2->z);\r
613\r
614v[2].x = fpoint(vertex4->x);\r
615v[2].y = fpoint(vertex4->y);\r
616v[2].z = fpoint(vertex4->z);\r
617\r
618v[3].x = fpoint(vertex3->x);\r
619v[3].y = fpoint(vertex3->y);\r
620v[3].z = fpoint(vertex3->z);\r
621\r
622glEnableClientState(GL_VERTEX_ARRAY);\r
623glVertexPointer(3, GL_FLOAT, sizeof(v[0]), &v[0]);\r
624glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);\r
625glDisableClientState(GL_VERTEX_ARRAY);\r
626}\r
627\r
628//////////////////////////////////////////////////////////////////////// \r
629// Transparent blending settings\r
630////////////////////////////////////////////////////////////////////////\r
631\r
632static GLenum obm1=GL_ZERO;\r
633static GLenum obm2=GL_ZERO;\r
634\r
635typedef struct SEMITRANSTAG\r
636{\r
637 GLenum srcFac;\r
638 GLenum dstFac;\r
639 GLubyte alpha;\r
640} SemiTransParams;\r
641\r
642SemiTransParams TransSets[4]=\r
643{\r
644 {GL_SRC_ALPHA,GL_SRC_ALPHA, 127},\r
645 {GL_ONE, GL_ONE, 255},\r
646 {GL_ZERO, GL_ONE_MINUS_SRC_COLOR,255},\r
647 {GL_ONE_MINUS_SRC_ALPHA,GL_ONE, 192}\r
648}; \r
649\r
650////////////////////////////////////////////////////////////////////////\r
651\r
652void SetSemiTrans(void)\r
653{\r
654/*\r
655* 0.5 x B + 0.5 x F\r
656* 1.0 x B + 1.0 x F\r
657* 1.0 x B - 1.0 x F\r
658* 1.0 x B +0.25 x F\r
659*/\r
660\r
661 if(!DrawSemiTrans) // no semi trans at all?\r
662 {\r
663 if(bBlendEnable)\r
9f58cabb 664 {glDisable(GL_BLEND);glError();bBlendEnable=FALSE;}// -> don't wanna blend\r
ce879073 665 ubGloAlpha=ubGloColAlpha=255; // -> full alpha\r
666 return; // -> and bye\r
667 }\r
668\r
669 ubGloAlpha=ubGloColAlpha=TransSets[GlobalTextABR].alpha;\r
670\r
671 if(!bBlendEnable)\r
9f58cabb 672 {glEnable(GL_BLEND);glError();bBlendEnable=TRUE;} // wanna blend\r
ce879073 673\r
674 if(TransSets[GlobalTextABR].srcFac!=obm1 || \r
675 TransSets[GlobalTextABR].dstFac!=obm2)\r
676 {\r
677 //if(glBlendEquationEXTEx==NULL)\r
678 {\r
679 obm1=TransSets[GlobalTextABR].srcFac;\r
680 obm2=TransSets[GlobalTextABR].dstFac;\r
9f58cabb 681 glBlendFunc(obm1,obm2); glError(); // set blend func\r
ce879073 682 }\r
683 /*else\r
684 if(TransSets[GlobalTextABR].dstFac !=GL_ONE_MINUS_SRC_COLOR)\r
685 {\r
686 if(obm2==GL_ONE_MINUS_SRC_COLOR)\r
687 glBlendEquationEXTEx(FUNC_ADD_EXT);\r
688 obm1=TransSets[GlobalTextABR].srcFac;\r
689 obm2=TransSets[GlobalTextABR].dstFac;\r
690 glBlendFunc(obm1,obm2); // set blend func\r
691 }\r
692 else\r
693 {\r
694 glBlendEquationEXTEx(FUNC_REVERSESUBTRACT_EXT);\r
695 obm1=TransSets[GlobalTextABR].srcFac;\r
696 obm2=TransSets[GlobalTextABR].dstFac;\r
697 glBlendFunc(GL_ONE,GL_ONE); // set blend func\r
698 }*/\r
699 }\r
700}\r
701\r
702void SetScanTrans(void) // blending for scan lines\r
703{\r
704/* if(glBlendEquationEXTEx!=NULL)\r
705 {\r
706 if(obm2==GL_ONE_MINUS_SRC_COLOR)\r
707 glBlendEquationEXTEx(FUNC_ADD_EXT);\r
708 }\r
709*/\r
710 obm1=TransSets[0].srcFac;\r
711 obm2=TransSets[0].dstFac;\r
9f58cabb 712 glBlendFunc(obm1,obm2); glError(); // set blend func\r
ce879073 713}\r
714\r
715void SetScanTexTrans(void) // blending for scan mask texture\r
716{\r
717/* if(glBlendEquationEXTEx!=NULL)\r
718 {\r
719 if(obm2==GL_ONE_MINUS_SRC_COLOR)\r
720 glBlendEquationEXTEx(FUNC_ADD_EXT);\r
721 }\r
722*/\r
723 obm1=TransSets[2].srcFac;\r
724 obm2=TransSets[2].dstFac;\r
9f58cabb 725 glBlendFunc(obm1,obm2); glError(); // set blend func\r
ce879073 726}\r
727\r
728//////////////////////////////////////////////////////////////////////// \r
729// multi pass in old 'Advanced blending' mode... got it from Lewpy :)\r
730//////////////////////////////////////////////////////////////////////// \r
731\r
732SemiTransParams MultiTexTransSets[4][2]=\r
733{\r
734 {\r
735 {GL_ONE ,GL_SRC_ALPHA, 127},\r
736 {GL_SRC_ALPHA,GL_ONE, 127}\r
737 },\r
738 {\r
739 {GL_ONE, GL_SRC_ALPHA, 255},\r
740 {GL_SRC_ALPHA,GL_ONE, 255}\r
741 },\r
742 {\r
743 {GL_ZERO, GL_ONE_MINUS_SRC_COLOR,255},\r
744 {GL_ZERO, GL_ONE_MINUS_SRC_COLOR,255}\r
745 },\r
746 {\r
747 {GL_SRC_ALPHA,GL_ONE, 127},\r
748 {GL_ONE_MINUS_SRC_ALPHA,GL_ONE, 255}\r
749 }\r
750}; \r
751\r
752//////////////////////////////////////////////////////////////////////// \r
753\r
754SemiTransParams MultiColTransSets[4]=\r
755{\r
756 {GL_ONE_MINUS_SRC_ALPHA,GL_SRC_ALPHA,127},\r
757 {GL_ONE, GL_ONE, 255},\r
758 {GL_ZERO, GL_ONE_MINUS_SRC_COLOR,255},\r
759 {GL_SRC_ALPHA,GL_ONE, 127}\r
760}; \r
761\r
762//////////////////////////////////////////////////////////////////////// \r
763\r
764void SetSemiTransMulti(int Pass)\r
765{\r
766 static GLenum bm1=GL_ZERO;\r
767 static GLenum bm2=GL_ONE;\r
768\r
769 ubGloAlpha=255;\r
770 ubGloColAlpha=255;\r
771 \r
772 // are we enabling SemiTransparent mode?\r
773 if(DrawSemiTrans)\r
774 {\r
775 if(bDrawTextured)\r
776 {\r
777 bm1=MultiTexTransSets[GlobalTextABR][Pass].srcFac;\r
778 bm2=MultiTexTransSets[GlobalTextABR][Pass].dstFac;\r
779 ubGloAlpha=MultiTexTransSets[GlobalTextABR][Pass].alpha;\r
780 }\r
781 // no texture\r
782 else\r
783 {\r
784 bm1=MultiColTransSets[GlobalTextABR].srcFac;\r
785 bm2=MultiColTransSets[GlobalTextABR].dstFac;\r
786 ubGloColAlpha=MultiColTransSets[GlobalTextABR].alpha;\r
787 }\r
788 }\r
789 // no shading\r
790 else\r
791 {\r
792 if(Pass==0)\r
793 {\r
794 // disable blending\r
795 bm1=GL_ONE;bm2=GL_ZERO;\r
796 }\r
797 else\r
798 {\r
799 // disable blending, but add src col a second time\r
800 bm1=GL_ONE;bm2=GL_ONE;\r
801 }\r
802 }\r
803\r
804 if(!bBlendEnable)\r
9f58cabb 805 {glEnable(GL_BLEND);glError();bBlendEnable=TRUE;} // wanna blend\r
ce879073 806\r
807 if(bm1!=obm1 || bm2!=obm2)\r
808 {\r
9f58cabb 809 glBlendFunc(bm1,bm2); glError(); // set blend func\r
ce879073 810 obm1=bm1;obm2=bm2;\r
811 }\r
812}\r
813\r
814//////////////////////////////////////////////////////////////////////// \r
815// Set several rendering stuff including blending \r
816////////////////////////////////////////////////////////////////////////\r
817\r
818__inline void SetZMask3O(void)\r
819{\r
820 if(iUseMask && DrawSemiTrans && !iSetMask)\r
821 {\r
822 vertex[0].z=vertex[1].z=vertex[2].z=gl_z;\r
823 gl_z+=0.00004f;\r
824 }\r
825}\r
826\r
827__inline void SetZMask3(void)\r
828{\r
829 if(iUseMask)\r
830 {\r
831 if(iSetMask || DrawSemiTrans)\r
832 {vertex[0].z=vertex[1].z=vertex[2].z=0.95f;}\r
833 else\r
834 {\r
835 vertex[0].z=vertex[1].z=vertex[2].z=gl_z;\r
836 gl_z+=0.00004f;\r
837 }\r
838 }\r
839}\r
840\r
841__inline void SetZMask3NT(void)\r
842{\r
843 if(iUseMask)\r
844 {\r
845 if(iSetMask)\r
846 {vertex[0].z=vertex[1].z=vertex[2].z=0.95f;}\r
847 else\r
848 {\r
849 vertex[0].z=vertex[1].z=vertex[2].z=gl_z;\r
850 gl_z+=0.00004f;\r
851 }\r
852 }\r
853}\r
854\r
855////////////////////////////////////////////////////////////////////////\r
856\r
857__inline void SetZMask4O(void)\r
858{\r
859 if(iUseMask && DrawSemiTrans && !iSetMask)\r
860 {\r
861 vertex[0].z=vertex[1].z=vertex[2].z=vertex[3].z=gl_z;\r
862 gl_z+=0.00004f;\r
863 }\r
864}\r
865\r
866__inline void SetZMask4(void)\r
867{\r
868 if(iUseMask)\r
869 {\r
870 if(iSetMask || DrawSemiTrans)\r
871 {vertex[0].z=vertex[1].z=vertex[2].z=vertex[3].z=0.95f;}\r
872 else\r
873 {\r
874 vertex[0].z=vertex[1].z=vertex[2].z=vertex[3].z=gl_z;\r
875 gl_z+=0.00004f;\r
876 }\r
877 }\r
878}\r
879\r
880__inline void SetZMask4NT(void)\r
881{\r
882 if(iUseMask)\r
883 {\r
884 if(iSetMask==1)\r
885 {vertex[0].z=vertex[1].z=vertex[2].z=vertex[3].z=0.95f;}\r
886 else\r
887 {\r
888 vertex[0].z=vertex[1].z=vertex[2].z=vertex[3].z=gl_z;\r
889 gl_z+=0.00004f;\r
890 }\r
891 }\r
892}\r
893\r
894__inline void SetZMask4SP(void)\r
895{\r
896 if(iUseMask)\r
897 {\r
898 if(iSetMask==1)\r
899 {vertex[0].z=vertex[1].z=vertex[2].z=vertex[3].z=0.95f;}\r
900 else\r
901 {\r
902 if(bCheckMask)\r
903 {\r
904 vertex[0].z=vertex[1].z=vertex[2].z=vertex[3].z=gl_z;\r
905 gl_z+=0.00004f;\r
906 }\r
907 else\r
908 {vertex[0].z=vertex[1].z=vertex[2].z=vertex[3].z=0.95f;}\r
909 }\r
910 }\r
911}\r
912\r
913////////////////////////////////////////////////////////////////////////\r
914\r
915__inline void SetRenderState(unsigned long DrawAttributes)\r
916{\r
917 bDrawNonShaded = (SHADETEXBIT(DrawAttributes)) ? TRUE : FALSE;\r
918 DrawSemiTrans = (SEMITRANSBIT(DrawAttributes)) ? TRUE : FALSE;\r
919} \r
920\r
921//////////////////////////////////////////////////////////////////////// \r
922\r
923__inline void SetRenderColor(unsigned long DrawAttributes)\r
924{\r
925 if(bDrawNonShaded) {g_m1=g_m2=g_m3=128;}\r
926 else\r
927 {\r
928 g_m1=DrawAttributes&0xff;\r
929 g_m2=(DrawAttributes>>8)&0xff;\r
930 g_m3=(DrawAttributes>>16)&0xff;\r
931 }\r
932}\r
933\r
934//////////////////////////////////////////////////////////////////////// \r
935 \r
936void SetRenderMode(unsigned long DrawAttributes,BOOL bSCol)\r
937{\r
938 if((bUseMultiPass) && (bDrawTextured) && !(bDrawNonShaded))\r
939 {bDrawMultiPass = TRUE; SetSemiTransMulti(0);}\r
940 else {bDrawMultiPass = FALSE;SetSemiTrans();}\r
941\r
942 if(bDrawTextured) // texture ? build it/get it from cache\r
943 {\r
944 GLuint currTex;\r
945 if(bUsingTWin) currTex=LoadTextureWnd(GlobalTexturePage,GlobalTextTP, ulClutID);\r
946 else if(bUsingMovie) currTex=LoadTextureMovie();\r
947 else currTex=SelectSubTextureS(GlobalTextTP,ulClutID);\r
948\r
949 if(gTexName!=currTex)\r
9f58cabb 950 {gTexName=currTex;glBindTexture(GL_TEXTURE_2D,currTex); glError();}\r
ce879073 951\r
952 if(!bTexEnabled) // -> turn texturing on\r
9f58cabb 953 {bTexEnabled=TRUE;glEnable(GL_TEXTURE_2D); glError();}\r
ce879073 954 }\r
955 else // no texture ?\r
956 if(bTexEnabled) \r
9f58cabb 957 {bTexEnabled=FALSE;glDisable(GL_TEXTURE_2D); glError();} // -> turn texturing off\r
ce879073 958\r
959 if(bSCol) // also set color ?\r
960 {\r
961 if((dwActFixes&4) && ((DrawAttributes&0x00ffffff)==0))\r
962 DrawAttributes|=0x007f7f7f;\r
963\r
964 if(bDrawNonShaded) // -> non shaded?\r
965 {\r
966/* if(bGLBlend) vertex[0].c.lcol=0x7f7f7f; // --> solid color...\r
967 else */vertex[0].c.lcol=0xffffff;\r
968 }\r
969 else // -> shaded?\r
970 {\r
971// if(!bUseMultiPass && !bGLBlend) // --> given color...\r
972 vertex[0].c.lcol=DoubleBGR2RGB(DrawAttributes);\r
973// else vertex[0].c.lcol=DrawAttributes;\r
974 }\r
975 vertex[0].c.col[3]=ubGloAlpha; // -> set color with\r
976 SETCOL(vertex[0]); // texture alpha\r
977 }\r
978 \r
979 if(bDrawSmoothShaded!=bOldSmoothShaded) // shading changed?\r
980 {\r
981 if(bDrawSmoothShaded) glShadeModel(GL_SMOOTH); // -> set actual shading\r
982 else glShadeModel(GL_FLAT);\r
9f58cabb 983 glError();\r
ce879073 984 bOldSmoothShaded=bDrawSmoothShaded;\r
985 }\r
986}\r
987\r
988//////////////////////////////////////////////////////////////////////// \r
989// Set Opaque multipass color\r
990////////////////////////////////////////////////////////////////////////\r
991\r
992void SetOpaqueColor(unsigned long DrawAttributes)\r
993{\r
994 if(bDrawNonShaded) return; // no shading? bye\r
995 \r
996 DrawAttributes=DoubleBGR2RGB(DrawAttributes); // multipass is just half color, so double it on opaque pass\r
997 vertex[0].c.lcol=DrawAttributes|0xff000000;\r
998 SETCOL(vertex[0]); // set color\r
999}\r
1000\r
1001//////////////////////////////////////////////////////////////////////// \r
1002// Fucking stupid screen coord checking\r
1003////////////////////////////////////////////////////////////////////////\r
1004\r
1005BOOL ClipVertexListScreen(void)\r
1006{\r
1007 if (lx0 >= PSXDisplay.DisplayEnd.x) goto NEXTSCRTEST;\r
1008 if (ly0 >= PSXDisplay.DisplayEnd.y) goto NEXTSCRTEST;\r
1009 if (lx2 < PSXDisplay.DisplayPosition.x) goto NEXTSCRTEST;\r
1010 if (ly2 < PSXDisplay.DisplayPosition.y) goto NEXTSCRTEST;\r
1011\r
1012 return TRUE;\r
1013\r
1014NEXTSCRTEST:\r
1015 if(PSXDisplay.InterlacedTest) return FALSE;\r
1016\r
1017 if (lx0 >= PreviousPSXDisplay.DisplayEnd.x) return FALSE;\r
1018 if (ly0 >= PreviousPSXDisplay.DisplayEnd.y) return FALSE;\r
1019 if (lx2 < PreviousPSXDisplay.DisplayPosition.x) return FALSE;\r
1020 if (ly2 < PreviousPSXDisplay.DisplayPosition.y) return FALSE;\r
1021\r
1022 return TRUE;\r
1023}\r
1024\r
1025////////////////////////////////////////////////////////////////////////\r
1026\r
1027BOOL bDrawOffscreenFront(void)\r
1028{\r
1029 if(sxmin < PSXDisplay.DisplayPosition.x) return FALSE; // must be complete in front\r
1030 if(symin < PSXDisplay.DisplayPosition.y) return FALSE;\r
1031 if(sxmax > PSXDisplay.DisplayEnd.x) return FALSE;\r
1032 if(symax > PSXDisplay.DisplayEnd.y) return FALSE;\r
1033 return TRUE;\r
1034}\r
1035\r
1036BOOL bOnePointInFront(void)\r
1037{\r
1038 if(sxmax< PSXDisplay.DisplayPosition.x)\r
1039 return FALSE;\r
1040\r
1041 if(symax< PSXDisplay.DisplayPosition.y)\r
1042 return FALSE;\r
1043\r
1044 if(sxmin>=PSXDisplay.DisplayEnd.x)\r
1045 return FALSE;\r
1046\r
1047 if(symin>=PSXDisplay.DisplayEnd.y)\r
1048 return FALSE;\r
1049\r
1050 return TRUE;\r
1051}\r
1052 \r
1053\r
1054BOOL bOnePointInBack(void)\r
1055{\r
1056 if(sxmax< PreviousPSXDisplay.DisplayPosition.x)\r
1057 return FALSE;\r
1058\r
1059 if(symax< PreviousPSXDisplay.DisplayPosition.y)\r
1060 return FALSE;\r
1061\r
1062 if(sxmin>=PreviousPSXDisplay.DisplayEnd.x)\r
1063 return FALSE;\r
1064\r
1065 if(symin>=PreviousPSXDisplay.DisplayEnd.y)\r
1066 return FALSE;\r
1067\r
1068 return TRUE;\r
1069}\r
1070 \r
1071BOOL bDrawOffscreen4(void)\r
1072{\r
1073 BOOL bFront;short sW,sH;\r
1074\r
1075 sxmax=max(lx0,max(lx1,max(lx2,lx3)));\r
1076 if(sxmax<drawX) return FALSE;\r
1077 sxmin=min(lx0,min(lx1,min(lx2,lx3)));\r
1078 if(sxmin>drawW) return FALSE;\r
1079 symax=max(ly0,max(ly1,max(ly2,ly3)));\r
1080 if(symax<drawY) return FALSE;\r
1081 symin=min(ly0,min(ly1,min(ly2,ly3)));\r
1082 if(symin>drawH) return FALSE;\r
1083\r
1084 if(PSXDisplay.Disabled) return TRUE; // disabled? ever\r
1085\r
1086 if(iOffscreenDrawing==1) return bFullVRam;\r
1087\r
1088 if(dwActFixes&1 && iOffscreenDrawing==4)\r
1089 {\r
1090 if(PreviousPSXDisplay.DisplayPosition.x==PSXDisplay.DisplayPosition.x &&\r
1091 PreviousPSXDisplay.DisplayPosition.y==PSXDisplay.DisplayPosition.y &&\r
1092 PreviousPSXDisplay.DisplayEnd.x==PSXDisplay.DisplayEnd.x &&\r
1093 PreviousPSXDisplay.DisplayEnd.y==PSXDisplay.DisplayEnd.y)\r
1094 {\r
1095 bRenderFrontBuffer=TRUE;\r
1096 return FALSE;\r
1097 }\r
1098 }\r
1099\r
1100 sW=drawW-1;sH=drawH-1;\r
1101 \r
1102 sxmin=min(sW,max(sxmin,drawX));\r
1103 sxmax=max(drawX,min(sxmax,sW));\r
1104 symin=min(sH,max(symin,drawY));\r
1105 symax=max(drawY,min(symax,sH));\r
1106\r
1107 if(bOnePointInBack()) return bFullVRam;\r
1108\r
1109 if(iOffscreenDrawing==2) \r
1110 bFront=bDrawOffscreenFront();\r
1111 else bFront=bOnePointInFront();\r
1112\r
1113 if(bFront)\r
1114 {\r
1115 if(PSXDisplay.InterlacedTest) return bFullVRam; // -> ok, no need for adjust\r
1116 \r
1117 vertex[0].x=lx0 - PSXDisplay.DisplayPosition.x+PreviousPSXDisplay.Range.x0;\r
1118 vertex[1].x=lx1 - PSXDisplay.DisplayPosition.x+PreviousPSXDisplay.Range.x0;\r
1119 vertex[2].x=lx2 - PSXDisplay.DisplayPosition.x+PreviousPSXDisplay.Range.x0;\r
1120 vertex[3].x=lx3 - PSXDisplay.DisplayPosition.x+PreviousPSXDisplay.Range.x0;\r
1121 vertex[0].y=ly0 - PSXDisplay.DisplayPosition.y+PreviousPSXDisplay.Range.y0;\r
1122 vertex[1].y=ly1 - PSXDisplay.DisplayPosition.y+PreviousPSXDisplay.Range.y0;\r
1123 vertex[2].y=ly2 - PSXDisplay.DisplayPosition.y+PreviousPSXDisplay.Range.y0;\r
1124 vertex[3].y=ly3 - PSXDisplay.DisplayPosition.y+PreviousPSXDisplay.Range.y0;\r
1125\r
1126 if(iOffscreenDrawing==4 && !(dwActFixes&1)) // -> frontbuffer wanted\r
1127 {\r
1128 bRenderFrontBuffer=TRUE;\r
1129 //return TRUE;\r
1130 }\r
1131 return bFullVRam; // -> but no od\r
1132 }\r
1133\r
1134 return TRUE;\r
1135}\r
1136\r
1137////////////////////////////////////////////////////////////////////////\r
1138 \r
1139BOOL bDrawOffscreen3(void)\r
1140{\r
1141 BOOL bFront;short sW,sH;\r
1142\r
1143 sxmax=max(lx0,max(lx1,lx2));\r
1144 if(sxmax<drawX) return FALSE;\r
1145 sxmin=min(lx0,min(lx1,lx2));\r
1146 if(sxmin>drawW) return FALSE;\r
1147 symax=max(ly0,max(ly1,ly2));\r
1148 if(symax<drawY) return FALSE;\r
1149 symin=min(ly0,min(ly1,ly2));\r
1150 if(symin>drawH) return FALSE;\r
1151\r
1152 if(PSXDisplay.Disabled) return TRUE; // disabled? ever\r
1153\r
1154 if(iOffscreenDrawing==1) return bFullVRam;\r
1155\r
1156 sW=drawW-1;sH=drawH-1;\r
1157 sxmin=min(sW,max(sxmin,drawX));\r
1158 sxmax=max(drawX,min(sxmax,sW));\r
1159 symin=min(sH,max(symin,drawY));\r
1160 symax=max(drawY,min(symax,sH));\r
1161\r
1162 if(bOnePointInBack()) return bFullVRam;\r
1163\r
1164 if(iOffscreenDrawing==2) \r
1165 bFront=bDrawOffscreenFront();\r
1166 else bFront=bOnePointInFront();\r
1167\r
1168 if(bFront)\r
1169 {\r
1170 if(PSXDisplay.InterlacedTest) return bFullVRam; // -> ok, no need for adjust\r
1171\r
1172 vertex[0].x=lx0 - PSXDisplay.DisplayPosition.x+PreviousPSXDisplay.Range.x0;\r
1173 vertex[1].x=lx1 - PSXDisplay.DisplayPosition.x+PreviousPSXDisplay.Range.x0;\r
1174 vertex[2].x=lx2 - PSXDisplay.DisplayPosition.x+PreviousPSXDisplay.Range.x0;\r
1175 vertex[0].y=ly0 - PSXDisplay.DisplayPosition.y+PreviousPSXDisplay.Range.y0;\r
1176 vertex[1].y=ly1 - PSXDisplay.DisplayPosition.y+PreviousPSXDisplay.Range.y0;\r
1177 vertex[2].y=ly2 - PSXDisplay.DisplayPosition.y+PreviousPSXDisplay.Range.y0;\r
1178\r
1179 if(iOffscreenDrawing==4) // -> frontbuffer wanted\r
1180 {\r
1181 bRenderFrontBuffer=TRUE;\r
1182 // return TRUE;\r
1183 }\r
1184\r
1185 return bFullVRam; // -> but no od\r
1186 }\r
1187\r
1188 return TRUE;\r
1189}\r
1190\r
1191////////////////////////////////////////////////////////////////////////\r
1192\r
1193BOOL FastCheckAgainstScreen(short imageX0,short imageY0,short imageX1,short imageY1)\r
1194{\r
1195 PSXRect_t xUploadArea;\r
1196\r
1197 imageX1 += imageX0;\r
1198 imageY1 += imageY0;\r
1199\r
1200 if (imageX0 < PreviousPSXDisplay.DisplayPosition.x)\r
1201 xUploadArea.x0 = PreviousPSXDisplay.DisplayPosition.x;\r
1202 else\r
1203 if (imageX0 > PreviousPSXDisplay.DisplayEnd.x)\r
1204 xUploadArea.x0 = PreviousPSXDisplay.DisplayEnd.x;\r
1205 else\r
1206 xUploadArea.x0 = imageX0;\r
1207\r
1208 if(imageX1 < PreviousPSXDisplay.DisplayPosition.x)\r
1209 xUploadArea.x1 = PreviousPSXDisplay.DisplayPosition.x;\r
1210 else\r
1211 if (imageX1 > PreviousPSXDisplay.DisplayEnd.x)\r
1212 xUploadArea.x1 = PreviousPSXDisplay.DisplayEnd.x;\r
1213 else\r
1214 xUploadArea.x1 = imageX1;\r
1215\r
1216 if (imageY0 < PreviousPSXDisplay.DisplayPosition.y)\r
1217 xUploadArea.y0 = PreviousPSXDisplay.DisplayPosition.y;\r
1218 else\r
1219 if (imageY0 > PreviousPSXDisplay.DisplayEnd.y)\r
1220 xUploadArea.y0 = PreviousPSXDisplay.DisplayEnd.y;\r
1221 else\r
1222 xUploadArea.y0 = imageY0;\r
1223\r
1224 if (imageY1 < PreviousPSXDisplay.DisplayPosition.y)\r
1225 xUploadArea.y1 = PreviousPSXDisplay.DisplayPosition.y;\r
1226 else\r
1227 if (imageY1 > PreviousPSXDisplay.DisplayEnd.y)\r
1228 xUploadArea.y1 = PreviousPSXDisplay.DisplayEnd.y;\r
1229 else\r
1230 xUploadArea.y1 = imageY1;\r
1231\r
1232 if ((xUploadArea.x0 != xUploadArea.x1) && (xUploadArea.y0 != xUploadArea.y1))\r
1233 return TRUE;\r
1234 else return FALSE;\r
1235}\r
1236\r
1237BOOL CheckAgainstScreen(short imageX0,short imageY0,short imageX1,short imageY1)\r
1238{\r
1239 imageX1 += imageX0;\r
1240 imageY1 += imageY0;\r
1241\r
1242 if (imageX0 < PreviousPSXDisplay.DisplayPosition.x)\r
1243 xrUploadArea.x0 = PreviousPSXDisplay.DisplayPosition.x;\r
1244 else\r
1245 if (imageX0 > PreviousPSXDisplay.DisplayEnd.x)\r
1246 xrUploadArea.x0 = PreviousPSXDisplay.DisplayEnd.x;\r
1247 else\r
1248 xrUploadArea.x0 = imageX0;\r
1249\r
1250 if(imageX1 < PreviousPSXDisplay.DisplayPosition.x)\r
1251 xrUploadArea.x1 = PreviousPSXDisplay.DisplayPosition.x;\r
1252 else\r
1253 if (imageX1 > PreviousPSXDisplay.DisplayEnd.x)\r
1254 xrUploadArea.x1 = PreviousPSXDisplay.DisplayEnd.x;\r
1255 else\r
1256 xrUploadArea.x1 = imageX1;\r
1257\r
1258 if (imageY0 < PreviousPSXDisplay.DisplayPosition.y)\r
1259 xrUploadArea.y0 = PreviousPSXDisplay.DisplayPosition.y;\r
1260 else\r
1261 if (imageY0 > PreviousPSXDisplay.DisplayEnd.y)\r
1262 xrUploadArea.y0 = PreviousPSXDisplay.DisplayEnd.y;\r
1263 else\r
1264 xrUploadArea.y0 = imageY0;\r
1265\r
1266 if (imageY1 < PreviousPSXDisplay.DisplayPosition.y)\r
1267 xrUploadArea.y1 = PreviousPSXDisplay.DisplayPosition.y;\r
1268 else\r
1269 if (imageY1 > PreviousPSXDisplay.DisplayEnd.y)\r
1270 xrUploadArea.y1 = PreviousPSXDisplay.DisplayEnd.y;\r
1271 else\r
1272 xrUploadArea.y1 = imageY1;\r
1273\r
1274 if ((xrUploadArea.x0 != xrUploadArea.x1) && (xrUploadArea.y0 != xrUploadArea.y1))\r
1275 return TRUE;\r
1276 else return FALSE;\r
1277}\r
1278\r
1279BOOL FastCheckAgainstFrontScreen(short imageX0,short imageY0,short imageX1,short imageY1)\r
1280{\r
1281 PSXRect_t xUploadArea;\r
1282\r
1283 imageX1 += imageX0;\r
1284 imageY1 += imageY0;\r
1285\r
1286 if (imageX0 < PSXDisplay.DisplayPosition.x)\r
1287 xUploadArea.x0 = PSXDisplay.DisplayPosition.x;\r
1288 else\r
1289 if (imageX0 > PSXDisplay.DisplayEnd.x)\r
1290 xUploadArea.x0 = PSXDisplay.DisplayEnd.x;\r
1291 else\r
1292 xUploadArea.x0 = imageX0;\r
1293\r
1294 if(imageX1 < PSXDisplay.DisplayPosition.x)\r
1295 xUploadArea.x1 = PSXDisplay.DisplayPosition.x;\r
1296 else\r
1297 if (imageX1 > PSXDisplay.DisplayEnd.x)\r
1298 xUploadArea.x1 = PSXDisplay.DisplayEnd.x;\r
1299 else\r
1300 xUploadArea.x1 = imageX1;\r
1301\r
1302 if (imageY0 < PSXDisplay.DisplayPosition.y)\r
1303 xUploadArea.y0 = PSXDisplay.DisplayPosition.y;\r
1304 else\r
1305 if (imageY0 > PSXDisplay.DisplayEnd.y)\r
1306 xUploadArea.y0 = PSXDisplay.DisplayEnd.y;\r
1307 else\r
1308 xUploadArea.y0 = imageY0;\r
1309\r
1310 if (imageY1 < PSXDisplay.DisplayPosition.y)\r
1311 xUploadArea.y1 = PSXDisplay.DisplayPosition.y;\r
1312 else\r
1313 if (imageY1 > PSXDisplay.DisplayEnd.y)\r
1314 xUploadArea.y1 = PSXDisplay.DisplayEnd.y;\r
1315 else\r
1316 xUploadArea.y1 = imageY1;\r
1317\r
1318 if ((xUploadArea.x0 != xUploadArea.x1) && (xUploadArea.y0 != xUploadArea.y1))\r
1319 return TRUE; \r
1320 else return FALSE;\r
1321}\r
1322\r
1323BOOL CheckAgainstFrontScreen(short imageX0,short imageY0,short imageX1,short imageY1)\r
1324{\r
1325 imageX1 += imageX0;\r
1326 imageY1 += imageY0;\r
1327\r
1328 if (imageX0 < PSXDisplay.DisplayPosition.x)\r
1329 xrUploadArea.x0 = PSXDisplay.DisplayPosition.x;\r
1330 else\r
1331 if (imageX0 > PSXDisplay.DisplayEnd.x)\r
1332 xrUploadArea.x0 = PSXDisplay.DisplayEnd.x;\r
1333 else\r
1334 xrUploadArea.x0 = imageX0;\r
1335\r
1336 if(imageX1 < PSXDisplay.DisplayPosition.x)\r
1337 xrUploadArea.x1 = PSXDisplay.DisplayPosition.x;\r
1338 else\r
1339 if (imageX1 > PSXDisplay.DisplayEnd.x)\r
1340 xrUploadArea.x1 = PSXDisplay.DisplayEnd.x;\r
1341 else\r
1342 xrUploadArea.x1 = imageX1;\r
1343\r
1344 if (imageY0 < PSXDisplay.DisplayPosition.y)\r
1345 xrUploadArea.y0 = PSXDisplay.DisplayPosition.y;\r
1346 else\r
1347 if (imageY0 > PSXDisplay.DisplayEnd.y)\r
1348 xrUploadArea.y0 = PSXDisplay.DisplayEnd.y;\r
1349 else\r
1350 xrUploadArea.y0 = imageY0;\r
1351\r
1352 if (imageY1 < PSXDisplay.DisplayPosition.y)\r
1353 xrUploadArea.y1 = PSXDisplay.DisplayPosition.y;\r
1354 else\r
1355 if (imageY1 > PSXDisplay.DisplayEnd.y)\r
1356 xrUploadArea.y1 = PSXDisplay.DisplayEnd.y;\r
1357 else\r
1358 xrUploadArea.y1 = imageY1;\r
1359\r
1360 if ((xrUploadArea.x0 != xrUploadArea.x1) && (xrUploadArea.y0 != xrUploadArea.y1))\r
1361 return TRUE; \r
1362 else return FALSE;\r
1363}\r
1364\r
1365////////////////////////////////////////////////////////////////////////\r
1366\r
1367void PrepareFullScreenUpload (long Position)\r
1368{\r
1369 if (Position==-1) // rgb24\r
1370 {\r
1371 if(PSXDisplay.Interlaced)\r
1372 {\r
1373 xrUploadArea.x0 = PSXDisplay.DisplayPosition.x;\r
1374 xrUploadArea.x1 = PSXDisplay.DisplayEnd.x;\r
1375 xrUploadArea.y0 = PSXDisplay.DisplayPosition.y;\r
1376 xrUploadArea.y1 = PSXDisplay.DisplayEnd.y;\r
1377 }\r
1378 else\r
1379 {\r
1380 xrUploadArea.x0 = PreviousPSXDisplay.DisplayPosition.x;\r
1381 xrUploadArea.x1 = PreviousPSXDisplay.DisplayEnd.x;\r
1382 xrUploadArea.y0 = PreviousPSXDisplay.DisplayPosition.y;\r
1383 xrUploadArea.y1 = PreviousPSXDisplay.DisplayEnd.y;\r
1384 }\r
1385\r
1386 if(bNeedRGB24Update)\r
1387 {\r
1388 if(lClearOnSwap) \r
1389 {\r
1390// lClearOnSwap=0;\r
1391 }\r
1392 else \r
1393 if(PSXDisplay.Interlaced && PreviousPSXDisplay.RGB24<2) // in interlaced mode we upload at least two full frames (GT1 menu)\r
1394 {\r
1395 PreviousPSXDisplay.RGB24++;\r
1396 }\r
1397 else\r
1398 {\r
1399 xrUploadArea.y1 = min(xrUploadArea.y0+xrUploadAreaRGB24.y1,xrUploadArea.y1);\r
1400 xrUploadArea.y0+=xrUploadAreaRGB24.y0;\r
1401 }\r
1402 }\r
1403 }\r
1404 else\r
1405 if (Position)\r
1406 {\r
1407 xrUploadArea.x0 = PSXDisplay.DisplayPosition.x;\r
1408 xrUploadArea.x1 = PSXDisplay.DisplayEnd.x;\r
1409 xrUploadArea.y0 = PSXDisplay.DisplayPosition.y;\r
1410 xrUploadArea.y1 = PSXDisplay.DisplayEnd.y;\r
1411 }\r
1412 else\r
1413 {\r
1414 xrUploadArea.x0 = PreviousPSXDisplay.DisplayPosition.x;\r
1415 xrUploadArea.x1 = PreviousPSXDisplay.DisplayEnd.x;\r
1416 xrUploadArea.y0 = PreviousPSXDisplay.DisplayPosition.y;\r
1417 xrUploadArea.y1 = PreviousPSXDisplay.DisplayEnd.y;\r
1418 }\r
1419\r
1420 if (xrUploadArea.x0 < 0) xrUploadArea.x0 = 0;\r
1421 else\r
1422 if (xrUploadArea.x0 > 1023) xrUploadArea.x0 = 1023;\r
1423\r
1424 if (xrUploadArea.x1 < 0) xrUploadArea.x1 = 0;\r
1425 else\r
1426 if (xrUploadArea.x1 > 1024) xrUploadArea.x1 = 1024;\r
1427\r
1428 if (xrUploadArea.y0 < 0) xrUploadArea.y0 = 0;\r
1429 else\r
1430 if (xrUploadArea.y0 > iGPUHeightMask) xrUploadArea.y0 = iGPUHeightMask;\r
1431\r
1432 if (xrUploadArea.y1 < 0) xrUploadArea.y1 = 0;\r
1433 else\r
1434 if (xrUploadArea.y1 > iGPUHeight) xrUploadArea.y1 = iGPUHeight;\r
1435\r
1436 if (PSXDisplay.RGB24)\r
1437 {\r
1438 InvalidateTextureArea(xrUploadArea.x0,xrUploadArea.y0,xrUploadArea.x1-xrUploadArea.x0,xrUploadArea.y1-xrUploadArea.y0);\r
1439 }\r
1440}\r
1441\r
1442////////////////////////////////////////////////////////////////////////\r
1443// Upload screen (MDEC and such)\r
1444////////////////////////////////////////////////////////////////////////\r
1445////////////////////////////////////////////////////////////////////////\r
1446\r
677ea103 1447unsigned char * LoadDirectMovieFast(void);\r
ce879073 1448\r
1449void UploadScreenEx(long Position)\r
1450{\r
1451 short ya,yb,xa,xb,x, y, YStep, XStep, U, UStep,ux[4],vy[4];\r
1452\r
1453 if(!PSXDisplay.DisplayMode.x) return;\r
1454 if(!PSXDisplay.DisplayMode.y) return;\r
1455\r
9f58cabb 1456 glDisable(GL_SCISSOR_TEST); glError();\r
1457 glShadeModel(GL_FLAT); glError();\r
ce879073 1458 bOldSmoothShaded=FALSE;\r
9f58cabb 1459 glDisable(GL_BLEND); glError();\r
ce879073 1460 bBlendEnable=FALSE;\r
9f58cabb 1461 glDisable(GL_TEXTURE_2D); glError();\r
ce879073 1462 bTexEnabled=FALSE;\r
9f58cabb 1463 glDisable(GL_ALPHA_TEST); glError();\r
ce879073 1464\r
1465 //glPixelZoom(((float)rRatioRect.right)/((float)PSXDisplay.DisplayMode.x),\r
1466 // -1.0f*(((float)rRatioRect.bottom)/((float)PSXDisplay.DisplayMode.y)));\r
1467 \r
1468 //----------------------------------------------------//\r
1469\r
1470 YStep = 256; // max texture size\r
1471 XStep = 256;\r
1472 UStep = (PSXDisplay.RGB24 ? 128 : 0);\r
1473 ya = xrUploadArea.y0;\r
1474 yb = xrUploadArea.y1;\r
1475 xa = xrUploadArea.x0;\r
1476 xb = xrUploadArea.x1;\r
1477 \r
1478 for(y=ya;y<=yb;y+=YStep) // loop y\r
1479 {\r
1480 U = 0;\r
1481 for(x=xa;x<=xb;x+=XStep) // loop x\r
1482 {\r
1483 ly0 = ly1 = y; // -> get y coords\r
1484 ly2 = y + YStep;\r
1485 if (ly2 > yb) ly2 = yb;\r
1486 ly3 = ly2;\r
1487\r
1488 lx0 = lx3 = x; // -> get x coords\r
1489 lx1 = x + XStep;\r
1490 if (lx1 > xb) lx1 = xb;\r
1491\r
1492 lx2 = lx1;\r
1493\r
1494 ux[0]=ux[3]=(xa - x); // -> set tex x coords\r
1495 if (ux[0] < 0) ux[0]=ux[3]=0;\r
1496 ux[2]=ux[1]=(xb - x);\r
1497 if (ux[2] > 256) ux[2]=ux[1]=256;\r
1498\r
1499 vy[0]=vy[1]=(ya - y); // -> set tex y coords\r
1500 if (vy[0] < 0) vy[0]=vy[1]=0;\r
1501 vy[2]=vy[3]=(yb - y);\r
1502 if (vy[2] > 256) vy[2]=vy[3]=256;\r
1503\r
1504 if ((ux[0] >= ux[2]) || // -> cheaters never win...\r
1505 (vy[0] >= vy[2])) continue; // (but winners always cheat...)\r
1506 \r
1507 xrMovieArea.x0=lx0+U; xrMovieArea.y0=ly0;\r
1508 xrMovieArea.x1=lx2+U; xrMovieArea.y1=ly2;\r
1509 \r
1510 offsetScreenUpload(Position);\r
1511\r
1512 //glRasterPos2f(vertex[0].x,vertex[0].y);\r
1513\r
1514 //glDrawPixels(xrMovieArea.x1-xrMovieArea.x0,\r
1515 // xrMovieArea.y1-xrMovieArea.y0,\r
1516 // GL_RGBA,GL_UNSIGNED_BYTE,\r
1517 LoadDirectMovieFast();//);\r
1518\r
1519 U+=UStep;\r
1520 }\r
1521 }\r
1522\r
1523 //----------------------------------------------------//\r
1524\r
1525// glPixelZoom(1.0F,1.0F);\r
1526\r
9f58cabb 1527 glEnable(GL_ALPHA_TEST); glError();\r
1528 glEnable(GL_SCISSOR_TEST); glError();\r
ce879073 1529}\r
1530\r
1531////////////////////////////////////////////////////////////////////////\r
1532\r
1533void UploadScreen(long Position)\r
1534{\r
1535 short x, y, YStep, XStep, U, s, UStep,ux[4],vy[4];\r
1536 short xa,xb,ya,yb;\r
1537\r
1538 if(xrUploadArea.x0>1023) xrUploadArea.x0=1023;\r
1539 if(xrUploadArea.x1>1024) xrUploadArea.x1=1024;\r
1540 if(xrUploadArea.y0>iGPUHeightMask) xrUploadArea.y0=iGPUHeightMask;\r
1541 if(xrUploadArea.y1>iGPUHeight) xrUploadArea.y1=iGPUHeight;\r
1542\r
1543 if(xrUploadArea.x0==xrUploadArea.x1) return;\r
1544 if(xrUploadArea.y0==xrUploadArea.y1) return;\r
1545\r
1546 if(PSXDisplay.Disabled && iOffscreenDrawing<4) return;\r
1547\r
1548 iDrawnSomething = 2;\r
1549 iLastRGB24=PSXDisplay.RGB24+1;\r
1550\r
1551 if(bSkipNextFrame) return;\r
1552\r
1553 if(dwActFixes & 2) {UploadScreenEx(Position);return;}\r
1554\r
1555 bUsingMovie = TRUE;\r
1556 bDrawTextured = TRUE; // just doing textures\r
1557 bDrawSmoothShaded = FALSE;\r
1558\r
1559/* if(bGLBlend) vertex[0].c.lcol=0xff7f7f7f; // set solid col\r
1560 else */vertex[0].c.lcol=0xffffffff;\r
1561 SETCOL(vertex[0]); \r
1562\r
1563 SetOGLDisplaySettings(0);\r
1564\r
1565 YStep = 256; // max texture size\r
1566 XStep = 256;\r
1567\r
1568 UStep = (PSXDisplay.RGB24 ? 128 : 0);\r
1569 \r
1570 ya=xrUploadArea.y0;\r
1571 yb=xrUploadArea.y1;\r
1572 xa=xrUploadArea.x0;\r
1573 xb=xrUploadArea.x1;\r
1574\r
1575 for(y=ya;y<=yb;y+=YStep) // loop y\r
1576 {\r
1577 U = 0;\r
1578 for(x=xa;x<=xb;x+=XStep) // loop x\r
1579 {\r
1580 ly0 = ly1 = y; // -> get y coords\r
1581 ly2 = y + YStep;\r
1582 if (ly2 > yb) ly2 = yb;\r
1583 ly3 = ly2;\r
1584\r
1585 lx0 = lx3 = x; // -> get x coords\r
1586 lx1 = x + XStep;\r
1587 if (lx1 > xb) lx1 = xb;\r
1588\r
1589 lx2 = lx1;\r
1590\r
1591 ux[0]=ux[3]=(xa - x); // -> set tex x coords\r
1592 if (ux[0] < 0) ux[0]=ux[3]=0;\r
1593 ux[2]=ux[1]=(xb - x);\r
1594 if (ux[2] > 256) ux[2]=ux[1]=256;\r
1595\r
1596 vy[0]=vy[1]=(ya - y); // -> set tex y coords\r
1597 if (vy[0] < 0) vy[0]=vy[1]=0;\r
1598 vy[2]=vy[3]=(yb - y);\r
1599 if (vy[2] > 256) vy[2]=vy[3]=256;\r
1600\r
1601 if ((ux[0] >= ux[2]) || // -> cheaters never win...\r
1602 (vy[0] >= vy[2])) continue; // (but winners always cheat...)\r
1603 \r
1604 xrMovieArea.x0=lx0+U; xrMovieArea.y0=ly0;\r
1605 xrMovieArea.x1=lx2+U; xrMovieArea.y1=ly2;\r
1606\r
1607 s=ux[2] - ux[0]; if(s>255) s=255;\r
1608\r
1609 gl_ux[2] = gl_ux[1] = s;\r
1610 s=vy[2] - vy[0]; if(s>255) s=255;\r
1611 gl_vy[2] = gl_vy[3] = s;\r
1612 gl_ux[0] = gl_ux[3] = gl_vy[0] = gl_vy[1] = 0;\r
1613\r
1614 SetRenderState((unsigned long)0x01000000);\r
1615 SetRenderMode((unsigned long)0x01000000, FALSE); // upload texture data\r
1616 offsetScreenUpload(Position);\r
1617 assignTextureVRAMWrite();\r
1618\r
1619 PRIMdrawTexturedQuad(&vertex[0], &vertex[1], &vertex[2], &vertex[3]);\r
1620\r
1621 U+=UStep;\r
1622 }\r
1623 }\r
1624\r
1625 bUsingMovie=FALSE; // done...\r
1626 bDisplayNotSet = TRUE;\r
1627}\r
1628\r
1629////////////////////////////////////////////////////////////////////////\r
1630// Detect next screen\r
1631////////////////////////////////////////////////////////////////////////\r
1632\r
1633BOOL IsCompleteInsideNextScreen(short x, short y, short xoff, short yoff)\r
1634{ \r
1635 if (x > PSXDisplay.DisplayPosition.x+1) return FALSE;\r
1636 if ((x + xoff) < PSXDisplay.DisplayEnd.x-1) return FALSE;\r
1637 yoff+=y;\r
1638 if (y >= PSXDisplay.DisplayPosition.y &&\r
1639 y <= PSXDisplay.DisplayEnd.y )\r
1640 {\r
1641 if ((yoff) >= PSXDisplay.DisplayPosition.y &&\r
1642 (yoff) <= PSXDisplay.DisplayEnd.y ) return TRUE;\r
1643 } \r
1644 if (y > PSXDisplay.DisplayPosition.y+1) return FALSE;\r
1645 if (yoff < PSXDisplay.DisplayEnd.y-1) return FALSE;\r
1646 return TRUE;\r
1647}\r
1648\r
1649BOOL IsPrimCompleteInsideNextScreen(short x, short y, short xoff, short yoff)\r
1650{\r
1651 x+=PSXDisplay.DrawOffset.x;\r
1652 if (x > PSXDisplay.DisplayPosition.x+1) return FALSE;\r
1653 y+=PSXDisplay.DrawOffset.y;\r
1654 if (y > PSXDisplay.DisplayPosition.y+1) return FALSE;\r
1655 xoff+=PSXDisplay.DrawOffset.x;\r
1656 if (xoff < PSXDisplay.DisplayEnd.x-1) return FALSE;\r
1657 yoff+=PSXDisplay.DrawOffset.y;\r
1658 if (yoff < PSXDisplay.DisplayEnd.y-1) return FALSE;\r
1659 return TRUE;\r
1660}\r
1661\r
1662BOOL IsInsideNextScreen(short x, short y, short xoff, short yoff)\r
1663{ \r
1664 if (x > PSXDisplay.DisplayEnd.x) return FALSE;\r
1665 if (y > PSXDisplay.DisplayEnd.y) return FALSE;\r
1666 if ((x + xoff) < PSXDisplay.DisplayPosition.x) return FALSE;\r
1667 if ((y + yoff) < PSXDisplay.DisplayPosition.y) return FALSE;\r
1668 return TRUE;\r
1669}\r
1670\r
1671////////////////////////////////////////////////////////////////////////\r
1672// mask stuff...\r
1673////////////////////////////////////////////////////////////////////////\r
1674\r
1675//Mask1 Set mask bit while drawing. 1 = on\r
1676//Mask2 Do not draw to mask areas. 1= on\r
1677\r
677ea103 1678void cmdSTP(unsigned char * baseAddr)\r
ce879073 1679{\r
1680 unsigned long gdata = ((unsigned long*)baseAddr)[0];\r
1681\r
1682 STATUSREG&=~0x1800; // clear the necessary bits\r
1683 STATUSREG|=((gdata & 0x03) << 11); // set the current bits\r
1684\r
1685 if(!iUseMask) return;\r
1686\r
1687 if(gdata&1) {sSetMask=0x8000;lSetMask=0x80008000;iSetMask=1;}\r
1688 else {sSetMask=0; lSetMask=0; iSetMask=0;}\r
1689\r
1690 if(gdata&2) \r
1691 {\r
1692 if(!(gdata&1)) iSetMask=2;\r
1693 bCheckMask=TRUE;\r
1694 if(iDepthFunc==0) return;\r
1695 iDepthFunc=0;\r
9f58cabb 1696 glDepthFunc(GL_LESS); glError();\r
ce879073 1697 }\r
1698 else\r
1699 {\r
1700 bCheckMask=FALSE;\r
1701 if(iDepthFunc==1) return;\r
9f58cabb 1702 glDepthFunc(GL_ALWAYS); glError();\r
ce879073 1703 iDepthFunc=1;\r
1704 }\r
1705}\r
1706\r
1707////////////////////////////////////////////////////////////////////////\r
1708// cmd: Set texture page infos\r
1709////////////////////////////////////////////////////////////////////////\r
1710\r
677ea103 1711void cmdTexturePage(unsigned char * baseAddr)\r
ce879073 1712{\r
1713 unsigned long gdata = ((unsigned long*)baseAddr)[0];\r
1714 UpdateGlobalTP((unsigned short)gdata);\r
1715 GlobalTextREST = (gdata&0x00ffffff)>>9;\r
1716}\r
1717\r
1718////////////////////////////////////////////////////////////////////////\r
1719// cmd: turn on/off texture window\r
1720////////////////////////////////////////////////////////////////////////\r
1721\r
677ea103 1722void cmdTextureWindow(unsigned char *baseAddr)\r
ce879073 1723{\r
1724 unsigned long gdata = ((unsigned long*)baseAddr)[0];\r
1725\r
1726 unsigned long YAlign,XAlign;\r
1727\r
1728 ulGPUInfoVals[INFO_TW]=gdata&0xFFFFF;\r
1729\r
1730 if(gdata & 0x020)\r
1731 TWin.Position.y1 = 8; // xxxx1\r
1732 else if (gdata & 0x040)\r
1733 TWin.Position.y1 = 16; // xxx10\r
1734 else if (gdata & 0x080)\r
1735 TWin.Position.y1 = 32; // xx100\r
1736 else if (gdata & 0x100)\r
1737 TWin.Position.y1 = 64; // x1000\r
1738 else if (gdata & 0x200)\r
1739 TWin.Position.y1 = 128; // 10000\r
1740 else\r
1741 TWin.Position.y1 = 256; // 00000\r
1742\r
1743 // Texture window size is determined by the least bit set of the relevant 5 bits\r
1744\r
1745 if (gdata & 0x001)\r
1746 TWin.Position.x1 = 8; // xxxx1\r
1747 else if (gdata & 0x002)\r
1748 TWin.Position.x1 = 16; // xxx10\r
1749 else if (gdata & 0x004)\r
1750 TWin.Position.x1 = 32; // xx100\r
1751 else if (gdata & 0x008)\r
1752 TWin.Position.x1 = 64; // x1000\r
1753 else if (gdata & 0x010)\r
1754 TWin.Position.x1 = 128; // 10000\r
1755 else\r
1756 TWin.Position.x1 = 256; // 00000\r
1757\r
1758 // Re-calculate the bit field, because we can't trust what is passed in the data\r
1759\r
1760 YAlign = (unsigned long)(32 - (TWin.Position.y1 >> 3));\r
1761 XAlign = (unsigned long)(32 - (TWin.Position.x1 >> 3));\r
1762\r
1763 // Absolute position of the start of the texture window\r
1764\r
1765 TWin.Position.y0 = (short)(((gdata >> 15) & YAlign) << 3);\r
1766 TWin.Position.x0 = (short)(((gdata >> 10) & XAlign) << 3);\r
1767\r
1768 if((TWin.Position.x0 == 0 && // tw turned off\r
1769 TWin.Position.y0 == 0 &&\r
1770 TWin.Position.x1 == 0 &&\r
1771 TWin.Position.y1 == 0) ||\r
1772 (TWin.Position.x1 == 256 &&\r
1773 TWin.Position.y1 == 256))\r
1774 {\r
1775 bUsingTWin = FALSE; // -> just do it\r
1776\r
1777#ifdef OWNSCALE\r
1778 TWin.UScaleFactor = 1.0f;\r
1779 TWin.VScaleFactor = 1.0f;\r
1780#else\r
1781 TWin.UScaleFactor = \r
1782 TWin.VScaleFactor = 1.0f/256.0f;\r
1783#endif\r
1784 }\r
1785 else // tw turned on\r
1786 {\r
1787 bUsingTWin = TRUE;\r
1788\r
1789 TWin.OPosition.y1 = TWin.Position.y1; // -> get psx sizes\r
1790 TWin.OPosition.x1 = TWin.Position.x1; \r
1791\r
1792 if(TWin.Position.x1<=2) TWin.Position.x1=2; // -> set OGL sizes\r
1793 else\r
1794 if(TWin.Position.x1<=4) TWin.Position.x1=4;\r
1795 else\r
1796 if(TWin.Position.x1<=8) TWin.Position.x1=8;\r
1797 else\r
1798 if(TWin.Position.x1<=16) TWin.Position.x1=16;\r
1799 else\r
1800 if(TWin.Position.x1<=32) TWin.Position.x1=32;\r
1801 else\r
1802 if(TWin.Position.x1<=64) TWin.Position.x1=64;\r
1803 else\r
1804 if(TWin.Position.x1<=128) TWin.Position.x1=128;\r
1805 else\r
1806 if(TWin.Position.x1<=256) TWin.Position.x1=256;\r
1807 \r
1808 if(TWin.Position.y1<=2) TWin.Position.y1=2;\r
1809 else\r
1810 if(TWin.Position.y1<=4) TWin.Position.y1=4;\r
1811 else\r
1812 if(TWin.Position.y1<=8) TWin.Position.y1=8;\r
1813 else\r
1814 if(TWin.Position.y1<=16) TWin.Position.y1=16;\r
1815 else\r
1816 if(TWin.Position.y1<=32) TWin.Position.y1=32;\r
1817 else\r
1818 if(TWin.Position.y1<=64) TWin.Position.y1=64;\r
1819 else\r
1820 if(TWin.Position.y1<=128) TWin.Position.y1=128;\r
1821 else\r
1822 if(TWin.Position.y1<=256) TWin.Position.y1=256;\r
1823\r
1824#ifdef OWNSCALE\r
1825 TWin.UScaleFactor = (float)TWin.Position.x1;\r
1826 TWin.VScaleFactor = (float)TWin.Position.y1;\r
1827#else\r
1828 TWin.UScaleFactor = ((float)TWin.Position.x1)/256.0f; // -> set scale factor\r
1829 TWin.VScaleFactor = ((float)TWin.Position.y1)/256.0f;\r
1830#endif\r
1831 }\r
1832}\r
1833\r
1834////////////////////////////////////////////////////////////////////////\r
1835// mmm, Lewpy uses that in TileS ... I don't ;)\r
1836////////////////////////////////////////////////////////////////////////\r
1837\r
1838/*\r
1839void ClampToPSXDrawAreaOffset(short *x0, short *y0, short *x1, short *y1)\r
1840{\r
1841 if (*x0 < PSXDisplay.DrawArea.x0)\r
1842 {\r
1843 *x1 -= (PSXDisplay.DrawArea.x0 - *x0);\r
1844 *x0 = PSXDisplay.DrawArea.x0;\r
1845 }\r
1846 else\r
1847 if (*x0 > PSXDisplay.DrawArea.x1)\r
1848 {\r
1849 *x0 = PSXDisplay.DrawArea.x1;\r
1850 *x1 = 0;\r
1851 }\r
1852\r
1853 if (*y0 < PSXDisplay.DrawArea.y0)\r
1854 {\r
1855 *y1 -= (PSXDisplay.DrawArea.y0 - *y0);\r
1856 *y0 = PSXDisplay.DrawArea.y0;\r
1857 }\r
1858 else\r
1859 if (*y0 > PSXDisplay.DrawArea.y1)\r
1860 {\r
1861 *y0 = PSXDisplay.DrawArea.y1;\r
1862 *y1 = 0;\r
1863 }\r
1864\r
1865 if (*x1 < 0) *x1 = 0;\r
1866\r
1867 if ((*x1 + *x0) > PSXDisplay.DrawArea.x1)\r
1868 *x1 = (PSXDisplay.DrawArea.x1 - *x0 + 1);\r
1869\r
1870 if (*y1 < 0) *y1 = 0;\r
1871\r
1872 if ((*y1 + *y0) > PSXDisplay.DrawArea.y1)\r
1873 *y1 = (PSXDisplay.DrawArea.y1 - *y0 + 1);\r
1874}\r
1875*/\r
1876\r
1877////////////////////////////////////////////////////////////////////////\r
1878// Check draw area dimensions\r
1879////////////////////////////////////////////////////////////////////////\r
1880\r
1881void ClampToPSXScreen(short *x0, short *y0, short *x1, short *y1)\r
1882{\r
1883 if (*x0 < 0) *x0 = 0;\r
1884 else\r
1885 if (*x0 > 1023) *x0 = 1023;\r
1886 \r
1887 if (*x1 < 0) *x1 = 0;\r
1888 else\r
1889 if (*x1 > 1023) *x1 = 1023;\r
1890\r
1891 if (*y0 < 0) *y0 = 0;\r
1892 else\r
1893 if (*y0 > iGPUHeightMask) *y0 = iGPUHeightMask;\r
1894 \r
1895 if (*y1 < 0) *y1 = 0;\r
1896 else\r
1897 if (*y1 > iGPUHeightMask) *y1 = iGPUHeightMask;\r
1898}\r
1899\r
1900////////////////////////////////////////////////////////////////////////\r
1901// Used in Load Image and Blk Fill\r
1902////////////////////////////////////////////////////////////////////////\r
1903\r
1904void ClampToPSXScreenOffset(short *x0, short *y0, short *x1, short *y1)\r
1905{\r
1906 if (*x0 < 0)\r
1907 { *x1 += *x0; *x0 = 0; }\r
1908 else\r
1909 if (*x0 > 1023)\r
1910 { *x0 = 1023; *x1 = 0; }\r
1911\r
1912 if (*y0 < 0)\r
1913 { *y1 += *y0; *y0 = 0; }\r
1914 else\r
1915 if (*y0 > iGPUHeightMask)\r
1916 { *y0 = iGPUHeightMask; *y1 = 0; }\r
1917\r
1918 if (*x1 < 0) *x1 = 0;\r
1919\r
1920 if ((*x1 + *x0) > 1024) *x1 = (1024 - *x0);\r
1921\r
1922 if (*y1 < 0) *y1 = 0;\r
1923\r
1924 if ((*y1 + *y0) > iGPUHeight) *y1 = (iGPUHeight - *y0);\r
1925}\r
1926\r
1927////////////////////////////////////////////////////////////////////////\r
1928// cmd: start of drawing area... primitives will be clipped inside\r
1929////////////////////////////////////////////////////////////////////////\r
1930\r
677ea103 1931void cmdDrawAreaStart(unsigned char * baseAddr)\r
ce879073 1932{\r
1933 unsigned long gdata = ((unsigned long*)baseAddr)[0];\r
1934\r
1935 drawX = gdata & 0x3ff; // for soft drawing\r
1936 if(drawX>=1024) drawX=1023;\r
1937\r
1938 if(dwGPUVersion==2)\r
1939 {\r
1940 ulGPUInfoVals[INFO_DRAWSTART]=gdata&0x3FFFFF;\r
1941 drawY = (gdata>>12)&0x3ff;\r
1942 }\r
1943 else\r
1944 {\r
1945 ulGPUInfoVals[INFO_DRAWSTART]=gdata&0xFFFFF;\r
1946 drawY = (gdata>>10)&0x3ff;\r
1947 }\r
1948\r
1949 if(drawY>=iGPUHeight) drawY=iGPUHeightMask;\r
1950\r
1951 PreviousPSXDisplay.DrawArea.y0=PSXDisplay.DrawArea.y0;\r
1952 PreviousPSXDisplay.DrawArea.x0=PSXDisplay.DrawArea.x0;\r
1953\r
1954 PSXDisplay.DrawArea.y0 = (short)drawY; // for OGL drawing\r
1955 PSXDisplay.DrawArea.x0 = (short)drawX;\r
1956}\r
1957\r
1958////////////////////////////////////////////////////////////////////////\r
1959// cmd: end of drawing area... primitives will be clipped inside\r
1960////////////////////////////////////////////////////////////////////////\r
1961\r
677ea103 1962void cmdDrawAreaEnd(unsigned char * baseAddr)\r
ce879073 1963{\r
1964 unsigned long gdata = ((unsigned long*)baseAddr)[0];\r
1965\r
1966 drawW = gdata & 0x3ff; // for soft drawing\r
1967 if(drawW>=1024) drawW=1023;\r
1968\r
1969 if(dwGPUVersion==2)\r
1970 {\r
1971 ulGPUInfoVals[INFO_DRAWEND]=gdata&0x3FFFFF;\r
1972 drawH = (gdata>>12)&0x3ff;\r
1973 }\r
1974 else\r
1975 {\r
1976 ulGPUInfoVals[INFO_DRAWEND]=gdata&0xFFFFF;\r
1977 drawH = (gdata>>10)&0x3ff;\r
1978 }\r
1979 \r
1980 if(drawH>=iGPUHeight) drawH=iGPUHeightMask;\r
1981\r
1982 PSXDisplay.DrawArea.y1 = (short)drawH; // for OGL drawing\r
1983 PSXDisplay.DrawArea.x1 = (short)drawW;\r
1984\r
1985 ClampToPSXScreen(&PSXDisplay.DrawArea.x0, // clamp\r
1986 &PSXDisplay.DrawArea.y0,\r
1987 &PSXDisplay.DrawArea.x1,\r
1988 &PSXDisplay.DrawArea.y1);\r
1989\r
1990 bDisplayNotSet = TRUE;\r
1991}\r
1992\r
1993////////////////////////////////////////////////////////////////////////\r
1994// cmd: draw offset... will be added to prim coords\r
1995////////////////////////////////////////////////////////////////////////\r
1996\r
677ea103 1997void cmdDrawOffset(unsigned char * baseAddr)\r
ce879073 1998{\r
1999 unsigned long gdata = ((unsigned long*)baseAddr)[0];\r
2000\r
2001 PreviousPSXDisplay.DrawOffset.x = \r
2002 PSXDisplay.DrawOffset.x = (short)(gdata & 0x7ff);\r
2003\r
2004 if(dwGPUVersion==2)\r
2005 {\r
2006 ulGPUInfoVals[INFO_DRAWOFF]=gdata&0x7FFFFF;\r
2007 PSXDisplay.DrawOffset.y = (short)((gdata>>12) & 0x7ff);\r
2008 }\r
2009 else\r
2010 {\r
2011 ulGPUInfoVals[INFO_DRAWOFF]=gdata&0x3FFFFF;\r
2012 PSXDisplay.DrawOffset.y = (short)((gdata>>11) & 0x7ff);\r
2013 }\r
2014 \r
2015 PSXDisplay.DrawOffset.x=(short)(((int)PSXDisplay.DrawOffset.x<<21)>>21);\r
2016 PSXDisplay.DrawOffset.y=(short)(((int)PSXDisplay.DrawOffset.y<<21)>>21);\r
2017\r
2018 PSXDisplay.CumulOffset.x = // new OGL prim offsets\r
2019 PSXDisplay.DrawOffset.x - PSXDisplay.GDrawOffset.x + PreviousPSXDisplay.Range.x0;\r
2020 PSXDisplay.CumulOffset.y = \r
2021 PSXDisplay.DrawOffset.y - PSXDisplay.GDrawOffset.y + PreviousPSXDisplay.Range.y0;\r
2022}\r
2023\r
2024////////////////////////////////////////////////////////////////////////\r
2025// cmd: load image to vram\r
2026////////////////////////////////////////////////////////////////////////\r
2027\r
677ea103 2028void primLoadImage(unsigned char * baseAddr)\r
ce879073 2029{\r
2030 unsigned short *sgpuData = ((unsigned short *) baseAddr);\r
2031\r
2032 VRAMWrite.x = sgpuData[2]&0x03ff;\r
2033 VRAMWrite.y = sgpuData[3]&iGPUHeightMask;\r
2034 VRAMWrite.Width = sgpuData[4];\r
2035 VRAMWrite.Height = sgpuData[5];\r
2036\r
2037 iDataWriteMode = DR_VRAMTRANSFER;\r
2038 VRAMWrite.ImagePtr = psxVuw + (VRAMWrite.y<<10) + VRAMWrite.x;\r
2039 VRAMWrite.RowsRemaining = VRAMWrite.Width;\r
2040 VRAMWrite.ColsRemaining = VRAMWrite.Height;\r
2041\r
2042 bNeedWriteUpload=TRUE;\r
2043}\r
2044\r
2045////////////////////////////////////////////////////////////////////////\r
2046\r
2047void PrepareRGB24Upload(void)\r
2048{\r
2049 VRAMWrite.x=(VRAMWrite.x*2)/3;\r
2050 VRAMWrite.Width=(VRAMWrite.Width*2)/3;\r
2051\r
2052 if(!PSXDisplay.InterlacedTest && // NEW\r
2053 CheckAgainstScreen(VRAMWrite.x, VRAMWrite.y, VRAMWrite.Width, VRAMWrite.Height))\r
2054 {\r
2055 xrUploadArea.x0-=PreviousPSXDisplay.DisplayPosition.x;\r
2056 xrUploadArea.x1-=PreviousPSXDisplay.DisplayPosition.x;\r
2057 xrUploadArea.y0-=PreviousPSXDisplay.DisplayPosition.y;\r
2058 xrUploadArea.y1-=PreviousPSXDisplay.DisplayPosition.y;\r
2059 } \r
2060 else\r
2061 if(CheckAgainstFrontScreen(VRAMWrite.x, VRAMWrite.y, VRAMWrite.Width, VRAMWrite.Height))\r
2062 {\r
2063 xrUploadArea.x0-=PSXDisplay.DisplayPosition.x;\r
2064 xrUploadArea.x1-=PSXDisplay.DisplayPosition.x;\r
2065 xrUploadArea.y0-=PSXDisplay.DisplayPosition.y;\r
2066 xrUploadArea.y1-=PSXDisplay.DisplayPosition.y;\r
2067 } \r
2068 else return;\r
2069\r
2070 if(bRenderFrontBuffer) \r
2071 {\r
2072 updateFrontDisplay();\r
2073 }\r
2074\r
2075 if(bNeedRGB24Update==FALSE)\r
2076 {\r
2077 xrUploadAreaRGB24=xrUploadArea;\r
2078 bNeedRGB24Update=TRUE;\r
2079 }\r
2080 else\r
2081 {\r
2082 xrUploadAreaRGB24.x0=min(xrUploadAreaRGB24.x0,xrUploadArea.x0);\r
2083 xrUploadAreaRGB24.x1=max(xrUploadAreaRGB24.x1,xrUploadArea.x1);\r
2084 xrUploadAreaRGB24.y0=min(xrUploadAreaRGB24.y0,xrUploadArea.y0);\r
2085 xrUploadAreaRGB24.y1=max(xrUploadAreaRGB24.y1,xrUploadArea.y1);\r
2086 }\r
2087}\r
2088\r
2089////////////////////////////////////////////////////////////////////////\r
2090\r
2091void CheckWriteUpdate()\r
2092{\r
2093 int iX=0,iY=0;\r
2094\r
2095 if(VRAMWrite.Width) iX=1;\r
2096 if(VRAMWrite.Height) iY=1;\r
2097\r
2098 InvalidateTextureArea(VRAMWrite.x, VRAMWrite.y, VRAMWrite.Width-iX, VRAMWrite.Height-iY);\r
2099\r
2100 if(PSXDisplay.Interlaced && !iOffscreenDrawing) return;\r
2101\r
2102 if(PSXDisplay.RGB24) {PrepareRGB24Upload();return;}\r
2103\r
2104 if(!PSXDisplay.InterlacedTest &&\r
2105 CheckAgainstScreen(VRAMWrite.x, VRAMWrite.y, VRAMWrite.Width, VRAMWrite.Height)) \r
2106 {\r
2107 if(dwActFixes&0x800) return;\r
2108\r
2109 if(bRenderFrontBuffer) \r
2110 {\r
2111 updateFrontDisplay();\r
2112 }\r
2113\r
2114 UploadScreen(FALSE);\r
2115\r
2116 bNeedUploadTest=TRUE;\r
2117 }\r
2118 else \r
2119 if(iOffscreenDrawing)\r
2120 {\r
2121 if (CheckAgainstFrontScreen(VRAMWrite.x, VRAMWrite.y, VRAMWrite.Width, VRAMWrite.Height)) \r
2122 {\r
2123 if(PSXDisplay.InterlacedTest)\r
2124 {\r
2125 if(PreviousPSXDisplay.InterlacedNew) \r
2126 {\r
2127 PreviousPSXDisplay.InterlacedNew=FALSE;\r
2128 bNeedInterlaceUpdate=TRUE;\r
2129 xrUploadAreaIL.x0=PSXDisplay.DisplayPosition.x;\r
2130 xrUploadAreaIL.y0=PSXDisplay.DisplayPosition.y;\r
2131 xrUploadAreaIL.x1=PSXDisplay.DisplayPosition.x+PSXDisplay.DisplayModeNew.x;\r
2132 xrUploadAreaIL.y1=PSXDisplay.DisplayPosition.y+PSXDisplay.DisplayModeNew.y;\r
2133 if(xrUploadAreaIL.x1>1023) xrUploadAreaIL.x1=1023;\r
2134 if(xrUploadAreaIL.y1>511) xrUploadAreaIL.y1=511;\r
2135 }\r
2136\r
2137 if(bNeedInterlaceUpdate==FALSE)\r
2138 {\r
2139 xrUploadAreaIL=xrUploadArea;\r
2140 bNeedInterlaceUpdate=TRUE;\r
2141 }\r
2142 else\r
2143 {\r
2144 xrUploadAreaIL.x0=min(xrUploadAreaIL.x0,xrUploadArea.x0);\r
2145 xrUploadAreaIL.x1=max(xrUploadAreaIL.x1,xrUploadArea.x1);\r
2146 xrUploadAreaIL.y0=min(xrUploadAreaIL.y0,xrUploadArea.y0);\r
2147 xrUploadAreaIL.y1=max(xrUploadAreaIL.y1,xrUploadArea.y1);\r
2148 }\r
2149 return;\r
2150 }\r
2151\r
2152 if(!bNeedUploadAfter)\r
2153 {\r
2154 bNeedUploadAfter = TRUE;\r
2155 xrUploadArea.x0=VRAMWrite.x;\r
2156 xrUploadArea.x1=VRAMWrite.x+VRAMWrite.Width;\r
2157 xrUploadArea.y0=VRAMWrite.y;\r
2158 xrUploadArea.y1=VRAMWrite.y+VRAMWrite.Height;\r
2159 }\r
2160 else\r
2161 {\r
2162 xrUploadArea.x0=min(xrUploadArea.x0,VRAMWrite.x);\r
2163 xrUploadArea.x1=max(xrUploadArea.x1,VRAMWrite.x+VRAMWrite.Width);\r
2164 xrUploadArea.y0=min(xrUploadArea.y0,VRAMWrite.y);\r
2165 xrUploadArea.y1=max(xrUploadArea.y1,VRAMWrite.y+VRAMWrite.Height);\r
2166 }\r
2167\r
2168 if(dwActFixes&0x8000)\r
2169 {\r
2170 if((xrUploadArea.x1-xrUploadArea.x0)>=(PSXDisplay.DisplayMode.x-32) &&\r
2171 (xrUploadArea.y1-xrUploadArea.y0)>=(PSXDisplay.DisplayMode.y-32))\r
2172 {\r
2173 UploadScreen(-1);\r
2174 updateFrontDisplay();\r
2175 }\r
2176 }\r
2177 }\r
2178 }\r
2179}\r
2180\r
2181////////////////////////////////////////////////////////////////////////\r
2182// cmd: vram -> psx mem\r
2183////////////////////////////////////////////////////////////////////////\r
2184\r
677ea103 2185void primStoreImage(unsigned char * baseAddr)\r
ce879073 2186{\r
2187 unsigned short *sgpuData = ((unsigned short *) baseAddr);\r
2188\r
2189 VRAMRead.x = sgpuData[2]&0x03ff;\r
2190 VRAMRead.y = sgpuData[3]&iGPUHeightMask;\r
2191 VRAMRead.Width = sgpuData[4];\r
2192 VRAMRead.Height = sgpuData[5];\r
2193\r
2194 VRAMRead.ImagePtr = psxVuw + (VRAMRead.y<<10) + VRAMRead.x;\r
2195 VRAMRead.RowsRemaining = VRAMRead.Width;\r
2196 VRAMRead.ColsRemaining = VRAMRead.Height;\r
2197\r
2198 iDataReadMode = DR_VRAMTRANSFER;\r
2199\r
2200 STATUSREG |= GPUSTATUS_READYFORVRAM;\r
2201}\r
2202\r
2203////////////////////////////////////////////////////////////////////////\r
2204// cmd: blkfill - NO primitive! Doesn't care about draw areas...\r
2205////////////////////////////////////////////////////////////////////////\r
2206\r
677ea103 2207void primBlkFill(unsigned char * baseAddr)\r
ce879073 2208{\r
2209 unsigned long *gpuData = ((unsigned long *) baseAddr);\r
2210 short *sgpuData = ((short *) baseAddr);\r
2211\r
2212 iDrawnSomething=1;\r
2213\r
2214 sprtX = sgpuData[2];\r
2215 sprtY = sgpuData[3];\r
2216 sprtW = sgpuData[4] & 0x3ff;\r
2217 sprtH = sgpuData[5] & iGPUHeightMask;\r
2218\r
2219 sprtW = (sprtW+15) & ~15;\r
2220\r
2221 // Increase H & W if they are one short of full values, because they never can be full values\r
2222 if (sprtH == iGPUHeightMask) sprtH=iGPUHeight;\r
2223 if (sprtW == 1023) sprtW=1024; \r
2224 \r
2225 // x and y of start\r
2226 ly0 = ly1 = sprtY;\r
2227 ly2 = ly3 = (sprtY+sprtH);\r
2228 lx0 = lx3 = sprtX;\r
2229 lx1 = lx2 = (sprtX+sprtW);\r
2230\r
2231 offsetBlk();\r
2232\r
2233 if(ClipVertexListScreen()) \r
2234 {\r
2235 PSXDisplay_t * pd;\r
2236 if(PSXDisplay.InterlacedTest) pd=&PSXDisplay;\r
2237 else pd=&PreviousPSXDisplay;\r
2238\r
2239 if ((lx0 <= pd->DisplayPosition.x+16) &&\r
2240 (ly0 <= pd->DisplayPosition.y+16) &&\r
2241 (lx2 >= pd->DisplayEnd.x-16) &&\r
2242 (ly2 >= pd->DisplayEnd.y-16))\r
2243 {\r
2244 GLclampf g,b,r;\r
2245 g=((GLclampf)GREEN(gpuData[0]))/255.0f;\r
2246 b=((GLclampf)BLUE(gpuData[0]))/255.0f;\r
2247 r=((GLclampf)RED(gpuData[0]))/255.0f;\r
2248 \r
9f58cabb 2249 glDisable(GL_SCISSOR_TEST); glError();\r
2250 glClearColor(r,g,b,1.0f); glError();\r
2251 glClear(uiBufferBits); glError();\r
ce879073 2252 gl_z=0.0f;\r
2253\r
2254 if(gpuData[0]!=0x02000000 &&\r
2255 (ly0>pd->DisplayPosition.y ||\r
2256 ly2<pd->DisplayEnd.y))\r
2257 {\r
2258 bDrawTextured = FALSE;\r
2259 bDrawSmoothShaded = FALSE;\r
2260 SetRenderState((unsigned long)0x01000000);\r
2261 SetRenderMode((unsigned long)0x01000000, FALSE);\r
2262 vertex[0].c.lcol=0xff000000;\r
2263 SETCOL(vertex[0]); \r
2264 if(ly0>pd->DisplayPosition.y)\r
2265 {\r
2266 vertex[0].x=0;vertex[0].y=0;\r
2267 vertex[1].x=pd->DisplayEnd.x-pd->DisplayPosition.x;vertex[1].y=0;\r
2268 vertex[2].x=vertex[1].x;vertex[2].y=ly0-pd->DisplayPosition.y;\r
2269 vertex[3].x=0;vertex[3].y=vertex[2].y;\r
2270 PRIMdrawQuad(&vertex[0], &vertex[1], &vertex[2], &vertex[3]);\r
2271 }\r
2272 if(ly2<pd->DisplayEnd.y)\r
2273 {\r
2274 vertex[0].x=0;vertex[0].y=(pd->DisplayEnd.y-pd->DisplayPosition.y)-(pd->DisplayEnd.y-ly2);\r
2275 vertex[1].x=pd->DisplayEnd.x-pd->DisplayPosition.x;vertex[1].y=vertex[0].y;\r
2276 vertex[2].x=vertex[1].x;vertex[2].y=pd->DisplayEnd.y;\r
2277 vertex[3].x=0;vertex[3].y=vertex[2].y;\r
2278 PRIMdrawQuad(&vertex[0], &vertex[1], &vertex[2], &vertex[3]);\r
2279 }\r
2280 }\r
2281\r
9f58cabb 2282 glEnable(GL_SCISSOR_TEST); glError();\r
ce879073 2283 }\r
2284 else\r
2285 {\r
2286 bDrawTextured = FALSE;\r
2287 bDrawSmoothShaded = FALSE;\r
2288 SetRenderState((unsigned long)0x01000000);\r
2289 SetRenderMode((unsigned long)0x01000000, FALSE);\r
2290 vertex[0].c.lcol=gpuData[0]|0xff000000;\r
2291 SETCOL(vertex[0]); \r
9f58cabb 2292 glDisable(GL_SCISSOR_TEST); glError();\r
ce879073 2293 PRIMdrawQuad(&vertex[0], &vertex[1], &vertex[2], &vertex[3]);\r
9f58cabb 2294 glEnable(GL_SCISSOR_TEST); glError();\r
ce879073 2295 }\r
2296 }\r
2297\r
2298 //mmm... will clean all stuff, also if not all _should_ be cleaned...\r
2299 //if (IsInsideNextScreen(sprtX, sprtY, sprtW, sprtH))\r
2300 // try this:\r
2301 if (IsCompleteInsideNextScreen(sprtX, sprtY, sprtW, sprtH))\r
2302 {\r
2303 lClearOnSwapColor = COLOR(gpuData[0]);\r
2304 lClearOnSwap = 1;\r
2305 }\r
2306\r
2307/* if(iOffscreenDrawing)\r
2308 {\r
2309 ClampToPSXScreenOffset( &sprtX, &sprtY, &sprtW, &sprtH);\r
2310 if ((sprtW == 0) || (sprtH == 0)) return;\r
2311 InvalidateTextureArea(sprtX, sprtY, sprtW-1, sprtH-1); \r
2312\r
2313 sprtW+=sprtX;\r
2314 sprtH+=sprtY;\r
2315\r
2316 FillSoftwareArea(sprtX, sprtY, sprtW, sprtH, BGR24to16(gpuData[0]));\r
2317 }*/\r
2318}\r
2319 \r
2320////////////////////////////////////////////////////////////////////////\r
2321// cmd: move image vram -> vram\r
2322////////////////////////////////////////////////////////////////////////\r
2323\r
2324void MoveImageWrapped(short imageX0,short imageY0,\r
2325 short imageX1,short imageY1,\r
2326 short imageSX,short imageSY)\r
2327{\r
2328 int i,j,imageXE,imageYE;\r
2329\r
2330 if(iFrameReadType&2)\r
2331 {\r
2332 imageXE=imageX0+imageSX;\r
2333 imageYE=imageY0+imageSY;\r
2334\r
2335 if(imageYE>iGPUHeight && imageXE>1024) \r
2336 {\r
2337 CheckVRamRead(0,0,\r
2338 (imageXE&0x3ff),\r
2339 (imageY0&iGPUHeightMask),\r
2340 FALSE);\r
2341 }\r
2342\r
2343 if(imageXE>1024) \r
2344 {\r
2345 CheckVRamRead(0,imageY0, \r
2346 (imageXE&0x3ff),\r
2347 (imageYE>iGPUHeight)?iGPUHeight:imageYE,\r
2348 FALSE);\r
2349 }\r
2350\r
2351 if(imageYE>iGPUHeight) \r
2352 {\r
2353 CheckVRamRead(imageX0,0, \r
2354 (imageXE>1024)?1024:imageXE,\r
2355 imageYE&iGPUHeightMask,\r
2356 FALSE);\r
2357 }\r
2358\r
2359 CheckVRamRead(imageX0,imageY0, \r
2360 (imageXE>1024)?1024:imageXE,\r
2361 (imageYE>iGPUHeight)?iGPUHeight:imageYE,\r
2362 FALSE);\r
2363 }\r
2364\r
2365 for(j=0;j<imageSY;j++)\r
2366 for(i=0;i<imageSX;i++)\r
2367 psxVuw [(1024*((imageY1+j)&iGPUHeightMask))+((imageX1+i)&0x3ff)]=\r
2368 psxVuw[(1024*((imageY0+j)&iGPUHeightMask))+((imageX0+i)&0x3ff)];\r
2369\r
2370 if(!PSXDisplay.RGB24)\r
2371 {\r
2372 imageXE=imageX1+imageSX;\r
2373 imageYE=imageY1+imageSY;\r
2374\r
2375 if(imageYE>iGPUHeight && imageXE>1024) \r
2376 {\r
2377 InvalidateTextureArea(0,0,\r
2378 (imageXE&0x3ff)-1,\r
2379 (imageYE&iGPUHeightMask)-1);\r
2380 }\r
2381\r
2382 if(imageXE>1024) \r
2383 {\r
2384 InvalidateTextureArea(0,imageY1,\r
2385 (imageXE&0x3ff)-1,\r
2386 ((imageYE>iGPUHeight)?iGPUHeight:imageYE)-imageY1-1);\r
2387 }\r
2388\r
2389 if(imageYE>iGPUHeight) \r
2390 {\r
2391 InvalidateTextureArea(imageX1,0,\r
2392 ((imageXE>1024)?1024:imageXE)-imageX1-1,\r
2393 (imageYE&iGPUHeightMask)-1);\r
2394 }\r
2395\r
2396 InvalidateTextureArea(imageX1,imageY1,\r
2397 ((imageXE>1024)?1024:imageXE)-imageX1-1,\r
2398 ((imageYE>iGPUHeight)?iGPUHeight:imageYE)-imageY1-1);\r
2399 }\r
2400}\r
2401\r
2402////////////////////////////////////////////////////////////////////////\r
2403\r
677ea103 2404void primMoveImage(unsigned char * baseAddr)\r
ce879073 2405{\r
2406 short *sgpuData = ((short *) baseAddr);\r
2407 short imageY0,imageX0,imageY1,imageX1,imageSX,imageSY,i,j;\r
2408\r
2409 imageX0 = sgpuData[2]&0x03ff;\r
2410 imageY0 = sgpuData[3]&iGPUHeightMask;\r
2411 imageX1 = sgpuData[4]&0x03ff;\r
2412 imageY1 = sgpuData[5]&iGPUHeightMask;\r
2413 imageSX = sgpuData[6];\r
2414 imageSY = sgpuData[7];\r
2415\r
2416 if((imageX0 == imageX1) && (imageY0 == imageY1)) return; \r
2417 if(imageSX<=0) return;\r
2418 if(imageSY<=0) return;\r
2419\r
2420 if(iGPUHeight==1024 && sgpuData[7]>1024) return;\r
2421\r
2422 if((imageY0+imageSY)>iGPUHeight ||\r
2423 (imageX0+imageSX)>1024 ||\r
2424 (imageY1+imageSY)>iGPUHeight ||\r
2425 (imageX1+imageSX)>1024)\r
2426 {\r
2427 MoveImageWrapped(imageX0,imageY0,imageX1,imageY1,imageSX,imageSY);\r
2428 if((imageY0+imageSY)>iGPUHeight) imageSY=iGPUHeight-imageY0;\r
2429 if((imageX0+imageSX)>1024) imageSX=1024-imageX0;\r
2430 if((imageY1+imageSY)>iGPUHeight) imageSY=iGPUHeight-imageY1;\r
2431 if((imageX1+imageSX)>1024) imageSX=1024-imageX1;\r
2432 }\r
2433\r
2434 if(iFrameReadType&2)\r
2435 CheckVRamRead(imageX0,imageY0, \r
2436 imageX0+imageSX,\r
2437 imageY0+imageSY,\r
2438 FALSE);\r
2439\r
2440 if(imageSX&1)\r
2441 {\r
2442 unsigned short *SRCPtr, *DSTPtr;\r
2443 unsigned short LineOffset;\r
2444\r
2445 SRCPtr = psxVuw + (1024*imageY0) + imageX0;\r
2446 DSTPtr = psxVuw + (1024*imageY1) + imageX1;\r
2447\r
2448 LineOffset = 1024 - imageSX;\r
2449\r
2450 for(j=0;j<imageSY;j++)\r
2451 {\r
2452 for(i=0;i<imageSX;i++) *DSTPtr++ = *SRCPtr++;\r
2453 SRCPtr += LineOffset;\r
2454 DSTPtr += LineOffset;\r
2455 }\r
2456 }\r
2457 else\r
2458 {\r
2459 unsigned long *SRCPtr, *DSTPtr;\r
2460 unsigned short LineOffset;\r
2461 int dx=imageSX>>1;\r
2462\r
2463 SRCPtr = (unsigned long *)(psxVuw + (1024*imageY0) + imageX0);\r
2464 DSTPtr = (unsigned long *)(psxVuw + (1024*imageY1) + imageX1);\r
2465\r
2466 LineOffset = 512 - dx;\r
2467\r
2468 for(j=0;j<imageSY;j++)\r
2469 {\r
2470 for(i=0;i<dx;i++) *DSTPtr++ = *SRCPtr++;\r
2471 SRCPtr += LineOffset;\r
2472 DSTPtr += LineOffset;\r
2473 }\r
2474 }\r
2475\r
2476 if (!PSXDisplay.RGB24)\r
2477 {\r
2478 InvalidateTextureArea(imageX1,imageY1,imageSX-1,imageSY-1);\r
2479\r
2480 if (CheckAgainstScreen(imageX1,imageY1,imageSX,imageSY)) \r
2481 {\r
2482 if(imageX1>=PreviousPSXDisplay.DisplayPosition.x &&\r
2483 imageX1<PreviousPSXDisplay.DisplayEnd.x &&\r
2484 imageY1>=PreviousPSXDisplay.DisplayPosition.y &&\r
2485 imageY1<PreviousPSXDisplay.DisplayEnd.y)\r
2486 {\r
2487 imageX1 += imageSX;\r
2488 imageY1 += imageSY;\r
2489\r
2490 if(imageX1>=PreviousPSXDisplay.DisplayPosition.x &&\r
2491 imageX1<=PreviousPSXDisplay.DisplayEnd.x &&\r
2492 imageY1>=PreviousPSXDisplay.DisplayPosition.y &&\r
2493 imageY1<=PreviousPSXDisplay.DisplayEnd.y)\r
2494 {\r
2495 if(!(\r
2496 imageX0>=PSXDisplay.DisplayPosition.x &&\r
2497 imageX0<PSXDisplay.DisplayEnd.x &&\r
2498 imageY0>=PSXDisplay.DisplayPosition.y &&\r
2499 imageY0<PSXDisplay.DisplayEnd.y \r
2500 ))\r
2501 {\r
2502 if(bRenderFrontBuffer) \r
2503 {\r
2504 updateFrontDisplay();\r
2505 }\r
2506 \r
2507 UploadScreen(FALSE);\r
2508 }\r
2509 else bFakeFrontBuffer=TRUE;\r
2510 }\r
2511 }\r
2512\r
2513 bNeedUploadTest=TRUE;\r
2514 }\r
2515 else\r
2516 if(iOffscreenDrawing)\r
2517 {\r
2518 if (CheckAgainstFrontScreen(imageX1,imageY1,imageSX,imageSY)) \r
2519 {\r
2520 if(!PSXDisplay.InterlacedTest &&\r
2521// !bFullVRam &&\r
2522 ((\r
2523 imageX0>=PreviousPSXDisplay.DisplayPosition.x &&\r
2524 imageX0<PreviousPSXDisplay.DisplayEnd.x &&\r
2525 imageY0>=PreviousPSXDisplay.DisplayPosition.y &&\r
2526 imageY0<PreviousPSXDisplay.DisplayEnd.y\r
2527 ) ||\r
2528 (\r
2529 imageX0>=PSXDisplay.DisplayPosition.x &&\r
2530 imageX0<PSXDisplay.DisplayEnd.x &&\r
2531 imageY0>=PSXDisplay.DisplayPosition.y &&\r
2532 imageY0<PSXDisplay.DisplayEnd.y\r
2533 )))\r
2534 return;\r
2535\r
2536 bNeedUploadTest=TRUE;\r
2537\r
2538 if(!bNeedUploadAfter)\r
2539 {\r
2540 bNeedUploadAfter = TRUE;\r
2541 xrUploadArea.x0=imageX0;\r
2542 xrUploadArea.x1=imageX0+imageSX;\r
2543 xrUploadArea.y0=imageY0;\r
2544 xrUploadArea.y1=imageY0+imageSY;\r
2545 }\r
2546 else\r
2547 {\r
2548 xrUploadArea.x0=min(xrUploadArea.x0,imageX0);\r
2549 xrUploadArea.x1=max(xrUploadArea.x1,imageX0+imageSX);\r
2550 xrUploadArea.y0=min(xrUploadArea.y0,imageY0);\r
2551 xrUploadArea.y1=max(xrUploadArea.y1,imageY0+imageSY);\r
2552 }\r
2553 }\r
2554 }\r
2555 }\r
2556}\r
2557\r
2558\r
2559////////////////////////////////////////////////////////////////////////\r
2560// cmd: draw free-size Tile \r
2561////////////////////////////////////////////////////////////////////////\r
2562\r
677ea103 2563void primTileS(unsigned char * baseAddr)\r
ce879073 2564{\r
2565 unsigned long *gpuData = ((unsigned long*)baseAddr);\r
2566 short *sgpuData = ((short *) baseAddr);\r
2567\r
2568 sprtX = sgpuData[2];\r
2569 sprtY = sgpuData[3];\r
2570 sprtW = sgpuData[4] & 0x3ff;\r
2571 sprtH = sgpuData[5] & iGPUHeightMask;\r
2572\r
2573 // x and y of start\r
2574\r
2575 lx0 = sprtX;\r
2576 ly0 = sprtY;\r
2577\r
2578 offsetST();\r
2579\r
2580 if((dwActFixes&1) && // FF7 special game gix (battle cursor)\r
2581 sprtX==0 && sprtY==0 && sprtW==24 && sprtH==16) \r
2582 return;\r
2583\r
2584 bDrawTextured = FALSE;\r
2585 bDrawSmoothShaded = FALSE;\r
2586\r
2587 SetRenderState(gpuData[0]);\r
2588\r
2589/* if(iOffscreenDrawing)\r
2590 {\r
2591 if(IsPrimCompleteInsideNextScreen(lx0,ly0,lx2,ly2) ||\r
2592 (ly0==-6 && ly2==10)) // OH MY GOD... I DIDN'T WANT TO DO IT... BUT I'VE FOUND NO OTHER WAY... HACK FOR GRADIUS SHOOTER :(\r
2593 {\r
2594 lClearOnSwapColor = COLOR(gpuData[0]);\r
2595 lClearOnSwap = 1;\r
2596 }\r
2597\r
2598 offsetPSX4();\r
2599 if(bDrawOffscreen4())\r
2600 {\r
2601 if(!(iTileCheat && sprtH==32 && gpuData[0]==0x60ffffff)) // special cheat for certain ZiNc games\r
2602 {\r
2603 InvalidateTextureAreaEx(); \r
2604 FillSoftwareAreaTrans(lx0,ly0,lx2,ly2,\r
2605 BGR24to16(gpuData[0])); \r
2606 }\r
2607 }\r
2608 }*/\r
2609\r
2610 SetRenderMode(gpuData[0], FALSE);\r
2611 SetZMask4NT();\r
2612\r
2613 if(bIgnoreNextTile) {bIgnoreNextTile=FALSE;return;}\r
2614\r
2615 vertex[0].c.lcol=gpuData[0];\r
2616 vertex[0].c.col[3]=ubGloColAlpha;\r
2617 SETCOL(vertex[0]); \r
2618 \r
2619 PRIMdrawQuad(&vertex[0], &vertex[1], &vertex[2], &vertex[3]);\r
2620\r
2621 iDrawnSomething=1;\r
2622}\r
2623\r
2624////////////////////////////////////////////////////////////////////////\r
2625// cmd: draw 1 dot Tile (point)\r
2626////////////////////////////////////////////////////////////////////////\r
2627\r
677ea103 2628void primTile1(unsigned char * baseAddr)\r
ce879073 2629{\r
2630 unsigned long *gpuData = ((unsigned long*)baseAddr);\r
2631 short *sgpuData = ((short *) baseAddr);\r
2632\r
2633 sprtX = sgpuData[2];\r
2634 sprtY = sgpuData[3];\r
2635 sprtW = 1;\r
2636 sprtH = 1;\r
2637\r
2638 lx0 = sprtX;\r
2639 ly0 = sprtY;\r
2640\r
2641 offsetST();\r
2642\r
2643 bDrawTextured = FALSE;\r
2644 bDrawSmoothShaded = FALSE;\r
2645\r
2646 SetRenderState(gpuData[0]);\r
2647\r
2648/* if(iOffscreenDrawing)\r
2649 {\r
2650 offsetPSX4();\r
2651\r
2652 if(bDrawOffscreen4())\r
2653 {\r
2654 InvalidateTextureAreaEx(); \r
2655 FillSoftwareAreaTrans(lx0,ly0,lx2,ly2,\r
2656 BGR24to16(gpuData[0])); \r
2657 }\r
2658 }\r
2659*/\r
2660 SetRenderMode(gpuData[0], FALSE);\r
2661 SetZMask4NT();\r
2662\r
2663 vertex[0].c.lcol=gpuData[0];vertex[0].c.col[3]=ubGloColAlpha;\r
2664 SETCOL(vertex[0]); \r
2665\r
2666 PRIMdrawQuad(&vertex[0], &vertex[1], &vertex[2], &vertex[3]);\r
2667\r
2668 iDrawnSomething=1;\r
2669}\r
2670\r
2671////////////////////////////////////////////////////////////////////////\r
2672// cmd: draw 8 dot Tile (small rect)\r
2673////////////////////////////////////////////////////////////////////////\r
2674\r
677ea103 2675void primTile8(unsigned char * baseAddr)\r
ce879073 2676{\r
2677 unsigned long *gpuData = ((unsigned long*)baseAddr);\r
2678 short *sgpuData = ((short *) baseAddr);\r
2679\r
2680 sprtX = sgpuData[2];\r
2681 sprtY = sgpuData[3];\r
2682 sprtW = 8;\r
2683 sprtH = 8;\r
2684\r
2685 lx0 = sprtX;\r
2686 ly0 = sprtY;\r
2687\r
2688 offsetST();\r
2689\r
2690 bDrawTextured = FALSE;\r
2691 bDrawSmoothShaded = FALSE;\r
2692 SetRenderState(gpuData[0]);\r
2693\r
2694/* if(iOffscreenDrawing)\r
2695 {\r
2696 offsetPSX4();\r
2697\r
2698 if(bDrawOffscreen4())\r
2699 {\r
2700 InvalidateTextureAreaEx(); \r
2701 FillSoftwareAreaTrans(lx0,ly0,lx2,ly2,\r
2702 BGR24to16(gpuData[0])); \r
2703 }\r
2704 }\r
2705*/\r
2706 SetRenderMode(gpuData[0], FALSE);\r
2707 SetZMask4NT();\r
2708\r
2709 vertex[0].c.lcol=gpuData[0];\r
2710 vertex[0].c.col[3]=ubGloColAlpha;\r
2711 SETCOL(vertex[0]); \r
2712\r
2713 PRIMdrawQuad(&vertex[0], &vertex[1], &vertex[2], &vertex[3]);\r
2714\r
2715 iDrawnSomething=1;\r
2716}\r
2717\r
2718////////////////////////////////////////////////////////////////////////\r
2719// cmd: draw 16 dot Tile (medium rect)\r
2720////////////////////////////////////////////////////////////////////////\r
2721\r
677ea103 2722void primTile16(unsigned char * baseAddr)\r
ce879073 2723{\r
2724 unsigned long *gpuData = ((unsigned long*)baseAddr);\r
2725 short *sgpuData = ((short *) baseAddr);\r
2726\r
2727 sprtX = sgpuData[2];\r
2728 sprtY = sgpuData[3];\r
2729 sprtW = 16;\r
2730 sprtH = 16;\r
2731 // x and y of start\r
2732 lx0 = sprtX;\r
2733 ly0 = sprtY;\r
2734\r
2735 offsetST();\r
2736\r
2737 bDrawTextured = FALSE;\r
2738 bDrawSmoothShaded = FALSE;\r
2739 SetRenderState(gpuData[0]);\r
2740\r
2741/* if(iOffscreenDrawing)\r
2742 {\r
2743 offsetPSX4();\r
2744\r
2745 if(bDrawOffscreen4())\r
2746 {\r
2747 InvalidateTextureAreaEx(); \r
2748 FillSoftwareAreaTrans(lx0,ly0,lx2,ly2,\r
2749 BGR24to16(gpuData[0])); \r
2750 }\r
2751 }\r
2752*/\r
2753 SetRenderMode(gpuData[0], FALSE);\r
2754 SetZMask4NT();\r
2755\r
2756 vertex[0].c.lcol=gpuData[0];\r
2757 vertex[0].c.col[3]=ubGloColAlpha;\r
2758 SETCOL(vertex[0]); \r
2759\r
2760 PRIMdrawQuad(&vertex[0], &vertex[1], &vertex[2], &vertex[3]);\r
2761\r
2762 iDrawnSomething=1;\r
2763}\r
2764\r
2765////////////////////////////////////////////////////////////////////////\r
2766// helper: filter effect by multipass rendering\r
2767////////////////////////////////////////////////////////////////////////\r
2768\r
2769/*void DrawMultiBlur(void)\r
2770{\r
2771 long lABR,lDST;float fx,fy;\r
2772\r
2773 lABR=GlobalTextABR;\r
2774 lDST=DrawSemiTrans;\r
2775\r
2776 fx=(float)PSXDisplay.DisplayMode.x/(float)(iResX); \r
2777 fy=(float)PSXDisplay.DisplayMode.y/(float)(iResY);\r
2778\r
2779 vertex[0].x+=fx;vertex[1].x+=fx;\r
2780 vertex[2].x+=fx;vertex[3].x+=fx;\r
2781\r
2782 GlobalTextABR=0;\r
2783 DrawSemiTrans=1;\r
2784 SetSemiTrans();\r
2785\r
2786 PRIMdrawTexturedQuad(&vertex[0], &vertex[1], &vertex[2], &vertex[3]);\r
2787\r
2788 vertex[0].y+=fy;vertex[1].y+=fy;\r
2789 vertex[2].y+=fy;vertex[3].y+=fy;\r
2790 PRIMdrawTexturedQuad(&vertex[0], &vertex[1], &vertex[2], &vertex[3]);\r
2791\r
2792 if(bDrawMultiPass) {obm1=obm2=GL_SRC_ALPHA;}\r
2793\r
2794 GlobalTextABR=lABR;\r
2795 DrawSemiTrans=lDST;\r
2796}\r
2797*/\r
2798////////////////////////////////////////////////////////////////////////\r
2799\r
2800#define POFF 0.375f\r
2801\r
2802void DrawMultiFilterSprite(void)\r
2803{\r
2804 long lABR,lDST;\r
2805\r
2806 if(bUseMultiPass || DrawSemiTrans || ubOpaqueDraw) \r
2807 {\r
2808 PRIMdrawTexturedQuad(&vertex[0], &vertex[1], &vertex[2], &vertex[3]);\r
2809 return;\r
2810 }\r
2811\r
2812 lABR=GlobalTextABR;\r
2813 lDST=DrawSemiTrans;\r
2814 vertex[0].c.col[3]=ubGloAlpha/2; // -> set color with\r
2815 SETCOL(vertex[0]); // texture alpha\r
2816 PRIMdrawTexturedQuad(&vertex[0], &vertex[1], &vertex[2], &vertex[3]);\r
2817 vertex[0].x+=POFF;vertex[1].x+=POFF;\r
2818 vertex[2].x+=POFF;vertex[3].x+=POFF;\r
2819 vertex[0].y+=POFF;vertex[1].y+=POFF;\r
2820 vertex[2].y+=POFF;vertex[3].y+=POFF;\r
2821 GlobalTextABR=0;\r
2822 DrawSemiTrans=1;\r
2823 SetSemiTrans();\r
2824 PRIMdrawTexturedQuad(&vertex[0], &vertex[1], &vertex[2], &vertex[3]);\r
2825 GlobalTextABR=lABR;\r
2826 DrawSemiTrans=lDST;\r
2827}\r
2828\r
2829////////////////////////////////////////////////////////////////////////\r
2830// cmd: small sprite (textured rect)\r
2831////////////////////////////////////////////////////////////////////////\r
2832\r
677ea103 2833void primSprt8(unsigned char * baseAddr)\r
ce879073 2834{\r
2835 unsigned long *gpuData = ((unsigned long *) baseAddr);\r
2836 short *sgpuData = ((short *) baseAddr);\r
2837 short s;\r
2838\r
2839 iSpriteTex=1;\r
2840\r
2841 sprtX = sgpuData[2];\r
2842 sprtY = sgpuData[3];\r
2843 sprtW = 8;\r
2844 sprtH = 8;\r
2845\r
2846 lx0 = sprtX;\r
2847 ly0 = sprtY;\r
2848\r
2849 offsetST();\r
2850\r
2851 // do texture stuff\r
2852 gl_ux[0]=gl_ux[3]=baseAddr[8];//gpuData[2]&0xff;\r
2853\r
2854 if(usMirror & 0x1000) \r
2855 {\r
2856 s=gl_ux[0];\r
2857 s-=sprtW-1;\r
2858 if(s<0) {s=0;}\r
2859 gl_ux[0]=gl_ux[3]=s;\r
2860 }\r
2861\r
2862 sSprite_ux2=s=gl_ux[0]+sprtW; \r
2863 if(s) s--;\r
2864 if(s>255) s=255;\r
2865 gl_ux[1]=gl_ux[2]=s;\r
2866 // Y coords\r
2867 gl_vy[0]=gl_vy[1]=baseAddr[9];//(gpuData[2]>>8)&0xff;\r
2868\r
2869 if(usMirror & 0x2000) \r
2870 {\r
2871 s=gl_vy[0];\r
2872 s-=sprtH-1;\r
2873 if(s<0) {s=0;}\r
2874 gl_vy[0]=gl_vy[1]=s;\r
2875 }\r
2876\r
2877 sSprite_vy2=s=gl_vy[0]+sprtH; \r
2878 if(s) s--;\r
2879 if(s>255) s=255;\r
2880 gl_vy[2]=gl_vy[3]=s;\r
2881\r
2882 ulClutID=(gpuData[2]>>16);\r
2883\r
2884 bDrawTextured = TRUE;\r
2885 bDrawSmoothShaded = FALSE;\r
2886 SetRenderState(gpuData[0]);\r
2887\r
2888/* if(iOffscreenDrawing) \r
2889 {\r
2890 offsetPSX4();\r
2891\r
2892 if(bDrawOffscreen4())\r
2893 {\r
2894 InvalidateTextureAreaEx(); \r
2895 SetRenderColor(gpuData[0]);\r
2896 lx0-=PSXDisplay.DrawOffset.x;\r
2897 ly0-=PSXDisplay.DrawOffset.y;\r
2898\r
2899 if(bUsingTWin) DrawSoftwareSpriteTWin(baseAddr,8,8);\r
2900 else\r
2901 if(usMirror) DrawSoftwareSpriteMirror(baseAddr,8,8);\r
2902 else\r
2903 DrawSoftwareSprite(baseAddr,8,8,baseAddr[8],baseAddr[9]);\r
2904 }\r
2905 }\r
2906*/\r
2907 SetRenderMode(gpuData[0], TRUE);\r
2908 SetZMask4SP();\r
2909\r
2910 sSprite_ux2=gl_ux[0]+sprtW;\r
2911 sSprite_vy2=gl_vy[0]+sprtH;\r
2912\r
2913 assignTextureSprite();\r
2914\r
2915 if(iFilterType>4) \r
2916 DrawMultiFilterSprite();\r
2917 else\r
2918 PRIMdrawTexturedQuad(&vertex[0], &vertex[1], &vertex[2], &vertex[3]);\r
2919\r
2920 if(bDrawMultiPass)\r
2921 {\r
2922 SetSemiTransMulti(1);\r
2923 PRIMdrawTexturedQuad(&vertex[0], &vertex[1], &vertex[2], &vertex[3]);\r
2924 }\r
2925\r
2926 if(ubOpaqueDraw)\r
2927 {\r
2928 SetZMask4O();\r
2929 if(bUseMultiPass) SetOpaqueColor(gpuData[0]);\r
2930 DEFOPAQUEON\r
2931\r
2932/* if(bSmallAlpha && iFilterType<=2)\r
2933 {\r
2934 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);\r
2935 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);\r
2936 PRIMdrawTexturedQuad(&vertex[0], &vertex[1], &vertex[2], &vertex[3]);\r
2937 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);\r
2938 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);\r
2939 SetZMask4O();\r
2940 }\r
2941*/\r
2942 PRIMdrawTexturedQuad(&vertex[0], &vertex[1], &vertex[2], &vertex[3]);\r
2943 DEFOPAQUEOFF\r
2944 }\r
2945\r
2946 iSpriteTex=0;\r
2947 iDrawnSomething=1;\r
2948}\r
2949\r
2950////////////////////////////////////////////////////////////////////////\r
2951// cmd: medium sprite (textured rect)\r
2952////////////////////////////////////////////////////////////////////////\r
2953\r
677ea103 2954void primSprt16(unsigned char * baseAddr)\r
ce879073 2955{\r
2956 unsigned long *gpuData = ((unsigned long *) baseAddr);\r
2957 short *sgpuData = ((short *) baseAddr);\r
2958 short s;\r
2959\r
2960 iSpriteTex=1;\r
2961\r
2962 sprtX = sgpuData[2];\r
2963 sprtY = sgpuData[3];\r
2964 sprtW = 16;\r
2965 sprtH = 16;\r
2966\r
2967 lx0 = sprtX;\r
2968 ly0 = sprtY;\r
2969\r
2970 offsetST();\r
2971\r
2972 // do texture stuff\r
2973 gl_ux[0]=gl_ux[3]=baseAddr[8];//gpuData[2]&0xff;\r
2974\r
2975 if(usMirror & 0x1000) \r
2976 {\r
2977 s=gl_ux[0];\r
2978 s-=sprtW-1;\r
2979 if(s<0) {s=0;}\r
2980 gl_ux[0]=gl_ux[3]=s;\r
2981 }\r
2982\r
2983 sSprite_ux2=s=gl_ux[0]+sprtW; \r
2984 if(s) s--;\r
2985 if(s>255) s=255;\r
2986 gl_ux[1]=gl_ux[2]=s; \r
2987 // Y coords\r
2988 gl_vy[0]=gl_vy[1]=baseAddr[9];//(gpuData[2]>>8)&0xff;\r
2989\r
2990 if(usMirror & 0x2000) \r
2991 {\r
2992 s=gl_vy[0];\r
2993 s-=sprtH-1;\r
2994 if(s<0) {s=0;}\r
2995 gl_vy[0]=gl_vy[1]=s;\r
2996 }\r
2997\r
2998 sSprite_vy2=s=gl_vy[0]+sprtH; \r
2999 if(s) s--;\r
3000 if(s>255) s=255;\r
3001 gl_vy[2]=gl_vy[3]=s;\r
3002\r
3003 ulClutID=(gpuData[2]>>16);\r
3004\r
3005 bDrawTextured = TRUE;\r
3006 bDrawSmoothShaded = FALSE;\r
3007 SetRenderState(gpuData[0]);\r
3008\r
3009/* if(iOffscreenDrawing) \r
3010 {\r
3011 offsetPSX4();\r
3012\r
3013 if(bDrawOffscreen4())\r
3014 {\r
3015 InvalidateTextureAreaEx(); \r
3016 SetRenderColor(gpuData[0]);\r
3017 lx0-=PSXDisplay.DrawOffset.x;\r
3018 ly0-=PSXDisplay.DrawOffset.y;\r
3019 if(bUsingTWin) DrawSoftwareSpriteTWin(baseAddr,16,16);\r
3020 else\r
3021 if(usMirror) DrawSoftwareSpriteMirror(baseAddr,16,16);\r
3022 else\r
3023 DrawSoftwareSprite(baseAddr,16,16,baseAddr[8],baseAddr[9]);\r
3024 }\r
3025 }\r
3026*/\r
3027 SetRenderMode(gpuData[0], TRUE);\r
3028 SetZMask4SP();\r
3029\r
3030 sSprite_ux2=gl_ux[0]+sprtW;\r
3031 sSprite_vy2=gl_vy[0]+sprtH;\r
3032\r
3033 assignTextureSprite();\r
3034\r
3035 if(iFilterType>4) \r
3036 DrawMultiFilterSprite();\r
3037 else\r
3038 PRIMdrawTexturedQuad(&vertex[0], &vertex[1], &vertex[2], &vertex[3]);\r
3039\r
3040 if(bDrawMultiPass)\r
3041 {\r
3042 SetSemiTransMulti(1);\r
3043 PRIMdrawTexturedQuad(&vertex[0], &vertex[1], &vertex[2], &vertex[3]);\r
3044 }\r
3045\r
3046 if(ubOpaqueDraw)\r
3047 {\r
3048 SetZMask4O();\r
3049 if(bUseMultiPass) SetOpaqueColor(gpuData[0]);\r
3050 DEFOPAQUEON\r
3051\r
3052/* if(bSmallAlpha && iFilterType<=2)\r
3053 {\r
3054 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);\r
3055 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);\r
3056 PRIMdrawTexturedQuad(&vertex[0], &vertex[1], &vertex[2], &vertex[3]);\r
3057 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);\r
3058 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);\r
3059 SetZMask4O();\r
3060 }\r
3061*/\r
3062 PRIMdrawTexturedQuad(&vertex[0], &vertex[1], &vertex[2], &vertex[3]);\r
3063 DEFOPAQUEOFF\r
3064 }\r
3065\r
3066 iSpriteTex=0;\r
3067 iDrawnSomething=1;\r
3068}\r
3069\r
3070////////////////////////////////////////////////////////////////////////\r
3071// cmd: free-size sprite (textured rect)\r
3072////////////////////////////////////////////////////////////////////////\r
3073 \r
677ea103 3074void primSprtSRest(unsigned char * baseAddr,unsigned short type)\r
ce879073 3075{\r
3076 unsigned long *gpuData = ((unsigned long *) baseAddr);\r
3077 short *sgpuData = ((short *) baseAddr);\r
3078 short s;unsigned short sTypeRest=0;\r
3079\r
3080 sprtX = sgpuData[2];\r
3081 sprtY = sgpuData[3];\r
3082 sprtW = sgpuData[6] & 0x3ff;\r
3083 sprtH = sgpuData[7] & 0x1ff;\r
3084\r
3085\r
3086 // do texture stuff\r
3087 switch(type)\r
3088 {\r
3089 case 1:\r
3090 gl_vy[0]=gl_vy[1]=baseAddr[9];\r
3091 s=256-baseAddr[8];\r
3092 sprtW-=s;\r
3093 sprtX+=s;\r
3094 gl_ux[0]=gl_ux[3]=0;\r
3095 break;\r
3096 case 2:\r
3097 gl_ux[0]=gl_ux[3]=baseAddr[8];\r
3098 s=256-baseAddr[9];\r
3099 sprtH-=s;\r
3100 sprtY+=s;\r
3101 gl_vy[0]=gl_vy[1]=0;\r
3102 break;\r
3103 case 3:\r
3104 s=256-baseAddr[8];\r
3105 sprtW-=s;\r
3106 sprtX+=s;\r
3107 gl_ux[0]=gl_ux[3]=0;\r
3108 s=256-baseAddr[9];\r
3109 sprtH-=s;\r
3110 sprtY+=s;\r
3111 gl_vy[0]=gl_vy[1]=0;\r
3112 break;\r
3113\r
3114 case 4:\r
3115 gl_vy[0]=gl_vy[1]=baseAddr[9];\r
3116 s=512-baseAddr[8];\r
3117 sprtW-=s;\r
3118 sprtX+=s;\r
3119 gl_ux[0]=gl_ux[3]=0;\r
3120 break;\r
3121 case 5:\r
3122 gl_ux[0]=gl_ux[3]=baseAddr[8];\r
3123 s=512-baseAddr[9];\r
3124 sprtH-=s;\r
3125 sprtY+=s;\r
3126 gl_vy[0]=gl_vy[1]=0;\r
3127 break;\r
3128 case 6:\r
3129 s=512-baseAddr[8];\r
3130 sprtW-=s;\r
3131 sprtX+=s;\r
3132 gl_ux[0]=gl_ux[3]=0;\r
3133 s=512-baseAddr[9];\r
3134 sprtH-=s;\r
3135 sprtY+=s;\r
3136 gl_vy[0]=gl_vy[1]=0;\r
3137 break;\r
3138\r
3139 }\r
3140\r
3141 if(usMirror & 0x1000) \r
3142 {\r
3143 s=gl_ux[0];\r
3144 s-=sprtW-1;if(s<0) s=0;\r
3145 gl_ux[0]=gl_ux[3]=s;\r
3146 }\r
3147 if(usMirror & 0x2000) \r
3148 {\r
3149 s=gl_vy[0];\r
3150 s-=sprtH-1;if(s<0) {s=0;}\r
3151 gl_vy[0]=gl_vy[1]=s;\r
3152 }\r
3153\r
3154 sSprite_ux2=s=gl_ux[0]+sprtW; \r
3155 if(s>255) s=255;\r
3156 gl_ux[1]=gl_ux[2]=s;\r
3157 sSprite_vy2=s=gl_vy[0]+sprtH; \r
3158 if(s>255) s=255;\r
3159 gl_vy[2]=gl_vy[3]=s;\r
3160\r
3161 if(!bUsingTWin)\r
3162 {\r
3163 if(sSprite_ux2>256) \r
3164 {sprtW=256-gl_ux[0];sSprite_ux2=256;sTypeRest+=1;}\r
3165 if(sSprite_vy2>256) \r
3166 {sprtH=256-gl_vy[0];sSprite_vy2=256;sTypeRest+=2;}\r
3167 }\r
3168 \r
3169 lx0 = sprtX;\r
3170 ly0 = sprtY;\r
3171\r
3172 offsetST();\r
3173\r
3174 ulClutID=(gpuData[2]>>16);\r
3175\r
3176 bDrawTextured = TRUE;\r
3177 bDrawSmoothShaded = FALSE;\r
3178 SetRenderState(gpuData[0]);\r
3179\r
3180/* if(iOffscreenDrawing)\r
3181 {\r
3182 offsetPSX4();\r
3183\r
3184 if(bDrawOffscreen4())\r
3185 {\r
3186 InvalidateTextureAreaEx(); \r
3187 SetRenderColor(gpuData[0]);\r
3188 lx0-=PSXDisplay.DrawOffset.x;\r
3189 ly0-=PSXDisplay.DrawOffset.y;\r
3190 if(bUsingTWin) DrawSoftwareSpriteTWin(baseAddr,sprtW,sprtH);\r
3191 else\r
3192 if(usMirror) DrawSoftwareSpriteMirror(baseAddr,sprtW,sprtH);\r
3193 else\r
3194 DrawSoftwareSprite(baseAddr,sprtW,sprtH,baseAddr[8],baseAddr[9]);\r
3195 }\r
3196 }\r
3197*/\r
3198 SetRenderMode(gpuData[0], TRUE);\r
3199 SetZMask4SP();\r
3200\r
3201 sSprite_ux2=gl_ux[0]+sprtW;\r
3202 sSprite_vy2=gl_vy[0]+sprtH;\r
3203\r
3204 assignTextureSprite();\r
3205\r
3206 if(iFilterType>4) \r
3207 DrawMultiFilterSprite();\r
3208 else\r
3209 PRIMdrawTexturedQuad(&vertex[0], &vertex[1], &vertex[2], &vertex[3]);\r
3210 \r
3211 if(bDrawMultiPass)\r
3212 {\r
3213 SetSemiTransMulti(1);\r
3214 PRIMdrawTexturedQuad(&vertex[0], &vertex[1], &vertex[2], &vertex[3]);\r
3215 }\r
3216\r
3217 if(ubOpaqueDraw)\r
3218 {\r
3219 SetZMask4O();\r
3220 if(bUseMultiPass) SetOpaqueColor(gpuData[0]);\r
3221 DEFOPAQUEON\r
3222\r
3223/* if(bSmallAlpha && iFilterType<=2)\r
3224 {\r
3225 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);\r
3226 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);\r
3227 PRIMdrawTexturedQuad(&vertex[0], &vertex[1], &vertex[2], &vertex[3]);\r
3228 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);\r
3229 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);\r
3230 SetZMask4O();\r
3231 }\r
3232*/\r
3233 PRIMdrawTexturedQuad(&vertex[0], &vertex[1], &vertex[2], &vertex[3]);\r
3234 DEFOPAQUEOFF\r
3235 }\r
3236\r
3237 if(sTypeRest && type<4) \r
3238 {\r
3239 if(sTypeRest&1 && type==1) primSprtSRest(baseAddr,4);\r
3240 if(sTypeRest&2 && type==2) primSprtSRest(baseAddr,5);\r
3241 if(sTypeRest==3 && type==3) primSprtSRest(baseAddr,6);\r
3242 }\r
3243}\r
3244\r
677ea103 3245void primSprtS(unsigned char * baseAddr)\r
ce879073 3246{\r
3247 unsigned long *gpuData = ((unsigned long *) baseAddr);\r
3248 short *sgpuData = ((short *) baseAddr);\r
3249\r
3250 short s;unsigned short sTypeRest=0;\r
3251\r
3252 sprtX = sgpuData[2];\r
3253 sprtY = sgpuData[3];\r
3254 sprtW = sgpuData[6] & 0x3ff;\r
3255 sprtH = sgpuData[7] & 0x1ff;\r
3256\r
3257 if(!sprtH) return;\r
3258 if(!sprtW) return;\r
3259\r
3260 iSpriteTex=1;\r
3261\r
3262 // do texture stuff\r
3263 gl_ux[0]=gl_ux[3]=baseAddr[8];//gpuData[2]&0xff;\r
3264 gl_vy[0]=gl_vy[1]=baseAddr[9];//(gpuData[2]>>8)&0xff;\r
3265\r
3266 if(usMirror & 0x1000) \r
3267 {\r
3268 s=gl_ux[0];\r
3269 s-=sprtW-1;\r
3270 if(s<0) {s=0;}\r
3271 gl_ux[0]=gl_ux[3]=s;\r
3272 }\r
3273 if(usMirror & 0x2000) \r
3274 {\r
3275 s=gl_vy[0];\r
3276 s-=sprtH-1;\r
3277 if(s<0) {s=0;}\r
3278 gl_vy[0]=gl_vy[1]=s;\r
3279 }\r
3280\r
3281 sSprite_ux2=s=gl_ux[0]+sprtW; \r
3282 if(s) s--;\r
3283 if(s>255) s=255;\r
3284 gl_ux[1]=gl_ux[2]=s;\r
3285 sSprite_vy2=s=gl_vy[0]+sprtH; \r
3286 if(s) s--;\r
3287 if(s>255) s=255;\r
3288 gl_vy[2]=gl_vy[3]=s;\r
3289\r
3290 if(!bUsingTWin)\r
3291 {\r
3292 if(sSprite_ux2>256) \r
3293 {sprtW=256-gl_ux[0];sSprite_ux2=256;sTypeRest+=1;}\r
3294 if(sSprite_vy2>256) \r
3295 {sprtH=256-gl_vy[0];sSprite_vy2=256;sTypeRest+=2;}\r
3296 }\r
3297\r
3298 lx0 = sprtX;\r
3299 ly0 = sprtY;\r
3300\r
3301 offsetST();\r
3302\r
3303 ulClutID=(gpuData[2]>>16);\r
3304\r
3305 bDrawTextured = TRUE;\r
3306 bDrawSmoothShaded = FALSE;\r
3307 SetRenderState(gpuData[0]);\r
3308\r
3309/* if(iOffscreenDrawing)\r
3310 {\r
3311 offsetPSX4();\r
3312\r
3313 if(bDrawOffscreen4())\r
3314 {\r
3315 InvalidateTextureAreaEx(); \r
3316 SetRenderColor(gpuData[0]);\r
3317 lx0-=PSXDisplay.DrawOffset.x;\r
3318 ly0-=PSXDisplay.DrawOffset.y;\r
3319 if(bUsingTWin) DrawSoftwareSpriteTWin(baseAddr,sprtW,sprtH);\r
3320 else\r
3321 if(usMirror) DrawSoftwareSpriteMirror(baseAddr,sprtW,sprtH);\r
3322 else\r
3323 DrawSoftwareSprite(baseAddr,sprtW,sprtH,baseAddr[8],baseAddr[9]);\r
3324 }\r
3325 }\r
3326*/\r
3327 SetRenderMode(gpuData[0], TRUE);\r
3328 SetZMask4SP();\r
3329\r
3330 if((dwActFixes&1) && gTexFrameName && gTexName==gTexFrameName) \r
3331 {iSpriteTex=0;return;}\r
3332\r
3333 sSprite_ux2=gl_ux[0]+sprtW;\r
3334 sSprite_vy2=gl_vy[0]+sprtH;\r
3335\r
3336 assignTextureSprite();\r
3337\r
3338 if(iFilterType>4) \r
3339 DrawMultiFilterSprite();\r
3340 else\r
3341 PRIMdrawTexturedQuad(&vertex[0], &vertex[1], &vertex[2], &vertex[3]);\r
3342 \r
3343 if(bDrawMultiPass)\r
3344 {\r
3345 SetSemiTransMulti(1);\r
3346 PRIMdrawTexturedQuad(&vertex[0], &vertex[1], &vertex[2], &vertex[3]);\r
3347 }\r
3348\r
3349 if(ubOpaqueDraw)\r
3350 {\r
3351 SetZMask4O();\r
3352 if(bUseMultiPass) SetOpaqueColor(gpuData[0]);\r
3353 DEFOPAQUEON\r
3354\r
3355/* if(bSmallAlpha && iFilterType<=2)\r
3356 {\r
3357 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);\r
3358 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);\r
3359 PRIMdrawTexturedQuad(&vertex[0], &vertex[1], &vertex[2], &vertex[3]);\r
3360 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);\r
3361 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);\r
3362 SetZMask4O();\r
3363 }\r
3364*/\r
3365 PRIMdrawTexturedQuad(&vertex[0], &vertex[1], &vertex[2], &vertex[3]);\r
3366 DEFOPAQUEOFF\r
3367 }\r
3368\r
3369 if(sTypeRest) \r
3370 {\r
3371 if(sTypeRest&1) primSprtSRest(baseAddr,1);\r
3372 if(sTypeRest&2) primSprtSRest(baseAddr,2);\r
3373 if(sTypeRest==3) primSprtSRest(baseAddr,3);\r
3374 }\r
3375\r
3376 iSpriteTex=0;\r
3377 iDrawnSomething=1;\r
3378}\r
3379\r
3380////////////////////////////////////////////////////////////////////////\r
3381// cmd: flat shaded Poly4\r
3382////////////////////////////////////////////////////////////////////////\r
3383\r
677ea103 3384void primPolyF4(unsigned char *baseAddr)\r
ce879073 3385{\r
3386 unsigned long *gpuData = ((unsigned long *) baseAddr);\r
3387 short *sgpuData = ((short *) baseAddr);\r
3388\r
3389 lx0 = sgpuData[2];\r
3390 ly0 = sgpuData[3];\r
3391 lx1 = sgpuData[4];\r
3392 ly1 = sgpuData[5];\r
3393 lx2 = sgpuData[6];\r
3394 ly2 = sgpuData[7];\r
3395 lx3 = sgpuData[8];\r
3396 ly3 = sgpuData[9];\r
3397\r
3398 if(offset4()) return;\r
3399\r
3400 bDrawTextured = FALSE;\r
3401 bDrawSmoothShaded = FALSE;\r
3402 SetRenderState(gpuData[0]);\r
3403\r
3404/* if(iOffscreenDrawing)\r
3405 {\r
3406 offsetPSX4();\r
3407 if(bDrawOffscreen4())\r
3408 {\r
3409 InvalidateTextureAreaEx(); \r
3410 drawPoly4F(gpuData[0]);\r
3411 }\r
3412 }\r
3413*/\r
3414 SetRenderMode(gpuData[0], FALSE);\r
3415 SetZMask4NT();\r
3416\r
3417 vertex[0].c.lcol=gpuData[0];vertex[0].c.col[3]=ubGloColAlpha;\r
3418 SETCOL(vertex[0]); \r
3419\r
3420 PRIMdrawTri2(&vertex[0], &vertex[1], &vertex[2],&vertex[3]);\r
3421\r
3422 iDrawnSomething=1;\r
3423}\r
3424\r
3425////////////////////////////////////////////////////////////////////////\r
3426// cmd: smooth shaded Poly4\r
3427////////////////////////////////////////////////////////////////////////\r
3428\r
677ea103 3429void primPolyG4(unsigned char * baseAddr);\r
ce879073 3430\r
3431BOOL bDrawOffscreenFrontFF9G4(void)\r
3432{\r
3433 if(lx0< PSXDisplay.DisplayPosition.x) return FALSE; // must be complete in front\r
3434 if(lx0> PSXDisplay.DisplayEnd.x) return FALSE;\r
3435 if(ly0< PSXDisplay.DisplayPosition.y) return FALSE;\r
3436 if(ly0> PSXDisplay.DisplayEnd.y) return FALSE;\r
3437 if(lx1< PSXDisplay.DisplayPosition.x) return FALSE;\r
3438 if(lx1> PSXDisplay.DisplayEnd.x) return FALSE;\r
3439 if(ly1< PSXDisplay.DisplayPosition.y) return FALSE;\r
3440 if(ly1> PSXDisplay.DisplayEnd.y) return FALSE;\r
3441 if(lx2< PSXDisplay.DisplayPosition.x) return FALSE;\r
3442 if(lx2> PSXDisplay.DisplayEnd.x) return FALSE;\r
3443 if(ly2< PSXDisplay.DisplayPosition.y) return FALSE;\r
3444 if(ly2> PSXDisplay.DisplayEnd.y) return FALSE;\r
3445 if(lx3< PSXDisplay.DisplayPosition.x) return FALSE;\r
3446 if(lx3> PSXDisplay.DisplayEnd.x) return FALSE;\r
3447 if(ly3< PSXDisplay.DisplayPosition.y) return FALSE;\r
3448 if(ly3> PSXDisplay.DisplayEnd.y) return FALSE;\r
3449 return TRUE;\r
3450}\r
3451\r
677ea103 3452BOOL bCheckFF9G4(unsigned char * baseAddr)\r
ce879073 3453{\r
677ea103 3454 static unsigned char pFF9G4Cache[32];\r
ce879073 3455 static int iFF9Fix=0;\r
3456\r
3457 if(baseAddr)\r
3458 {\r
3459 if(iFF9Fix==0)\r
3460 {\r
3461 if(bDrawOffscreenFrontFF9G4())\r
3462 {\r
3463 short *sgpuData = ((short *) pFF9G4Cache);\r
3464 iFF9Fix=2;\r
3465 memcpy(pFF9G4Cache,baseAddr,32);\r
3466\r
3467 if(sgpuData[2]==142)\r
3468 {\r
3469 sgpuData[2] +=65;\r
3470 sgpuData[10]+=65;\r
3471 }\r
3472 return TRUE;\r
3473 }\r
3474 else iFF9Fix=1;\r
3475 }\r
3476 return FALSE;\r
3477 }\r
3478\r
3479 if(iFF9Fix==2)\r
3480 {\r
3481 long labr=GlobalTextABR;\r
3482 GlobalTextABR=1;\r
3483 primPolyG4(pFF9G4Cache);\r
3484 GlobalTextABR=labr;\r
3485 }\r
3486 iFF9Fix=0;\r
3487\r
3488 return FALSE;\r
3489}\r
3490\r
3491////////////////////////////////////////////////////////////////////////\r
3492\r
677ea103 3493void primPolyG4(unsigned char * baseAddr)\r
ce879073 3494{\r
3495 unsigned long *gpuData = (unsigned long *)baseAddr;\r
3496 short *sgpuData = ((short *) baseAddr);\r
3497\r
3498 lx0 = sgpuData[2];\r
3499 ly0 = sgpuData[3];\r
3500 lx1 = sgpuData[6];\r
3501 ly1 = sgpuData[7];\r
3502 lx2 = sgpuData[10];\r
3503 ly2 = sgpuData[11];\r
3504 lx3 = sgpuData[14];\r
3505 ly3 = sgpuData[15];\r
3506\r
3507 if(offset4()) return;\r
3508\r
3509 bDrawTextured = FALSE;\r
3510 bDrawSmoothShaded = TRUE;\r
3511 SetRenderState(gpuData[0]);\r
3512\r
3513/* if(iOffscreenDrawing)\r
3514 {\r
3515 offsetPSX4();\r
3516\r
3517 if((dwActFixes&512) && bCheckFF9G4(baseAddr)) return;\r
3518\r
3519 if(bDrawOffscreen4())\r
3520 {\r
3521 InvalidateTextureAreaEx(); \r
3522 drawPoly4G(gpuData[0], gpuData[2], gpuData[4], gpuData[6]);\r
3523 } \r
3524 }\r
3525*/\r
3526 SetRenderMode(gpuData[0], FALSE);\r
3527 SetZMask4NT();\r
3528\r
3529 vertex[0].c.lcol=gpuData[0];\r
3530 vertex[1].c.lcol=gpuData[2];\r
3531 vertex[2].c.lcol=gpuData[4];\r
3532 vertex[3].c.lcol=gpuData[6];\r
3533\r
3534 vertex[0].c.col[3]=vertex[1].c.col[3]=vertex[2].c.col[3]=vertex[3].c.col[3]=ubGloAlpha;\r
3535\r
3536\r
3537 PRIMdrawGouraudTri2Color(&vertex[0],&vertex[1], &vertex[2], &vertex[3]);\r
3538\r
3539 iDrawnSomething=1;\r
3540}\r
3541\r
3542////////////////////////////////////////////////////////////////////////\r
3543// cmd: flat shaded Texture3\r
3544////////////////////////////////////////////////////////////////////////\r
3545\r
3546BOOL DoLineCheck(unsigned long * gpuData)\r
3547{\r
3548 BOOL bQuad=FALSE;short dx,dy;\r
3549\r
3550 if(lx0==lx1)\r
3551 {\r
3552 dx=lx0-lx2;if(dx<0) dx=-dx;\r
3553\r
3554 if(ly1==ly2) \r
3555 {\r
3556 dy=ly1-ly0;if(dy<0) dy=-dy;\r
3557 if(dx<=1)\r
3558 {\r
3559 vertex[3]=vertex[2];\r
3560 vertex[2]=vertex[0];\r
3561 vertex[2].x=vertex[3].x;\r
3562 }\r
3563 else\r
3564 if(dy<=1)\r
3565 {\r
3566 vertex[3]=vertex[2];\r
3567 vertex[2].y=vertex[0].y;\r
3568 }\r
3569 else return FALSE;\r
3570\r
3571 bQuad=TRUE;\r
3572 }\r
3573 else\r
3574 if(ly0==ly2) \r
3575 {\r
3576 dy=ly0-ly1;if(dy<0) dy=-dy;\r
3577 if(dx<=1)\r
3578 {\r
3579 vertex[3]=vertex[1];\r
3580 vertex[3].x=vertex[2].x;\r
3581 }\r
3582 else\r
3583 if(dy<=1)\r
3584 {\r
3585 vertex[3]=vertex[2];\r
3586 vertex[3].y=vertex[1].y;\r
3587 }\r
3588 else return FALSE;\r
3589\r
3590 bQuad=TRUE;\r
3591 }\r
3592 }\r
3593\r
3594 if(lx0==lx2)\r
3595 {\r
3596 dx=lx0-lx1;if(dx<0) dx=-dx;\r
3597\r
3598 if(ly2==ly1) \r
3599 {\r
3600 dy=ly2-ly0;if(dy<0) dy=-dy;\r
3601 if(dx<=1)\r
3602 {\r
3603 vertex[3]=vertex[1];\r
3604 vertex[1]=vertex[0];\r
3605 vertex[1].x=vertex[3].x;\r
3606 }\r
3607 else\r
3608 if(dy<=1)\r
3609 {\r
3610 vertex[3]=vertex[1];\r
3611 vertex[1].y=vertex[0].y;\r
3612 }\r
3613 else return FALSE;\r
3614\r
3615 bQuad=TRUE;\r
3616 }\r
3617 else\r
3618 if(ly0==ly1)\r
3619 {\r
3620 dy=ly2-ly0;if(dy<0) dy=-dy;\r
3621 if(dx<=1)\r
3622 {\r
3623 vertex[3]=vertex[2];\r
3624 vertex[3].x=vertex[1].x;\r
3625 }\r
3626 else\r
3627 if(dy<=1)\r
3628 {\r
3629 vertex[3]=vertex[1];\r
3630 vertex[3].y=vertex[2].y;\r
3631 }\r
3632 else return FALSE;\r
3633\r
3634 bQuad=TRUE;\r
3635 }\r
3636 }\r
3637\r
3638 if(lx1==lx2)\r
3639 {\r
3640 dx=lx1-lx0;if(dx<0) dx=-dx;\r
3641\r
3642 if(ly1==ly0)\r
3643 {\r
3644 dy=ly1-ly2;if(dy<0) dy=-dy;\r
3645\r
3646 if(dx<=1)\r
3647 {\r
3648 vertex[3]=vertex[2];\r
3649 vertex[2].x=vertex[0].x;\r
3650 }\r
3651 else\r
3652 if(dy<=1)\r
3653 {\r
3654 vertex[3]=vertex[2];\r
3655 vertex[2]=vertex[0];\r
3656 vertex[2].y=vertex[3].y;\r
3657 }\r
3658 else return FALSE;\r
3659\r
3660 bQuad=TRUE;\r
3661 }\r
3662 else\r
3663 if(ly2==ly0)\r
3664 {\r
3665 dy=ly2-ly1;if(dy<0) dy=-dy;\r
3666\r
3667 if(dx<=1)\r
3668 {\r
3669 vertex[3]=vertex[1];\r
3670 vertex[1].x=vertex[0].x;\r
3671 }\r
3672 else\r
3673 if(dy<=1)\r
3674 {\r
3675 vertex[3]=vertex[1];\r
3676 vertex[1]=vertex[0];\r
3677 vertex[1].y=vertex[3].y;\r
3678 }\r
3679 else return FALSE;\r
3680\r
3681 bQuad=TRUE;\r
3682 }\r
3683 }\r
3684\r
3685 if(!bQuad) return FALSE;\r
3686\r
3687 PRIMdrawTexturedQuad(&vertex[0], &vertex[1], &vertex[3], &vertex[2]);\r
3688\r
3689 if(bDrawMultiPass)\r
3690 {\r
3691 SetSemiTransMulti(1);\r
3692 PRIMdrawTexturedQuad(&vertex[0], &vertex[1], &vertex[3], &vertex[2]);\r
3693 }\r
3694\r
3695 if(ubOpaqueDraw)\r
3696 {\r
3697 SetZMask4O();\r
3698 if(bUseMultiPass) SetOpaqueColor(gpuData[0]);\r
3699 DEFOPAQUEON\r
3700 PRIMdrawTexturedQuad(&vertex[0], &vertex[1], &vertex[3], &vertex[2]);\r
3701 DEFOPAQUEOFF\r
3702 }\r
3703\r
3704 iDrawnSomething=1;\r
3705\r
3706 return TRUE;\r
3707}\r
3708\r
3709////////////////////////////////////////////////////////////////////////\r
3710\r
677ea103 3711void primPolyFT3(unsigned char * baseAddr)\r
ce879073 3712{\r
3713 unsigned long *gpuData = ((unsigned long *) baseAddr);\r
3714 short *sgpuData = ((short *) baseAddr);\r
3715\r
3716 lx0 = sgpuData[2];\r
3717 ly0 = sgpuData[3];\r
3718 lx1 = sgpuData[6];\r
3719 ly1 = sgpuData[7];\r
3720 lx2 = sgpuData[10];\r
3721 ly2 = sgpuData[11];\r
3722\r
3723 if(offset3()) return;\r
3724 \r
3725 // do texture UV coordinates stuff\r
3726 gl_ux[0]=gl_ux[3]=baseAddr[8];//gpuData[2]&0xff;\r
3727 gl_vy[0]=gl_vy[3]=baseAddr[9];//(gpuData[2]>>8)&0xff;\r
3728 gl_ux[1]=baseAddr[16];//gpuData[4]&0xff;\r
3729 gl_vy[1]=baseAddr[17];//(gpuData[4]>>8)&0xff;\r
3730 gl_ux[2]=baseAddr[24];//gpuData[6]&0xff;\r
3731 gl_vy[2]=baseAddr[25];//(gpuData[6]>>8)&0xff;\r
3732\r
3733 UpdateGlobalTP((unsigned short)(gpuData[4]>>16));\r
3734 ulClutID=gpuData[2]>>16;\r
3735\r
3736 bDrawTextured = TRUE;\r
3737 bDrawSmoothShaded = FALSE;\r
3738 SetRenderState(gpuData[0]);\r
3739\r
3740/* if(iOffscreenDrawing)\r
3741 {\r
3742 offsetPSX3();\r
3743 if(bDrawOffscreen3())\r
3744 {\r
3745 InvalidateTextureAreaEx(); \r
3746 SetRenderColor(gpuData[0]);\r
3747 drawPoly3FT(baseAddr);\r
3748 }\r
3749 }\r
3750*/\r
3751 SetRenderMode(gpuData[0], TRUE);\r
3752 SetZMask3();\r
3753\r
3754 assignTexture3();\r
3755\r
3756 if(!(dwActFixes&0x10))\r
3757 {\r
3758 if(DoLineCheck(gpuData)) return;\r
3759 }\r
3760\r
3761 PRIMdrawTexturedTri(&vertex[0], &vertex[1], &vertex[2]);\r
3762\r
3763 if(bDrawMultiPass)\r
3764 {\r
3765 SetSemiTransMulti(1);\r
3766 PRIMdrawTexturedTri(&vertex[0], &vertex[1], &vertex[2]);\r
3767 }\r
3768\r
3769 if(ubOpaqueDraw)\r
3770 {\r
3771 SetZMask3O();\r
3772 if(bUseMultiPass) SetOpaqueColor(gpuData[0]);\r
3773 DEFOPAQUEON\r
3774 PRIMdrawTexturedTri(&vertex[0], &vertex[1], &vertex[2]);\r
3775 DEFOPAQUEOFF\r
3776 }\r
3777\r
3778 iDrawnSomething=1;\r
3779}\r
3780\r
3781////////////////////////////////////////////////////////////////////////\r
3782// cmd: flat shaded Texture4\r
3783////////////////////////////////////////////////////////////////////////\r
3784\r
3785#define ST_FAC 255.99f\r
3786\r
3787void RectTexAlign(void)\r
3788{\r
3789 int UFlipped = FALSE;\r
3790 int VFlipped = FALSE;\r
3791\r
3792 if(gTexName==gTexFrameName) return;\r
3793\r
3794 if(ly0==ly1)\r
3795 {\r
3796 if(!((lx1==lx3 && ly3==ly2 && lx2==lx0) ||\r
3797 (lx1==lx2 && ly2==ly3 && lx3==lx0)))\r
3798 return;\r
3799\r
3800 if(ly0<ly2) \r
3801 {\r
3802 if (vertex[0].tow > vertex[2].tow)\r
3803 VFlipped = 1;\r
3804 }\r
3805 else\r
3806 {\r
3807 if (vertex[0].tow < vertex[2].tow)\r
3808 VFlipped = 2;\r
3809 }\r
3810 }\r
3811 else\r
3812 if(ly0==ly2)\r
3813 {\r
3814 if(!((lx2==lx3 && ly3==ly1 && lx1==lx0) ||\r
3815 (lx2==lx1 && ly1==ly3 && lx3==lx0)))\r
3816 return;\r
3817\r
3818 if(ly0<ly1) \r
3819 {\r
3820 if (vertex[0].tow > vertex[1].tow)\r
3821 VFlipped = 3;\r
3822 }\r
3823 else\r
3824 {\r
3825 if (vertex[0].tow < vertex[1].tow)\r
3826 VFlipped = 4;\r
3827 }\r
3828 }\r
3829 else\r
3830 if(ly0==ly3)\r
3831 {\r
3832 if(!((lx3==lx2 && ly2==ly1 && lx1==lx0) ||\r
3833 (lx3==lx1 && ly1==ly2 && lx2==lx0)))\r
3834 return;\r
3835\r
3836 if(ly0<ly1) \r
3837 {\r
3838 if (vertex[0].tow > vertex[1].tow)\r
3839 VFlipped = 5;\r
3840 }\r
3841 else\r
3842 {\r
3843 if (vertex[0].tow < vertex[1].tow)\r
3844 VFlipped = 6;\r
3845 }\r
3846 }\r
3847 else return;\r
3848\r
3849 if(lx0==lx1)\r
3850 {\r
3851 if(lx0<lx2) \r
3852 {\r
3853 if (vertex[0].sow > vertex[2].sow)\r
3854 UFlipped = 1;\r
3855 }\r
3856 else\r
3857 {\r
3858 if (vertex[0].sow < vertex[2].sow)\r
3859 UFlipped = 2;\r
3860 }\r
3861 }\r
3862 else\r
3863 if(lx0==lx2)\r
3864 {\r
3865 if(lx0<lx1) \r
3866 {\r
3867 if (vertex[0].sow > vertex[1].sow)\r
3868 UFlipped = 3;\r
3869 }\r
3870 else\r
3871 {\r
3872 if (vertex[0].sow < vertex[1].sow)\r
3873 UFlipped = 4;\r
3874 }\r
3875 }\r
3876 else\r
3877 if(lx0==lx3)\r
3878 {\r
3879 if(lx0<lx1) \r
3880 {\r
3881 if (vertex[0].sow > vertex[1].sow)\r
3882 UFlipped = 5;\r
3883 }\r
3884 else\r
3885 {\r
3886 if (vertex[0].sow < vertex[1].sow)\r
3887 UFlipped = 6;\r
3888 }\r
3889 }\r
3890\r
3891 if (UFlipped)\r
3892 {\r
3893#ifdef OWNSCALE\r
3894 if(bUsingTWin)\r
3895 {\r
3896 switch(UFlipped)\r
3897 {\r
3898 case 1:\r
3899 vertex[2].sow+=0.95f/TWin.UScaleFactor; \r
3900 vertex[3].sow+=0.95f/TWin.UScaleFactor;\r
3901 break;\r
3902 case 2:\r
3903 vertex[0].sow+=0.95f/TWin.UScaleFactor; \r
3904 vertex[1].sow+=0.95f/TWin.UScaleFactor;\r
3905 break;\r
3906 case 3:\r
3907 vertex[1].sow+=0.95f/TWin.UScaleFactor; \r
3908 vertex[3].sow+=0.95f/TWin.UScaleFactor;\r
3909 break;\r
3910 case 4:\r
3911 vertex[0].sow+=0.95f/TWin.UScaleFactor; \r
3912 vertex[2].sow+=0.95f/TWin.UScaleFactor;\r
3913 break;\r
3914 case 5:\r
3915 vertex[1].sow+=0.95f/TWin.UScaleFactor; \r
3916 vertex[2].sow+=0.95f/TWin.UScaleFactor;\r
3917 break;\r
3918 case 6:\r
3919 vertex[0].sow+=0.95f/TWin.UScaleFactor; \r
3920 vertex[3].sow+=0.95f/TWin.UScaleFactor;\r
3921 break;\r
3922 }\r
3923 }\r
3924 else\r
3925 {\r
3926 switch(UFlipped)\r
3927 {\r
3928 case 1:\r
3929 vertex[2].sow+=1.0f/ST_FAC; \r
3930 vertex[3].sow+=1.0f/ST_FAC;\r
3931 break;\r
3932 case 2:\r
3933 vertex[0].sow+=1.0f/ST_FAC; \r
3934 vertex[1].sow+=1.0f/ST_FAC;\r
3935 break;\r
3936 case 3:\r
3937 vertex[1].sow+=1.0f/ST_FAC; \r
3938 vertex[3].sow+=1.0f/ST_FAC;\r
3939 break;\r
3940 case 4:\r
3941 vertex[0].sow+=1.0f/ST_FAC; \r
3942 vertex[2].sow+=1.0f/ST_FAC;\r
3943 break;\r
3944 case 5:\r
3945 vertex[1].sow+=1.0f/ST_FAC; \r
3946 vertex[2].sow+=1.0f/ST_FAC;\r
3947 break;\r
3948 case 6:\r
3949 vertex[0].sow+=1.0f/ST_FAC; \r
3950 vertex[3].sow+=1.0f/ST_FAC;\r
3951 break;\r
3952 }\r
3953 }\r
3954#else\r
3955 if(bUsingTWin)\r
3956 {\r
3957 switch(UFlipped)\r
3958 {\r
3959 case 1:\r
3960 vertex[2].sow+=1.0f/TWin.UScaleFactor; \r
3961 vertex[3].sow+=1.0f/TWin.UScaleFactor;\r
3962 break;\r
3963 case 2:\r
3964 vertex[0].sow+=1.0f/TWin.UScaleFactor; \r
3965 vertex[1].sow+=1.0f/TWin.UScaleFactor;\r
3966 break;\r
3967 case 3:\r
3968 vertex[1].sow+=1.0f/TWin.UScaleFactor; \r
3969 vertex[3].sow+=1.0f/TWin.UScaleFactor;\r
3970 break;\r
3971 case 4:\r
3972 vertex[0].sow+=1.0f/TWin.UScaleFactor; \r
3973 vertex[2].sow+=1.0f/TWin.UScaleFactor;\r
3974 break;\r
3975 case 5:\r
3976 vertex[1].sow+=1.0f/TWin.UScaleFactor; \r
3977 vertex[2].sow+=1.0f/TWin.UScaleFactor;\r
3978 break;\r
3979 case 6:\r
3980 vertex[0].sow+=1.0f/TWin.UScaleFactor; \r
3981 vertex[3].sow+=1.0f/TWin.UScaleFactor;\r
3982 break;\r
3983 }\r
3984 }\r
3985 else\r
3986 {\r
3987 switch(UFlipped)\r
3988 {\r
3989 case 1:\r
3990 vertex[2].sow+=1.0f; \r
3991 vertex[3].sow+=1.0f;\r
3992 break;\r
3993 case 2:\r
3994 vertex[0].sow+=1.0f; \r
3995 vertex[1].sow+=1.0f;\r
3996 break;\r
3997 case 3:\r
3998 vertex[1].sow+=1.0f; \r
3999 vertex[3].sow+=1.0f;\r
4000 break;\r
4001 case 4:\r
4002 vertex[0].sow+=1.0f; \r
4003 vertex[2].sow+=1.0f;\r
4004 break;\r
4005 case 5:\r
4006 vertex[1].sow+=1.0f; \r
4007 vertex[2].sow+=1.0f;\r
4008 break;\r
4009 case 6:\r
4010 vertex[0].sow+=1.0f; \r
4011 vertex[3].sow+=1.0f;\r
4012 break;\r
4013 }\r
4014 }\r
4015#endif\r
4016 }\r
4017\r
4018 if (VFlipped)\r
4019 {\r
4020#ifdef OWNSCALE\r
4021 if(bUsingTWin)\r
4022 {\r
4023 switch(VFlipped)\r
4024 {\r
4025 case 1:\r
4026 vertex[2].tow+=0.95f/TWin.VScaleFactor; \r
4027 vertex[3].tow+=0.95f/TWin.VScaleFactor;\r
4028 break;\r
4029 case 2:\r
4030 vertex[0].tow+=0.95f/TWin.VScaleFactor; \r
4031 vertex[1].tow+=0.95f/TWin.VScaleFactor;\r
4032 break;\r
4033 case 3:\r
4034 vertex[1].tow+=0.95f/TWin.VScaleFactor; \r
4035 vertex[3].tow+=0.95f/TWin.VScaleFactor;\r
4036 break;\r
4037 case 4:\r
4038 vertex[0].tow+=0.95f/TWin.VScaleFactor; \r
4039 vertex[2].tow+=0.95f/TWin.VScaleFactor;\r
4040 break;\r
4041 case 5:\r
4042 vertex[1].tow+=0.95f/TWin.VScaleFactor; \r
4043 vertex[2].tow+=0.95f/TWin.VScaleFactor;\r
4044 break;\r
4045 case 6:\r
4046 vertex[0].tow+=0.95f/TWin.VScaleFactor; \r
4047 vertex[3].tow+=0.95f/TWin.VScaleFactor;\r
4048 break;\r
4049 }\r
4050 }\r
4051 else\r
4052 {\r
4053 switch(VFlipped)\r
4054 {\r
4055 case 1:\r
4056 vertex[2].tow+=1.0f/ST_FAC; \r
4057 vertex[3].tow+=1.0f/ST_FAC;\r
4058 break;\r
4059 case 2:\r
4060 vertex[0].tow+=1.0f/ST_FAC; \r
4061 vertex[1].tow+=1.0f/ST_FAC;\r
4062 break;\r
4063 case 3:\r
4064 vertex[1].tow+=1.0f/ST_FAC;\r
4065 vertex[3].tow+=1.0f/ST_FAC;\r
4066 break;\r
4067 case 4:\r
4068 vertex[0].tow+=1.0f/ST_FAC; \r
4069 vertex[2].tow+=1.0f/ST_FAC;\r
4070 break;\r
4071 case 5:\r
4072 vertex[1].tow+=1.0f/ST_FAC;\r
4073 vertex[2].tow+=1.0f/ST_FAC;\r
4074 break;\r
4075 case 6:\r
4076 vertex[0].tow+=1.0f/ST_FAC;\r
4077 vertex[3].tow+=1.0f/ST_FAC;\r
4078 break;\r
4079 }\r
4080 }\r
4081#else\r
4082 if(bUsingTWin)\r
4083 {\r
4084 switch(VFlipped)\r
4085 {\r
4086 case 1:\r
4087 vertex[2].tow+=1.0f/TWin.VScaleFactor; \r
4088 vertex[3].tow+=1.0f/TWin.VScaleFactor;\r
4089 break;\r
4090 case 2:\r
4091 vertex[0].tow+=1.0f/TWin.VScaleFactor; \r
4092 vertex[1].tow+=1.0f/TWin.VScaleFactor;\r
4093 break;\r
4094 case 3:\r
4095 vertex[1].tow+=1.0f/TWin.VScaleFactor; \r
4096 vertex[3].tow+=1.0f/TWin.VScaleFactor;\r
4097 break;\r
4098 case 4:\r
4099 vertex[0].tow+=1.0f/TWin.VScaleFactor; \r
4100 vertex[2].tow+=1.0f/TWin.VScaleFactor;\r
4101 break;\r
4102 case 5:\r
4103 vertex[1].tow+=1.0f/TWin.VScaleFactor; \r
4104 vertex[2].tow+=1.0f/TWin.VScaleFactor;\r
4105 break;\r
4106 case 6:\r
4107 vertex[0].tow+=1.0f/TWin.VScaleFactor; \r
4108 vertex[3].tow+=1.0f/TWin.VScaleFactor;\r
4109 break;\r
4110 }\r
4111 }\r
4112 else\r
4113 {\r
4114 switch(VFlipped)\r
4115 {\r
4116 case 1:\r
4117 vertex[2].tow+=1.0f; \r
4118 vertex[3].tow+=1.0f;\r
4119 break;\r
4120 case 2:\r
4121 vertex[0].tow+=1.0f; \r
4122 vertex[1].tow+=1.0f;\r
4123 break;\r
4124 case 3:\r
4125 vertex[1].tow+=1.0f; \r
4126 vertex[3].tow+=1.0f;\r
4127 break;\r
4128 case 4:\r
4129 vertex[0].tow+=1.0f; \r
4130 vertex[2].tow+=1.0f;\r
4131 break;\r
4132 case 5:\r
4133 vertex[1].tow+=1.0f; \r
4134 vertex[2].tow+=1.0f;\r
4135 break;\r
4136 case 6:\r
4137 vertex[0].tow+=1.0f; \r
4138 vertex[3].tow+=1.0f;\r
4139 break;\r
4140 }\r
4141 }\r
4142#endif\r
4143 }\r
4144\r
4145}\r
4146\r
677ea103 4147void primPolyFT4(unsigned char * baseAddr)\r
ce879073 4148{\r
4149 unsigned long *gpuData = ((unsigned long *) baseAddr);\r
4150 short *sgpuData = ((short *) baseAddr);\r
4151\r
4152 lx0 = sgpuData[2];\r
4153 ly0 = sgpuData[3];\r
4154 lx1 = sgpuData[6];\r
4155 ly1 = sgpuData[7];\r
4156 lx2 = sgpuData[10];\r
4157 ly2 = sgpuData[11];\r
4158 lx3 = sgpuData[14];\r
4159 ly3 = sgpuData[15];\r
4160\r
4161 if(offset4()) return;\r
4162\r
4163 gl_vy[0]=baseAddr[9];//((gpuData[2]>>8)&0xff);\r
4164 gl_vy[1]=baseAddr[17];//((gpuData[4]>>8)&0xff);\r
4165 gl_vy[2]=baseAddr[25];//((gpuData[6]>>8)&0xff);\r
4166 gl_vy[3]=baseAddr[33];//((gpuData[8]>>8)&0xff);\r
4167 \r
4168 gl_ux[0]=baseAddr[8];//(gpuData[2]&0xff);\r
4169 gl_ux[1]=baseAddr[16];//(gpuData[4]&0xff);\r
4170 gl_ux[2]=baseAddr[24];//(gpuData[6]&0xff);\r
4171 gl_ux[3]=baseAddr[32];//(gpuData[8]&0xff);\r
4172\r
4173 UpdateGlobalTP((unsigned short)(gpuData[4]>>16));\r
4174 ulClutID=(gpuData[2]>>16);\r
4175\r
4176 bDrawTextured = TRUE;\r
4177 bDrawSmoothShaded = FALSE;\r
4178 SetRenderState(gpuData[0]);\r
4179\r
4180/* if(iOffscreenDrawing)\r
4181 {\r
4182 offsetPSX4();\r
4183 if(bDrawOffscreen4())\r
4184 {\r
4185 InvalidateTextureAreaEx(); \r
4186 SetRenderColor(gpuData[0]);\r
4187 drawPoly4FT(baseAddr);\r
4188 }\r
4189 }\r
4190*/\r
4191 SetRenderMode(gpuData[0], TRUE);\r
4192\r
4193 SetZMask4();\r
4194\r
4195 assignTexture4();\r
4196\r
4197 RectTexAlign();\r
4198\r
4199 PRIMdrawTexturedQuad(&vertex[0], &vertex[1], &vertex[3], &vertex[2]);\r
4200\r
4201 if(bDrawMultiPass)\r
4202 {\r
4203 SetSemiTransMulti(1);\r
4204 PRIMdrawTexturedQuad(&vertex[0], &vertex[1], &vertex[3], &vertex[2]);\r
4205 }\r
4206\r
4207 if(ubOpaqueDraw)\r
4208 {\r
4209 SetZMask4O();\r
4210 if(bUseMultiPass) SetOpaqueColor(gpuData[0]);\r
4211 DEFOPAQUEON\r
4212\r
4213/* if(bSmallAlpha && iFilterType<=2)\r
4214 {\r
4215 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);\r
4216 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);\r
4217 PRIMdrawTexturedQuad(&vertex[0], &vertex[1], &vertex[3], &vertex[2]);\r
4218 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);\r
4219 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);\r
4220 SetZMask4O();\r
4221 }\r
4222*/\r
4223 \r
4224 PRIMdrawTexturedQuad(&vertex[0], &vertex[1], &vertex[3], &vertex[2]);\r
4225 DEFOPAQUEOFF\r
4226 }\r
4227\r
4228 iDrawnSomething=1;\r
4229}\r
4230\r
4231////////////////////////////////////////////////////////////////////////\r
4232// cmd: smooth shaded Texture3\r
4233////////////////////////////////////////////////////////////////////////\r
4234\r
677ea103 4235void primPolyGT3(unsigned char *baseAddr)\r
ce879073 4236{ \r
4237 unsigned long *gpuData = ((unsigned long *) baseAddr);\r
4238 short *sgpuData = ((short *) baseAddr);\r
4239\r
4240 lx0 = sgpuData[2];\r
4241 ly0 = sgpuData[3];\r
4242 lx1 = sgpuData[8];\r
4243 ly1 = sgpuData[9];\r
4244 lx2 = sgpuData[14];\r
4245 ly2 = sgpuData[15];\r
4246\r
4247 if(offset3()) return;\r
4248\r
4249 // do texture stuff\r
4250 gl_ux[0]=gl_ux[3]=baseAddr[8];//gpuData[2]&0xff;\r
4251 gl_vy[0]=gl_vy[3]=baseAddr[9];//(gpuData[2]>>8)&0xff;\r
4252 gl_ux[1]=baseAddr[20];//gpuData[5]&0xff;\r
4253 gl_vy[1]=baseAddr[21];//(gpuData[5]>>8)&0xff;\r
4254 gl_ux[2]=baseAddr[32];//gpuData[8]&0xff;\r
4255 gl_vy[2]=baseAddr[33];//(gpuData[8]>>8)&0xff;\r
4256\r
4257 UpdateGlobalTP((unsigned short)(gpuData[5]>>16));\r
4258 ulClutID=(gpuData[2]>>16);\r
4259 \r
4260 bDrawTextured = TRUE;\r
4261 bDrawSmoothShaded = TRUE;\r
4262 SetRenderState(gpuData[0]);\r
4263\r
4264/* if(iOffscreenDrawing)\r
4265 {\r
4266 offsetPSX3();\r
4267 if(bDrawOffscreen3())\r
4268 {\r
4269 InvalidateTextureAreaEx(); \r
4270 drawPoly3GT(baseAddr);\r
4271 }\r
4272 }\r
4273*/\r
4274 SetRenderMode(gpuData[0], FALSE);\r
4275 SetZMask3();\r
4276\r
4277 assignTexture3();\r
4278\r
4279 if(bDrawNonShaded)\r
4280 {\r
4281 //if(!bUseMultiPass) vertex[0].lcol=DoubleBGR2RGB(gpuData[0]); else vertex[0].lcol=gpuData[0];\r
4282 // eat this...\r
4283/* if(bGLBlend) vertex[0].c.lcol=0x7f7f7f;\r
4284 else */vertex[0].c.lcol=0xffffff;\r
4285 vertex[0].c.col[3]=ubGloAlpha;\r
4286 SETCOL(vertex[0]); \r
4287\r
4288 PRIMdrawTexturedTri(&vertex[0], &vertex[1], &vertex[2]);\r
4289\r
4290 if(ubOpaqueDraw)\r
4291 {\r
4292 SetZMask3O();\r
4293 DEFOPAQUEON\r
4294 PRIMdrawTexturedTri(&vertex[0], &vertex[1], &vertex[2]);\r
4295 DEFOPAQUEOFF\r
4296 }\r
4297 return; \r
4298 }\r
4299\r
4300/* if(!bUseMultiPass && !bGLBlend)\r
4301 {\r
4302 */ vertex[0].c.lcol=DoubleBGR2RGB(gpuData[0]); \r
4303 vertex[1].c.lcol=DoubleBGR2RGB(gpuData[3]); \r
4304 vertex[2].c.lcol=DoubleBGR2RGB(gpuData[6]);\r
4305 /*}\r
4306 else\r
4307 {\r
4308 vertex[0].c.lcol=gpuData[0];\r
4309 vertex[1].c.lcol=gpuData[3];\r
4310 vertex[2].c.lcol=gpuData[6];\r
4311 }*/\r
4312 vertex[0].c.col[3]=vertex[1].c.col[3]=vertex[2].c.col[3]=ubGloAlpha;\r
4313\r
4314 PRIMdrawTexGouraudTriColor(&vertex[0], &vertex[1], &vertex[2]);\r
4315\r
4316 if(bDrawMultiPass)\r
4317 {\r
4318 SetSemiTransMulti(1);\r
4319 PRIMdrawTexGouraudTriColor(&vertex[0], &vertex[1], &vertex[2]);\r
4320 }\r
4321\r
4322 if(ubOpaqueDraw)\r
4323 {\r
4324 SetZMask3O();\r
4325 if(bUseMultiPass) \r
4326 {\r
4327 vertex[0].c.lcol=DoubleBGR2RGB(gpuData[0]);\r
4328 vertex[1].c.lcol=DoubleBGR2RGB(gpuData[3]);\r
4329 vertex[2].c.lcol=DoubleBGR2RGB(gpuData[6]);\r
4330 vertex[0].c.col[3]=vertex[1].c.col[3]=vertex[2].c.col[3]=ubGloAlpha;\r
4331 }\r
4332 DEFOPAQUEON\r
4333 PRIMdrawTexGouraudTriColor(&vertex[0], &vertex[1], &vertex[2]);\r
4334 DEFOPAQUEOFF\r
4335 }\r
4336\r
4337 iDrawnSomething=1;\r
4338}\r
4339\r
4340////////////////////////////////////////////////////////////////////////\r
4341// cmd: smooth shaded Poly3\r
4342////////////////////////////////////////////////////////////////////////\r
4343\r
677ea103 4344void primPolyG3(unsigned char *baseAddr)\r
ce879073 4345{ \r
4346 unsigned long *gpuData = ((unsigned long *) baseAddr);\r
4347 short *sgpuData = ((short *) baseAddr);\r
4348\r
4349 lx0 = sgpuData[2];\r
4350 ly0 = sgpuData[3];\r
4351 lx1 = sgpuData[6];\r
4352 ly1 = sgpuData[7];\r
4353 lx2 = sgpuData[10];\r
4354 ly2 = sgpuData[11];\r
4355\r
4356 if(offset3()) return;\r
4357\r
4358 bDrawTextured = FALSE;\r
4359 bDrawSmoothShaded = TRUE;\r
4360 SetRenderState(gpuData[0]);\r
4361\r
4362/* if(iOffscreenDrawing) \r
4363 {\r
4364 offsetPSX3();\r
4365 if(bDrawOffscreen3())\r
4366 {\r
4367 InvalidateTextureAreaEx(); \r
4368 drawPoly3G(gpuData[0], gpuData[2], gpuData[4]);\r
4369 }\r
4370 }\r
4371*/\r
4372 SetRenderMode(gpuData[0], FALSE);\r
4373 SetZMask3NT();\r
4374\r
4375 vertex[0].c.lcol=gpuData[0];\r
4376 vertex[1].c.lcol=gpuData[2];\r
4377 vertex[2].c.lcol=gpuData[4];\r
4378 vertex[0].c.col[3]=vertex[1].c.col[3]=vertex[2].c.col[3]=ubGloColAlpha; \r
4379\r
4380 PRIMdrawGouraudTriColor(&vertex[0], &vertex[1], &vertex[2]);\r
4381\r
4382 iDrawnSomething=1;\r
4383}\r
4384\r
4385////////////////////////////////////////////////////////////////////////\r
4386// cmd: smooth shaded Texture4\r
4387////////////////////////////////////////////////////////////////////////\r
4388\r
677ea103 4389void primPolyGT4(unsigned char *baseAddr)\r
ce879073 4390{ \r
4391 unsigned long *gpuData = ((unsigned long *) baseAddr);\r
4392 short *sgpuData = ((short *) baseAddr);\r
4393\r
4394 lx0 = sgpuData[2];\r
4395 ly0 = sgpuData[3];\r
4396 lx1 = sgpuData[8];\r
4397 ly1 = sgpuData[9];\r
4398 lx2 = sgpuData[14];\r
4399 ly2 = sgpuData[15];\r
4400 lx3 = sgpuData[20];\r
4401 ly3 = sgpuData[21];\r
4402\r
4403 if(offset4()) return;\r
4404\r
4405 // do texture stuff\r
4406 gl_ux[0]=baseAddr[8];//gpuData[2]&0xff;\r
4407 gl_vy[0]=baseAddr[9];//(gpuData[2]>>8)&0xff;\r
4408 gl_ux[1]=baseAddr[20];//gpuData[5]&0xff;\r
4409 gl_vy[1]=baseAddr[21];//(gpuData[5]>>8)&0xff;\r
4410 gl_ux[2]=baseAddr[32];//gpuData[8]&0xff;\r
4411 gl_vy[2]=baseAddr[33];//(gpuData[8]>>8)&0xff;\r
4412 gl_ux[3]=baseAddr[44];//gpuData[11]&0xff;\r
4413 gl_vy[3]=baseAddr[45];//(gpuData[11]>>8)&0xff;\r
4414\r
4415 UpdateGlobalTP((unsigned short)(gpuData[5]>>16));\r
4416 ulClutID=(gpuData[2]>>16);\r
4417\r
4418 bDrawTextured = TRUE;\r
4419 bDrawSmoothShaded = TRUE;\r
4420 SetRenderState(gpuData[0]);\r
4421\r
4422/* if(iOffscreenDrawing)\r
4423 {\r
4424 offsetPSX4();\r
4425 if(bDrawOffscreen4())\r
4426 {\r
4427 InvalidateTextureAreaEx(); \r
4428 drawPoly4GT(baseAddr);\r
4429 } \r
4430 }\r
4431*/\r
4432 SetRenderMode(gpuData[0], FALSE);\r
4433 SetZMask4();\r
4434\r
4435 assignTexture4();\r
4436\r
4437 RectTexAlign();\r
4438\r
4439 if(bDrawNonShaded)\r
4440 {\r
4441 //if(!bUseMultiPass) vertex[0].lcol=DoubleBGR2RGB(gpuData[0]); else vertex[0].lcol=gpuData[0];\r
4442/* if(bGLBlend) vertex[0].c.lcol=0x7f7f7f;\r
4443 else */vertex[0].c.lcol=0xffffff;\r
4444 vertex[0].c.col[3]=ubGloAlpha;\r
4445 SETCOL(vertex[0]); \r
4446\r
4447 PRIMdrawTexturedQuad(&vertex[0], &vertex[1], &vertex[3], &vertex[2]);\r
4448 \r
4449 if(ubOpaqueDraw)\r
4450 {\r
4451 SetZMask4O();\r
4452 ubGloAlpha=ubGloColAlpha=0xff; \r
4453 DEFOPAQUEON\r
4454 PRIMdrawTexturedQuad(&vertex[0], &vertex[1], &vertex[3], &vertex[2]);\r
4455 DEFOPAQUEOFF\r
4456 }\r
4457 return;\r
4458 }\r
4459\r
4460// if(!bUseMultiPass && !bGLBlend) \r
4461 {\r
4462 vertex[0].c.lcol=DoubleBGR2RGB(gpuData[0]);\r
4463 vertex[1].c.lcol=DoubleBGR2RGB(gpuData[3]);\r
4464 vertex[2].c.lcol=DoubleBGR2RGB(gpuData[6]);\r
4465 vertex[3].c.lcol=DoubleBGR2RGB(gpuData[9]);\r
4466 }\r
4467 /*else\r
4468 {\r
4469 vertex[0].c.lcol=gpuData[0];\r
4470 vertex[1].c.lcol=gpuData[3];\r
4471 vertex[2].c.lcol=gpuData[6];\r
4472 vertex[3].c.lcol=gpuData[9];\r
4473 }*/\r
4474\r
4475 vertex[0].c.col[3]=vertex[1].c.col[3]=vertex[2].c.col[3]=vertex[3].c.col[3]=ubGloAlpha; \r
4476\r
4477 PRIMdrawTexGouraudTriColorQuad(&vertex[0], &vertex[1], &vertex[3],&vertex[2]);\r
4478 \r
4479 if(bDrawMultiPass)\r
4480 {\r
4481 SetSemiTransMulti(1);\r
4482 PRIMdrawTexGouraudTriColorQuad(&vertex[0], &vertex[1], &vertex[3],&vertex[2]);\r
4483 }\r
4484\r
4485 if(ubOpaqueDraw)\r
4486 {\r
4487 SetZMask4O();\r
4488 if(bUseMultiPass) \r
4489 {\r
4490 vertex[0].c.lcol=DoubleBGR2RGB(gpuData[0]);\r
4491 vertex[1].c.lcol=DoubleBGR2RGB(gpuData[3]);\r
4492 vertex[2].c.lcol=DoubleBGR2RGB(gpuData[6]);\r
4493 vertex[3].c.lcol=DoubleBGR2RGB(gpuData[9]);\r
4494 vertex[0].c.col[3]=vertex[1].c.col[3]=vertex[2].c.col[3]=vertex[3].c.col[3]=ubGloAlpha; \r
4495 }\r
4496 ubGloAlpha=ubGloColAlpha=0xff; \r
4497 DEFOPAQUEON\r
4498 PRIMdrawTexGouraudTriColorQuad(&vertex[0], &vertex[1], &vertex[3],&vertex[2]);\r
4499 DEFOPAQUEOFF\r
4500 }\r
4501\r
4502 iDrawnSomething=1;\r
4503}\r
4504\r
4505////////////////////////////////////////////////////////////////////////\r
4506// cmd: smooth shaded Poly3\r
4507////////////////////////////////////////////////////////////////////////\r
4508\r
677ea103 4509void primPolyF3(unsigned char *baseAddr)\r
ce879073 4510{ \r
4511 unsigned long *gpuData = ((unsigned long *) baseAddr);\r
4512 short *sgpuData = ((short *) baseAddr);\r
4513\r
4514 lx0 = sgpuData[2];\r
4515 ly0 = sgpuData[3];\r
4516 lx1 = sgpuData[4];\r
4517 ly1 = sgpuData[5];\r
4518 lx2 = sgpuData[6];\r
4519 ly2 = sgpuData[7];\r
4520\r
4521 if(offset3()) return;\r
4522\r
4523 bDrawTextured = FALSE;\r
4524 bDrawSmoothShaded = FALSE;\r
4525 SetRenderState(gpuData[0]);\r
4526\r
4527/* if(iOffscreenDrawing)\r
4528 {\r
4529 offsetPSX3();\r
4530 if(bDrawOffscreen3())\r
4531 {\r
4532 InvalidateTextureAreaEx(); \r
4533 drawPoly3F(gpuData[0]);\r
4534 }\r
4535 }\r
4536*/\r
4537 SetRenderMode(gpuData[0], FALSE);\r
4538 SetZMask3NT();\r
4539\r
4540 vertex[0].c.lcol=gpuData[0];\r
4541 vertex[0].c.col[3]=ubGloColAlpha;\r
4542 SETCOL(vertex[0]); \r
4543\r
4544 PRIMdrawTri(&vertex[0], &vertex[1], &vertex[2]);\r
4545\r
4546 iDrawnSomething=1;\r
4547}\r
4548\r
4549////////////////////////////////////////////////////////////////////////\r
4550// cmd: skipping shaded polylines\r
4551////////////////////////////////////////////////////////////////////////\r
4552\r
677ea103 4553void primLineGSkip(unsigned char *baseAddr)\r
ce879073 4554{ \r
4555 unsigned long *gpuData = ((unsigned long *) baseAddr);\r
4556 short *sgpuData = ((short *) baseAddr);\r
4557 int iMax=255;\r
4558 int i=2;\r
4559\r
4560 lx1 = sgpuData[2];\r
4561 ly1 = sgpuData[3];\r
4562\r
4563 while(!(((gpuData[i] & 0xF000F000) == 0x50005000) && i>=4))\r
4564 {\r
4565 i++;\r
4566\r
4567 ly1 = (short)((gpuData[i]>>16) & 0xffff);\r
4568 lx1 = (short)(gpuData[i] & 0xffff);\r
4569\r
4570 i++;if(i>iMax) break;\r
4571 }\r
4572}\r
4573\r
4574////////////////////////////////////////////////////////////////////////\r
4575// cmd: shaded polylines\r
4576////////////////////////////////////////////////////////////////////////\r
4577\r
677ea103 4578void primLineGEx(unsigned char *baseAddr)\r
ce879073 4579{ \r
4580 unsigned long *gpuData = ((unsigned long *) baseAddr);\r
4581 int iMax=255;\r
4582 short cx0,cx1,cy0,cy1;int i;BOOL bDraw=TRUE;\r
4583\r
4584 bDrawTextured = FALSE;\r
4585 bDrawSmoothShaded = TRUE;\r
4586 SetRenderState(gpuData[0]);\r
4587 SetRenderMode(gpuData[0], FALSE);\r
4588 SetZMask4NT();\r
4589\r
4590 vertex[0].c.lcol=vertex[3].c.lcol=gpuData[0];\r
4591 vertex[0].c.col[3]=vertex[3].c.col[3]=ubGloColAlpha; \r
4592 ly1 = (short)((gpuData[1]>>16) & 0xffff);\r
4593 lx1 = (short)(gpuData[1] & 0xffff);\r
4594\r
4595 i=2;\r
4596\r
4597 //while((gpuData[i]>>24)!=0x55)\r
4598 //while((gpuData[i]&0x50000000)!=0x50000000) \r
4599 // currently best way to check for poly line end:\r
4600 while(!(((gpuData[i] & 0xF000F000) == 0x50005000) && i>=4))\r
4601 {\r
4602 ly0 = ly1;lx0=lx1;\r
4603 vertex[1].c.lcol=vertex[2].c.lcol=vertex[0].c.lcol;\r
4604 vertex[0].c.lcol=vertex[3].c.lcol=gpuData[i];\r
4605 vertex[0].c.col[3]=vertex[3].c.col[3]=ubGloColAlpha; \r
4606\r
4607 i++;\r
4608\r
4609 ly1 = (short)((gpuData[i]>>16) & 0xffff);\r
4610 lx1 = (short)(gpuData[i] & 0xffff);\r
4611\r
4612 if(offsetline()) bDraw=FALSE; else bDraw=TRUE;\r
4613 \r
4614 if (bDraw && ((lx0 != lx1) || (ly0 != ly1)))\r
4615 {\r
4616/* if(iOffscreenDrawing)\r
4617 {\r
4618 cx0=lx0;cx1=lx1;cy0=ly0;cy1=ly1;\r
4619 offsetPSXLine();\r
4620 if(bDrawOffscreen4())\r
4621 {\r
4622 InvalidateTextureAreaEx(); \r
4623 drawPoly4G(gpuData[i-3],gpuData[i-1],gpuData[i-3],gpuData[i-1]);\r
4624 }\r
4625 lx0=cx0;lx1=cx1;ly0=cy0;ly1=cy1;\r
4626 }*/\r
4627\r
4628 PRIMdrawGouraudLine(&vertex[0], &vertex[1], &vertex[2], &vertex[3]);\r
4629 }\r
4630 i++; \r
4631\r
4632 if(i>iMax) break;\r
4633 }\r
4634\r
4635 iDrawnSomething=1;\r
4636}\r
4637\r
4638////////////////////////////////////////////////////////////////////////\r
4639// cmd: shaded polyline2\r
4640////////////////////////////////////////////////////////////////////////\r
4641\r
677ea103 4642void primLineG2(unsigned char *baseAddr)\r
ce879073 4643{ \r
4644 unsigned long *gpuData = ((unsigned long *) baseAddr);\r
4645 short *sgpuData = ((short *) baseAddr);\r
4646\r
4647 lx0 = sgpuData[2];\r
4648 ly0 = sgpuData[3];\r
4649 lx1 = sgpuData[6];\r
4650 ly1 = sgpuData[7];\r
4651\r
4652 vertex[0].c.lcol=vertex[3].c.lcol=gpuData[0];\r
4653 vertex[1].c.lcol=vertex[2].c.lcol=gpuData[2];\r
4654 vertex[0].c.col[3]=vertex[1].c.col[3]=vertex[2].c.col[3]=vertex[3].c.col[3]=ubGloColAlpha; \r
4655\r
4656 bDrawTextured = FALSE;\r
4657 bDrawSmoothShaded = TRUE;\r
4658\r
4659 if((lx0 == lx1) && (ly0 == ly1)) return;\r
4660 \r
4661 if(offsetline()) return;\r
4662 \r
4663 SetRenderState(gpuData[0]);\r
4664 SetRenderMode(gpuData[0], FALSE);\r
4665 SetZMask4NT();\r
4666\r
4667/* if(iOffscreenDrawing)\r
4668 {\r
4669 offsetPSXLine();\r
4670 if(bDrawOffscreen4())\r
4671 {\r
4672 InvalidateTextureAreaEx(); \r
4673 drawPoly4G(gpuData[0],gpuData[2],gpuData[0],gpuData[2]);\r
4674 }\r
4675 }\r
4676*/\r
4677 //if(ClipVertexList4())\r
4678 PRIMdrawGouraudLine(&vertex[0], &vertex[1], &vertex[2], &vertex[3]);\r
4679\r
4680 iDrawnSomething=1;\r
4681}\r
4682\r
4683////////////////////////////////////////////////////////////////////////\r
4684// cmd: skipping flat polylines\r
4685////////////////////////////////////////////////////////////////////////\r
4686\r
677ea103 4687void primLineFSkip(unsigned char *baseAddr)\r
ce879073 4688{\r
4689 unsigned long *gpuData = ((unsigned long *) baseAddr);\r
4690 int i=2,iMax=255;\r
4691\r
4692 ly1 = (short)((gpuData[1]>>16) & 0xffff);\r
4693 lx1 = (short)(gpuData[1] & 0xffff);\r
4694\r
4695 while(!(((gpuData[i] & 0xF000F000) == 0x50005000) && i>=3))\r
4696 {\r
4697 ly1 = (short)((gpuData[i]>>16) & 0xffff);\r
4698 lx1 = (short)(gpuData[i] & 0xffff);\r
4699 i++;if(i>iMax) break;\r
4700 } \r
4701}\r
4702\r
4703////////////////////////////////////////////////////////////////////////\r
4704// cmd: drawing flat polylines\r
4705////////////////////////////////////////////////////////////////////////\r
4706\r
677ea103 4707void primLineFEx(unsigned char *baseAddr)\r
ce879073 4708{\r
4709 unsigned long *gpuData = ((unsigned long *) baseAddr);\r
4710 int iMax;\r
4711 short cx0,cx1,cy0,cy1;int i;\r
4712\r
4713 iMax=255;\r
4714\r
4715 bDrawTextured = FALSE;\r
4716 bDrawSmoothShaded = FALSE;\r
4717 SetRenderState(gpuData[0]);\r
4718 SetRenderMode(gpuData[0], FALSE);\r
4719 SetZMask4NT();\r
4720\r
4721 vertex[0].c.lcol=gpuData[0];\r
4722 vertex[0].c.col[3]=ubGloColAlpha; \r
4723\r
4724 ly1 = (short)((gpuData[1]>>16) & 0xffff);\r
4725 lx1 = (short)(gpuData[1] & 0xffff);\r
4726\r
4727 i=2;\r
4728\r
4729// while(!(gpuData[i]&0x40000000)) \r
4730// while((gpuData[i]>>24)!=0x55)\r
4731// while((gpuData[i]&0x50000000)!=0x50000000) \r
4732// currently best way to check for poly line end:\r
4733 while(!(((gpuData[i] & 0xF000F000) == 0x50005000) && i>=3))\r
4734 {\r
4735 ly0 = ly1;lx0=lx1;\r
4736 ly1 = (short)((gpuData[i]>>16) & 0xffff);\r
4737 lx1 = (short)(gpuData[i] & 0xffff);\r
4738\r
4739 if(!offsetline())\r
4740 {\r
4741/* if(iOffscreenDrawing)\r
4742 {\r
4743 cx0=lx0;cx1=lx1;cy0=ly0;cy1=ly1;\r
4744 offsetPSXLine();\r
4745 if(bDrawOffscreen4())\r
4746 {\r
4747 InvalidateTextureAreaEx(); \r
4748 drawPoly4F(gpuData[0]);\r
4749 }\r
4750 lx0=cx0;lx1=cx1;ly0=cy0;ly1=cy1;\r
4751 }*/\r
4752 PRIMdrawFlatLine(&vertex[0], &vertex[1], &vertex[2], &vertex[3]);\r
4753 }\r
4754 \r
4755 i++;if(i>iMax) break;\r
4756 }\r
4757\r
4758 iDrawnSomething=1;\r
4759}\r
4760\r
4761////////////////////////////////////////////////////////////////////////\r
4762// cmd: drawing flat polyline2\r
4763////////////////////////////////////////////////////////////////////////\r
4764\r
677ea103 4765void primLineF2(unsigned char *baseAddr)\r
ce879073 4766{\r
4767 unsigned long *gpuData = ((unsigned long *) baseAddr);\r
4768 short *sgpuData = ((short *) baseAddr);\r
4769\r
4770 lx0 = sgpuData[2];\r
4771 ly0 = sgpuData[3];\r
4772 lx1 = sgpuData[4];\r
4773 ly1 = sgpuData[5];\r
4774\r
4775 if(offsetline()) return;\r
4776\r
4777 bDrawTextured = FALSE;\r
4778 bDrawSmoothShaded = FALSE;\r
4779 SetRenderState(gpuData[0]);\r
4780 SetRenderMode(gpuData[0], FALSE);\r
4781 SetZMask4NT();\r
4782\r
4783 vertex[0].c.lcol=gpuData[0];\r
4784 vertex[0].c.col[3]=ubGloColAlpha; \r
4785\r
4786/* if(iOffscreenDrawing)\r
4787 {\r
4788 offsetPSXLine();\r
4789 if(bDrawOffscreen4())\r
4790 {\r
4791 InvalidateTextureAreaEx(); \r
4792 drawPoly4F(gpuData[0]);\r
4793 }\r
4794 }\r
4795*/\r
4796 //if(ClipVertexList4()) \r
4797 PRIMdrawFlatLine(&vertex[0], &vertex[1], &vertex[2], &vertex[3]);\r
4798\r
4799 iDrawnSomething=1;\r
4800}\r
4801\r
4802////////////////////////////////////////////////////////////////////////\r
4803// cmd: well, easiest command... not implemented\r
4804////////////////////////////////////////////////////////////////////////\r
4805\r
677ea103 4806void primNI(unsigned char *bA)\r
ce879073 4807{\r
4808}\r
4809\r
4810////////////////////////////////////////////////////////////////////////\r
4811// cmd func ptr table\r
4812////////////////////////////////////////////////////////////////////////\r
4813\r
677ea103 4814void (*primTableJ[256])(unsigned char *) = \r
ce879073 4815{\r
4816 // 00\r
4817 primNI,primNI,primBlkFill,primNI,primNI,primNI,primNI,primNI,\r
4818 // 08\r
4819 primNI,primNI,primNI,primNI,primNI,primNI,primNI,primNI,\r
4820 // 10\r
4821 primNI,primNI,primNI,primNI,primNI,primNI,primNI,primNI,\r
4822 // 18\r
4823 primNI,primNI,primNI,primNI,primNI,primNI,primNI,primNI,\r
4824 // 20\r
4825 primPolyF3,primPolyF3,primPolyF3,primPolyF3,primPolyFT3,primPolyFT3,primPolyFT3,primPolyFT3,\r
4826 // 28\r
4827 primPolyF4,primPolyF4,primPolyF4,primPolyF4,primPolyFT4,primPolyFT4,primPolyFT4,primPolyFT4,\r
4828 // 30\r
4829 primPolyG3,primPolyG3,primPolyG3,primPolyG3,primPolyGT3,primPolyGT3,primPolyGT3,primPolyGT3,\r
4830 // 38\r
4831 primPolyG4,primPolyG4,primPolyG4,primPolyG4,primPolyGT4,primPolyGT4,primPolyGT4,primPolyGT4,\r
4832 // 40\r
4833 primLineF2,primLineF2,primLineF2,primLineF2,primNI,primNI,primNI,primNI,\r
4834 // 48\r
4835 primLineFEx,primLineFEx,primLineFEx,primLineFEx,primLineFEx,primLineFEx,primLineFEx,primLineFEx,\r
4836 // 50\r
4837 primLineG2,primLineG2,primLineG2,primLineG2,primNI,primNI,primNI,primNI,\r
4838 // 58\r
4839 primLineGEx,primLineGEx,primLineGEx,primLineGEx,primLineGEx,primLineGEx,primLineGEx,primLineGEx,\r
4840 // 60\r
4841 primTileS,primTileS,primTileS,primTileS,primSprtS,primSprtS,primSprtS,primSprtS,\r
4842 // 68\r
4843 primTile1,primTile1,primTile1,primTile1,primNI,primNI,primNI,primNI,\r
4844 // 70\r
4845 primTile8,primTile8,primTile8,primTile8,primSprt8,primSprt8,primSprt8,primSprt8,\r
4846 // 78\r
4847 primTile16,primTile16,primTile16,primTile16,primSprt16,primSprt16,primSprt16,primSprt16,\r
4848 // 80\r
4849 primMoveImage,primNI,primNI,primNI,primNI,primNI,primNI,primNI,\r
4850 // 88\r
4851 primNI,primNI,primNI,primNI,primNI,primNI,primNI,primNI,\r
4852 // 90\r
4853 primNI,primNI,primNI,primNI,primNI,primNI,primNI,primNI,\r
4854 // 98\r
4855 primNI,primNI,primNI,primNI,primNI,primNI,primNI,primNI,\r
4856 // a0\r
4857 primLoadImage,primNI,primNI,primNI,primNI,primNI,primNI,primNI,\r
4858 // a8\r
4859 primNI,primNI,primNI,primNI,primNI,primNI,primNI,primNI,\r
4860 // b0\r
4861 primNI,primNI,primNI,primNI,primNI,primNI,primNI,primNI,\r
4862 // b8\r
4863 primNI,primNI,primNI,primNI,primNI,primNI,primNI,primNI,\r
4864 // c0\r
4865 primStoreImage,primNI,primNI,primNI,primNI,primNI,primNI,primNI,\r
4866 // c8\r
4867 primNI,primNI,primNI,primNI,primNI,primNI,primNI,primNI,\r
4868 // d0\r
4869 primNI,primNI,primNI,primNI,primNI,primNI,primNI,primNI,\r
4870 // d8\r
4871 primNI,primNI,primNI,primNI,primNI,primNI,primNI,primNI,\r
4872 // e0\r
4873 primNI,cmdTexturePage,cmdTextureWindow,cmdDrawAreaStart,cmdDrawAreaEnd,cmdDrawOffset,cmdSTP,primNI,\r
4874 // e8\r
4875 primNI,primNI,primNI,primNI,primNI,primNI,primNI,primNI,\r
4876 // f0\r
4877 primNI,primNI,primNI,primNI,primNI,primNI,primNI,primNI,\r
4878 // f8\r
4879 primNI,primNI,primNI,primNI,primNI,primNI,primNI,primNI\r
4880};\r
4881\r
4882////////////////////////////////////////////////////////////////////////\r
4883// cmd func ptr table for skipping\r
4884////////////////////////////////////////////////////////////////////////\r
4885\r
677ea103 4886void (*primTableSkip[256])(unsigned char *) = \r
ce879073 4887{\r
4888 // 00\r
4889 primNI,primNI,primBlkFill,primNI,primNI,primNI,primNI,primNI,\r
4890 // 08\r
4891 primNI,primNI,primNI,primNI,primNI,primNI,primNI,primNI,\r
4892 // 10\r
4893 primNI,primNI,primNI,primNI,primNI,primNI,primNI,primNI,\r
4894 // 18\r
4895 primNI,primNI,primNI,primNI,primNI,primNI,primNI,primNI,\r
4896 // 20\r
4897 primNI,primNI,primNI,primNI,primNI,primNI,primNI,primNI,\r
4898 // 28\r
4899 primNI,primNI,primNI,primNI,primNI,primNI,primNI,primNI,\r
4900 // 30\r
4901 primNI,primNI,primNI,primNI,primNI,primNI,primNI,primNI,\r
4902 // 38\r
4903 primNI,primNI,primNI,primNI,primNI,primNI,primNI,primNI,\r
4904 // 40\r
4905 primNI,primNI,primNI,primNI,primNI,primNI,primNI,primNI,\r
4906 // 48\r
4907 primLineFSkip,primLineFSkip,primLineFSkip,primLineFSkip,primLineFSkip,primLineFSkip,primLineFSkip,primLineFSkip,\r
4908 // 50\r
4909 primNI,primNI,primNI,primNI,primNI,primNI,primNI,primNI,\r
4910 // 58\r
4911 primLineGSkip,primLineGSkip,primLineGSkip,primLineGSkip,primLineGSkip,primLineGSkip,primLineGSkip,primLineGSkip,\r
4912 // 60\r
4913 primNI,primNI,primNI,primNI,primNI,primNI,primNI,primNI,\r
4914 // 68\r
4915 primNI,primNI,primNI,primNI,primNI,primNI,primNI,primNI,\r
4916 // 70\r
4917 primNI,primNI,primNI,primNI,primNI,primNI,primNI,primNI,\r
4918 // 78\r
4919 primNI,primNI,primNI,primNI,primNI,primNI,primNI,primNI,\r
4920 // 80\r
4921 primMoveImage,primNI,primNI,primNI,primNI,primNI,primNI,primNI,\r
4922 // 88\r
4923 primNI,primNI,primNI,primNI,primNI,primNI,primNI,primNI,\r
4924 // 90\r
4925 primNI,primNI,primNI,primNI,primNI,primNI,primNI,primNI,\r
4926 // 98\r
4927 primNI,primNI,primNI,primNI,primNI,primNI,primNI,primNI,\r
4928 // a0\r
4929 primLoadImage,primNI,primNI,primNI,primNI,primNI,primNI,primNI,\r
4930 // a8\r
4931 primNI,primNI,primNI,primNI,primNI,primNI,primNI,primNI,\r
4932 // b0\r
4933 primNI,primNI,primNI,primNI,primNI,primNI,primNI,primNI,\r
4934 // b8\r
4935 primNI,primNI,primNI,primNI,primNI,primNI,primNI,primNI,\r
4936 // c0\r
4937 primStoreImage,primNI,primNI,primNI,primNI,primNI,primNI,primNI,\r
4938 // c8\r
4939 primNI,primNI,primNI,primNI,primNI,primNI,primNI,primNI,\r
4940 // d0\r
4941 primNI,primNI,primNI,primNI,primNI,primNI,primNI,primNI,\r
4942 // d8\r
4943 primNI,primNI,primNI,primNI,primNI,primNI,primNI,primNI,\r
4944 // e0\r
4945 primNI,cmdTexturePage,cmdTextureWindow,cmdDrawAreaStart,cmdDrawAreaEnd,cmdDrawOffset,cmdSTP,primNI,\r
4946 // e8\r
4947 primNI,primNI,primNI,primNI,primNI,primNI,primNI,primNI,\r
4948 // f0\r
4949 primNI,primNI,primNI,primNI,primNI,primNI,primNI,primNI,\r
4950 // f8\r
4951 primNI,primNI,primNI,primNI,primNI,primNI,primNI,primNI\r
4952};\r
ARM optimized PCSX fork