1 /***************************************************************************
\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
9 /***************************************************************************
\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
17 ***************************************************************************/
\r
19 //*************************************************************************//
\r
20 // History of changes:
\r
22 // 2009/03/08 - Pete
\r
23 // - generic cleanup for the Peops release
\r
25 //*************************************************************************//
\r
27 #define _IN_PRIMDRAW
\r
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
36 ////////////////////////////////////////////////////////////////////////
\r
38 ////////////////////////////////////////////////////////////////////////
\r
40 #define DEFOPAQUEON glAlphaFunc(GL_EQUAL,0.0f);bBlendEnable=FALSE;glDisable(GL_BLEND);
\r
41 #define DEFOPAQUEOFF glAlphaFunc(GL_GREATER,0.49f);
\r
43 ////////////////////////////////////////////////////////////////////////
\r
45 ////////////////////////////////////////////////////////////////////////
\r
51 BOOL bDrawTextured; // current active drawing states
\r
52 BOOL bDrawSmoothShaded;
\r
53 BOOL bOldSmoothShaded;
\r
54 BOOL bDrawNonShaded;
\r
55 BOOL bDrawMultiPass;
\r
56 int iOffscreenDrawing;
\r
57 int iDrawnSomething=0;
\r
59 BOOL bRenderFrontBuffer=FALSE; // flag for front buffer rendering
\r
61 GLubyte ubGloAlpha; // texture alpha
\r
62 GLubyte ubGloColAlpha; // color alpha
\r
63 int iFilterType; // type of filter
\r
64 BOOL bFullVRam=FALSE; // sign for tex win
\r
65 BOOL bDrawDither; // sign for dither
\r
66 BOOL bUseMultiPass; // sign for multi pass
\r
67 GLuint gTexName; // binded texture
\r
68 BOOL bTexEnabled; // texture enable flag
\r
69 BOOL bBlendEnable; // blend enable flag
\r
70 PSXRect_t xrUploadArea; // rect to upload
\r
71 PSXRect_t xrUploadAreaIL; // rect to upload
\r
72 PSXRect_t xrUploadAreaRGB24; // rect to upload rgb24
\r
73 int iSpriteTex=0; // flag for "hey, it's a sprite"
\r
74 unsigned short usMirror; // mirror, mirror on the wall
\r
76 BOOL bNeedUploadAfter=FALSE; // sign for uploading in next frame
\r
77 BOOL bNeedUploadTest=FALSE; // sign for upload test
\r
78 BOOL bUsingTWin=FALSE; // tex win active flag
\r
79 BOOL bUsingMovie=FALSE; // movie active flag
\r
80 PSXRect_t xrMovieArea; // rect for movie upload
\r
81 short sSprite_ux2; // needed for sprire adjust
\r
82 short sSprite_vy2; //
\r
83 unsigned long ulOLDCOL=0; // active color
\r
84 unsigned long ulClutID; // clut
\r
86 unsigned long dwCfgFixes; // game fixes
\r
87 unsigned long dwActFixes=0;
\r
88 unsigned long dwEmuFixes=0;
\r
91 long drawX,drawY,drawW,drawH; // offscreen drawing checkers
\r
92 short sxmin,sxmax,symin,symax;
\r
94 ////////////////////////////////////////////////////////////////////////
\r
95 // Update global TP infos
\r
96 ////////////////////////////////////////////////////////////////////////
\r
98 void UpdateGlobalTP(unsigned short gdata)
\r
100 GlobalTextAddrX = (gdata << 6) & 0x3c0;
\r
102 if(iGPUHeight==1024) // ZN mode
\r
104 if(dwGPUVersion==2) // very special zn gpu
\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
113 STATUSREG = (STATUSREG & 0xffffe000 ) | (gdata & 0x1fff );
\r
116 else // "enhanced" psx gpu
\r
118 GlobalTextAddrY = (unsigned short)(((gdata << 4) & 0x100) | ((gdata >> 2) & 0x200));
\r
121 else GlobalTextAddrY = (gdata << 4) & 0x100; // "normal" psx gpu
\r
123 usMirror=gdata&0x3000;
\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
129 GlobalTexturePage = (GlobalTextAddrX>>6)+(GlobalTextAddrY>>4);
\r
131 STATUSREG&=~0x07ff; // Clear the necessary bits
\r
132 STATUSREG|=(gdata & 0x07ff); // set the necessary bits
\r
135 ////////////////////////////////////////////////////////////////////////
\r
136 // Some ASM color convertion... Lewpy's special...
\r
137 ////////////////////////////////////////////////////////////////////////
\r
140 unsigned long DoubleBGR2RGB (unsigned long BGR)
\r
142 unsigned long ebx,eax,edx;
\r
144 ebx=(BGR&0x000000ff)<<1;
\r
145 if(ebx&0x00000100) ebx=0x000000ff;
\r
147 eax=(BGR&0x0000ff00)<<1;
\r
148 if(eax&0x00010000) eax=0x0000ff00;
\r
150 edx=(BGR&0x00ff0000)<<1;
\r
151 if(edx&0x01000000) edx=0x00ff0000;
\r
153 return (ebx|eax|edx);
\r
156 unsigned short BGR24to16 (unsigned long BGR)
\r
158 return ((BGR>>3)&0x1f)|((BGR&0xf80000)>>9)|((BGR&0xf800)>>6);
\r
162 ////////////////////////////////////////////////////////////////////////
\r
163 // OpenGL primitive drawing commands
\r
164 ////////////////////////////////////////////////////////////////////////
\r
166 void PRIMdrawTexturedQuad(OGLVertex* vertex1, OGLVertex* vertex2,
\r
167 OGLVertex* vertex3, OGLVertex* vertex4)
\r
173 v[0].xyz.x = fpoint(vertex1->x);
\r
174 v[0].xyz.y = fpoint(vertex1->y);
\r
175 v[0].xyz.z = fpoint(vertex1->z);
\r
176 v[0].st.x = fpoint(vertex1->sow);
\r
177 v[0].st.y = fpoint(vertex1->tow);
\r
179 v[1].xyz.x = fpoint(vertex2->x);
\r
180 v[1].xyz.y = fpoint(vertex2->y);
\r
181 v[1].xyz.z = fpoint(vertex2->z);
\r
182 v[1].st.x = fpoint(vertex2->sow);
\r
183 v[1].st.y = fpoint(vertex2->tow);
\r
185 v[2].xyz.x = fpoint(vertex4->x);
\r
186 v[2].xyz.y = fpoint(vertex4->y);
\r
187 v[2].xyz.z = fpoint(vertex4->z);
\r
188 v[2].st.x = fpoint(vertex4->sow);
\r
189 v[2].st.y = fpoint(vertex4->tow);
\r
191 v[3].xyz.x = fpoint(vertex3->x);
\r
192 v[3].xyz.y = fpoint(vertex3->y);
\r
193 v[3].xyz.z = fpoint(vertex3->z);
\r
194 v[3].st.x = fpoint(vertex3->sow);
\r
195 v[3].st.y = fpoint(vertex3->tow);
\r
197 glEnableClientState(GL_TEXTURE_COORD_ARRAY);
\r
198 glEnableClientState(GL_VERTEX_ARRAY);
\r
199 glTexCoordPointer(2, GL_FLOAT, sizeof(v[0]), &v[0].st);
\r
200 glVertexPointer(3, GL_FLOAT, sizeof(v[0]), &v[0].xyz);
\r
201 glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
\r
202 glDisableClientState(GL_TEXTURE_COORD_ARRAY);
\r
203 glDisableClientState(GL_VERTEX_ARRAY);
\r
206 /////////////////////////////////////////////////////////
\r
208 __inline void PRIMdrawTexturedTri(OGLVertex* vertex1, OGLVertex* vertex2,
\r
209 OGLVertex* vertex3)
\r
213 v[0].xyz.x = fpoint(vertex1->x);
\r
214 v[0].xyz.y = fpoint(vertex1->y);
\r
215 v[0].xyz.z = fpoint(vertex1->z);
\r
216 v[0].st.x = fpoint(vertex1->sow);
\r
217 v[0].st.y = fpoint(vertex1->tow);
\r
219 v[1].xyz.x = fpoint(vertex2->x);
\r
220 v[1].xyz.y = fpoint(vertex2->y);
\r
221 v[1].xyz.z = fpoint(vertex2->z);
\r
222 v[1].st.x = fpoint(vertex2->sow);
\r
223 v[1].st.y = fpoint(vertex2->tow);
\r
225 v[2].xyz.x = fpoint(vertex3->x);
\r
226 v[2].xyz.y = fpoint(vertex3->y);
\r
227 v[2].xyz.z = fpoint(vertex3->z);
\r
228 v[2].st.x = fpoint(vertex3->sow);
\r
229 v[2].st.y = fpoint(vertex3->tow);
\r
231 glEnableClientState(GL_TEXTURE_COORD_ARRAY);
\r
232 glEnableClientState(GL_VERTEX_ARRAY);
\r
233 glTexCoordPointer(2, GL_FLOAT, sizeof(v[0]), &v[0].st);
\r
234 glVertexPointer(3, GL_FLOAT, sizeof(v[0]), &v[0].xyz);
\r
235 glDrawArrays(GL_TRIANGLES, 0, 3);
\r
236 glDisableClientState(GL_TEXTURE_COORD_ARRAY);
\r
237 glDisableClientState(GL_VERTEX_ARRAY);
\r
241 /////////////////////////////////////////////////////////
\r
243 __inline void PRIMdrawTexGouraudTriColor(OGLVertex* vertex1, OGLVertex* vertex2,
\r
244 OGLVertex* vertex3)
\r
249 v[0].xyz.x = fpoint(vertex1->x);
\r
250 v[0].xyz.y = fpoint(vertex1->y);
\r
251 v[0].xyz.z = fpoint(vertex1->z);
\r
252 v[0].st.x = fpoint(vertex1->sow);
\r
253 v[0].st.y = fpoint(vertex1->tow);
\r
254 v[0].rgba.r = vertex1->c.col[0];
\r
255 v[0].rgba.g = vertex1->c.col[1];
\r
256 v[0].rgba.b = vertex1->c.col[2];
\r
257 v[0].rgba.a = vertex1->c.col[3];
\r
259 v[1].xyz.x = fpoint(vertex2->x);
\r
260 v[1].xyz.y = fpoint(vertex2->y);
\r
261 v[1].xyz.z = fpoint(vertex2->z);
\r
262 v[1].st.x = fpoint(vertex2->sow);
\r
263 v[1].st.y = fpoint(vertex2->tow);
\r
264 v[1].rgba.r = vertex2->c.col[0];
\r
265 v[1].rgba.g = vertex2->c.col[1];
\r
266 v[1].rgba.b = vertex2->c.col[2];
\r
267 v[1].rgba.a = vertex2->c.col[3];
\r
269 v[2].xyz.x = fpoint(vertex3->x);
\r
270 v[2].xyz.y = fpoint(vertex3->y);
\r
271 v[2].xyz.z = fpoint(vertex3->z);
\r
272 v[2].st.x = fpoint(vertex3->sow);
\r
273 v[2].st.y = fpoint(vertex3->tow);
\r
274 v[2].rgba.r = vertex3->c.col[0];
\r
275 v[2].rgba.g = vertex3->c.col[1];
\r
276 v[2].rgba.b = vertex3->c.col[2];
\r
277 v[2].rgba.a = vertex3->c.col[3];
\r
279 glEnableClientState(GL_TEXTURE_COORD_ARRAY);
\r
280 glEnableClientState(GL_VERTEX_ARRAY);
\r
281 glEnableClientState(GL_COLOR_ARRAY);
\r
283 glTexCoordPointer(2, GL_FLOAT, sizeof(v[0]), &v[0].st);
\r
284 glVertexPointer(3, GL_FLOAT, sizeof(v[0]), &v[0].xyz);
\r
285 glColorPointer(4, GL_UNSIGNED_BYTE, sizeof(v[0]), &v[0].rgba);
\r
287 glDrawArrays(GL_TRIANGLES, 0, 3);
\r
288 glDisableClientState(GL_TEXTURE_COORD_ARRAY);
\r
289 glDisableClientState(GL_VERTEX_ARRAY);
\r
290 glDisableClientState(GL_COLOR_ARRAY);
\r
293 /////////////////////////////////////////////////////////
\r
295 __inline void PRIMdrawTexGouraudTriColorQuad(OGLVertex* vertex1, OGLVertex* vertex2,
\r
296 OGLVertex* vertex3, OGLVertex* vertex4)
\r
300 v[0].xyz.x = fpoint(vertex1->x);
\r
301 v[0].xyz.y = fpoint(vertex1->y);
\r
302 v[0].xyz.z = fpoint(vertex1->z);
\r
303 v[0].st.x = fpoint(vertex1->sow);
\r
304 v[0].st.y = fpoint(vertex1->tow);
\r
305 v[0].rgba.r = vertex1->c.col[0];
\r
306 v[0].rgba.g = vertex1->c.col[1];
\r
307 v[0].rgba.b = vertex1->c.col[2];
\r
308 v[0].rgba.a = vertex1->c.col[3];
\r
310 v[1].xyz.x = fpoint(vertex2->x);
\r
311 v[1].xyz.y = fpoint(vertex2->y);
\r
312 v[1].xyz.z = fpoint(vertex2->z);
\r
313 v[1].st.x = fpoint(vertex2->sow);
\r
314 v[1].st.y = fpoint(vertex2->tow);
\r
315 v[1].rgba.r = vertex2->c.col[0];
\r
316 v[1].rgba.g = vertex2->c.col[1];
\r
317 v[1].rgba.b = vertex2->c.col[2];
\r
318 v[1].rgba.a = vertex2->c.col[3];
\r
320 v[2].xyz.x = fpoint(vertex4->x);
\r
321 v[2].xyz.y = fpoint(vertex4->y);
\r
322 v[2].xyz.z = fpoint(vertex4->z);
\r
323 v[2].st.x = fpoint(vertex4->sow);
\r
324 v[2].st.y = fpoint(vertex4->tow);
\r
325 v[2].rgba.r = vertex4->c.col[0];
\r
326 v[2].rgba.g = vertex4->c.col[1];
\r
327 v[2].rgba.b = vertex4->c.col[2];
\r
328 v[2].rgba.a = vertex4->c.col[3];
\r
330 v[3].xyz.x = fpoint(vertex3->x);
\r
331 v[3].xyz.y = fpoint(vertex3->y);
\r
332 v[3].xyz.z = fpoint(vertex3->z);
\r
333 v[3].st.x = fpoint(vertex3->sow);
\r
334 v[3].st.y = fpoint(vertex3->tow);
\r
335 v[3].rgba.r = vertex3->c.col[0];
\r
336 v[3].rgba.g = vertex3->c.col[1];
\r
337 v[3].rgba.b = vertex3->c.col[2];
\r
338 v[3].rgba.a = vertex3->c.col[3];
\r
340 glEnableClientState(GL_TEXTURE_COORD_ARRAY);
\r
341 glEnableClientState(GL_VERTEX_ARRAY);
\r
342 glEnableClientState(GL_COLOR_ARRAY);
\r
344 glTexCoordPointer(2, GL_FLOAT, sizeof(v[0]), &v[0].st);
\r
345 glVertexPointer(3, GL_FLOAT, sizeof(v[0]), &v[0].xyz);
\r
346 glColorPointer(4, GL_UNSIGNED_BYTE, sizeof(v[0]), &v[0].rgba);
\r
348 glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
\r
349 glDisableClientState(GL_TEXTURE_COORD_ARRAY);
\r
350 glDisableClientState(GL_VERTEX_ARRAY);
\r
351 glDisableClientState(GL_COLOR_ARRAY);
\r
354 /////////////////////////////////////////////////////////
\r
356 __inline void PRIMdrawTri(OGLVertex* vertex1, OGLVertex* vertex2, OGLVertex* vertex3)
\r
360 v[0].x = fpoint(vertex1->x);
\r
361 v[0].y = fpoint(vertex1->y);
\r
362 v[0].z = fpoint(vertex1->z);
\r
364 v[1].x = fpoint(vertex2->x);
\r
365 v[1].y = fpoint(vertex2->y);
\r
366 v[1].z = fpoint(vertex2->z);
\r
368 v[2].x = fpoint(vertex3->x);
\r
369 v[2].y = fpoint(vertex3->y);
\r
370 v[2].z = fpoint(vertex3->z);
\r
372 glEnableClientState(GL_VERTEX_ARRAY);
\r
373 glVertexPointer(3, GL_FLOAT, sizeof(v[0]), &v[0]);
\r
374 glDrawArrays(GL_TRIANGLES, 0, 3);
\r
375 glDisableClientState(GL_VERTEX_ARRAY);
\r
378 /////////////////////////////////////////////////////////
\r
380 __inline void PRIMdrawTri2(OGLVertex* vertex1, OGLVertex* vertex2,
\r
381 OGLVertex* vertex3, OGLVertex* vertex4)
\r
385 v[0].x = fpoint(vertex1->x);
\r
386 v[0].y = fpoint(vertex1->y);
\r
387 v[0].z = fpoint(vertex1->z);
\r
389 v[1].x = fpoint(vertex3->x);
\r
390 v[1].y = fpoint(vertex3->y);
\r
391 v[1].z = fpoint(vertex3->z);
\r
393 v[2].x = fpoint(vertex2->x);
\r
394 v[2].y = fpoint(vertex2->y);
\r
395 v[2].z = fpoint(vertex2->z);
\r
397 v[3].x = fpoint(vertex4->x);
\r
398 v[3].y = fpoint(vertex4->y);
\r
399 v[3].z = fpoint(vertex4->z);
\r
401 glEnableClientState(GL_VERTEX_ARRAY);
\r
402 glVertexPointer(3, GL_FLOAT, sizeof(v[0]), &v[0]);
\r
403 glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
\r
404 glDisableClientState(GL_VERTEX_ARRAY);
\r
407 /////////////////////////////////////////////////////////
\r
409 __inline void PRIMdrawGouraudTriColor(OGLVertex* vertex1, OGLVertex* vertex2,
\r
410 OGLVertex* vertex3)
\r
414 v[0].xyz.x = fpoint(vertex1->x);
\r
415 v[0].xyz.y = fpoint(vertex1->y);
\r
416 v[0].xyz.z = fpoint(vertex1->z);
\r
417 v[0].rgba.r = vertex1->c.col[0];
\r
418 v[0].rgba.g = vertex1->c.col[1];
\r
419 v[0].rgba.b = vertex1->c.col[2];
\r
420 v[0].rgba.a = vertex1->c.col[3];
\r
422 v[1].xyz.x = fpoint(vertex2->x);
\r
423 v[1].xyz.y = fpoint(vertex2->y);
\r
424 v[1].xyz.z = fpoint(vertex2->z);
\r
425 v[1].rgba.r = vertex2->c.col[0];
\r
426 v[1].rgba.g = vertex2->c.col[1];
\r
427 v[1].rgba.b = vertex2->c.col[2];
\r
428 v[1].rgba.a = vertex2->c.col[3];
\r
430 v[2].xyz.x = fpoint(vertex3->x);
\r
431 v[2].xyz.y = fpoint(vertex3->y);
\r
432 v[2].xyz.z = fpoint(vertex3->z);
\r
433 v[2].rgba.r = vertex3->c.col[0];
\r
434 v[2].rgba.g = vertex3->c.col[1];
\r
435 v[2].rgba.b = vertex3->c.col[2];
\r
436 v[2].rgba.a = vertex3->c.col[3];
\r
438 glEnableClientState(GL_VERTEX_ARRAY);
\r
439 glEnableClientState(GL_COLOR_ARRAY);
\r
441 glVertexPointer(3, GL_FLOAT, sizeof(v[0]), &v[0].xyz);
\r
442 glColorPointer(4, GL_UNSIGNED_BYTE, sizeof(v[0]), &v[0].rgba);
\r
444 glDrawArrays(GL_TRIANGLES, 0, 3);
\r
445 glDisableClientState(GL_VERTEX_ARRAY);
\r
446 glDisableClientState(GL_COLOR_ARRAY);
\r
449 /////////////////////////////////////////////////////////
\r
451 __inline void PRIMdrawGouraudTri2Color(OGLVertex* vertex1, OGLVertex* vertex2,
\r
452 OGLVertex* vertex3, OGLVertex* vertex4)
\r
456 v[0].xyz.x = fpoint(vertex1->x);
\r
457 v[0].xyz.y = fpoint(vertex1->y);
\r
458 v[0].xyz.z = fpoint(vertex1->z);
\r
459 v[0].rgba.r = vertex1->c.col[0];
\r
460 v[0].rgba.g = vertex1->c.col[1];
\r
461 v[0].rgba.b = vertex1->c.col[2];
\r
462 v[0].rgba.a = vertex1->c.col[3];
\r
464 v[1].xyz.x = fpoint(vertex2->x);
\r
465 v[1].xyz.y = fpoint(vertex2->y);
\r
466 v[1].xyz.z = fpoint(vertex2->z);
\r
467 v[1].rgba.r = vertex2->c.col[0];
\r
468 v[1].rgba.g = vertex2->c.col[1];
\r
469 v[1].rgba.b = vertex2->c.col[2];
\r
470 v[1].rgba.a = vertex2->c.col[3];
\r
472 v[2].xyz.x = fpoint(vertex3->x);
\r
473 v[2].xyz.y = fpoint(vertex3->y);
\r
474 v[2].xyz.z = fpoint(vertex3->z);
\r
475 v[2].rgba.r = vertex3->c.col[0];
\r
476 v[2].rgba.g = vertex3->c.col[1];
\r
477 v[2].rgba.b = vertex3->c.col[2];
\r
478 v[2].rgba.a = vertex3->c.col[3];
\r
480 v[3].xyz.x = fpoint(vertex4->x);
\r
481 v[3].xyz.y = fpoint(vertex4->y);
\r
482 v[3].xyz.z = fpoint(vertex4->z);
\r
483 v[3].rgba.r = vertex4->c.col[0];
\r
484 v[3].rgba.g = vertex4->c.col[1];
\r
485 v[3].rgba.b = vertex4->c.col[2];
\r
486 v[3].rgba.a = vertex4->c.col[3];
\r
488 glEnableClientState(GL_VERTEX_ARRAY);
\r
489 glEnableClientState(GL_COLOR_ARRAY);
\r
491 glVertexPointer(3, GL_FLOAT, sizeof(v[0]), &v[0].xyz);
\r
492 glColorPointer(4, GL_UNSIGNED_BYTE, sizeof(v[0]), &v[0].rgba);
\r
494 glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
\r
495 glDisableClientState(GL_VERTEX_ARRAY);
\r
496 glDisableClientState(GL_COLOR_ARRAY);
\r
499 /////////////////////////////////////////////////////////
\r
501 __inline void PRIMdrawFlatLine(OGLVertex* vertex1, OGLVertex* vertex2,OGLVertex* vertex3, OGLVertex* vertex4)
\r
505 v[0].xyz.x = fpoint(vertex1->x);
\r
506 v[0].xyz.y = fpoint(vertex1->y);
\r
507 v[0].xyz.z = fpoint(vertex1->z);
\r
508 v[0].rgba.r = vertex1->c.col[0];
\r
509 v[0].rgba.g = vertex1->c.col[1];
\r
510 v[0].rgba.b = vertex1->c.col[2];
\r
511 v[0].rgba.a = vertex1->c.col[3];
\r
513 v[1].xyz.x = fpoint(vertex2->x);
\r
514 v[1].xyz.y = fpoint(vertex2->y);
\r
515 v[1].xyz.z = fpoint(vertex2->z);
\r
516 v[1].rgba.r = vertex1->c.col[0];
\r
517 v[1].rgba.g = vertex1->c.col[1];
\r
518 v[1].rgba.b = vertex1->c.col[2];
\r
519 v[1].rgba.a = vertex1->c.col[3];
\r
521 v[2].xyz.x = fpoint(vertex4->x);
\r
522 v[2].xyz.y = fpoint(vertex4->y);
\r
523 v[2].xyz.z = fpoint(vertex4->z);
\r
524 v[2].rgba.r = vertex1->c.col[0];
\r
525 v[2].rgba.g = vertex1->c.col[1];
\r
526 v[2].rgba.b = vertex1->c.col[2];
\r
527 v[2].rgba.a = vertex1->c.col[3];
\r
529 v[3].xyz.x = fpoint(vertex3->x);
\r
530 v[3].xyz.y = fpoint(vertex3->y);
\r
531 v[3].xyz.z = fpoint(vertex3->z);
\r
532 v[3].rgba.r = vertex1->c.col[0];
\r
533 v[3].rgba.g = vertex1->c.col[1];
\r
534 v[3].rgba.b = vertex1->c.col[2];
\r
535 v[3].rgba.a = vertex1->c.col[3];
\r
537 glEnableClientState(GL_VERTEX_ARRAY);
\r
538 glEnableClientState(GL_COLOR_ARRAY);
\r
540 glVertexPointer(3, GL_FLOAT, sizeof(v[0]), &v[0].xyz);
\r
541 glColorPointer(4, GL_UNSIGNED_BYTE, sizeof(v[0]), &v[0].rgba);
\r
543 glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
\r
544 glDisableClientState(GL_VERTEX_ARRAY);
\r
545 glDisableClientState(GL_COLOR_ARRAY);
\r
550 /////////////////////////////////////////////////////////
\r
552 __inline void PRIMdrawGouraudLine(OGLVertex* vertex1, OGLVertex* vertex2,OGLVertex* vertex3, OGLVertex* vertex4)
\r
556 v[0].xyz.x = fpoint(vertex1->x);
\r
557 v[0].xyz.y = fpoint(vertex1->y);
\r
558 v[0].xyz.z = fpoint(vertex1->z);
\r
559 v[0].rgba.r = vertex1->c.col[0];
\r
560 v[0].rgba.g = vertex1->c.col[1];
\r
561 v[0].rgba.b = vertex1->c.col[2];
\r
562 v[0].rgba.a = vertex1->c.col[3];
\r
564 v[1].xyz.x = fpoint(vertex2->x);
\r
565 v[1].xyz.y = fpoint(vertex2->y);
\r
566 v[1].xyz.z = fpoint(vertex2->z);
\r
567 v[1].rgba.r = vertex2->c.col[0];
\r
568 v[1].rgba.g = vertex2->c.col[1];
\r
569 v[1].rgba.b = vertex2->c.col[2];
\r
570 v[1].rgba.a = vertex2->c.col[3];
\r
572 v[3].xyz.x = fpoint(vertex3->x);
\r
573 v[3].xyz.y = fpoint(vertex3->y);
\r
574 v[3].xyz.z = fpoint(vertex3->z);
\r
575 v[3].rgba.r = vertex3->c.col[0];
\r
576 v[3].rgba.g = vertex3->c.col[1];
\r
577 v[3].rgba.b = vertex3->c.col[2];
\r
578 v[3].rgba.a = vertex3->c.col[3];
\r
580 v[2].xyz.x = fpoint(vertex4->x);
\r
581 v[2].xyz.y = fpoint(vertex4->y);
\r
582 v[2].xyz.z = fpoint(vertex4->z);
\r
583 v[2].rgba.r = vertex4->c.col[0];
\r
584 v[2].rgba.g = vertex4->c.col[1];
\r
585 v[2].rgba.b = vertex4->c.col[2];
\r
586 v[2].rgba.a = vertex4->c.col[3];
\r
588 glEnableClientState(GL_VERTEX_ARRAY);
\r
589 glEnableClientState(GL_COLOR_ARRAY);
\r
591 glVertexPointer(3, GL_FLOAT, sizeof(v[0]), &v[0].xyz);
\r
592 glColorPointer(4, GL_UNSIGNED_BYTE, sizeof(v[0]), &v[0].rgba);
\r
594 glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
\r
595 glDisableClientState(GL_VERTEX_ARRAY);
\r
596 glDisableClientState(GL_COLOR_ARRAY);
\r
599 /////////////////////////////////////////////////////////
\r
601 __inline void PRIMdrawQuad(OGLVertex* vertex1, OGLVertex* vertex2,
\r
602 OGLVertex* vertex3, OGLVertex* vertex4)
\r
606 v[0].x = fpoint(vertex1->x);
\r
607 v[0].y = fpoint(vertex1->y);
\r
608 v[0].z = fpoint(vertex1->z);
\r
610 v[1].x = fpoint(vertex2->x);
\r
611 v[1].y = fpoint(vertex2->y);
\r
612 v[1].z = fpoint(vertex2->z);
\r
614 v[2].x = fpoint(vertex4->x);
\r
615 v[2].y = fpoint(vertex4->y);
\r
616 v[2].z = fpoint(vertex4->z);
\r
618 v[3].x = fpoint(vertex3->x);
\r
619 v[3].y = fpoint(vertex3->y);
\r
620 v[3].z = fpoint(vertex3->z);
\r
622 glEnableClientState(GL_VERTEX_ARRAY);
\r
623 glVertexPointer(3, GL_FLOAT, sizeof(v[0]), &v[0]);
\r
624 glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
\r
625 glDisableClientState(GL_VERTEX_ARRAY);
\r
628 ////////////////////////////////////////////////////////////////////////
\r
629 // Transparent blending settings
\r
630 ////////////////////////////////////////////////////////////////////////
\r
632 static GLenum obm1=GL_ZERO;
\r
633 static GLenum obm2=GL_ZERO;
\r
635 typedef struct SEMITRANSTAG
\r
642 SemiTransParams TransSets[4]=
\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
650 ////////////////////////////////////////////////////////////////////////
\r
652 void SetSemiTrans(void)
\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
661 if(!DrawSemiTrans) // no semi trans at all?
\r
664 {glDisable(GL_BLEND);glError();bBlendEnable=FALSE;}// -> don't wanna blend
\r
665 ubGloAlpha=ubGloColAlpha=255; // -> full alpha
\r
666 return; // -> and bye
\r
669 ubGloAlpha=ubGloColAlpha=TransSets[GlobalTextABR].alpha;
\r
672 {glEnable(GL_BLEND);glError();bBlendEnable=TRUE;} // wanna blend
\r
674 if(TransSets[GlobalTextABR].srcFac!=obm1 ||
\r
675 TransSets[GlobalTextABR].dstFac!=obm2)
\r
677 //if(glBlendEquationEXTEx==NULL)
\r
679 obm1=TransSets[GlobalTextABR].srcFac;
\r
680 obm2=TransSets[GlobalTextABR].dstFac;
\r
681 glBlendFunc(obm1,obm2); glError(); // set blend func
\r
684 if(TransSets[GlobalTextABR].dstFac !=GL_ONE_MINUS_SRC_COLOR)
\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
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
702 void SetScanTrans(void) // blending for scan lines
\r
704 /* if(glBlendEquationEXTEx!=NULL)
\r
706 if(obm2==GL_ONE_MINUS_SRC_COLOR)
\r
707 glBlendEquationEXTEx(FUNC_ADD_EXT);
\r
710 obm1=TransSets[0].srcFac;
\r
711 obm2=TransSets[0].dstFac;
\r
712 glBlendFunc(obm1,obm2); glError(); // set blend func
\r
715 void SetScanTexTrans(void) // blending for scan mask texture
\r
717 /* if(glBlendEquationEXTEx!=NULL)
\r
719 if(obm2==GL_ONE_MINUS_SRC_COLOR)
\r
720 glBlendEquationEXTEx(FUNC_ADD_EXT);
\r
723 obm1=TransSets[2].srcFac;
\r
724 obm2=TransSets[2].dstFac;
\r
725 glBlendFunc(obm1,obm2); glError(); // set blend func
\r
728 ////////////////////////////////////////////////////////////////////////
\r
729 // multi pass in old 'Advanced blending' mode... got it from Lewpy :)
\r
730 ////////////////////////////////////////////////////////////////////////
\r
732 SemiTransParams MultiTexTransSets[4][2]=
\r
735 {GL_ONE ,GL_SRC_ALPHA, 127},
\r
736 {GL_SRC_ALPHA,GL_ONE, 127}
\r
739 {GL_ONE, GL_SRC_ALPHA, 255},
\r
740 {GL_SRC_ALPHA,GL_ONE, 255}
\r
743 {GL_ZERO, GL_ONE_MINUS_SRC_COLOR,255},
\r
744 {GL_ZERO, GL_ONE_MINUS_SRC_COLOR,255}
\r
747 {GL_SRC_ALPHA,GL_ONE, 127},
\r
748 {GL_ONE_MINUS_SRC_ALPHA,GL_ONE, 255}
\r
752 ////////////////////////////////////////////////////////////////////////
\r
754 SemiTransParams MultiColTransSets[4]=
\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
762 ////////////////////////////////////////////////////////////////////////
\r
764 void SetSemiTransMulti(int Pass)
\r
766 static GLenum bm1=GL_ZERO;
\r
767 static GLenum bm2=GL_ONE;
\r
772 // are we enabling SemiTransparent mode?
\r
777 bm1=MultiTexTransSets[GlobalTextABR][Pass].srcFac;
\r
778 bm2=MultiTexTransSets[GlobalTextABR][Pass].dstFac;
\r
779 ubGloAlpha=MultiTexTransSets[GlobalTextABR][Pass].alpha;
\r
784 bm1=MultiColTransSets[GlobalTextABR].srcFac;
\r
785 bm2=MultiColTransSets[GlobalTextABR].dstFac;
\r
786 ubGloColAlpha=MultiColTransSets[GlobalTextABR].alpha;
\r
794 // disable blending
\r
795 bm1=GL_ONE;bm2=GL_ZERO;
\r
799 // disable blending, but add src col a second time
\r
800 bm1=GL_ONE;bm2=GL_ONE;
\r
805 {glEnable(GL_BLEND);glError();bBlendEnable=TRUE;} // wanna blend
\r
807 if(bm1!=obm1 || bm2!=obm2)
\r
809 glBlendFunc(bm1,bm2); glError(); // set blend func
\r
814 ////////////////////////////////////////////////////////////////////////
\r
815 // Set several rendering stuff including blending
\r
816 ////////////////////////////////////////////////////////////////////////
\r
818 __inline void SetZMask3O(void)
\r
820 if(iUseMask && DrawSemiTrans && !iSetMask)
\r
822 vertex[0].z=vertex[1].z=vertex[2].z=gl_z;
\r
827 __inline void SetZMask3(void)
\r
831 if(iSetMask || DrawSemiTrans)
\r
832 {vertex[0].z=vertex[1].z=vertex[2].z=0.95f;}
\r
835 vertex[0].z=vertex[1].z=vertex[2].z=gl_z;
\r
841 __inline void SetZMask3NT(void)
\r
846 {vertex[0].z=vertex[1].z=vertex[2].z=0.95f;}
\r
849 vertex[0].z=vertex[1].z=vertex[2].z=gl_z;
\r
855 ////////////////////////////////////////////////////////////////////////
\r
857 __inline void SetZMask4O(void)
\r
859 if(iUseMask && DrawSemiTrans && !iSetMask)
\r
861 vertex[0].z=vertex[1].z=vertex[2].z=vertex[3].z=gl_z;
\r
866 __inline void SetZMask4(void)
\r
870 if(iSetMask || DrawSemiTrans)
\r
871 {vertex[0].z=vertex[1].z=vertex[2].z=vertex[3].z=0.95f;}
\r
874 vertex[0].z=vertex[1].z=vertex[2].z=vertex[3].z=gl_z;
\r
880 __inline void SetZMask4NT(void)
\r
885 {vertex[0].z=vertex[1].z=vertex[2].z=vertex[3].z=0.95f;}
\r
888 vertex[0].z=vertex[1].z=vertex[2].z=vertex[3].z=gl_z;
\r
894 __inline void SetZMask4SP(void)
\r
899 {vertex[0].z=vertex[1].z=vertex[2].z=vertex[3].z=0.95f;}
\r
904 vertex[0].z=vertex[1].z=vertex[2].z=vertex[3].z=gl_z;
\r
908 {vertex[0].z=vertex[1].z=vertex[2].z=vertex[3].z=0.95f;}
\r
913 ////////////////////////////////////////////////////////////////////////
\r
915 __inline void SetRenderState(unsigned long DrawAttributes)
\r
917 bDrawNonShaded = (SHADETEXBIT(DrawAttributes)) ? TRUE : FALSE;
\r
918 DrawSemiTrans = (SEMITRANSBIT(DrawAttributes)) ? TRUE : FALSE;
\r
921 ////////////////////////////////////////////////////////////////////////
\r
923 __inline void SetRenderColor(unsigned long DrawAttributes)
\r
925 if(bDrawNonShaded) {g_m1=g_m2=g_m3=128;}
\r
928 g_m1=DrawAttributes&0xff;
\r
929 g_m2=(DrawAttributes>>8)&0xff;
\r
930 g_m3=(DrawAttributes>>16)&0xff;
\r
934 ////////////////////////////////////////////////////////////////////////
\r
936 void SetRenderMode(unsigned long DrawAttributes,BOOL bSCol)
\r
938 if((bUseMultiPass) && (bDrawTextured) && !(bDrawNonShaded))
\r
939 {bDrawMultiPass = TRUE; SetSemiTransMulti(0);}
\r
940 else {bDrawMultiPass = FALSE;SetSemiTrans();}
\r
942 if(bDrawTextured) // texture ? build it/get it from cache
\r
945 if(bUsingTWin) currTex=LoadTextureWnd(GlobalTexturePage,GlobalTextTP, ulClutID);
\r
946 else if(bUsingMovie) currTex=LoadTextureMovie();
\r
947 else currTex=SelectSubTextureS(GlobalTextTP,ulClutID);
\r
949 if(gTexName!=currTex)
\r
950 {gTexName=currTex;glBindTexture(GL_TEXTURE_2D,currTex); glError();}
\r
952 if(!bTexEnabled) // -> turn texturing on
\r
953 {bTexEnabled=TRUE;glEnable(GL_TEXTURE_2D); glError();}
\r
955 else // no texture ?
\r
957 {bTexEnabled=FALSE;glDisable(GL_TEXTURE_2D); glError();} // -> turn texturing off
\r
959 if(bSCol) // also set color ?
\r
961 if((dwActFixes&4) && ((DrawAttributes&0x00ffffff)==0))
\r
962 DrawAttributes|=0x007f7f7f;
\r
964 if(bDrawNonShaded) // -> non shaded?
\r
966 /* if(bGLBlend) vertex[0].c.lcol=0x7f7f7f; // --> solid color...
\r
967 else */vertex[0].c.lcol=0xffffff;
\r
971 // if(!bUseMultiPass && !bGLBlend) // --> given color...
\r
972 vertex[0].c.lcol=DoubleBGR2RGB(DrawAttributes);
\r
973 // else vertex[0].c.lcol=DrawAttributes;
\r
975 vertex[0].c.col[3]=ubGloAlpha; // -> set color with
\r
976 SETCOL(vertex[0]); // texture alpha
\r
979 if(bDrawSmoothShaded!=bOldSmoothShaded) // shading changed?
\r
981 if(bDrawSmoothShaded) glShadeModel(GL_SMOOTH); // -> set actual shading
\r
982 else glShadeModel(GL_FLAT);
\r
984 bOldSmoothShaded=bDrawSmoothShaded;
\r
988 ////////////////////////////////////////////////////////////////////////
\r
989 // Set Opaque multipass color
\r
990 ////////////////////////////////////////////////////////////////////////
\r
992 void SetOpaqueColor(unsigned long DrawAttributes)
\r
994 if(bDrawNonShaded) return; // no shading? bye
\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
1001 ////////////////////////////////////////////////////////////////////////
\r
1002 // Fucking stupid screen coord checking
\r
1003 ////////////////////////////////////////////////////////////////////////
\r
1005 BOOL ClipVertexListScreen(void)
\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
1015 if(PSXDisplay.InterlacedTest) return FALSE;
\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
1025 ////////////////////////////////////////////////////////////////////////
\r
1027 BOOL bDrawOffscreenFront(void)
\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
1036 BOOL bOnePointInFront(void)
\r
1038 if(sxmax< PSXDisplay.DisplayPosition.x)
\r
1041 if(symax< PSXDisplay.DisplayPosition.y)
\r
1044 if(sxmin>=PSXDisplay.DisplayEnd.x)
\r
1047 if(symin>=PSXDisplay.DisplayEnd.y)
\r
1054 BOOL bOnePointInBack(void)
\r
1056 if(sxmax< PreviousPSXDisplay.DisplayPosition.x)
\r
1059 if(symax< PreviousPSXDisplay.DisplayPosition.y)
\r
1062 if(sxmin>=PreviousPSXDisplay.DisplayEnd.x)
\r
1065 if(symin>=PreviousPSXDisplay.DisplayEnd.y)
\r
1071 BOOL bDrawOffscreen4(void)
\r
1073 BOOL bFront;short sW,sH;
\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
1084 if(PSXDisplay.Disabled) return TRUE; // disabled? ever
\r
1086 if(iOffscreenDrawing==1) return bFullVRam;
\r
1088 if(dwActFixes&1 && iOffscreenDrawing==4)
\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
1095 bRenderFrontBuffer=TRUE;
\r
1100 sW=drawW-1;sH=drawH-1;
\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
1107 if(bOnePointInBack()) return bFullVRam;
\r
1109 if(iOffscreenDrawing==2)
\r
1110 bFront=bDrawOffscreenFront();
\r
1111 else bFront=bOnePointInFront();
\r
1115 if(PSXDisplay.InterlacedTest) return bFullVRam; // -> ok, no need for adjust
\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
1126 if(iOffscreenDrawing==4 && !(dwActFixes&1)) // -> frontbuffer wanted
\r
1128 bRenderFrontBuffer=TRUE;
\r
1131 return bFullVRam; // -> but no od
\r
1137 ////////////////////////////////////////////////////////////////////////
\r
1139 BOOL bDrawOffscreen3(void)
\r
1141 BOOL bFront;short sW,sH;
\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
1152 if(PSXDisplay.Disabled) return TRUE; // disabled? ever
\r
1154 if(iOffscreenDrawing==1) return bFullVRam;
\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
1162 if(bOnePointInBack()) return bFullVRam;
\r
1164 if(iOffscreenDrawing==2)
\r
1165 bFront=bDrawOffscreenFront();
\r
1166 else bFront=bOnePointInFront();
\r
1170 if(PSXDisplay.InterlacedTest) return bFullVRam; // -> ok, no need for adjust
\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
1179 if(iOffscreenDrawing==4) // -> frontbuffer wanted
\r
1181 bRenderFrontBuffer=TRUE;
\r
1185 return bFullVRam; // -> but no od
\r
1191 ////////////////////////////////////////////////////////////////////////
\r
1193 BOOL FastCheckAgainstScreen(short imageX0,short imageY0,short imageX1,short imageY1)
\r
1195 PSXRect_t xUploadArea;
\r
1197 imageX1 += imageX0;
\r
1198 imageY1 += imageY0;
\r
1200 if (imageX0 < PreviousPSXDisplay.DisplayPosition.x)
\r
1201 xUploadArea.x0 = PreviousPSXDisplay.DisplayPosition.x;
\r
1203 if (imageX0 > PreviousPSXDisplay.DisplayEnd.x)
\r
1204 xUploadArea.x0 = PreviousPSXDisplay.DisplayEnd.x;
\r
1206 xUploadArea.x0 = imageX0;
\r
1208 if(imageX1 < PreviousPSXDisplay.DisplayPosition.x)
\r
1209 xUploadArea.x1 = PreviousPSXDisplay.DisplayPosition.x;
\r
1211 if (imageX1 > PreviousPSXDisplay.DisplayEnd.x)
\r
1212 xUploadArea.x1 = PreviousPSXDisplay.DisplayEnd.x;
\r
1214 xUploadArea.x1 = imageX1;
\r
1216 if (imageY0 < PreviousPSXDisplay.DisplayPosition.y)
\r
1217 xUploadArea.y0 = PreviousPSXDisplay.DisplayPosition.y;
\r
1219 if (imageY0 > PreviousPSXDisplay.DisplayEnd.y)
\r
1220 xUploadArea.y0 = PreviousPSXDisplay.DisplayEnd.y;
\r
1222 xUploadArea.y0 = imageY0;
\r
1224 if (imageY1 < PreviousPSXDisplay.DisplayPosition.y)
\r
1225 xUploadArea.y1 = PreviousPSXDisplay.DisplayPosition.y;
\r
1227 if (imageY1 > PreviousPSXDisplay.DisplayEnd.y)
\r
1228 xUploadArea.y1 = PreviousPSXDisplay.DisplayEnd.y;
\r
1230 xUploadArea.y1 = imageY1;
\r
1232 if ((xUploadArea.x0 != xUploadArea.x1) && (xUploadArea.y0 != xUploadArea.y1))
\r
1234 else return FALSE;
\r
1237 BOOL CheckAgainstScreen(short imageX0,short imageY0,short imageX1,short imageY1)
\r
1239 imageX1 += imageX0;
\r
1240 imageY1 += imageY0;
\r
1242 if (imageX0 < PreviousPSXDisplay.DisplayPosition.x)
\r
1243 xrUploadArea.x0 = PreviousPSXDisplay.DisplayPosition.x;
\r
1245 if (imageX0 > PreviousPSXDisplay.DisplayEnd.x)
\r
1246 xrUploadArea.x0 = PreviousPSXDisplay.DisplayEnd.x;
\r
1248 xrUploadArea.x0 = imageX0;
\r
1250 if(imageX1 < PreviousPSXDisplay.DisplayPosition.x)
\r
1251 xrUploadArea.x1 = PreviousPSXDisplay.DisplayPosition.x;
\r
1253 if (imageX1 > PreviousPSXDisplay.DisplayEnd.x)
\r
1254 xrUploadArea.x1 = PreviousPSXDisplay.DisplayEnd.x;
\r
1256 xrUploadArea.x1 = imageX1;
\r
1258 if (imageY0 < PreviousPSXDisplay.DisplayPosition.y)
\r
1259 xrUploadArea.y0 = PreviousPSXDisplay.DisplayPosition.y;
\r
1261 if (imageY0 > PreviousPSXDisplay.DisplayEnd.y)
\r
1262 xrUploadArea.y0 = PreviousPSXDisplay.DisplayEnd.y;
\r
1264 xrUploadArea.y0 = imageY0;
\r
1266 if (imageY1 < PreviousPSXDisplay.DisplayPosition.y)
\r
1267 xrUploadArea.y1 = PreviousPSXDisplay.DisplayPosition.y;
\r
1269 if (imageY1 > PreviousPSXDisplay.DisplayEnd.y)
\r
1270 xrUploadArea.y1 = PreviousPSXDisplay.DisplayEnd.y;
\r
1272 xrUploadArea.y1 = imageY1;
\r
1274 if ((xrUploadArea.x0 != xrUploadArea.x1) && (xrUploadArea.y0 != xrUploadArea.y1))
\r
1276 else return FALSE;
\r
1279 BOOL FastCheckAgainstFrontScreen(short imageX0,short imageY0,short imageX1,short imageY1)
\r
1281 PSXRect_t xUploadArea;
\r
1283 imageX1 += imageX0;
\r
1284 imageY1 += imageY0;
\r
1286 if (imageX0 < PSXDisplay.DisplayPosition.x)
\r
1287 xUploadArea.x0 = PSXDisplay.DisplayPosition.x;
\r
1289 if (imageX0 > PSXDisplay.DisplayEnd.x)
\r
1290 xUploadArea.x0 = PSXDisplay.DisplayEnd.x;
\r
1292 xUploadArea.x0 = imageX0;
\r
1294 if(imageX1 < PSXDisplay.DisplayPosition.x)
\r
1295 xUploadArea.x1 = PSXDisplay.DisplayPosition.x;
\r
1297 if (imageX1 > PSXDisplay.DisplayEnd.x)
\r
1298 xUploadArea.x1 = PSXDisplay.DisplayEnd.x;
\r
1300 xUploadArea.x1 = imageX1;
\r
1302 if (imageY0 < PSXDisplay.DisplayPosition.y)
\r
1303 xUploadArea.y0 = PSXDisplay.DisplayPosition.y;
\r
1305 if (imageY0 > PSXDisplay.DisplayEnd.y)
\r
1306 xUploadArea.y0 = PSXDisplay.DisplayEnd.y;
\r
1308 xUploadArea.y0 = imageY0;
\r
1310 if (imageY1 < PSXDisplay.DisplayPosition.y)
\r
1311 xUploadArea.y1 = PSXDisplay.DisplayPosition.y;
\r
1313 if (imageY1 > PSXDisplay.DisplayEnd.y)
\r
1314 xUploadArea.y1 = PSXDisplay.DisplayEnd.y;
\r
1316 xUploadArea.y1 = imageY1;
\r
1318 if ((xUploadArea.x0 != xUploadArea.x1) && (xUploadArea.y0 != xUploadArea.y1))
\r
1320 else return FALSE;
\r
1323 BOOL CheckAgainstFrontScreen(short imageX0,short imageY0,short imageX1,short imageY1)
\r
1325 imageX1 += imageX0;
\r
1326 imageY1 += imageY0;
\r
1328 if (imageX0 < PSXDisplay.DisplayPosition.x)
\r
1329 xrUploadArea.x0 = PSXDisplay.DisplayPosition.x;
\r
1331 if (imageX0 > PSXDisplay.DisplayEnd.x)
\r
1332 xrUploadArea.x0 = PSXDisplay.DisplayEnd.x;
\r
1334 xrUploadArea.x0 = imageX0;
\r
1336 if(imageX1 < PSXDisplay.DisplayPosition.x)
\r
1337 xrUploadArea.x1 = PSXDisplay.DisplayPosition.x;
\r
1339 if (imageX1 > PSXDisplay.DisplayEnd.x)
\r
1340 xrUploadArea.x1 = PSXDisplay.DisplayEnd.x;
\r
1342 xrUploadArea.x1 = imageX1;
\r
1344 if (imageY0 < PSXDisplay.DisplayPosition.y)
\r
1345 xrUploadArea.y0 = PSXDisplay.DisplayPosition.y;
\r
1347 if (imageY0 > PSXDisplay.DisplayEnd.y)
\r
1348 xrUploadArea.y0 = PSXDisplay.DisplayEnd.y;
\r
1350 xrUploadArea.y0 = imageY0;
\r
1352 if (imageY1 < PSXDisplay.DisplayPosition.y)
\r
1353 xrUploadArea.y1 = PSXDisplay.DisplayPosition.y;
\r
1355 if (imageY1 > PSXDisplay.DisplayEnd.y)
\r
1356 xrUploadArea.y1 = PSXDisplay.DisplayEnd.y;
\r
1358 xrUploadArea.y1 = imageY1;
\r
1360 if ((xrUploadArea.x0 != xrUploadArea.x1) && (xrUploadArea.y0 != xrUploadArea.y1))
\r
1362 else return FALSE;
\r
1365 ////////////////////////////////////////////////////////////////////////
\r
1367 void PrepareFullScreenUpload (long Position)
\r
1369 if (Position==-1) // rgb24
\r
1371 if(PSXDisplay.Interlaced)
\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
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
1386 if(bNeedRGB24Update)
\r
1390 // lClearOnSwap=0;
\r
1393 if(PSXDisplay.Interlaced && PreviousPSXDisplay.RGB24<2) // in interlaced mode we upload at least two full frames (GT1 menu)
\r
1395 PreviousPSXDisplay.RGB24++;
\r
1399 xrUploadArea.y1 = min(xrUploadArea.y0+xrUploadAreaRGB24.y1,xrUploadArea.y1);
\r
1400 xrUploadArea.y0+=xrUploadAreaRGB24.y0;
\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
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
1420 if (xrUploadArea.x0 < 0) xrUploadArea.x0 = 0;
\r
1422 if (xrUploadArea.x0 > 1023) xrUploadArea.x0 = 1023;
\r
1424 if (xrUploadArea.x1 < 0) xrUploadArea.x1 = 0;
\r
1426 if (xrUploadArea.x1 > 1024) xrUploadArea.x1 = 1024;
\r
1428 if (xrUploadArea.y0 < 0) xrUploadArea.y0 = 0;
\r
1430 if (xrUploadArea.y0 > iGPUHeightMask) xrUploadArea.y0 = iGPUHeightMask;
\r
1432 if (xrUploadArea.y1 < 0) xrUploadArea.y1 = 0;
\r
1434 if (xrUploadArea.y1 > iGPUHeight) xrUploadArea.y1 = iGPUHeight;
\r
1436 if (PSXDisplay.RGB24)
\r
1438 InvalidateTextureArea(xrUploadArea.x0,xrUploadArea.y0,xrUploadArea.x1-xrUploadArea.x0,xrUploadArea.y1-xrUploadArea.y0);
\r
1442 ////////////////////////////////////////////////////////////////////////
\r
1443 // Upload screen (MDEC and such)
\r
1444 ////////////////////////////////////////////////////////////////////////
\r
1445 ////////////////////////////////////////////////////////////////////////
\r
1447 unsigned char * LoadDirectMovieFast(void);
\r
1449 void UploadScreenEx(long Position)
\r
1451 short ya,yb,xa,xb,x, y, YStep, XStep, U, UStep,ux[4],vy[4];
\r
1453 if(!PSXDisplay.DisplayMode.x) return;
\r
1454 if(!PSXDisplay.DisplayMode.y) return;
\r
1456 glDisable(GL_SCISSOR_TEST); glError();
\r
1457 glShadeModel(GL_FLAT); glError();
\r
1458 bOldSmoothShaded=FALSE;
\r
1459 glDisable(GL_BLEND); glError();
\r
1460 bBlendEnable=FALSE;
\r
1461 glDisable(GL_TEXTURE_2D); glError();
\r
1462 bTexEnabled=FALSE;
\r
1463 glDisable(GL_ALPHA_TEST); glError();
\r
1465 //glPixelZoom(((float)rRatioRect.right)/((float)PSXDisplay.DisplayMode.x),
\r
1466 // -1.0f*(((float)rRatioRect.bottom)/((float)PSXDisplay.DisplayMode.y)));
\r
1468 //----------------------------------------------------//
\r
1470 YStep = 256; // max texture size
\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
1478 for(y=ya;y<=yb;y+=YStep) // loop y
\r
1481 for(x=xa;x<=xb;x+=XStep) // loop x
\r
1483 ly0 = ly1 = y; // -> get y coords
\r
1485 if (ly2 > yb) ly2 = yb;
\r
1488 lx0 = lx3 = x; // -> get x coords
\r
1490 if (lx1 > xb) lx1 = xb;
\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
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
1504 if ((ux[0] >= ux[2]) || // -> cheaters never win...
\r
1505 (vy[0] >= vy[2])) continue; // (but winners always cheat...)
\r
1507 xrMovieArea.x0=lx0+U; xrMovieArea.y0=ly0;
\r
1508 xrMovieArea.x1=lx2+U; xrMovieArea.y1=ly2;
\r
1510 offsetScreenUpload(Position);
\r
1512 //glRasterPos2f(vertex[0].x,vertex[0].y);
\r
1514 //glDrawPixels(xrMovieArea.x1-xrMovieArea.x0,
\r
1515 // xrMovieArea.y1-xrMovieArea.y0,
\r
1516 // GL_RGBA,GL_UNSIGNED_BYTE,
\r
1517 LoadDirectMovieFast();//);
\r
1523 //----------------------------------------------------//
\r
1525 // glPixelZoom(1.0F,1.0F);
\r
1527 glEnable(GL_ALPHA_TEST); glError();
\r
1528 glEnable(GL_SCISSOR_TEST); glError();
\r
1531 ////////////////////////////////////////////////////////////////////////
\r
1533 void UploadScreen(long Position)
\r
1535 short x, y, YStep, XStep, U, s, UStep,ux[4],vy[4];
\r
1536 short xa,xb,ya,yb;
\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
1543 if(xrUploadArea.x0==xrUploadArea.x1) return;
\r
1544 if(xrUploadArea.y0==xrUploadArea.y1) return;
\r
1546 if(PSXDisplay.Disabled && iOffscreenDrawing<4) return;
\r
1548 iDrawnSomething = 2;
\r
1549 iLastRGB24=PSXDisplay.RGB24+1;
\r
1551 if(bSkipNextFrame) return;
\r
1553 if(dwActFixes & 2) {UploadScreenEx(Position);return;}
\r
1555 bUsingMovie = TRUE;
\r
1556 bDrawTextured = TRUE; // just doing textures
\r
1557 bDrawSmoothShaded = FALSE;
\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
1563 SetOGLDisplaySettings(0);
\r
1565 YStep = 256; // max texture size
\r
1568 UStep = (PSXDisplay.RGB24 ? 128 : 0);
\r
1570 ya=xrUploadArea.y0;
\r
1571 yb=xrUploadArea.y1;
\r
1572 xa=xrUploadArea.x0;
\r
1573 xb=xrUploadArea.x1;
\r
1575 for(y=ya;y<=yb;y+=YStep) // loop y
\r
1578 for(x=xa;x<=xb;x+=XStep) // loop x
\r
1580 ly0 = ly1 = y; // -> get y coords
\r
1582 if (ly2 > yb) ly2 = yb;
\r
1585 lx0 = lx3 = x; // -> get x coords
\r
1587 if (lx1 > xb) lx1 = xb;
\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
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
1601 if ((ux[0] >= ux[2]) || // -> cheaters never win...
\r
1602 (vy[0] >= vy[2])) continue; // (but winners always cheat...)
\r
1604 xrMovieArea.x0=lx0+U; xrMovieArea.y0=ly0;
\r
1605 xrMovieArea.x1=lx2+U; xrMovieArea.y1=ly2;
\r
1607 s=ux[2] - ux[0]; if(s>255) s=255;
\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
1614 SetRenderState((unsigned long)0x01000000);
\r
1615 SetRenderMode((unsigned long)0x01000000, FALSE); // upload texture data
\r
1616 offsetScreenUpload(Position);
\r
1617 assignTextureVRAMWrite();
\r
1619 PRIMdrawTexturedQuad(&vertex[0], &vertex[1], &vertex[2], &vertex[3]);
\r
1625 bUsingMovie=FALSE; // done...
\r
1626 bDisplayNotSet = TRUE;
\r
1629 ////////////////////////////////////////////////////////////////////////
\r
1630 // Detect next screen
\r
1631 ////////////////////////////////////////////////////////////////////////
\r
1633 BOOL IsCompleteInsideNextScreen(short x, short y, short xoff, short yoff)
\r
1635 if (x > PSXDisplay.DisplayPosition.x+1) return FALSE;
\r
1636 if ((x + xoff) < PSXDisplay.DisplayEnd.x-1) return FALSE;
\r
1638 if (y >= PSXDisplay.DisplayPosition.y &&
\r
1639 y <= PSXDisplay.DisplayEnd.y )
\r
1641 if ((yoff) >= PSXDisplay.DisplayPosition.y &&
\r
1642 (yoff) <= PSXDisplay.DisplayEnd.y ) return TRUE;
\r
1644 if (y > PSXDisplay.DisplayPosition.y+1) return FALSE;
\r
1645 if (yoff < PSXDisplay.DisplayEnd.y-1) return FALSE;
\r
1649 BOOL IsPrimCompleteInsideNextScreen(short x, short y, short xoff, short yoff)
\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
1662 BOOL IsInsideNextScreen(short x, short y, short xoff, short yoff)
\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
1671 ////////////////////////////////////////////////////////////////////////
\r
1673 ////////////////////////////////////////////////////////////////////////
\r
1675 //Mask1 Set mask bit while drawing. 1 = on
\r
1676 //Mask2 Do not draw to mask areas. 1= on
\r
1678 void cmdSTP(unsigned char * baseAddr)
\r
1680 unsigned long gdata = ((unsigned long*)baseAddr)[0];
\r
1682 STATUSREG&=~0x1800; // clear the necessary bits
\r
1683 STATUSREG|=((gdata & 0x03) << 11); // set the current bits
\r
1685 if(!iUseMask) return;
\r
1687 if(gdata&1) {sSetMask=0x8000;lSetMask=0x80008000;iSetMask=1;}
\r
1688 else {sSetMask=0; lSetMask=0; iSetMask=0;}
\r
1692 if(!(gdata&1)) iSetMask=2;
\r
1694 if(iDepthFunc==0) return;
\r
1696 glDepthFunc(GL_LESS); glError();
\r
1701 if(iDepthFunc==1) return;
\r
1702 glDepthFunc(GL_ALWAYS); glError();
\r
1707 ////////////////////////////////////////////////////////////////////////
\r
1708 // cmd: Set texture page infos
\r
1709 ////////////////////////////////////////////////////////////////////////
\r
1711 void cmdTexturePage(unsigned char * baseAddr)
\r
1713 unsigned long gdata = ((unsigned long*)baseAddr)[0];
\r
1714 UpdateGlobalTP((unsigned short)gdata);
\r
1715 GlobalTextREST = (gdata&0x00ffffff)>>9;
\r
1718 ////////////////////////////////////////////////////////////////////////
\r
1719 // cmd: turn on/off texture window
\r
1720 ////////////////////////////////////////////////////////////////////////
\r
1722 void cmdTextureWindow(unsigned char *baseAddr)
\r
1724 unsigned long gdata = ((unsigned long*)baseAddr)[0];
\r
1726 unsigned long YAlign,XAlign;
\r
1728 ulGPUInfoVals[INFO_TW]=gdata&0xFFFFF;
\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
1741 TWin.Position.y1 = 256; // 00000
\r
1743 // Texture window size is determined by the least bit set of the relevant 5 bits
\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
1756 TWin.Position.x1 = 256; // 00000
\r
1758 // Re-calculate the bit field, because we can't trust what is passed in the data
\r
1760 YAlign = (unsigned long)(32 - (TWin.Position.y1 >> 3));
\r
1761 XAlign = (unsigned long)(32 - (TWin.Position.x1 >> 3));
\r
1763 // Absolute position of the start of the texture window
\r
1765 TWin.Position.y0 = (short)(((gdata >> 15) & YAlign) << 3);
\r
1766 TWin.Position.x0 = (short)(((gdata >> 10) & XAlign) << 3);
\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
1775 bUsingTWin = FALSE; // -> just do it
\r
1778 TWin.UScaleFactor = 1.0f;
\r
1779 TWin.VScaleFactor = 1.0f;
\r
1781 TWin.UScaleFactor =
\r
1782 TWin.VScaleFactor = 1.0f/256.0f;
\r
1785 else // tw turned on
\r
1787 bUsingTWin = TRUE;
\r
1789 TWin.OPosition.y1 = TWin.Position.y1; // -> get psx sizes
\r
1790 TWin.OPosition.x1 = TWin.Position.x1;
\r
1792 if(TWin.Position.x1<=2) TWin.Position.x1=2; // -> set OGL sizes
\r
1794 if(TWin.Position.x1<=4) TWin.Position.x1=4;
\r
1796 if(TWin.Position.x1<=8) TWin.Position.x1=8;
\r
1798 if(TWin.Position.x1<=16) TWin.Position.x1=16;
\r
1800 if(TWin.Position.x1<=32) TWin.Position.x1=32;
\r
1802 if(TWin.Position.x1<=64) TWin.Position.x1=64;
\r
1804 if(TWin.Position.x1<=128) TWin.Position.x1=128;
\r
1806 if(TWin.Position.x1<=256) TWin.Position.x1=256;
\r
1808 if(TWin.Position.y1<=2) TWin.Position.y1=2;
\r
1810 if(TWin.Position.y1<=4) TWin.Position.y1=4;
\r
1812 if(TWin.Position.y1<=8) TWin.Position.y1=8;
\r
1814 if(TWin.Position.y1<=16) TWin.Position.y1=16;
\r
1816 if(TWin.Position.y1<=32) TWin.Position.y1=32;
\r
1818 if(TWin.Position.y1<=64) TWin.Position.y1=64;
\r
1820 if(TWin.Position.y1<=128) TWin.Position.y1=128;
\r
1822 if(TWin.Position.y1<=256) TWin.Position.y1=256;
\r
1825 TWin.UScaleFactor = (float)TWin.Position.x1;
\r
1826 TWin.VScaleFactor = (float)TWin.Position.y1;
\r
1828 TWin.UScaleFactor = ((float)TWin.Position.x1)/256.0f; // -> set scale factor
\r
1829 TWin.VScaleFactor = ((float)TWin.Position.y1)/256.0f;
\r
1834 ////////////////////////////////////////////////////////////////////////
\r
1835 // mmm, Lewpy uses that in TileS ... I don't ;)
\r
1836 ////////////////////////////////////////////////////////////////////////
\r
1839 void ClampToPSXDrawAreaOffset(short *x0, short *y0, short *x1, short *y1)
\r
1841 if (*x0 < PSXDisplay.DrawArea.x0)
\r
1843 *x1 -= (PSXDisplay.DrawArea.x0 - *x0);
\r
1844 *x0 = PSXDisplay.DrawArea.x0;
\r
1847 if (*x0 > PSXDisplay.DrawArea.x1)
\r
1849 *x0 = PSXDisplay.DrawArea.x1;
\r
1853 if (*y0 < PSXDisplay.DrawArea.y0)
\r
1855 *y1 -= (PSXDisplay.DrawArea.y0 - *y0);
\r
1856 *y0 = PSXDisplay.DrawArea.y0;
\r
1859 if (*y0 > PSXDisplay.DrawArea.y1)
\r
1861 *y0 = PSXDisplay.DrawArea.y1;
\r
1865 if (*x1 < 0) *x1 = 0;
\r
1867 if ((*x1 + *x0) > PSXDisplay.DrawArea.x1)
\r
1868 *x1 = (PSXDisplay.DrawArea.x1 - *x0 + 1);
\r
1870 if (*y1 < 0) *y1 = 0;
\r
1872 if ((*y1 + *y0) > PSXDisplay.DrawArea.y1)
\r
1873 *y1 = (PSXDisplay.DrawArea.y1 - *y0 + 1);
\r
1877 ////////////////////////////////////////////////////////////////////////
\r
1878 // Check draw area dimensions
\r
1879 ////////////////////////////////////////////////////////////////////////
\r
1881 void ClampToPSXScreen(short *x0, short *y0, short *x1, short *y1)
\r
1883 if (*x0 < 0) *x0 = 0;
\r
1885 if (*x0 > 1023) *x0 = 1023;
\r
1887 if (*x1 < 0) *x1 = 0;
\r
1889 if (*x1 > 1023) *x1 = 1023;
\r
1891 if (*y0 < 0) *y0 = 0;
\r
1893 if (*y0 > iGPUHeightMask) *y0 = iGPUHeightMask;
\r
1895 if (*y1 < 0) *y1 = 0;
\r
1897 if (*y1 > iGPUHeightMask) *y1 = iGPUHeightMask;
\r
1900 ////////////////////////////////////////////////////////////////////////
\r
1901 // Used in Load Image and Blk Fill
\r
1902 ////////////////////////////////////////////////////////////////////////
\r
1904 void ClampToPSXScreenOffset(short *x0, short *y0, short *x1, short *y1)
\r
1907 { *x1 += *x0; *x0 = 0; }
\r
1910 { *x0 = 1023; *x1 = 0; }
\r
1913 { *y1 += *y0; *y0 = 0; }
\r
1915 if (*y0 > iGPUHeightMask)
\r
1916 { *y0 = iGPUHeightMask; *y1 = 0; }
\r
1918 if (*x1 < 0) *x1 = 0;
\r
1920 if ((*x1 + *x0) > 1024) *x1 = (1024 - *x0);
\r
1922 if (*y1 < 0) *y1 = 0;
\r
1924 if ((*y1 + *y0) > iGPUHeight) *y1 = (iGPUHeight - *y0);
\r
1927 ////////////////////////////////////////////////////////////////////////
\r
1928 // cmd: start of drawing area... primitives will be clipped inside
\r
1929 ////////////////////////////////////////////////////////////////////////
\r
1931 void cmdDrawAreaStart(unsigned char * baseAddr)
\r
1933 unsigned long gdata = ((unsigned long*)baseAddr)[0];
\r
1935 drawX = gdata & 0x3ff; // for soft drawing
\r
1936 if(drawX>=1024) drawX=1023;
\r
1938 if(dwGPUVersion==2)
\r
1940 ulGPUInfoVals[INFO_DRAWSTART]=gdata&0x3FFFFF;
\r
1941 drawY = (gdata>>12)&0x3ff;
\r
1945 ulGPUInfoVals[INFO_DRAWSTART]=gdata&0xFFFFF;
\r
1946 drawY = (gdata>>10)&0x3ff;
\r
1949 if(drawY>=iGPUHeight) drawY=iGPUHeightMask;
\r
1951 PreviousPSXDisplay.DrawArea.y0=PSXDisplay.DrawArea.y0;
\r
1952 PreviousPSXDisplay.DrawArea.x0=PSXDisplay.DrawArea.x0;
\r
1954 PSXDisplay.DrawArea.y0 = (short)drawY; // for OGL drawing
\r
1955 PSXDisplay.DrawArea.x0 = (short)drawX;
\r
1958 ////////////////////////////////////////////////////////////////////////
\r
1959 // cmd: end of drawing area... primitives will be clipped inside
\r
1960 ////////////////////////////////////////////////////////////////////////
\r
1962 void cmdDrawAreaEnd(unsigned char * baseAddr)
\r
1964 unsigned long gdata = ((unsigned long*)baseAddr)[0];
\r
1966 drawW = gdata & 0x3ff; // for soft drawing
\r
1967 if(drawW>=1024) drawW=1023;
\r
1969 if(dwGPUVersion==2)
\r
1971 ulGPUInfoVals[INFO_DRAWEND]=gdata&0x3FFFFF;
\r
1972 drawH = (gdata>>12)&0x3ff;
\r
1976 ulGPUInfoVals[INFO_DRAWEND]=gdata&0xFFFFF;
\r
1977 drawH = (gdata>>10)&0x3ff;
\r
1980 if(drawH>=iGPUHeight) drawH=iGPUHeightMask;
\r
1982 PSXDisplay.DrawArea.y1 = (short)drawH; // for OGL drawing
\r
1983 PSXDisplay.DrawArea.x1 = (short)drawW;
\r
1985 ClampToPSXScreen(&PSXDisplay.DrawArea.x0, // clamp
\r
1986 &PSXDisplay.DrawArea.y0,
\r
1987 &PSXDisplay.DrawArea.x1,
\r
1988 &PSXDisplay.DrawArea.y1);
\r
1990 bDisplayNotSet = TRUE;
\r
1993 ////////////////////////////////////////////////////////////////////////
\r
1994 // cmd: draw offset... will be added to prim coords
\r
1995 ////////////////////////////////////////////////////////////////////////
\r
1997 void cmdDrawOffset(unsigned char * baseAddr)
\r
1999 unsigned long gdata = ((unsigned long*)baseAddr)[0];
\r
2001 PreviousPSXDisplay.DrawOffset.x =
\r
2002 PSXDisplay.DrawOffset.x = (short)(gdata & 0x7ff);
\r
2004 if(dwGPUVersion==2)
\r
2006 ulGPUInfoVals[INFO_DRAWOFF]=gdata&0x7FFFFF;
\r
2007 PSXDisplay.DrawOffset.y = (short)((gdata>>12) & 0x7ff);
\r
2011 ulGPUInfoVals[INFO_DRAWOFF]=gdata&0x3FFFFF;
\r
2012 PSXDisplay.DrawOffset.y = (short)((gdata>>11) & 0x7ff);
\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
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
2024 ////////////////////////////////////////////////////////////////////////
\r
2025 // cmd: load image to vram
\r
2026 ////////////////////////////////////////////////////////////////////////
\r
2028 void primLoadImage(unsigned char * baseAddr)
\r
2030 unsigned short *sgpuData = ((unsigned short *) baseAddr);
\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
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
2042 bNeedWriteUpload=TRUE;
\r
2045 ////////////////////////////////////////////////////////////////////////
\r
2047 void PrepareRGB24Upload(void)
\r
2049 VRAMWrite.x=(VRAMWrite.x*2)/3;
\r
2050 VRAMWrite.Width=(VRAMWrite.Width*2)/3;
\r
2052 if(!PSXDisplay.InterlacedTest && // NEW
\r
2053 CheckAgainstScreen(VRAMWrite.x, VRAMWrite.y, VRAMWrite.Width, VRAMWrite.Height))
\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
2061 if(CheckAgainstFrontScreen(VRAMWrite.x, VRAMWrite.y, VRAMWrite.Width, VRAMWrite.Height))
\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
2070 if(bRenderFrontBuffer)
\r
2072 updateFrontDisplay();
\r
2075 if(bNeedRGB24Update==FALSE)
\r
2077 xrUploadAreaRGB24=xrUploadArea;
\r
2078 bNeedRGB24Update=TRUE;
\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
2089 ////////////////////////////////////////////////////////////////////////
\r
2091 void CheckWriteUpdate()
\r
2095 if(VRAMWrite.Width) iX=1;
\r
2096 if(VRAMWrite.Height) iY=1;
\r
2098 InvalidateTextureArea(VRAMWrite.x, VRAMWrite.y, VRAMWrite.Width-iX, VRAMWrite.Height-iY);
\r
2100 if(PSXDisplay.Interlaced && !iOffscreenDrawing) return;
\r
2102 if(PSXDisplay.RGB24) {PrepareRGB24Upload();return;}
\r
2104 if(!PSXDisplay.InterlacedTest &&
\r
2105 CheckAgainstScreen(VRAMWrite.x, VRAMWrite.y, VRAMWrite.Width, VRAMWrite.Height))
\r
2107 if(dwActFixes&0x800) return;
\r
2109 if(bRenderFrontBuffer)
\r
2111 updateFrontDisplay();
\r
2114 UploadScreen(FALSE);
\r
2116 bNeedUploadTest=TRUE;
\r
2119 if(iOffscreenDrawing)
\r
2121 if (CheckAgainstFrontScreen(VRAMWrite.x, VRAMWrite.y, VRAMWrite.Width, VRAMWrite.Height))
\r
2123 if(PSXDisplay.InterlacedTest)
\r
2125 if(PreviousPSXDisplay.InterlacedNew)
\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
2137 if(bNeedInterlaceUpdate==FALSE)
\r
2139 xrUploadAreaIL=xrUploadArea;
\r
2140 bNeedInterlaceUpdate=TRUE;
\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
2152 if(!bNeedUploadAfter)
\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
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
2168 if(dwActFixes&0x8000)
\r
2170 if((xrUploadArea.x1-xrUploadArea.x0)>=(PSXDisplay.DisplayMode.x-32) &&
\r
2171 (xrUploadArea.y1-xrUploadArea.y0)>=(PSXDisplay.DisplayMode.y-32))
\r
2174 updateFrontDisplay();
\r
2181 ////////////////////////////////////////////////////////////////////////
\r
2182 // cmd: vram -> psx mem
\r
2183 ////////////////////////////////////////////////////////////////////////
\r
2185 void primStoreImage(unsigned char * baseAddr)
\r
2187 unsigned short *sgpuData = ((unsigned short *) baseAddr);
\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
2194 VRAMRead.ImagePtr = psxVuw + (VRAMRead.y<<10) + VRAMRead.x;
\r
2195 VRAMRead.RowsRemaining = VRAMRead.Width;
\r
2196 VRAMRead.ColsRemaining = VRAMRead.Height;
\r
2198 iDataReadMode = DR_VRAMTRANSFER;
\r
2200 STATUSREG |= GPUSTATUS_READYFORVRAM;
\r
2203 ////////////////////////////////////////////////////////////////////////
\r
2204 // cmd: blkfill - NO primitive! Doesn't care about draw areas...
\r
2205 ////////////////////////////////////////////////////////////////////////
\r
2207 void primBlkFill(unsigned char * baseAddr)
\r
2209 unsigned long *gpuData = ((unsigned long *) baseAddr);
\r
2210 short *sgpuData = ((short *) baseAddr);
\r
2212 iDrawnSomething=1;
\r
2214 sprtX = sgpuData[2];
\r
2215 sprtY = sgpuData[3];
\r
2216 sprtW = sgpuData[4] & 0x3ff;
\r
2217 sprtH = sgpuData[5] & iGPUHeightMask;
\r
2219 sprtW = (sprtW+15) & ~15;
\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
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
2233 if(ClipVertexListScreen())
\r
2235 PSXDisplay_t * pd;
\r
2236 if(PSXDisplay.InterlacedTest) pd=&PSXDisplay;
\r
2237 else pd=&PreviousPSXDisplay;
\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
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
2249 glDisable(GL_SCISSOR_TEST); glError();
\r
2250 glClearColor(r,g,b,1.0f); glError();
\r
2251 glClear(uiBufferBits); glError();
\r
2254 if(gpuData[0]!=0x02000000 &&
\r
2255 (ly0>pd->DisplayPosition.y ||
\r
2256 ly2<pd->DisplayEnd.y))
\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
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
2272 if(ly2<pd->DisplayEnd.y)
\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
2282 glEnable(GL_SCISSOR_TEST); glError();
\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
2292 glDisable(GL_SCISSOR_TEST); glError();
\r
2293 PRIMdrawQuad(&vertex[0], &vertex[1], &vertex[2], &vertex[3]);
\r
2294 glEnable(GL_SCISSOR_TEST); glError();
\r
2298 //mmm... will clean all stuff, also if not all _should_ be cleaned...
\r
2299 //if (IsInsideNextScreen(sprtX, sprtY, sprtW, sprtH))
\r
2301 if (IsCompleteInsideNextScreen(sprtX, sprtY, sprtW, sprtH))
\r
2303 lClearOnSwapColor = COLOR(gpuData[0]);
\r
2307 /* if(iOffscreenDrawing)
\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
2316 FillSoftwareArea(sprtX, sprtY, sprtW, sprtH, BGR24to16(gpuData[0]));
\r
2320 ////////////////////////////////////////////////////////////////////////
\r
2321 // cmd: move image vram -> vram
\r
2322 ////////////////////////////////////////////////////////////////////////
\r
2324 void MoveImageWrapped(short imageX0,short imageY0,
\r
2325 short imageX1,short imageY1,
\r
2326 short imageSX,short imageSY)
\r
2328 int i,j,imageXE,imageYE;
\r
2330 if(iFrameReadType&2)
\r
2332 imageXE=imageX0+imageSX;
\r
2333 imageYE=imageY0+imageSY;
\r
2335 if(imageYE>iGPUHeight && imageXE>1024)
\r
2337 CheckVRamRead(0,0,
\r
2339 (imageY0&iGPUHeightMask),
\r
2345 CheckVRamRead(0,imageY0,
\r
2347 (imageYE>iGPUHeight)?iGPUHeight:imageYE,
\r
2351 if(imageYE>iGPUHeight)
\r
2353 CheckVRamRead(imageX0,0,
\r
2354 (imageXE>1024)?1024:imageXE,
\r
2355 imageYE&iGPUHeightMask,
\r
2359 CheckVRamRead(imageX0,imageY0,
\r
2360 (imageXE>1024)?1024:imageXE,
\r
2361 (imageYE>iGPUHeight)?iGPUHeight:imageYE,
\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
2370 if(!PSXDisplay.RGB24)
\r
2372 imageXE=imageX1+imageSX;
\r
2373 imageYE=imageY1+imageSY;
\r
2375 if(imageYE>iGPUHeight && imageXE>1024)
\r
2377 InvalidateTextureArea(0,0,
\r
2378 (imageXE&0x3ff)-1,
\r
2379 (imageYE&iGPUHeightMask)-1);
\r
2384 InvalidateTextureArea(0,imageY1,
\r
2385 (imageXE&0x3ff)-1,
\r
2386 ((imageYE>iGPUHeight)?iGPUHeight:imageYE)-imageY1-1);
\r
2389 if(imageYE>iGPUHeight)
\r
2391 InvalidateTextureArea(imageX1,0,
\r
2392 ((imageXE>1024)?1024:imageXE)-imageX1-1,
\r
2393 (imageYE&iGPUHeightMask)-1);
\r
2396 InvalidateTextureArea(imageX1,imageY1,
\r
2397 ((imageXE>1024)?1024:imageXE)-imageX1-1,
\r
2398 ((imageYE>iGPUHeight)?iGPUHeight:imageYE)-imageY1-1);
\r
2402 ////////////////////////////////////////////////////////////////////////
\r
2404 void primMoveImage(unsigned char * baseAddr)
\r
2406 short *sgpuData = ((short *) baseAddr);
\r
2407 short imageY0,imageX0,imageY1,imageX1,imageSX,imageSY,i,j;
\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
2416 if((imageX0 == imageX1) && (imageY0 == imageY1)) return;
\r
2417 if(imageSX<=0) return;
\r
2418 if(imageSY<=0) return;
\r
2420 if(iGPUHeight==1024 && sgpuData[7]>1024) return;
\r
2422 if((imageY0+imageSY)>iGPUHeight ||
\r
2423 (imageX0+imageSX)>1024 ||
\r
2424 (imageY1+imageSY)>iGPUHeight ||
\r
2425 (imageX1+imageSX)>1024)
\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
2434 if(iFrameReadType&2)
\r
2435 CheckVRamRead(imageX0,imageY0,
\r
2442 unsigned short *SRCPtr, *DSTPtr;
\r
2443 unsigned short LineOffset;
\r
2445 SRCPtr = psxVuw + (1024*imageY0) + imageX0;
\r
2446 DSTPtr = psxVuw + (1024*imageY1) + imageX1;
\r
2448 LineOffset = 1024 - imageSX;
\r
2450 for(j=0;j<imageSY;j++)
\r
2452 for(i=0;i<imageSX;i++) *DSTPtr++ = *SRCPtr++;
\r
2453 SRCPtr += LineOffset;
\r
2454 DSTPtr += LineOffset;
\r
2459 unsigned long *SRCPtr, *DSTPtr;
\r
2460 unsigned short LineOffset;
\r
2461 int dx=imageSX>>1;
\r
2463 SRCPtr = (unsigned long *)(psxVuw + (1024*imageY0) + imageX0);
\r
2464 DSTPtr = (unsigned long *)(psxVuw + (1024*imageY1) + imageX1);
\r
2466 LineOffset = 512 - dx;
\r
2468 for(j=0;j<imageSY;j++)
\r
2470 for(i=0;i<dx;i++) *DSTPtr++ = *SRCPtr++;
\r
2471 SRCPtr += LineOffset;
\r
2472 DSTPtr += LineOffset;
\r
2476 if (!PSXDisplay.RGB24)
\r
2478 InvalidateTextureArea(imageX1,imageY1,imageSX-1,imageSY-1);
\r
2480 if (CheckAgainstScreen(imageX1,imageY1,imageSX,imageSY))
\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
2487 imageX1 += imageSX;
\r
2488 imageY1 += imageSY;
\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
2496 imageX0>=PSXDisplay.DisplayPosition.x &&
\r
2497 imageX0<PSXDisplay.DisplayEnd.x &&
\r
2498 imageY0>=PSXDisplay.DisplayPosition.y &&
\r
2499 imageY0<PSXDisplay.DisplayEnd.y
\r
2502 if(bRenderFrontBuffer)
\r
2504 updateFrontDisplay();
\r
2507 UploadScreen(FALSE);
\r
2509 else bFakeFrontBuffer=TRUE;
\r
2513 bNeedUploadTest=TRUE;
\r
2516 if(iOffscreenDrawing)
\r
2518 if (CheckAgainstFrontScreen(imageX1,imageY1,imageSX,imageSY))
\r
2520 if(!PSXDisplay.InterlacedTest &&
\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
2529 imageX0>=PSXDisplay.DisplayPosition.x &&
\r
2530 imageX0<PSXDisplay.DisplayEnd.x &&
\r
2531 imageY0>=PSXDisplay.DisplayPosition.y &&
\r
2532 imageY0<PSXDisplay.DisplayEnd.y
\r
2536 bNeedUploadTest=TRUE;
\r
2538 if(!bNeedUploadAfter)
\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
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
2559 ////////////////////////////////////////////////////////////////////////
\r
2560 // cmd: draw free-size Tile
\r
2561 ////////////////////////////////////////////////////////////////////////
\r
2563 void primTileS(unsigned char * baseAddr)
\r
2565 unsigned long *gpuData = ((unsigned long*)baseAddr);
\r
2566 short *sgpuData = ((short *) baseAddr);
\r
2568 sprtX = sgpuData[2];
\r
2569 sprtY = sgpuData[3];
\r
2570 sprtW = sgpuData[4] & 0x3ff;
\r
2571 sprtH = sgpuData[5] & iGPUHeightMask;
\r
2573 // x and y of start
\r
2580 if((dwActFixes&1) && // FF7 special game gix (battle cursor)
\r
2581 sprtX==0 && sprtY==0 && sprtW==24 && sprtH==16)
\r
2584 bDrawTextured = FALSE;
\r
2585 bDrawSmoothShaded = FALSE;
\r
2587 SetRenderState(gpuData[0]);
\r
2589 /* if(iOffscreenDrawing)
\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
2594 lClearOnSwapColor = COLOR(gpuData[0]);
\r
2599 if(bDrawOffscreen4())
\r
2601 if(!(iTileCheat && sprtH==32 && gpuData[0]==0x60ffffff)) // special cheat for certain ZiNc games
\r
2603 InvalidateTextureAreaEx();
\r
2604 FillSoftwareAreaTrans(lx0,ly0,lx2,ly2,
\r
2605 BGR24to16(gpuData[0]));
\r
2610 SetRenderMode(gpuData[0], FALSE);
\r
2613 if(bIgnoreNextTile) {bIgnoreNextTile=FALSE;return;}
\r
2615 vertex[0].c.lcol=gpuData[0];
\r
2616 vertex[0].c.col[3]=ubGloColAlpha;
\r
2617 SETCOL(vertex[0]);
\r
2619 PRIMdrawQuad(&vertex[0], &vertex[1], &vertex[2], &vertex[3]);
\r
2621 iDrawnSomething=1;
\r
2624 ////////////////////////////////////////////////////////////////////////
\r
2625 // cmd: draw 1 dot Tile (point)
\r
2626 ////////////////////////////////////////////////////////////////////////
\r
2628 void primTile1(unsigned char * baseAddr)
\r
2630 unsigned long *gpuData = ((unsigned long*)baseAddr);
\r
2631 short *sgpuData = ((short *) baseAddr);
\r
2633 sprtX = sgpuData[2];
\r
2634 sprtY = sgpuData[3];
\r
2643 bDrawTextured = FALSE;
\r
2644 bDrawSmoothShaded = FALSE;
\r
2646 SetRenderState(gpuData[0]);
\r
2648 /* if(iOffscreenDrawing)
\r
2652 if(bDrawOffscreen4())
\r
2654 InvalidateTextureAreaEx();
\r
2655 FillSoftwareAreaTrans(lx0,ly0,lx2,ly2,
\r
2656 BGR24to16(gpuData[0]));
\r
2660 SetRenderMode(gpuData[0], FALSE);
\r
2663 vertex[0].c.lcol=gpuData[0];vertex[0].c.col[3]=ubGloColAlpha;
\r
2664 SETCOL(vertex[0]);
\r
2666 PRIMdrawQuad(&vertex[0], &vertex[1], &vertex[2], &vertex[3]);
\r
2668 iDrawnSomething=1;
\r
2671 ////////////////////////////////////////////////////////////////////////
\r
2672 // cmd: draw 8 dot Tile (small rect)
\r
2673 ////////////////////////////////////////////////////////////////////////
\r
2675 void primTile8(unsigned char * baseAddr)
\r
2677 unsigned long *gpuData = ((unsigned long*)baseAddr);
\r
2678 short *sgpuData = ((short *) baseAddr);
\r
2680 sprtX = sgpuData[2];
\r
2681 sprtY = sgpuData[3];
\r
2690 bDrawTextured = FALSE;
\r
2691 bDrawSmoothShaded = FALSE;
\r
2692 SetRenderState(gpuData[0]);
\r
2694 /* if(iOffscreenDrawing)
\r
2698 if(bDrawOffscreen4())
\r
2700 InvalidateTextureAreaEx();
\r
2701 FillSoftwareAreaTrans(lx0,ly0,lx2,ly2,
\r
2702 BGR24to16(gpuData[0]));
\r
2706 SetRenderMode(gpuData[0], FALSE);
\r
2709 vertex[0].c.lcol=gpuData[0];
\r
2710 vertex[0].c.col[3]=ubGloColAlpha;
\r
2711 SETCOL(vertex[0]);
\r
2713 PRIMdrawQuad(&vertex[0], &vertex[1], &vertex[2], &vertex[3]);
\r
2715 iDrawnSomething=1;
\r
2718 ////////////////////////////////////////////////////////////////////////
\r
2719 // cmd: draw 16 dot Tile (medium rect)
\r
2720 ////////////////////////////////////////////////////////////////////////
\r
2722 void primTile16(unsigned char * baseAddr)
\r
2724 unsigned long *gpuData = ((unsigned long*)baseAddr);
\r
2725 short *sgpuData = ((short *) baseAddr);
\r
2727 sprtX = sgpuData[2];
\r
2728 sprtY = sgpuData[3];
\r
2731 // x and y of start
\r
2737 bDrawTextured = FALSE;
\r
2738 bDrawSmoothShaded = FALSE;
\r
2739 SetRenderState(gpuData[0]);
\r
2741 /* if(iOffscreenDrawing)
\r
2745 if(bDrawOffscreen4())
\r
2747 InvalidateTextureAreaEx();
\r
2748 FillSoftwareAreaTrans(lx0,ly0,lx2,ly2,
\r
2749 BGR24to16(gpuData[0]));
\r
2753 SetRenderMode(gpuData[0], FALSE);
\r
2756 vertex[0].c.lcol=gpuData[0];
\r
2757 vertex[0].c.col[3]=ubGloColAlpha;
\r
2758 SETCOL(vertex[0]);
\r
2760 PRIMdrawQuad(&vertex[0], &vertex[1], &vertex[2], &vertex[3]);
\r
2762 iDrawnSomething=1;
\r
2765 ////////////////////////////////////////////////////////////////////////
\r
2766 // helper: filter effect by multipass rendering
\r
2767 ////////////////////////////////////////////////////////////////////////
\r
2769 /*void DrawMultiBlur(void)
\r
2771 long lABR,lDST;float fx,fy;
\r
2773 lABR=GlobalTextABR;
\r
2774 lDST=DrawSemiTrans;
\r
2776 fx=(float)PSXDisplay.DisplayMode.x/(float)(iResX);
\r
2777 fy=(float)PSXDisplay.DisplayMode.y/(float)(iResY);
\r
2779 vertex[0].x+=fx;vertex[1].x+=fx;
\r
2780 vertex[2].x+=fx;vertex[3].x+=fx;
\r
2786 PRIMdrawTexturedQuad(&vertex[0], &vertex[1], &vertex[2], &vertex[3]);
\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
2792 if(bDrawMultiPass) {obm1=obm2=GL_SRC_ALPHA;}
\r
2794 GlobalTextABR=lABR;
\r
2795 DrawSemiTrans=lDST;
\r
2798 ////////////////////////////////////////////////////////////////////////
\r
2800 #define POFF 0.375f
\r
2802 void DrawMultiFilterSprite(void)
\r
2806 if(bUseMultiPass || DrawSemiTrans || ubOpaqueDraw)
\r
2808 PRIMdrawTexturedQuad(&vertex[0], &vertex[1], &vertex[2], &vertex[3]);
\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
2824 PRIMdrawTexturedQuad(&vertex[0], &vertex[1], &vertex[2], &vertex[3]);
\r
2825 GlobalTextABR=lABR;
\r
2826 DrawSemiTrans=lDST;
\r
2829 ////////////////////////////////////////////////////////////////////////
\r
2830 // cmd: small sprite (textured rect)
\r
2831 ////////////////////////////////////////////////////////////////////////
\r
2833 void primSprt8(unsigned char * baseAddr)
\r
2835 unsigned long *gpuData = ((unsigned long *) baseAddr);
\r
2836 short *sgpuData = ((short *) baseAddr);
\r
2841 sprtX = sgpuData[2];
\r
2842 sprtY = sgpuData[3];
\r
2851 // do texture stuff
\r
2852 gl_ux[0]=gl_ux[3]=baseAddr[8];//gpuData[2]&0xff;
\r
2854 if(usMirror & 0x1000)
\r
2859 gl_ux[0]=gl_ux[3]=s;
\r
2862 sSprite_ux2=s=gl_ux[0]+sprtW;
\r
2865 gl_ux[1]=gl_ux[2]=s;
\r
2867 gl_vy[0]=gl_vy[1]=baseAddr[9];//(gpuData[2]>>8)&0xff;
\r
2869 if(usMirror & 0x2000)
\r
2874 gl_vy[0]=gl_vy[1]=s;
\r
2877 sSprite_vy2=s=gl_vy[0]+sprtH;
\r
2880 gl_vy[2]=gl_vy[3]=s;
\r
2882 ulClutID=(gpuData[2]>>16);
\r
2884 bDrawTextured = TRUE;
\r
2885 bDrawSmoothShaded = FALSE;
\r
2886 SetRenderState(gpuData[0]);
\r
2888 /* if(iOffscreenDrawing)
\r
2892 if(bDrawOffscreen4())
\r
2894 InvalidateTextureAreaEx();
\r
2895 SetRenderColor(gpuData[0]);
\r
2896 lx0-=PSXDisplay.DrawOffset.x;
\r
2897 ly0-=PSXDisplay.DrawOffset.y;
\r
2899 if(bUsingTWin) DrawSoftwareSpriteTWin(baseAddr,8,8);
\r
2901 if(usMirror) DrawSoftwareSpriteMirror(baseAddr,8,8);
\r
2903 DrawSoftwareSprite(baseAddr,8,8,baseAddr[8],baseAddr[9]);
\r
2907 SetRenderMode(gpuData[0], TRUE);
\r
2910 sSprite_ux2=gl_ux[0]+sprtW;
\r
2911 sSprite_vy2=gl_vy[0]+sprtH;
\r
2913 assignTextureSprite();
\r
2915 if(iFilterType>4)
\r
2916 DrawMultiFilterSprite();
\r
2918 PRIMdrawTexturedQuad(&vertex[0], &vertex[1], &vertex[2], &vertex[3]);
\r
2920 if(bDrawMultiPass)
\r
2922 SetSemiTransMulti(1);
\r
2923 PRIMdrawTexturedQuad(&vertex[0], &vertex[1], &vertex[2], &vertex[3]);
\r
2929 if(bUseMultiPass) SetOpaqueColor(gpuData[0]);
\r
2932 /* if(bSmallAlpha && iFilterType<=2)
\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
2942 PRIMdrawTexturedQuad(&vertex[0], &vertex[1], &vertex[2], &vertex[3]);
\r
2947 iDrawnSomething=1;
\r
2950 ////////////////////////////////////////////////////////////////////////
\r
2951 // cmd: medium sprite (textured rect)
\r
2952 ////////////////////////////////////////////////////////////////////////
\r
2954 void primSprt16(unsigned char * baseAddr)
\r
2956 unsigned long *gpuData = ((unsigned long *) baseAddr);
\r
2957 short *sgpuData = ((short *) baseAddr);
\r
2962 sprtX = sgpuData[2];
\r
2963 sprtY = sgpuData[3];
\r
2972 // do texture stuff
\r
2973 gl_ux[0]=gl_ux[3]=baseAddr[8];//gpuData[2]&0xff;
\r
2975 if(usMirror & 0x1000)
\r
2980 gl_ux[0]=gl_ux[3]=s;
\r
2983 sSprite_ux2=s=gl_ux[0]+sprtW;
\r
2986 gl_ux[1]=gl_ux[2]=s;
\r
2988 gl_vy[0]=gl_vy[1]=baseAddr[9];//(gpuData[2]>>8)&0xff;
\r
2990 if(usMirror & 0x2000)
\r
2995 gl_vy[0]=gl_vy[1]=s;
\r
2998 sSprite_vy2=s=gl_vy[0]+sprtH;
\r
3001 gl_vy[2]=gl_vy[3]=s;
\r
3003 ulClutID=(gpuData[2]>>16);
\r
3005 bDrawTextured = TRUE;
\r
3006 bDrawSmoothShaded = FALSE;
\r
3007 SetRenderState(gpuData[0]);
\r
3009 /* if(iOffscreenDrawing)
\r
3013 if(bDrawOffscreen4())
\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
3021 if(usMirror) DrawSoftwareSpriteMirror(baseAddr,16,16);
\r
3023 DrawSoftwareSprite(baseAddr,16,16,baseAddr[8],baseAddr[9]);
\r
3027 SetRenderMode(gpuData[0], TRUE);
\r
3030 sSprite_ux2=gl_ux[0]+sprtW;
\r
3031 sSprite_vy2=gl_vy[0]+sprtH;
\r
3033 assignTextureSprite();
\r
3035 if(iFilterType>4)
\r
3036 DrawMultiFilterSprite();
\r
3038 PRIMdrawTexturedQuad(&vertex[0], &vertex[1], &vertex[2], &vertex[3]);
\r
3040 if(bDrawMultiPass)
\r
3042 SetSemiTransMulti(1);
\r
3043 PRIMdrawTexturedQuad(&vertex[0], &vertex[1], &vertex[2], &vertex[3]);
\r
3049 if(bUseMultiPass) SetOpaqueColor(gpuData[0]);
\r
3052 /* if(bSmallAlpha && iFilterType<=2)
\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
3062 PRIMdrawTexturedQuad(&vertex[0], &vertex[1], &vertex[2], &vertex[3]);
\r
3067 iDrawnSomething=1;
\r
3070 ////////////////////////////////////////////////////////////////////////
\r
3071 // cmd: free-size sprite (textured rect)
\r
3072 ////////////////////////////////////////////////////////////////////////
\r
3074 void primSprtSRest(unsigned char * baseAddr,unsigned short type)
\r
3076 unsigned long *gpuData = ((unsigned long *) baseAddr);
\r
3077 short *sgpuData = ((short *) baseAddr);
\r
3078 short s;unsigned short sTypeRest=0;
\r
3080 sprtX = sgpuData[2];
\r
3081 sprtY = sgpuData[3];
\r
3082 sprtW = sgpuData[6] & 0x3ff;
\r
3083 sprtH = sgpuData[7] & 0x1ff;
\r
3086 // do texture stuff
\r
3090 gl_vy[0]=gl_vy[1]=baseAddr[9];
\r
3091 s=256-baseAddr[8];
\r
3094 gl_ux[0]=gl_ux[3]=0;
\r
3097 gl_ux[0]=gl_ux[3]=baseAddr[8];
\r
3098 s=256-baseAddr[9];
\r
3101 gl_vy[0]=gl_vy[1]=0;
\r
3104 s=256-baseAddr[8];
\r
3107 gl_ux[0]=gl_ux[3]=0;
\r
3108 s=256-baseAddr[9];
\r
3111 gl_vy[0]=gl_vy[1]=0;
\r
3115 gl_vy[0]=gl_vy[1]=baseAddr[9];
\r
3116 s=512-baseAddr[8];
\r
3119 gl_ux[0]=gl_ux[3]=0;
\r
3122 gl_ux[0]=gl_ux[3]=baseAddr[8];
\r
3123 s=512-baseAddr[9];
\r
3126 gl_vy[0]=gl_vy[1]=0;
\r
3129 s=512-baseAddr[8];
\r
3132 gl_ux[0]=gl_ux[3]=0;
\r
3133 s=512-baseAddr[9];
\r
3136 gl_vy[0]=gl_vy[1]=0;
\r
3141 if(usMirror & 0x1000)
\r
3144 s-=sprtW-1;if(s<0) s=0;
\r
3145 gl_ux[0]=gl_ux[3]=s;
\r
3147 if(usMirror & 0x2000)
\r
3150 s-=sprtH-1;if(s<0) {s=0;}
\r
3151 gl_vy[0]=gl_vy[1]=s;
\r
3154 sSprite_ux2=s=gl_ux[0]+sprtW;
\r
3156 gl_ux[1]=gl_ux[2]=s;
\r
3157 sSprite_vy2=s=gl_vy[0]+sprtH;
\r
3159 gl_vy[2]=gl_vy[3]=s;
\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
3174 ulClutID=(gpuData[2]>>16);
\r
3176 bDrawTextured = TRUE;
\r
3177 bDrawSmoothShaded = FALSE;
\r
3178 SetRenderState(gpuData[0]);
\r
3180 /* if(iOffscreenDrawing)
\r
3184 if(bDrawOffscreen4())
\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
3192 if(usMirror) DrawSoftwareSpriteMirror(baseAddr,sprtW,sprtH);
\r
3194 DrawSoftwareSprite(baseAddr,sprtW,sprtH,baseAddr[8],baseAddr[9]);
\r
3198 SetRenderMode(gpuData[0], TRUE);
\r
3201 sSprite_ux2=gl_ux[0]+sprtW;
\r
3202 sSprite_vy2=gl_vy[0]+sprtH;
\r
3204 assignTextureSprite();
\r
3206 if(iFilterType>4)
\r
3207 DrawMultiFilterSprite();
\r
3209 PRIMdrawTexturedQuad(&vertex[0], &vertex[1], &vertex[2], &vertex[3]);
\r
3211 if(bDrawMultiPass)
\r
3213 SetSemiTransMulti(1);
\r
3214 PRIMdrawTexturedQuad(&vertex[0], &vertex[1], &vertex[2], &vertex[3]);
\r
3220 if(bUseMultiPass) SetOpaqueColor(gpuData[0]);
\r
3223 /* if(bSmallAlpha && iFilterType<=2)
\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
3233 PRIMdrawTexturedQuad(&vertex[0], &vertex[1], &vertex[2], &vertex[3]);
\r
3237 if(sTypeRest && type<4)
\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
3245 void primSprtS(unsigned char * baseAddr)
\r
3247 unsigned long *gpuData = ((unsigned long *) baseAddr);
\r
3248 short *sgpuData = ((short *) baseAddr);
\r
3250 short s;unsigned short sTypeRest=0;
\r
3252 sprtX = sgpuData[2];
\r
3253 sprtY = sgpuData[3];
\r
3254 sprtW = sgpuData[6] & 0x3ff;
\r
3255 sprtH = sgpuData[7] & 0x1ff;
\r
3257 if(!sprtH) return;
\r
3258 if(!sprtW) return;
\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
3266 if(usMirror & 0x1000)
\r
3271 gl_ux[0]=gl_ux[3]=s;
\r
3273 if(usMirror & 0x2000)
\r
3278 gl_vy[0]=gl_vy[1]=s;
\r
3281 sSprite_ux2=s=gl_ux[0]+sprtW;
\r
3284 gl_ux[1]=gl_ux[2]=s;
\r
3285 sSprite_vy2=s=gl_vy[0]+sprtH;
\r
3288 gl_vy[2]=gl_vy[3]=s;
\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
3303 ulClutID=(gpuData[2]>>16);
\r
3305 bDrawTextured = TRUE;
\r
3306 bDrawSmoothShaded = FALSE;
\r
3307 SetRenderState(gpuData[0]);
\r
3309 /* if(iOffscreenDrawing)
\r
3313 if(bDrawOffscreen4())
\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
3321 if(usMirror) DrawSoftwareSpriteMirror(baseAddr,sprtW,sprtH);
\r
3323 DrawSoftwareSprite(baseAddr,sprtW,sprtH,baseAddr[8],baseAddr[9]);
\r
3327 SetRenderMode(gpuData[0], TRUE);
\r
3330 if((dwActFixes&1) && gTexFrameName && gTexName==gTexFrameName)
\r
3331 {iSpriteTex=0;return;}
\r
3333 sSprite_ux2=gl_ux[0]+sprtW;
\r
3334 sSprite_vy2=gl_vy[0]+sprtH;
\r
3336 assignTextureSprite();
\r
3338 if(iFilterType>4)
\r
3339 DrawMultiFilterSprite();
\r
3341 PRIMdrawTexturedQuad(&vertex[0], &vertex[1], &vertex[2], &vertex[3]);
\r
3343 if(bDrawMultiPass)
\r
3345 SetSemiTransMulti(1);
\r
3346 PRIMdrawTexturedQuad(&vertex[0], &vertex[1], &vertex[2], &vertex[3]);
\r
3352 if(bUseMultiPass) SetOpaqueColor(gpuData[0]);
\r
3355 /* if(bSmallAlpha && iFilterType<=2)
\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
3365 PRIMdrawTexturedQuad(&vertex[0], &vertex[1], &vertex[2], &vertex[3]);
\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
3377 iDrawnSomething=1;
\r
3380 ////////////////////////////////////////////////////////////////////////
\r
3381 // cmd: flat shaded Poly4
\r
3382 ////////////////////////////////////////////////////////////////////////
\r
3384 void primPolyF4(unsigned char *baseAddr)
\r
3386 unsigned long *gpuData = ((unsigned long *) baseAddr);
\r
3387 short *sgpuData = ((short *) baseAddr);
\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
3398 if(offset4()) return;
\r
3400 bDrawTextured = FALSE;
\r
3401 bDrawSmoothShaded = FALSE;
\r
3402 SetRenderState(gpuData[0]);
\r
3404 /* if(iOffscreenDrawing)
\r
3407 if(bDrawOffscreen4())
\r
3409 InvalidateTextureAreaEx();
\r
3410 drawPoly4F(gpuData[0]);
\r
3414 SetRenderMode(gpuData[0], FALSE);
\r
3417 vertex[0].c.lcol=gpuData[0];vertex[0].c.col[3]=ubGloColAlpha;
\r
3418 SETCOL(vertex[0]);
\r
3420 PRIMdrawTri2(&vertex[0], &vertex[1], &vertex[2],&vertex[3]);
\r
3422 iDrawnSomething=1;
\r
3425 ////////////////////////////////////////////////////////////////////////
\r
3426 // cmd: smooth shaded Poly4
\r
3427 ////////////////////////////////////////////////////////////////////////
\r
3429 void primPolyG4(unsigned char * baseAddr);
\r
3431 BOOL bDrawOffscreenFrontFF9G4(void)
\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
3452 BOOL bCheckFF9G4(unsigned char * baseAddr)
\r
3454 static unsigned char pFF9G4Cache[32];
\r
3455 static int iFF9Fix=0;
\r
3461 if(bDrawOffscreenFrontFF9G4())
\r
3463 short *sgpuData = ((short *) pFF9G4Cache);
\r
3465 memcpy(pFF9G4Cache,baseAddr,32);
\r
3467 if(sgpuData[2]==142)
\r
3481 long labr=GlobalTextABR;
\r
3483 primPolyG4(pFF9G4Cache);
\r
3484 GlobalTextABR=labr;
\r
3491 ////////////////////////////////////////////////////////////////////////
\r
3493 void primPolyG4(unsigned char * baseAddr)
\r
3495 unsigned long *gpuData = (unsigned long *)baseAddr;
\r
3496 short *sgpuData = ((short *) baseAddr);
\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
3507 if(offset4()) return;
\r
3509 bDrawTextured = FALSE;
\r
3510 bDrawSmoothShaded = TRUE;
\r
3511 SetRenderState(gpuData[0]);
\r
3513 /* if(iOffscreenDrawing)
\r
3517 if((dwActFixes&512) && bCheckFF9G4(baseAddr)) return;
\r
3519 if(bDrawOffscreen4())
\r
3521 InvalidateTextureAreaEx();
\r
3522 drawPoly4G(gpuData[0], gpuData[2], gpuData[4], gpuData[6]);
\r
3526 SetRenderMode(gpuData[0], FALSE);
\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
3534 vertex[0].c.col[3]=vertex[1].c.col[3]=vertex[2].c.col[3]=vertex[3].c.col[3]=ubGloAlpha;
\r
3537 PRIMdrawGouraudTri2Color(&vertex[0],&vertex[1], &vertex[2], &vertex[3]);
\r
3539 iDrawnSomething=1;
\r
3542 ////////////////////////////////////////////////////////////////////////
\r
3543 // cmd: flat shaded Texture3
\r
3544 ////////////////////////////////////////////////////////////////////////
\r
3546 BOOL DoLineCheck(unsigned long * gpuData)
\r
3548 BOOL bQuad=FALSE;short dx,dy;
\r
3552 dx=lx0-lx2;if(dx<0) dx=-dx;
\r
3556 dy=ly1-ly0;if(dy<0) dy=-dy;
\r
3559 vertex[3]=vertex[2];
\r
3560 vertex[2]=vertex[0];
\r
3561 vertex[2].x=vertex[3].x;
\r
3566 vertex[3]=vertex[2];
\r
3567 vertex[2].y=vertex[0].y;
\r
3569 else return FALSE;
\r
3576 dy=ly0-ly1;if(dy<0) dy=-dy;
\r
3579 vertex[3]=vertex[1];
\r
3580 vertex[3].x=vertex[2].x;
\r
3585 vertex[3]=vertex[2];
\r
3586 vertex[3].y=vertex[1].y;
\r
3588 else return FALSE;
\r
3596 dx=lx0-lx1;if(dx<0) dx=-dx;
\r
3600 dy=ly2-ly0;if(dy<0) dy=-dy;
\r
3603 vertex[3]=vertex[1];
\r
3604 vertex[1]=vertex[0];
\r
3605 vertex[1].x=vertex[3].x;
\r
3610 vertex[3]=vertex[1];
\r
3611 vertex[1].y=vertex[0].y;
\r
3613 else return FALSE;
\r
3620 dy=ly2-ly0;if(dy<0) dy=-dy;
\r
3623 vertex[3]=vertex[2];
\r
3624 vertex[3].x=vertex[1].x;
\r
3629 vertex[3]=vertex[1];
\r
3630 vertex[3].y=vertex[2].y;
\r
3632 else return FALSE;
\r
3640 dx=lx1-lx0;if(dx<0) dx=-dx;
\r
3644 dy=ly1-ly2;if(dy<0) dy=-dy;
\r
3648 vertex[3]=vertex[2];
\r
3649 vertex[2].x=vertex[0].x;
\r
3654 vertex[3]=vertex[2];
\r
3655 vertex[2]=vertex[0];
\r
3656 vertex[2].y=vertex[3].y;
\r
3658 else return FALSE;
\r
3665 dy=ly2-ly1;if(dy<0) dy=-dy;
\r
3669 vertex[3]=vertex[1];
\r
3670 vertex[1].x=vertex[0].x;
\r
3675 vertex[3]=vertex[1];
\r
3676 vertex[1]=vertex[0];
\r
3677 vertex[1].y=vertex[3].y;
\r
3679 else return FALSE;
\r
3685 if(!bQuad) return FALSE;
\r
3687 PRIMdrawTexturedQuad(&vertex[0], &vertex[1], &vertex[3], &vertex[2]);
\r
3689 if(bDrawMultiPass)
\r
3691 SetSemiTransMulti(1);
\r
3692 PRIMdrawTexturedQuad(&vertex[0], &vertex[1], &vertex[3], &vertex[2]);
\r
3698 if(bUseMultiPass) SetOpaqueColor(gpuData[0]);
\r
3700 PRIMdrawTexturedQuad(&vertex[0], &vertex[1], &vertex[3], &vertex[2]);
\r
3704 iDrawnSomething=1;
\r
3709 ////////////////////////////////////////////////////////////////////////
\r
3711 void primPolyFT3(unsigned char * baseAddr)
\r
3713 unsigned long *gpuData = ((unsigned long *) baseAddr);
\r
3714 short *sgpuData = ((short *) baseAddr);
\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
3723 if(offset3()) return;
\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
3733 UpdateGlobalTP((unsigned short)(gpuData[4]>>16));
\r
3734 ulClutID=gpuData[2]>>16;
\r
3736 bDrawTextured = TRUE;
\r
3737 bDrawSmoothShaded = FALSE;
\r
3738 SetRenderState(gpuData[0]);
\r
3740 /* if(iOffscreenDrawing)
\r
3743 if(bDrawOffscreen3())
\r
3745 InvalidateTextureAreaEx();
\r
3746 SetRenderColor(gpuData[0]);
\r
3747 drawPoly3FT(baseAddr);
\r
3751 SetRenderMode(gpuData[0], TRUE);
\r
3756 if(!(dwActFixes&0x10))
\r
3758 if(DoLineCheck(gpuData)) return;
\r
3761 PRIMdrawTexturedTri(&vertex[0], &vertex[1], &vertex[2]);
\r
3763 if(bDrawMultiPass)
\r
3765 SetSemiTransMulti(1);
\r
3766 PRIMdrawTexturedTri(&vertex[0], &vertex[1], &vertex[2]);
\r
3772 if(bUseMultiPass) SetOpaqueColor(gpuData[0]);
\r
3774 PRIMdrawTexturedTri(&vertex[0], &vertex[1], &vertex[2]);
\r
3778 iDrawnSomething=1;
\r
3781 ////////////////////////////////////////////////////////////////////////
\r
3782 // cmd: flat shaded Texture4
\r
3783 ////////////////////////////////////////////////////////////////////////
\r
3785 #define ST_FAC 255.99f
\r
3787 void RectTexAlign(void)
\r
3789 int UFlipped = FALSE;
\r
3790 int VFlipped = FALSE;
\r
3792 if(gTexName==gTexFrameName) return;
\r
3796 if(!((lx1==lx3 && ly3==ly2 && lx2==lx0) ||
\r
3797 (lx1==lx2 && ly2==ly3 && lx3==lx0)))
\r
3802 if (vertex[0].tow > vertex[2].tow)
\r
3807 if (vertex[0].tow < vertex[2].tow)
\r
3814 if(!((lx2==lx3 && ly3==ly1 && lx1==lx0) ||
\r
3815 (lx2==lx1 && ly1==ly3 && lx3==lx0)))
\r
3820 if (vertex[0].tow > vertex[1].tow)
\r
3825 if (vertex[0].tow < vertex[1].tow)
\r
3832 if(!((lx3==lx2 && ly2==ly1 && lx1==lx0) ||
\r
3833 (lx3==lx1 && ly1==ly2 && lx2==lx0)))
\r
3838 if (vertex[0].tow > vertex[1].tow)
\r
3843 if (vertex[0].tow < vertex[1].tow)
\r
3853 if (vertex[0].sow > vertex[2].sow)
\r
3858 if (vertex[0].sow < vertex[2].sow)
\r
3867 if (vertex[0].sow > vertex[1].sow)
\r
3872 if (vertex[0].sow < vertex[1].sow)
\r
3881 if (vertex[0].sow > vertex[1].sow)
\r
3886 if (vertex[0].sow < vertex[1].sow)
\r
3899 vertex[2].sow+=0.95f/TWin.UScaleFactor;
\r
3900 vertex[3].sow+=0.95f/TWin.UScaleFactor;
\r
3903 vertex[0].sow+=0.95f/TWin.UScaleFactor;
\r
3904 vertex[1].sow+=0.95f/TWin.UScaleFactor;
\r
3907 vertex[1].sow+=0.95f/TWin.UScaleFactor;
\r
3908 vertex[3].sow+=0.95f/TWin.UScaleFactor;
\r
3911 vertex[0].sow+=0.95f/TWin.UScaleFactor;
\r
3912 vertex[2].sow+=0.95f/TWin.UScaleFactor;
\r
3915 vertex[1].sow+=0.95f/TWin.UScaleFactor;
\r
3916 vertex[2].sow+=0.95f/TWin.UScaleFactor;
\r
3919 vertex[0].sow+=0.95f/TWin.UScaleFactor;
\r
3920 vertex[3].sow+=0.95f/TWin.UScaleFactor;
\r
3929 vertex[2].sow+=1.0f/ST_FAC;
\r
3930 vertex[3].sow+=1.0f/ST_FAC;
\r
3933 vertex[0].sow+=1.0f/ST_FAC;
\r
3934 vertex[1].sow+=1.0f/ST_FAC;
\r
3937 vertex[1].sow+=1.0f/ST_FAC;
\r
3938 vertex[3].sow+=1.0f/ST_FAC;
\r
3941 vertex[0].sow+=1.0f/ST_FAC;
\r
3942 vertex[2].sow+=1.0f/ST_FAC;
\r
3945 vertex[1].sow+=1.0f/ST_FAC;
\r
3946 vertex[2].sow+=1.0f/ST_FAC;
\r
3949 vertex[0].sow+=1.0f/ST_FAC;
\r
3950 vertex[3].sow+=1.0f/ST_FAC;
\r
3960 vertex[2].sow+=1.0f/TWin.UScaleFactor;
\r
3961 vertex[3].sow+=1.0f/TWin.UScaleFactor;
\r
3964 vertex[0].sow+=1.0f/TWin.UScaleFactor;
\r
3965 vertex[1].sow+=1.0f/TWin.UScaleFactor;
\r
3968 vertex[1].sow+=1.0f/TWin.UScaleFactor;
\r
3969 vertex[3].sow+=1.0f/TWin.UScaleFactor;
\r
3972 vertex[0].sow+=1.0f/TWin.UScaleFactor;
\r
3973 vertex[2].sow+=1.0f/TWin.UScaleFactor;
\r
3976 vertex[1].sow+=1.0f/TWin.UScaleFactor;
\r
3977 vertex[2].sow+=1.0f/TWin.UScaleFactor;
\r
3980 vertex[0].sow+=1.0f/TWin.UScaleFactor;
\r
3981 vertex[3].sow+=1.0f/TWin.UScaleFactor;
\r
3990 vertex[2].sow+=1.0f;
\r
3991 vertex[3].sow+=1.0f;
\r
3994 vertex[0].sow+=1.0f;
\r
3995 vertex[1].sow+=1.0f;
\r
3998 vertex[1].sow+=1.0f;
\r
3999 vertex[3].sow+=1.0f;
\r
4002 vertex[0].sow+=1.0f;
\r
4003 vertex[2].sow+=1.0f;
\r
4006 vertex[1].sow+=1.0f;
\r
4007 vertex[2].sow+=1.0f;
\r
4010 vertex[0].sow+=1.0f;
\r
4011 vertex[3].sow+=1.0f;
\r
4026 vertex[2].tow+=0.95f/TWin.VScaleFactor;
\r
4027 vertex[3].tow+=0.95f/TWin.VScaleFactor;
\r
4030 vertex[0].tow+=0.95f/TWin.VScaleFactor;
\r
4031 vertex[1].tow+=0.95f/TWin.VScaleFactor;
\r
4034 vertex[1].tow+=0.95f/TWin.VScaleFactor;
\r
4035 vertex[3].tow+=0.95f/TWin.VScaleFactor;
\r
4038 vertex[0].tow+=0.95f/TWin.VScaleFactor;
\r
4039 vertex[2].tow+=0.95f/TWin.VScaleFactor;
\r
4042 vertex[1].tow+=0.95f/TWin.VScaleFactor;
\r
4043 vertex[2].tow+=0.95f/TWin.VScaleFactor;
\r
4046 vertex[0].tow+=0.95f/TWin.VScaleFactor;
\r
4047 vertex[3].tow+=0.95f/TWin.VScaleFactor;
\r
4056 vertex[2].tow+=1.0f/ST_FAC;
\r
4057 vertex[3].tow+=1.0f/ST_FAC;
\r
4060 vertex[0].tow+=1.0f/ST_FAC;
\r
4061 vertex[1].tow+=1.0f/ST_FAC;
\r
4064 vertex[1].tow+=1.0f/ST_FAC;
\r
4065 vertex[3].tow+=1.0f/ST_FAC;
\r
4068 vertex[0].tow+=1.0f/ST_FAC;
\r
4069 vertex[2].tow+=1.0f/ST_FAC;
\r
4072 vertex[1].tow+=1.0f/ST_FAC;
\r
4073 vertex[2].tow+=1.0f/ST_FAC;
\r
4076 vertex[0].tow+=1.0f/ST_FAC;
\r
4077 vertex[3].tow+=1.0f/ST_FAC;
\r
4087 vertex[2].tow+=1.0f/TWin.VScaleFactor;
\r
4088 vertex[3].tow+=1.0f/TWin.VScaleFactor;
\r
4091 vertex[0].tow+=1.0f/TWin.VScaleFactor;
\r
4092 vertex[1].tow+=1.0f/TWin.VScaleFactor;
\r
4095 vertex[1].tow+=1.0f/TWin.VScaleFactor;
\r
4096 vertex[3].tow+=1.0f/TWin.VScaleFactor;
\r
4099 vertex[0].tow+=1.0f/TWin.VScaleFactor;
\r
4100 vertex[2].tow+=1.0f/TWin.VScaleFactor;
\r
4103 vertex[1].tow+=1.0f/TWin.VScaleFactor;
\r
4104 vertex[2].tow+=1.0f/TWin.VScaleFactor;
\r
4107 vertex[0].tow+=1.0f/TWin.VScaleFactor;
\r
4108 vertex[3].tow+=1.0f/TWin.VScaleFactor;
\r
4117 vertex[2].tow+=1.0f;
\r
4118 vertex[3].tow+=1.0f;
\r
4121 vertex[0].tow+=1.0f;
\r
4122 vertex[1].tow+=1.0f;
\r
4125 vertex[1].tow+=1.0f;
\r
4126 vertex[3].tow+=1.0f;
\r
4129 vertex[0].tow+=1.0f;
\r
4130 vertex[2].tow+=1.0f;
\r
4133 vertex[1].tow+=1.0f;
\r
4134 vertex[2].tow+=1.0f;
\r
4137 vertex[0].tow+=1.0f;
\r
4138 vertex[3].tow+=1.0f;
\r
4147 void primPolyFT4(unsigned char * baseAddr)
\r
4149 unsigned long *gpuData = ((unsigned long *) baseAddr);
\r
4150 short *sgpuData = ((short *) baseAddr);
\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
4161 if(offset4()) return;
\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
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
4173 UpdateGlobalTP((unsigned short)(gpuData[4]>>16));
\r
4174 ulClutID=(gpuData[2]>>16);
\r
4176 bDrawTextured = TRUE;
\r
4177 bDrawSmoothShaded = FALSE;
\r
4178 SetRenderState(gpuData[0]);
\r
4180 /* if(iOffscreenDrawing)
\r
4183 if(bDrawOffscreen4())
\r
4185 InvalidateTextureAreaEx();
\r
4186 SetRenderColor(gpuData[0]);
\r
4187 drawPoly4FT(baseAddr);
\r
4191 SetRenderMode(gpuData[0], TRUE);
\r
4199 PRIMdrawTexturedQuad(&vertex[0], &vertex[1], &vertex[3], &vertex[2]);
\r
4201 if(bDrawMultiPass)
\r
4203 SetSemiTransMulti(1);
\r
4204 PRIMdrawTexturedQuad(&vertex[0], &vertex[1], &vertex[3], &vertex[2]);
\r
4210 if(bUseMultiPass) SetOpaqueColor(gpuData[0]);
\r
4213 /* if(bSmallAlpha && iFilterType<=2)
\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
4224 PRIMdrawTexturedQuad(&vertex[0], &vertex[1], &vertex[3], &vertex[2]);
\r
4228 iDrawnSomething=1;
\r
4231 ////////////////////////////////////////////////////////////////////////
\r
4232 // cmd: smooth shaded Texture3
\r
4233 ////////////////////////////////////////////////////////////////////////
\r
4235 void primPolyGT3(unsigned char *baseAddr)
\r
4237 unsigned long *gpuData = ((unsigned long *) baseAddr);
\r
4238 short *sgpuData = ((short *) baseAddr);
\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
4247 if(offset3()) return;
\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
4257 UpdateGlobalTP((unsigned short)(gpuData[5]>>16));
\r
4258 ulClutID=(gpuData[2]>>16);
\r
4260 bDrawTextured = TRUE;
\r
4261 bDrawSmoothShaded = TRUE;
\r
4262 SetRenderState(gpuData[0]);
\r
4264 /* if(iOffscreenDrawing)
\r
4267 if(bDrawOffscreen3())
\r
4269 InvalidateTextureAreaEx();
\r
4270 drawPoly3GT(baseAddr);
\r
4274 SetRenderMode(gpuData[0], FALSE);
\r
4279 if(bDrawNonShaded)
\r
4281 //if(!bUseMultiPass) vertex[0].lcol=DoubleBGR2RGB(gpuData[0]); else vertex[0].lcol=gpuData[0];
\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
4288 PRIMdrawTexturedTri(&vertex[0], &vertex[1], &vertex[2]);
\r
4294 PRIMdrawTexturedTri(&vertex[0], &vertex[1], &vertex[2]);
\r
4300 /* if(!bUseMultiPass && !bGLBlend)
\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
4308 vertex[0].c.lcol=gpuData[0];
\r
4309 vertex[1].c.lcol=gpuData[3];
\r
4310 vertex[2].c.lcol=gpuData[6];
\r
4312 vertex[0].c.col[3]=vertex[1].c.col[3]=vertex[2].c.col[3]=ubGloAlpha;
\r
4314 PRIMdrawTexGouraudTriColor(&vertex[0], &vertex[1], &vertex[2]);
\r
4316 if(bDrawMultiPass)
\r
4318 SetSemiTransMulti(1);
\r
4319 PRIMdrawTexGouraudTriColor(&vertex[0], &vertex[1], &vertex[2]);
\r
4325 if(bUseMultiPass)
\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
4333 PRIMdrawTexGouraudTriColor(&vertex[0], &vertex[1], &vertex[2]);
\r
4337 iDrawnSomething=1;
\r
4340 ////////////////////////////////////////////////////////////////////////
\r
4341 // cmd: smooth shaded Poly3
\r
4342 ////////////////////////////////////////////////////////////////////////
\r
4344 void primPolyG3(unsigned char *baseAddr)
\r
4346 unsigned long *gpuData = ((unsigned long *) baseAddr);
\r
4347 short *sgpuData = ((short *) baseAddr);
\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
4356 if(offset3()) return;
\r
4358 bDrawTextured = FALSE;
\r
4359 bDrawSmoothShaded = TRUE;
\r
4360 SetRenderState(gpuData[0]);
\r
4362 /* if(iOffscreenDrawing)
\r
4365 if(bDrawOffscreen3())
\r
4367 InvalidateTextureAreaEx();
\r
4368 drawPoly3G(gpuData[0], gpuData[2], gpuData[4]);
\r
4372 SetRenderMode(gpuData[0], FALSE);
\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
4380 PRIMdrawGouraudTriColor(&vertex[0], &vertex[1], &vertex[2]);
\r
4382 iDrawnSomething=1;
\r
4385 ////////////////////////////////////////////////////////////////////////
\r
4386 // cmd: smooth shaded Texture4
\r
4387 ////////////////////////////////////////////////////////////////////////
\r
4389 void primPolyGT4(unsigned char *baseAddr)
\r
4391 unsigned long *gpuData = ((unsigned long *) baseAddr);
\r
4392 short *sgpuData = ((short *) baseAddr);
\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
4403 if(offset4()) return;
\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
4415 UpdateGlobalTP((unsigned short)(gpuData[5]>>16));
\r
4416 ulClutID=(gpuData[2]>>16);
\r
4418 bDrawTextured = TRUE;
\r
4419 bDrawSmoothShaded = TRUE;
\r
4420 SetRenderState(gpuData[0]);
\r
4422 /* if(iOffscreenDrawing)
\r
4425 if(bDrawOffscreen4())
\r
4427 InvalidateTextureAreaEx();
\r
4428 drawPoly4GT(baseAddr);
\r
4432 SetRenderMode(gpuData[0], FALSE);
\r
4439 if(bDrawNonShaded)
\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
4447 PRIMdrawTexturedQuad(&vertex[0], &vertex[1], &vertex[3], &vertex[2]);
\r
4452 ubGloAlpha=ubGloColAlpha=0xff;
\r
4454 PRIMdrawTexturedQuad(&vertex[0], &vertex[1], &vertex[3], &vertex[2]);
\r
4460 // if(!bUseMultiPass && !bGLBlend)
\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
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
4475 vertex[0].c.col[3]=vertex[1].c.col[3]=vertex[2].c.col[3]=vertex[3].c.col[3]=ubGloAlpha;
\r
4477 PRIMdrawTexGouraudTriColorQuad(&vertex[0], &vertex[1], &vertex[3],&vertex[2]);
\r
4479 if(bDrawMultiPass)
\r
4481 SetSemiTransMulti(1);
\r
4482 PRIMdrawTexGouraudTriColorQuad(&vertex[0], &vertex[1], &vertex[3],&vertex[2]);
\r
4488 if(bUseMultiPass)
\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
4496 ubGloAlpha=ubGloColAlpha=0xff;
\r
4498 PRIMdrawTexGouraudTriColorQuad(&vertex[0], &vertex[1], &vertex[3],&vertex[2]);
\r
4502 iDrawnSomething=1;
\r
4505 ////////////////////////////////////////////////////////////////////////
\r
4506 // cmd: smooth shaded Poly3
\r
4507 ////////////////////////////////////////////////////////////////////////
\r
4509 void primPolyF3(unsigned char *baseAddr)
\r
4511 unsigned long *gpuData = ((unsigned long *) baseAddr);
\r
4512 short *sgpuData = ((short *) baseAddr);
\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
4521 if(offset3()) return;
\r
4523 bDrawTextured = FALSE;
\r
4524 bDrawSmoothShaded = FALSE;
\r
4525 SetRenderState(gpuData[0]);
\r
4527 /* if(iOffscreenDrawing)
\r
4530 if(bDrawOffscreen3())
\r
4532 InvalidateTextureAreaEx();
\r
4533 drawPoly3F(gpuData[0]);
\r
4537 SetRenderMode(gpuData[0], FALSE);
\r
4540 vertex[0].c.lcol=gpuData[0];
\r
4541 vertex[0].c.col[3]=ubGloColAlpha;
\r
4542 SETCOL(vertex[0]);
\r
4544 PRIMdrawTri(&vertex[0], &vertex[1], &vertex[2]);
\r
4546 iDrawnSomething=1;
\r
4549 ////////////////////////////////////////////////////////////////////////
\r
4550 // cmd: skipping shaded polylines
\r
4551 ////////////////////////////////////////////////////////////////////////
\r
4553 void primLineGSkip(unsigned char *baseAddr)
\r
4555 unsigned long *gpuData = ((unsigned long *) baseAddr);
\r
4556 short *sgpuData = ((short *) baseAddr);
\r
4560 lx1 = sgpuData[2];
\r
4561 ly1 = sgpuData[3];
\r
4563 while(!(((gpuData[i] & 0xF000F000) == 0x50005000) && i>=4))
\r
4567 ly1 = (short)((gpuData[i]>>16) & 0xffff);
\r
4568 lx1 = (short)(gpuData[i] & 0xffff);
\r
4570 i++;if(i>iMax) break;
\r
4574 ////////////////////////////////////////////////////////////////////////
\r
4575 // cmd: shaded polylines
\r
4576 ////////////////////////////////////////////////////////////////////////
\r
4578 void primLineGEx(unsigned char *baseAddr)
\r
4580 unsigned long *gpuData = ((unsigned long *) baseAddr);
\r
4582 short cx0,cx1,cy0,cy1;int i;BOOL bDraw=TRUE;
\r
4584 bDrawTextured = FALSE;
\r
4585 bDrawSmoothShaded = TRUE;
\r
4586 SetRenderState(gpuData[0]);
\r
4587 SetRenderMode(gpuData[0], FALSE);
\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
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
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
4609 ly1 = (short)((gpuData[i]>>16) & 0xffff);
\r
4610 lx1 = (short)(gpuData[i] & 0xffff);
\r
4612 if(offsetline()) bDraw=FALSE; else bDraw=TRUE;
\r
4614 if (bDraw && ((lx0 != lx1) || (ly0 != ly1)))
\r
4616 /* if(iOffscreenDrawing)
\r
4618 cx0=lx0;cx1=lx1;cy0=ly0;cy1=ly1;
\r
4620 if(bDrawOffscreen4())
\r
4622 InvalidateTextureAreaEx();
\r
4623 drawPoly4G(gpuData[i-3],gpuData[i-1],gpuData[i-3],gpuData[i-1]);
\r
4625 lx0=cx0;lx1=cx1;ly0=cy0;ly1=cy1;
\r
4628 PRIMdrawGouraudLine(&vertex[0], &vertex[1], &vertex[2], &vertex[3]);
\r
4635 iDrawnSomething=1;
\r
4638 ////////////////////////////////////////////////////////////////////////
\r
4639 // cmd: shaded polyline2
\r
4640 ////////////////////////////////////////////////////////////////////////
\r
4642 void primLineG2(unsigned char *baseAddr)
\r
4644 unsigned long *gpuData = ((unsigned long *) baseAddr);
\r
4645 short *sgpuData = ((short *) baseAddr);
\r
4647 lx0 = sgpuData[2];
\r
4648 ly0 = sgpuData[3];
\r
4649 lx1 = sgpuData[6];
\r
4650 ly1 = sgpuData[7];
\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
4656 bDrawTextured = FALSE;
\r
4657 bDrawSmoothShaded = TRUE;
\r
4659 if((lx0 == lx1) && (ly0 == ly1)) return;
\r
4661 if(offsetline()) return;
\r
4663 SetRenderState(gpuData[0]);
\r
4664 SetRenderMode(gpuData[0], FALSE);
\r
4667 /* if(iOffscreenDrawing)
\r
4670 if(bDrawOffscreen4())
\r
4672 InvalidateTextureAreaEx();
\r
4673 drawPoly4G(gpuData[0],gpuData[2],gpuData[0],gpuData[2]);
\r
4677 //if(ClipVertexList4())
\r
4678 PRIMdrawGouraudLine(&vertex[0], &vertex[1], &vertex[2], &vertex[3]);
\r
4680 iDrawnSomething=1;
\r
4683 ////////////////////////////////////////////////////////////////////////
\r
4684 // cmd: skipping flat polylines
\r
4685 ////////////////////////////////////////////////////////////////////////
\r
4687 void primLineFSkip(unsigned char *baseAddr)
\r
4689 unsigned long *gpuData = ((unsigned long *) baseAddr);
\r
4692 ly1 = (short)((gpuData[1]>>16) & 0xffff);
\r
4693 lx1 = (short)(gpuData[1] & 0xffff);
\r
4695 while(!(((gpuData[i] & 0xF000F000) == 0x50005000) && i>=3))
\r
4697 ly1 = (short)((gpuData[i]>>16) & 0xffff);
\r
4698 lx1 = (short)(gpuData[i] & 0xffff);
\r
4699 i++;if(i>iMax) break;
\r
4703 ////////////////////////////////////////////////////////////////////////
\r
4704 // cmd: drawing flat polylines
\r
4705 ////////////////////////////////////////////////////////////////////////
\r
4707 void primLineFEx(unsigned char *baseAddr)
\r
4709 unsigned long *gpuData = ((unsigned long *) baseAddr);
\r
4711 short cx0,cx1,cy0,cy1;int i;
\r
4715 bDrawTextured = FALSE;
\r
4716 bDrawSmoothShaded = FALSE;
\r
4717 SetRenderState(gpuData[0]);
\r
4718 SetRenderMode(gpuData[0], FALSE);
\r
4721 vertex[0].c.lcol=gpuData[0];
\r
4722 vertex[0].c.col[3]=ubGloColAlpha;
\r
4724 ly1 = (short)((gpuData[1]>>16) & 0xffff);
\r
4725 lx1 = (short)(gpuData[1] & 0xffff);
\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
4735 ly0 = ly1;lx0=lx1;
\r
4736 ly1 = (short)((gpuData[i]>>16) & 0xffff);
\r
4737 lx1 = (short)(gpuData[i] & 0xffff);
\r
4741 /* if(iOffscreenDrawing)
\r
4743 cx0=lx0;cx1=lx1;cy0=ly0;cy1=ly1;
\r
4745 if(bDrawOffscreen4())
\r
4747 InvalidateTextureAreaEx();
\r
4748 drawPoly4F(gpuData[0]);
\r
4750 lx0=cx0;lx1=cx1;ly0=cy0;ly1=cy1;
\r
4752 PRIMdrawFlatLine(&vertex[0], &vertex[1], &vertex[2], &vertex[3]);
\r
4755 i++;if(i>iMax) break;
\r
4758 iDrawnSomething=1;
\r
4761 ////////////////////////////////////////////////////////////////////////
\r
4762 // cmd: drawing flat polyline2
\r
4763 ////////////////////////////////////////////////////////////////////////
\r
4765 void primLineF2(unsigned char *baseAddr)
\r
4767 unsigned long *gpuData = ((unsigned long *) baseAddr);
\r
4768 short *sgpuData = ((short *) baseAddr);
\r
4770 lx0 = sgpuData[2];
\r
4771 ly0 = sgpuData[3];
\r
4772 lx1 = sgpuData[4];
\r
4773 ly1 = sgpuData[5];
\r
4775 if(offsetline()) return;
\r
4777 bDrawTextured = FALSE;
\r
4778 bDrawSmoothShaded = FALSE;
\r
4779 SetRenderState(gpuData[0]);
\r
4780 SetRenderMode(gpuData[0], FALSE);
\r
4783 vertex[0].c.lcol=gpuData[0];
\r
4784 vertex[0].c.col[3]=ubGloColAlpha;
\r
4786 /* if(iOffscreenDrawing)
\r
4789 if(bDrawOffscreen4())
\r
4791 InvalidateTextureAreaEx();
\r
4792 drawPoly4F(gpuData[0]);
\r
4796 //if(ClipVertexList4())
\r
4797 PRIMdrawFlatLine(&vertex[0], &vertex[1], &vertex[2], &vertex[3]);
\r
4799 iDrawnSomething=1;
\r
4802 ////////////////////////////////////////////////////////////////////////
\r
4803 // cmd: well, easiest command... not implemented
\r
4804 ////////////////////////////////////////////////////////////////////////
\r
4806 void primNI(unsigned char *bA)
\r
4810 ////////////////////////////////////////////////////////////////////////
\r
4811 // cmd func ptr table
\r
4812 ////////////////////////////////////////////////////////////////////////
\r
4814 void (*primTableJ[256])(unsigned char *) =
\r
4817 primNI,primNI,primBlkFill,primNI,primNI,primNI,primNI,primNI,
\r
4819 primNI,primNI,primNI,primNI,primNI,primNI,primNI,primNI,
\r
4821 primNI,primNI,primNI,primNI,primNI,primNI,primNI,primNI,
\r
4823 primNI,primNI,primNI,primNI,primNI,primNI,primNI,primNI,
\r
4825 primPolyF3,primPolyF3,primPolyF3,primPolyF3,primPolyFT3,primPolyFT3,primPolyFT3,primPolyFT3,
\r
4827 primPolyF4,primPolyF4,primPolyF4,primPolyF4,primPolyFT4,primPolyFT4,primPolyFT4,primPolyFT4,
\r
4829 primPolyG3,primPolyG3,primPolyG3,primPolyG3,primPolyGT3,primPolyGT3,primPolyGT3,primPolyGT3,
\r
4831 primPolyG4,primPolyG4,primPolyG4,primPolyG4,primPolyGT4,primPolyGT4,primPolyGT4,primPolyGT4,
\r
4833 primLineF2,primLineF2,primLineF2,primLineF2,primNI,primNI,primNI,primNI,
\r
4835 primLineFEx,primLineFEx,primLineFEx,primLineFEx,primLineFEx,primLineFEx,primLineFEx,primLineFEx,
\r
4837 primLineG2,primLineG2,primLineG2,primLineG2,primNI,primNI,primNI,primNI,
\r
4839 primLineGEx,primLineGEx,primLineGEx,primLineGEx,primLineGEx,primLineGEx,primLineGEx,primLineGEx,
\r
4841 primTileS,primTileS,primTileS,primTileS,primSprtS,primSprtS,primSprtS,primSprtS,
\r
4843 primTile1,primTile1,primTile1,primTile1,primNI,primNI,primNI,primNI,
\r
4845 primTile8,primTile8,primTile8,primTile8,primSprt8,primSprt8,primSprt8,primSprt8,
\r
4847 primTile16,primTile16,primTile16,primTile16,primSprt16,primSprt16,primSprt16,primSprt16,
\r
4849 primMoveImage,primNI,primNI,primNI,primNI,primNI,primNI,primNI,
\r
4851 primNI,primNI,primNI,primNI,primNI,primNI,primNI,primNI,
\r
4853 primNI,primNI,primNI,primNI,primNI,primNI,primNI,primNI,
\r
4855 primNI,primNI,primNI,primNI,primNI,primNI,primNI,primNI,
\r
4857 primLoadImage,primNI,primNI,primNI,primNI,primNI,primNI,primNI,
\r
4859 primNI,primNI,primNI,primNI,primNI,primNI,primNI,primNI,
\r
4861 primNI,primNI,primNI,primNI,primNI,primNI,primNI,primNI,
\r
4863 primNI,primNI,primNI,primNI,primNI,primNI,primNI,primNI,
\r
4865 primStoreImage,primNI,primNI,primNI,primNI,primNI,primNI,primNI,
\r
4867 primNI,primNI,primNI,primNI,primNI,primNI,primNI,primNI,
\r
4869 primNI,primNI,primNI,primNI,primNI,primNI,primNI,primNI,
\r
4871 primNI,primNI,primNI,primNI,primNI,primNI,primNI,primNI,
\r
4873 primNI,cmdTexturePage,cmdTextureWindow,cmdDrawAreaStart,cmdDrawAreaEnd,cmdDrawOffset,cmdSTP,primNI,
\r
4875 primNI,primNI,primNI,primNI,primNI,primNI,primNI,primNI,
\r
4877 primNI,primNI,primNI,primNI,primNI,primNI,primNI,primNI,
\r
4879 primNI,primNI,primNI,primNI,primNI,primNI,primNI,primNI
\r
4882 ////////////////////////////////////////////////////////////////////////
\r
4883 // cmd func ptr table for skipping
\r
4884 ////////////////////////////////////////////////////////////////////////
\r
4886 void (*primTableSkip[256])(unsigned char *) =
\r
4889 primNI,primNI,primBlkFill,primNI,primNI,primNI,primNI,primNI,
\r
4891 primNI,primNI,primNI,primNI,primNI,primNI,primNI,primNI,
\r
4893 primNI,primNI,primNI,primNI,primNI,primNI,primNI,primNI,
\r
4895 primNI,primNI,primNI,primNI,primNI,primNI,primNI,primNI,
\r
4897 primNI,primNI,primNI,primNI,primNI,primNI,primNI,primNI,
\r
4899 primNI,primNI,primNI,primNI,primNI,primNI,primNI,primNI,
\r
4901 primNI,primNI,primNI,primNI,primNI,primNI,primNI,primNI,
\r
4903 primNI,primNI,primNI,primNI,primNI,primNI,primNI,primNI,
\r
4905 primNI,primNI,primNI,primNI,primNI,primNI,primNI,primNI,
\r
4907 primLineFSkip,primLineFSkip,primLineFSkip,primLineFSkip,primLineFSkip,primLineFSkip,primLineFSkip,primLineFSkip,
\r
4909 primNI,primNI,primNI,primNI,primNI,primNI,primNI,primNI,
\r
4911 primLineGSkip,primLineGSkip,primLineGSkip,primLineGSkip,primLineGSkip,primLineGSkip,primLineGSkip,primLineGSkip,
\r
4913 primNI,primNI,primNI,primNI,primNI,primNI,primNI,primNI,
\r
4915 primNI,primNI,primNI,primNI,primNI,primNI,primNI,primNI,
\r
4917 primNI,primNI,primNI,primNI,primNI,primNI,primNI,primNI,
\r
4919 primNI,primNI,primNI,primNI,primNI,primNI,primNI,primNI,
\r
4921 primMoveImage,primNI,primNI,primNI,primNI,primNI,primNI,primNI,
\r
4923 primNI,primNI,primNI,primNI,primNI,primNI,primNI,primNI,
\r
4925 primNI,primNI,primNI,primNI,primNI,primNI,primNI,primNI,
\r
4927 primNI,primNI,primNI,primNI,primNI,primNI,primNI,primNI,
\r
4929 primLoadImage,primNI,primNI,primNI,primNI,primNI,primNI,primNI,
\r
4931 primNI,primNI,primNI,primNI,primNI,primNI,primNI,primNI,
\r
4933 primNI,primNI,primNI,primNI,primNI,primNI,primNI,primNI,
\r
4935 primNI,primNI,primNI,primNI,primNI,primNI,primNI,primNI,
\r
4937 primStoreImage,primNI,primNI,primNI,primNI,primNI,primNI,primNI,
\r
4939 primNI,primNI,primNI,primNI,primNI,primNI,primNI,primNI,
\r
4941 primNI,primNI,primNI,primNI,primNI,primNI,primNI,primNI,
\r
4943 primNI,primNI,primNI,primNI,primNI,primNI,primNI,primNI,
\r
4945 primNI,cmdTexturePage,cmdTextureWindow,cmdDrawAreaStart,cmdDrawAreaEnd,cmdDrawOffset,cmdSTP,primNI,
\r
4947 primNI,primNI,primNI,primNI,primNI,primNI,primNI,primNI,
\r
4949 primNI,primNI,primNI,primNI,primNI,primNI,primNI,primNI,
\r
4951 primNI,primNI,primNI,primNI,primNI,primNI,primNI,primNI
\r