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);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);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); // 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); // 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); // 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);bBlendEnable=TRUE;} // wanna blend
\r
807 if(bm1!=obm1 || bm2!=obm2)
\r
809 glBlendFunc(bm1,bm2); // 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);}
\r
952 if(!bTexEnabled) // -> turn texturing on
\r
953 {bTexEnabled=TRUE;glEnable(GL_TEXTURE_2D);}
\r
955 else // no texture ?
\r
957 {bTexEnabled=FALSE;glDisable(GL_TEXTURE_2D);} // -> 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
983 bOldSmoothShaded=bDrawSmoothShaded;
\r
987 ////////////////////////////////////////////////////////////////////////
\r
988 // Set Opaque multipass color
\r
989 ////////////////////////////////////////////////////////////////////////
\r
991 void SetOpaqueColor(unsigned long DrawAttributes)
\r
993 if(bDrawNonShaded) return; // no shading? bye
\r
995 DrawAttributes=DoubleBGR2RGB(DrawAttributes); // multipass is just half color, so double it on opaque pass
\r
996 vertex[0].c.lcol=DrawAttributes|0xff000000;
\r
997 SETCOL(vertex[0]); // set color
\r
1000 ////////////////////////////////////////////////////////////////////////
\r
1001 // Fucking stupid screen coord checking
\r
1002 ////////////////////////////////////////////////////////////////////////
\r
1004 BOOL ClipVertexListScreen(void)
\r
1006 if (lx0 >= PSXDisplay.DisplayEnd.x) goto NEXTSCRTEST;
\r
1007 if (ly0 >= PSXDisplay.DisplayEnd.y) goto NEXTSCRTEST;
\r
1008 if (lx2 < PSXDisplay.DisplayPosition.x) goto NEXTSCRTEST;
\r
1009 if (ly2 < PSXDisplay.DisplayPosition.y) goto NEXTSCRTEST;
\r
1014 if(PSXDisplay.InterlacedTest) return FALSE;
\r
1016 if (lx0 >= PreviousPSXDisplay.DisplayEnd.x) return FALSE;
\r
1017 if (ly0 >= PreviousPSXDisplay.DisplayEnd.y) return FALSE;
\r
1018 if (lx2 < PreviousPSXDisplay.DisplayPosition.x) return FALSE;
\r
1019 if (ly2 < PreviousPSXDisplay.DisplayPosition.y) return FALSE;
\r
1024 ////////////////////////////////////////////////////////////////////////
\r
1026 BOOL bDrawOffscreenFront(void)
\r
1028 if(sxmin < PSXDisplay.DisplayPosition.x) return FALSE; // must be complete in front
\r
1029 if(symin < PSXDisplay.DisplayPosition.y) return FALSE;
\r
1030 if(sxmax > PSXDisplay.DisplayEnd.x) return FALSE;
\r
1031 if(symax > PSXDisplay.DisplayEnd.y) return FALSE;
\r
1035 BOOL bOnePointInFront(void)
\r
1037 if(sxmax< PSXDisplay.DisplayPosition.x)
\r
1040 if(symax< PSXDisplay.DisplayPosition.y)
\r
1043 if(sxmin>=PSXDisplay.DisplayEnd.x)
\r
1046 if(symin>=PSXDisplay.DisplayEnd.y)
\r
1053 BOOL bOnePointInBack(void)
\r
1055 if(sxmax< PreviousPSXDisplay.DisplayPosition.x)
\r
1058 if(symax< PreviousPSXDisplay.DisplayPosition.y)
\r
1061 if(sxmin>=PreviousPSXDisplay.DisplayEnd.x)
\r
1064 if(symin>=PreviousPSXDisplay.DisplayEnd.y)
\r
1070 BOOL bDrawOffscreen4(void)
\r
1072 BOOL bFront;short sW,sH;
\r
1074 sxmax=max(lx0,max(lx1,max(lx2,lx3)));
\r
1075 if(sxmax<drawX) return FALSE;
\r
1076 sxmin=min(lx0,min(lx1,min(lx2,lx3)));
\r
1077 if(sxmin>drawW) return FALSE;
\r
1078 symax=max(ly0,max(ly1,max(ly2,ly3)));
\r
1079 if(symax<drawY) return FALSE;
\r
1080 symin=min(ly0,min(ly1,min(ly2,ly3)));
\r
1081 if(symin>drawH) return FALSE;
\r
1083 if(PSXDisplay.Disabled) return TRUE; // disabled? ever
\r
1085 if(iOffscreenDrawing==1) return bFullVRam;
\r
1087 if(dwActFixes&1 && iOffscreenDrawing==4)
\r
1089 if(PreviousPSXDisplay.DisplayPosition.x==PSXDisplay.DisplayPosition.x &&
\r
1090 PreviousPSXDisplay.DisplayPosition.y==PSXDisplay.DisplayPosition.y &&
\r
1091 PreviousPSXDisplay.DisplayEnd.x==PSXDisplay.DisplayEnd.x &&
\r
1092 PreviousPSXDisplay.DisplayEnd.y==PSXDisplay.DisplayEnd.y)
\r
1094 bRenderFrontBuffer=TRUE;
\r
1099 sW=drawW-1;sH=drawH-1;
\r
1101 sxmin=min(sW,max(sxmin,drawX));
\r
1102 sxmax=max(drawX,min(sxmax,sW));
\r
1103 symin=min(sH,max(symin,drawY));
\r
1104 symax=max(drawY,min(symax,sH));
\r
1106 if(bOnePointInBack()) return bFullVRam;
\r
1108 if(iOffscreenDrawing==2)
\r
1109 bFront=bDrawOffscreenFront();
\r
1110 else bFront=bOnePointInFront();
\r
1114 if(PSXDisplay.InterlacedTest) return bFullVRam; // -> ok, no need for adjust
\r
1116 vertex[0].x=lx0 - PSXDisplay.DisplayPosition.x+PreviousPSXDisplay.Range.x0;
\r
1117 vertex[1].x=lx1 - PSXDisplay.DisplayPosition.x+PreviousPSXDisplay.Range.x0;
\r
1118 vertex[2].x=lx2 - PSXDisplay.DisplayPosition.x+PreviousPSXDisplay.Range.x0;
\r
1119 vertex[3].x=lx3 - PSXDisplay.DisplayPosition.x+PreviousPSXDisplay.Range.x0;
\r
1120 vertex[0].y=ly0 - PSXDisplay.DisplayPosition.y+PreviousPSXDisplay.Range.y0;
\r
1121 vertex[1].y=ly1 - PSXDisplay.DisplayPosition.y+PreviousPSXDisplay.Range.y0;
\r
1122 vertex[2].y=ly2 - PSXDisplay.DisplayPosition.y+PreviousPSXDisplay.Range.y0;
\r
1123 vertex[3].y=ly3 - PSXDisplay.DisplayPosition.y+PreviousPSXDisplay.Range.y0;
\r
1125 if(iOffscreenDrawing==4 && !(dwActFixes&1)) // -> frontbuffer wanted
\r
1127 bRenderFrontBuffer=TRUE;
\r
1130 return bFullVRam; // -> but no od
\r
1136 ////////////////////////////////////////////////////////////////////////
\r
1138 BOOL bDrawOffscreen3(void)
\r
1140 BOOL bFront;short sW,sH;
\r
1142 sxmax=max(lx0,max(lx1,lx2));
\r
1143 if(sxmax<drawX) return FALSE;
\r
1144 sxmin=min(lx0,min(lx1,lx2));
\r
1145 if(sxmin>drawW) return FALSE;
\r
1146 symax=max(ly0,max(ly1,ly2));
\r
1147 if(symax<drawY) return FALSE;
\r
1148 symin=min(ly0,min(ly1,ly2));
\r
1149 if(symin>drawH) return FALSE;
\r
1151 if(PSXDisplay.Disabled) return TRUE; // disabled? ever
\r
1153 if(iOffscreenDrawing==1) return bFullVRam;
\r
1155 sW=drawW-1;sH=drawH-1;
\r
1156 sxmin=min(sW,max(sxmin,drawX));
\r
1157 sxmax=max(drawX,min(sxmax,sW));
\r
1158 symin=min(sH,max(symin,drawY));
\r
1159 symax=max(drawY,min(symax,sH));
\r
1161 if(bOnePointInBack()) return bFullVRam;
\r
1163 if(iOffscreenDrawing==2)
\r
1164 bFront=bDrawOffscreenFront();
\r
1165 else bFront=bOnePointInFront();
\r
1169 if(PSXDisplay.InterlacedTest) return bFullVRam; // -> ok, no need for adjust
\r
1171 vertex[0].x=lx0 - PSXDisplay.DisplayPosition.x+PreviousPSXDisplay.Range.x0;
\r
1172 vertex[1].x=lx1 - PSXDisplay.DisplayPosition.x+PreviousPSXDisplay.Range.x0;
\r
1173 vertex[2].x=lx2 - PSXDisplay.DisplayPosition.x+PreviousPSXDisplay.Range.x0;
\r
1174 vertex[0].y=ly0 - PSXDisplay.DisplayPosition.y+PreviousPSXDisplay.Range.y0;
\r
1175 vertex[1].y=ly1 - PSXDisplay.DisplayPosition.y+PreviousPSXDisplay.Range.y0;
\r
1176 vertex[2].y=ly2 - PSXDisplay.DisplayPosition.y+PreviousPSXDisplay.Range.y0;
\r
1178 if(iOffscreenDrawing==4) // -> frontbuffer wanted
\r
1180 bRenderFrontBuffer=TRUE;
\r
1184 return bFullVRam; // -> but no od
\r
1190 ////////////////////////////////////////////////////////////////////////
\r
1192 BOOL FastCheckAgainstScreen(short imageX0,short imageY0,short imageX1,short imageY1)
\r
1194 PSXRect_t xUploadArea;
\r
1196 imageX1 += imageX0;
\r
1197 imageY1 += imageY0;
\r
1199 if (imageX0 < PreviousPSXDisplay.DisplayPosition.x)
\r
1200 xUploadArea.x0 = PreviousPSXDisplay.DisplayPosition.x;
\r
1202 if (imageX0 > PreviousPSXDisplay.DisplayEnd.x)
\r
1203 xUploadArea.x0 = PreviousPSXDisplay.DisplayEnd.x;
\r
1205 xUploadArea.x0 = imageX0;
\r
1207 if(imageX1 < PreviousPSXDisplay.DisplayPosition.x)
\r
1208 xUploadArea.x1 = PreviousPSXDisplay.DisplayPosition.x;
\r
1210 if (imageX1 > PreviousPSXDisplay.DisplayEnd.x)
\r
1211 xUploadArea.x1 = PreviousPSXDisplay.DisplayEnd.x;
\r
1213 xUploadArea.x1 = imageX1;
\r
1215 if (imageY0 < PreviousPSXDisplay.DisplayPosition.y)
\r
1216 xUploadArea.y0 = PreviousPSXDisplay.DisplayPosition.y;
\r
1218 if (imageY0 > PreviousPSXDisplay.DisplayEnd.y)
\r
1219 xUploadArea.y0 = PreviousPSXDisplay.DisplayEnd.y;
\r
1221 xUploadArea.y0 = imageY0;
\r
1223 if (imageY1 < PreviousPSXDisplay.DisplayPosition.y)
\r
1224 xUploadArea.y1 = PreviousPSXDisplay.DisplayPosition.y;
\r
1226 if (imageY1 > PreviousPSXDisplay.DisplayEnd.y)
\r
1227 xUploadArea.y1 = PreviousPSXDisplay.DisplayEnd.y;
\r
1229 xUploadArea.y1 = imageY1;
\r
1231 if ((xUploadArea.x0 != xUploadArea.x1) && (xUploadArea.y0 != xUploadArea.y1))
\r
1233 else return FALSE;
\r
1236 BOOL CheckAgainstScreen(short imageX0,short imageY0,short imageX1,short imageY1)
\r
1238 imageX1 += imageX0;
\r
1239 imageY1 += imageY0;
\r
1241 if (imageX0 < PreviousPSXDisplay.DisplayPosition.x)
\r
1242 xrUploadArea.x0 = PreviousPSXDisplay.DisplayPosition.x;
\r
1244 if (imageX0 > PreviousPSXDisplay.DisplayEnd.x)
\r
1245 xrUploadArea.x0 = PreviousPSXDisplay.DisplayEnd.x;
\r
1247 xrUploadArea.x0 = imageX0;
\r
1249 if(imageX1 < PreviousPSXDisplay.DisplayPosition.x)
\r
1250 xrUploadArea.x1 = PreviousPSXDisplay.DisplayPosition.x;
\r
1252 if (imageX1 > PreviousPSXDisplay.DisplayEnd.x)
\r
1253 xrUploadArea.x1 = PreviousPSXDisplay.DisplayEnd.x;
\r
1255 xrUploadArea.x1 = imageX1;
\r
1257 if (imageY0 < PreviousPSXDisplay.DisplayPosition.y)
\r
1258 xrUploadArea.y0 = PreviousPSXDisplay.DisplayPosition.y;
\r
1260 if (imageY0 > PreviousPSXDisplay.DisplayEnd.y)
\r
1261 xrUploadArea.y0 = PreviousPSXDisplay.DisplayEnd.y;
\r
1263 xrUploadArea.y0 = imageY0;
\r
1265 if (imageY1 < PreviousPSXDisplay.DisplayPosition.y)
\r
1266 xrUploadArea.y1 = PreviousPSXDisplay.DisplayPosition.y;
\r
1268 if (imageY1 > PreviousPSXDisplay.DisplayEnd.y)
\r
1269 xrUploadArea.y1 = PreviousPSXDisplay.DisplayEnd.y;
\r
1271 xrUploadArea.y1 = imageY1;
\r
1273 if ((xrUploadArea.x0 != xrUploadArea.x1) && (xrUploadArea.y0 != xrUploadArea.y1))
\r
1275 else return FALSE;
\r
1278 BOOL FastCheckAgainstFrontScreen(short imageX0,short imageY0,short imageX1,short imageY1)
\r
1280 PSXRect_t xUploadArea;
\r
1282 imageX1 += imageX0;
\r
1283 imageY1 += imageY0;
\r
1285 if (imageX0 < PSXDisplay.DisplayPosition.x)
\r
1286 xUploadArea.x0 = PSXDisplay.DisplayPosition.x;
\r
1288 if (imageX0 > PSXDisplay.DisplayEnd.x)
\r
1289 xUploadArea.x0 = PSXDisplay.DisplayEnd.x;
\r
1291 xUploadArea.x0 = imageX0;
\r
1293 if(imageX1 < PSXDisplay.DisplayPosition.x)
\r
1294 xUploadArea.x1 = PSXDisplay.DisplayPosition.x;
\r
1296 if (imageX1 > PSXDisplay.DisplayEnd.x)
\r
1297 xUploadArea.x1 = PSXDisplay.DisplayEnd.x;
\r
1299 xUploadArea.x1 = imageX1;
\r
1301 if (imageY0 < PSXDisplay.DisplayPosition.y)
\r
1302 xUploadArea.y0 = PSXDisplay.DisplayPosition.y;
\r
1304 if (imageY0 > PSXDisplay.DisplayEnd.y)
\r
1305 xUploadArea.y0 = PSXDisplay.DisplayEnd.y;
\r
1307 xUploadArea.y0 = imageY0;
\r
1309 if (imageY1 < PSXDisplay.DisplayPosition.y)
\r
1310 xUploadArea.y1 = PSXDisplay.DisplayPosition.y;
\r
1312 if (imageY1 > PSXDisplay.DisplayEnd.y)
\r
1313 xUploadArea.y1 = PSXDisplay.DisplayEnd.y;
\r
1315 xUploadArea.y1 = imageY1;
\r
1317 if ((xUploadArea.x0 != xUploadArea.x1) && (xUploadArea.y0 != xUploadArea.y1))
\r
1319 else return FALSE;
\r
1322 BOOL CheckAgainstFrontScreen(short imageX0,short imageY0,short imageX1,short imageY1)
\r
1324 imageX1 += imageX0;
\r
1325 imageY1 += imageY0;
\r
1327 if (imageX0 < PSXDisplay.DisplayPosition.x)
\r
1328 xrUploadArea.x0 = PSXDisplay.DisplayPosition.x;
\r
1330 if (imageX0 > PSXDisplay.DisplayEnd.x)
\r
1331 xrUploadArea.x0 = PSXDisplay.DisplayEnd.x;
\r
1333 xrUploadArea.x0 = imageX0;
\r
1335 if(imageX1 < PSXDisplay.DisplayPosition.x)
\r
1336 xrUploadArea.x1 = PSXDisplay.DisplayPosition.x;
\r
1338 if (imageX1 > PSXDisplay.DisplayEnd.x)
\r
1339 xrUploadArea.x1 = PSXDisplay.DisplayEnd.x;
\r
1341 xrUploadArea.x1 = imageX1;
\r
1343 if (imageY0 < PSXDisplay.DisplayPosition.y)
\r
1344 xrUploadArea.y0 = PSXDisplay.DisplayPosition.y;
\r
1346 if (imageY0 > PSXDisplay.DisplayEnd.y)
\r
1347 xrUploadArea.y0 = PSXDisplay.DisplayEnd.y;
\r
1349 xrUploadArea.y0 = imageY0;
\r
1351 if (imageY1 < PSXDisplay.DisplayPosition.y)
\r
1352 xrUploadArea.y1 = PSXDisplay.DisplayPosition.y;
\r
1354 if (imageY1 > PSXDisplay.DisplayEnd.y)
\r
1355 xrUploadArea.y1 = PSXDisplay.DisplayEnd.y;
\r
1357 xrUploadArea.y1 = imageY1;
\r
1359 if ((xrUploadArea.x0 != xrUploadArea.x1) && (xrUploadArea.y0 != xrUploadArea.y1))
\r
1361 else return FALSE;
\r
1364 ////////////////////////////////////////////////////////////////////////
\r
1366 void PrepareFullScreenUpload (long Position)
\r
1368 if (Position==-1) // rgb24
\r
1370 if(PSXDisplay.Interlaced)
\r
1372 xrUploadArea.x0 = PSXDisplay.DisplayPosition.x;
\r
1373 xrUploadArea.x1 = PSXDisplay.DisplayEnd.x;
\r
1374 xrUploadArea.y0 = PSXDisplay.DisplayPosition.y;
\r
1375 xrUploadArea.y1 = PSXDisplay.DisplayEnd.y;
\r
1379 xrUploadArea.x0 = PreviousPSXDisplay.DisplayPosition.x;
\r
1380 xrUploadArea.x1 = PreviousPSXDisplay.DisplayEnd.x;
\r
1381 xrUploadArea.y0 = PreviousPSXDisplay.DisplayPosition.y;
\r
1382 xrUploadArea.y1 = PreviousPSXDisplay.DisplayEnd.y;
\r
1385 if(bNeedRGB24Update)
\r
1389 // lClearOnSwap=0;
\r
1392 if(PSXDisplay.Interlaced && PreviousPSXDisplay.RGB24<2) // in interlaced mode we upload at least two full frames (GT1 menu)
\r
1394 PreviousPSXDisplay.RGB24++;
\r
1398 xrUploadArea.y1 = min(xrUploadArea.y0+xrUploadAreaRGB24.y1,xrUploadArea.y1);
\r
1399 xrUploadArea.y0+=xrUploadAreaRGB24.y0;
\r
1406 xrUploadArea.x0 = PSXDisplay.DisplayPosition.x;
\r
1407 xrUploadArea.x1 = PSXDisplay.DisplayEnd.x;
\r
1408 xrUploadArea.y0 = PSXDisplay.DisplayPosition.y;
\r
1409 xrUploadArea.y1 = PSXDisplay.DisplayEnd.y;
\r
1413 xrUploadArea.x0 = PreviousPSXDisplay.DisplayPosition.x;
\r
1414 xrUploadArea.x1 = PreviousPSXDisplay.DisplayEnd.x;
\r
1415 xrUploadArea.y0 = PreviousPSXDisplay.DisplayPosition.y;
\r
1416 xrUploadArea.y1 = PreviousPSXDisplay.DisplayEnd.y;
\r
1419 if (xrUploadArea.x0 < 0) xrUploadArea.x0 = 0;
\r
1421 if (xrUploadArea.x0 > 1023) xrUploadArea.x0 = 1023;
\r
1423 if (xrUploadArea.x1 < 0) xrUploadArea.x1 = 0;
\r
1425 if (xrUploadArea.x1 > 1024) xrUploadArea.x1 = 1024;
\r
1427 if (xrUploadArea.y0 < 0) xrUploadArea.y0 = 0;
\r
1429 if (xrUploadArea.y0 > iGPUHeightMask) xrUploadArea.y0 = iGPUHeightMask;
\r
1431 if (xrUploadArea.y1 < 0) xrUploadArea.y1 = 0;
\r
1433 if (xrUploadArea.y1 > iGPUHeight) xrUploadArea.y1 = iGPUHeight;
\r
1435 if (PSXDisplay.RGB24)
\r
1437 InvalidateTextureArea(xrUploadArea.x0,xrUploadArea.y0,xrUploadArea.x1-xrUploadArea.x0,xrUploadArea.y1-xrUploadArea.y0);
\r
1441 ////////////////////////////////////////////////////////////////////////
\r
1442 // Upload screen (MDEC and such)
\r
1443 ////////////////////////////////////////////////////////////////////////
\r
1444 ////////////////////////////////////////////////////////////////////////
\r
1446 unsigned char * LoadDirectMovieFast(void);
\r
1448 void UploadScreenEx(long Position)
\r
1450 short ya,yb,xa,xb,x, y, YStep, XStep, U, UStep,ux[4],vy[4];
\r
1452 if(!PSXDisplay.DisplayMode.x) return;
\r
1453 if(!PSXDisplay.DisplayMode.y) return;
\r
1455 glDisable(GL_SCISSOR_TEST);
\r
1456 glShadeModel(GL_FLAT);
\r
1457 bOldSmoothShaded=FALSE;
\r
1458 glDisable(GL_BLEND);
\r
1459 bBlendEnable=FALSE;
\r
1460 glDisable(GL_TEXTURE_2D);
\r
1461 bTexEnabled=FALSE;
\r
1462 glDisable(GL_ALPHA_TEST);
\r
1464 //glPixelZoom(((float)rRatioRect.right)/((float)PSXDisplay.DisplayMode.x),
\r
1465 // -1.0f*(((float)rRatioRect.bottom)/((float)PSXDisplay.DisplayMode.y)));
\r
1467 //----------------------------------------------------//
\r
1469 YStep = 256; // max texture size
\r
1471 UStep = (PSXDisplay.RGB24 ? 128 : 0);
\r
1472 ya = xrUploadArea.y0;
\r
1473 yb = xrUploadArea.y1;
\r
1474 xa = xrUploadArea.x0;
\r
1475 xb = xrUploadArea.x1;
\r
1477 for(y=ya;y<=yb;y+=YStep) // loop y
\r
1480 for(x=xa;x<=xb;x+=XStep) // loop x
\r
1482 ly0 = ly1 = y; // -> get y coords
\r
1484 if (ly2 > yb) ly2 = yb;
\r
1487 lx0 = lx3 = x; // -> get x coords
\r
1489 if (lx1 > xb) lx1 = xb;
\r
1493 ux[0]=ux[3]=(xa - x); // -> set tex x coords
\r
1494 if (ux[0] < 0) ux[0]=ux[3]=0;
\r
1495 ux[2]=ux[1]=(xb - x);
\r
1496 if (ux[2] > 256) ux[2]=ux[1]=256;
\r
1498 vy[0]=vy[1]=(ya - y); // -> set tex y coords
\r
1499 if (vy[0] < 0) vy[0]=vy[1]=0;
\r
1500 vy[2]=vy[3]=(yb - y);
\r
1501 if (vy[2] > 256) vy[2]=vy[3]=256;
\r
1503 if ((ux[0] >= ux[2]) || // -> cheaters never win...
\r
1504 (vy[0] >= vy[2])) continue; // (but winners always cheat...)
\r
1506 xrMovieArea.x0=lx0+U; xrMovieArea.y0=ly0;
\r
1507 xrMovieArea.x1=lx2+U; xrMovieArea.y1=ly2;
\r
1509 offsetScreenUpload(Position);
\r
1511 //glRasterPos2f(vertex[0].x,vertex[0].y);
\r
1513 //glDrawPixels(xrMovieArea.x1-xrMovieArea.x0,
\r
1514 // xrMovieArea.y1-xrMovieArea.y0,
\r
1515 // GL_RGBA,GL_UNSIGNED_BYTE,
\r
1516 LoadDirectMovieFast();//);
\r
1522 //----------------------------------------------------//
\r
1524 // glPixelZoom(1.0F,1.0F);
\r
1526 glEnable(GL_ALPHA_TEST);
\r
1527 glEnable(GL_SCISSOR_TEST);
\r
1530 ////////////////////////////////////////////////////////////////////////
\r
1532 void UploadScreen(long Position)
\r
1534 short x, y, YStep, XStep, U, s, UStep,ux[4],vy[4];
\r
1535 short xa,xb,ya,yb;
\r
1537 if(xrUploadArea.x0>1023) xrUploadArea.x0=1023;
\r
1538 if(xrUploadArea.x1>1024) xrUploadArea.x1=1024;
\r
1539 if(xrUploadArea.y0>iGPUHeightMask) xrUploadArea.y0=iGPUHeightMask;
\r
1540 if(xrUploadArea.y1>iGPUHeight) xrUploadArea.y1=iGPUHeight;
\r
1542 if(xrUploadArea.x0==xrUploadArea.x1) return;
\r
1543 if(xrUploadArea.y0==xrUploadArea.y1) return;
\r
1545 if(PSXDisplay.Disabled && iOffscreenDrawing<4) return;
\r
1547 iDrawnSomething = 2;
\r
1548 iLastRGB24=PSXDisplay.RGB24+1;
\r
1550 if(bSkipNextFrame) return;
\r
1552 if(dwActFixes & 2) {UploadScreenEx(Position);return;}
\r
1554 bUsingMovie = TRUE;
\r
1555 bDrawTextured = TRUE; // just doing textures
\r
1556 bDrawSmoothShaded = FALSE;
\r
1558 /* if(bGLBlend) vertex[0].c.lcol=0xff7f7f7f; // set solid col
\r
1559 else */vertex[0].c.lcol=0xffffffff;
\r
1560 SETCOL(vertex[0]);
\r
1562 SetOGLDisplaySettings(0);
\r
1564 YStep = 256; // max texture size
\r
1567 UStep = (PSXDisplay.RGB24 ? 128 : 0);
\r
1569 ya=xrUploadArea.y0;
\r
1570 yb=xrUploadArea.y1;
\r
1571 xa=xrUploadArea.x0;
\r
1572 xb=xrUploadArea.x1;
\r
1574 for(y=ya;y<=yb;y+=YStep) // loop y
\r
1577 for(x=xa;x<=xb;x+=XStep) // loop x
\r
1579 ly0 = ly1 = y; // -> get y coords
\r
1581 if (ly2 > yb) ly2 = yb;
\r
1584 lx0 = lx3 = x; // -> get x coords
\r
1586 if (lx1 > xb) lx1 = xb;
\r
1590 ux[0]=ux[3]=(xa - x); // -> set tex x coords
\r
1591 if (ux[0] < 0) ux[0]=ux[3]=0;
\r
1592 ux[2]=ux[1]=(xb - x);
\r
1593 if (ux[2] > 256) ux[2]=ux[1]=256;
\r
1595 vy[0]=vy[1]=(ya - y); // -> set tex y coords
\r
1596 if (vy[0] < 0) vy[0]=vy[1]=0;
\r
1597 vy[2]=vy[3]=(yb - y);
\r
1598 if (vy[2] > 256) vy[2]=vy[3]=256;
\r
1600 if ((ux[0] >= ux[2]) || // -> cheaters never win...
\r
1601 (vy[0] >= vy[2])) continue; // (but winners always cheat...)
\r
1603 xrMovieArea.x0=lx0+U; xrMovieArea.y0=ly0;
\r
1604 xrMovieArea.x1=lx2+U; xrMovieArea.y1=ly2;
\r
1606 s=ux[2] - ux[0]; if(s>255) s=255;
\r
1608 gl_ux[2] = gl_ux[1] = s;
\r
1609 s=vy[2] - vy[0]; if(s>255) s=255;
\r
1610 gl_vy[2] = gl_vy[3] = s;
\r
1611 gl_ux[0] = gl_ux[3] = gl_vy[0] = gl_vy[1] = 0;
\r
1613 SetRenderState((unsigned long)0x01000000);
\r
1614 SetRenderMode((unsigned long)0x01000000, FALSE); // upload texture data
\r
1615 offsetScreenUpload(Position);
\r
1616 assignTextureVRAMWrite();
\r
1618 PRIMdrawTexturedQuad(&vertex[0], &vertex[1], &vertex[2], &vertex[3]);
\r
1624 bUsingMovie=FALSE; // done...
\r
1625 bDisplayNotSet = TRUE;
\r
1628 ////////////////////////////////////////////////////////////////////////
\r
1629 // Detect next screen
\r
1630 ////////////////////////////////////////////////////////////////////////
\r
1632 BOOL IsCompleteInsideNextScreen(short x, short y, short xoff, short yoff)
\r
1634 if (x > PSXDisplay.DisplayPosition.x+1) return FALSE;
\r
1635 if ((x + xoff) < PSXDisplay.DisplayEnd.x-1) return FALSE;
\r
1637 if (y >= PSXDisplay.DisplayPosition.y &&
\r
1638 y <= PSXDisplay.DisplayEnd.y )
\r
1640 if ((yoff) >= PSXDisplay.DisplayPosition.y &&
\r
1641 (yoff) <= PSXDisplay.DisplayEnd.y ) return TRUE;
\r
1643 if (y > PSXDisplay.DisplayPosition.y+1) return FALSE;
\r
1644 if (yoff < PSXDisplay.DisplayEnd.y-1) return FALSE;
\r
1648 BOOL IsPrimCompleteInsideNextScreen(short x, short y, short xoff, short yoff)
\r
1650 x+=PSXDisplay.DrawOffset.x;
\r
1651 if (x > PSXDisplay.DisplayPosition.x+1) return FALSE;
\r
1652 y+=PSXDisplay.DrawOffset.y;
\r
1653 if (y > PSXDisplay.DisplayPosition.y+1) return FALSE;
\r
1654 xoff+=PSXDisplay.DrawOffset.x;
\r
1655 if (xoff < PSXDisplay.DisplayEnd.x-1) return FALSE;
\r
1656 yoff+=PSXDisplay.DrawOffset.y;
\r
1657 if (yoff < PSXDisplay.DisplayEnd.y-1) return FALSE;
\r
1661 BOOL IsInsideNextScreen(short x, short y, short xoff, short yoff)
\r
1663 if (x > PSXDisplay.DisplayEnd.x) return FALSE;
\r
1664 if (y > PSXDisplay.DisplayEnd.y) return FALSE;
\r
1665 if ((x + xoff) < PSXDisplay.DisplayPosition.x) return FALSE;
\r
1666 if ((y + yoff) < PSXDisplay.DisplayPosition.y) return FALSE;
\r
1670 ////////////////////////////////////////////////////////////////////////
\r
1672 ////////////////////////////////////////////////////////////////////////
\r
1674 //Mask1 Set mask bit while drawing. 1 = on
\r
1675 //Mask2 Do not draw to mask areas. 1= on
\r
1677 void cmdSTP(unsigned char * baseAddr)
\r
1679 unsigned long gdata = ((unsigned long*)baseAddr)[0];
\r
1681 STATUSREG&=~0x1800; // clear the necessary bits
\r
1682 STATUSREG|=((gdata & 0x03) << 11); // set the current bits
\r
1684 if(!iUseMask) return;
\r
1686 if(gdata&1) {sSetMask=0x8000;lSetMask=0x80008000;iSetMask=1;}
\r
1687 else {sSetMask=0; lSetMask=0; iSetMask=0;}
\r
1691 if(!(gdata&1)) iSetMask=2;
\r
1693 if(iDepthFunc==0) return;
\r
1695 glDepthFunc(GL_LESS);
\r
1700 if(iDepthFunc==1) return;
\r
1701 glDepthFunc(GL_ALWAYS);
\r
1706 ////////////////////////////////////////////////////////////////////////
\r
1707 // cmd: Set texture page infos
\r
1708 ////////////////////////////////////////////////////////////////////////
\r
1710 void cmdTexturePage(unsigned char * baseAddr)
\r
1712 unsigned long gdata = ((unsigned long*)baseAddr)[0];
\r
1713 UpdateGlobalTP((unsigned short)gdata);
\r
1714 GlobalTextREST = (gdata&0x00ffffff)>>9;
\r
1717 ////////////////////////////////////////////////////////////////////////
\r
1718 // cmd: turn on/off texture window
\r
1719 ////////////////////////////////////////////////////////////////////////
\r
1721 void cmdTextureWindow(unsigned char *baseAddr)
\r
1723 unsigned long gdata = ((unsigned long*)baseAddr)[0];
\r
1725 unsigned long YAlign,XAlign;
\r
1727 ulGPUInfoVals[INFO_TW]=gdata&0xFFFFF;
\r
1730 TWin.Position.y1 = 8; // xxxx1
\r
1731 else if (gdata & 0x040)
\r
1732 TWin.Position.y1 = 16; // xxx10
\r
1733 else if (gdata & 0x080)
\r
1734 TWin.Position.y1 = 32; // xx100
\r
1735 else if (gdata & 0x100)
\r
1736 TWin.Position.y1 = 64; // x1000
\r
1737 else if (gdata & 0x200)
\r
1738 TWin.Position.y1 = 128; // 10000
\r
1740 TWin.Position.y1 = 256; // 00000
\r
1742 // Texture window size is determined by the least bit set of the relevant 5 bits
\r
1744 if (gdata & 0x001)
\r
1745 TWin.Position.x1 = 8; // xxxx1
\r
1746 else if (gdata & 0x002)
\r
1747 TWin.Position.x1 = 16; // xxx10
\r
1748 else if (gdata & 0x004)
\r
1749 TWin.Position.x1 = 32; // xx100
\r
1750 else if (gdata & 0x008)
\r
1751 TWin.Position.x1 = 64; // x1000
\r
1752 else if (gdata & 0x010)
\r
1753 TWin.Position.x1 = 128; // 10000
\r
1755 TWin.Position.x1 = 256; // 00000
\r
1757 // Re-calculate the bit field, because we can't trust what is passed in the data
\r
1759 YAlign = (unsigned long)(32 - (TWin.Position.y1 >> 3));
\r
1760 XAlign = (unsigned long)(32 - (TWin.Position.x1 >> 3));
\r
1762 // Absolute position of the start of the texture window
\r
1764 TWin.Position.y0 = (short)(((gdata >> 15) & YAlign) << 3);
\r
1765 TWin.Position.x0 = (short)(((gdata >> 10) & XAlign) << 3);
\r
1767 if((TWin.Position.x0 == 0 && // tw turned off
\r
1768 TWin.Position.y0 == 0 &&
\r
1769 TWin.Position.x1 == 0 &&
\r
1770 TWin.Position.y1 == 0) ||
\r
1771 (TWin.Position.x1 == 256 &&
\r
1772 TWin.Position.y1 == 256))
\r
1774 bUsingTWin = FALSE; // -> just do it
\r
1777 TWin.UScaleFactor = 1.0f;
\r
1778 TWin.VScaleFactor = 1.0f;
\r
1780 TWin.UScaleFactor =
\r
1781 TWin.VScaleFactor = 1.0f/256.0f;
\r
1784 else // tw turned on
\r
1786 bUsingTWin = TRUE;
\r
1788 TWin.OPosition.y1 = TWin.Position.y1; // -> get psx sizes
\r
1789 TWin.OPosition.x1 = TWin.Position.x1;
\r
1791 if(TWin.Position.x1<=2) TWin.Position.x1=2; // -> set OGL sizes
\r
1793 if(TWin.Position.x1<=4) TWin.Position.x1=4;
\r
1795 if(TWin.Position.x1<=8) TWin.Position.x1=8;
\r
1797 if(TWin.Position.x1<=16) TWin.Position.x1=16;
\r
1799 if(TWin.Position.x1<=32) TWin.Position.x1=32;
\r
1801 if(TWin.Position.x1<=64) TWin.Position.x1=64;
\r
1803 if(TWin.Position.x1<=128) TWin.Position.x1=128;
\r
1805 if(TWin.Position.x1<=256) TWin.Position.x1=256;
\r
1807 if(TWin.Position.y1<=2) TWin.Position.y1=2;
\r
1809 if(TWin.Position.y1<=4) TWin.Position.y1=4;
\r
1811 if(TWin.Position.y1<=8) TWin.Position.y1=8;
\r
1813 if(TWin.Position.y1<=16) TWin.Position.y1=16;
\r
1815 if(TWin.Position.y1<=32) TWin.Position.y1=32;
\r
1817 if(TWin.Position.y1<=64) TWin.Position.y1=64;
\r
1819 if(TWin.Position.y1<=128) TWin.Position.y1=128;
\r
1821 if(TWin.Position.y1<=256) TWin.Position.y1=256;
\r
1824 TWin.UScaleFactor = (float)TWin.Position.x1;
\r
1825 TWin.VScaleFactor = (float)TWin.Position.y1;
\r
1827 TWin.UScaleFactor = ((float)TWin.Position.x1)/256.0f; // -> set scale factor
\r
1828 TWin.VScaleFactor = ((float)TWin.Position.y1)/256.0f;
\r
1833 ////////////////////////////////////////////////////////////////////////
\r
1834 // mmm, Lewpy uses that in TileS ... I don't ;)
\r
1835 ////////////////////////////////////////////////////////////////////////
\r
1838 void ClampToPSXDrawAreaOffset(short *x0, short *y0, short *x1, short *y1)
\r
1840 if (*x0 < PSXDisplay.DrawArea.x0)
\r
1842 *x1 -= (PSXDisplay.DrawArea.x0 - *x0);
\r
1843 *x0 = PSXDisplay.DrawArea.x0;
\r
1846 if (*x0 > PSXDisplay.DrawArea.x1)
\r
1848 *x0 = PSXDisplay.DrawArea.x1;
\r
1852 if (*y0 < PSXDisplay.DrawArea.y0)
\r
1854 *y1 -= (PSXDisplay.DrawArea.y0 - *y0);
\r
1855 *y0 = PSXDisplay.DrawArea.y0;
\r
1858 if (*y0 > PSXDisplay.DrawArea.y1)
\r
1860 *y0 = PSXDisplay.DrawArea.y1;
\r
1864 if (*x1 < 0) *x1 = 0;
\r
1866 if ((*x1 + *x0) > PSXDisplay.DrawArea.x1)
\r
1867 *x1 = (PSXDisplay.DrawArea.x1 - *x0 + 1);
\r
1869 if (*y1 < 0) *y1 = 0;
\r
1871 if ((*y1 + *y0) > PSXDisplay.DrawArea.y1)
\r
1872 *y1 = (PSXDisplay.DrawArea.y1 - *y0 + 1);
\r
1876 ////////////////////////////////////////////////////////////////////////
\r
1877 // Check draw area dimensions
\r
1878 ////////////////////////////////////////////////////////////////////////
\r
1880 void ClampToPSXScreen(short *x0, short *y0, short *x1, short *y1)
\r
1882 if (*x0 < 0) *x0 = 0;
\r
1884 if (*x0 > 1023) *x0 = 1023;
\r
1886 if (*x1 < 0) *x1 = 0;
\r
1888 if (*x1 > 1023) *x1 = 1023;
\r
1890 if (*y0 < 0) *y0 = 0;
\r
1892 if (*y0 > iGPUHeightMask) *y0 = iGPUHeightMask;
\r
1894 if (*y1 < 0) *y1 = 0;
\r
1896 if (*y1 > iGPUHeightMask) *y1 = iGPUHeightMask;
\r
1899 ////////////////////////////////////////////////////////////////////////
\r
1900 // Used in Load Image and Blk Fill
\r
1901 ////////////////////////////////////////////////////////////////////////
\r
1903 void ClampToPSXScreenOffset(short *x0, short *y0, short *x1, short *y1)
\r
1906 { *x1 += *x0; *x0 = 0; }
\r
1909 { *x0 = 1023; *x1 = 0; }
\r
1912 { *y1 += *y0; *y0 = 0; }
\r
1914 if (*y0 > iGPUHeightMask)
\r
1915 { *y0 = iGPUHeightMask; *y1 = 0; }
\r
1917 if (*x1 < 0) *x1 = 0;
\r
1919 if ((*x1 + *x0) > 1024) *x1 = (1024 - *x0);
\r
1921 if (*y1 < 0) *y1 = 0;
\r
1923 if ((*y1 + *y0) > iGPUHeight) *y1 = (iGPUHeight - *y0);
\r
1926 ////////////////////////////////////////////////////////////////////////
\r
1927 // cmd: start of drawing area... primitives will be clipped inside
\r
1928 ////////////////////////////////////////////////////////////////////////
\r
1930 void cmdDrawAreaStart(unsigned char * baseAddr)
\r
1932 unsigned long gdata = ((unsigned long*)baseAddr)[0];
\r
1934 drawX = gdata & 0x3ff; // for soft drawing
\r
1935 if(drawX>=1024) drawX=1023;
\r
1937 if(dwGPUVersion==2)
\r
1939 ulGPUInfoVals[INFO_DRAWSTART]=gdata&0x3FFFFF;
\r
1940 drawY = (gdata>>12)&0x3ff;
\r
1944 ulGPUInfoVals[INFO_DRAWSTART]=gdata&0xFFFFF;
\r
1945 drawY = (gdata>>10)&0x3ff;
\r
1948 if(drawY>=iGPUHeight) drawY=iGPUHeightMask;
\r
1950 PreviousPSXDisplay.DrawArea.y0=PSXDisplay.DrawArea.y0;
\r
1951 PreviousPSXDisplay.DrawArea.x0=PSXDisplay.DrawArea.x0;
\r
1953 PSXDisplay.DrawArea.y0 = (short)drawY; // for OGL drawing
\r
1954 PSXDisplay.DrawArea.x0 = (short)drawX;
\r
1957 ////////////////////////////////////////////////////////////////////////
\r
1958 // cmd: end of drawing area... primitives will be clipped inside
\r
1959 ////////////////////////////////////////////////////////////////////////
\r
1961 void cmdDrawAreaEnd(unsigned char * baseAddr)
\r
1963 unsigned long gdata = ((unsigned long*)baseAddr)[0];
\r
1965 drawW = gdata & 0x3ff; // for soft drawing
\r
1966 if(drawW>=1024) drawW=1023;
\r
1968 if(dwGPUVersion==2)
\r
1970 ulGPUInfoVals[INFO_DRAWEND]=gdata&0x3FFFFF;
\r
1971 drawH = (gdata>>12)&0x3ff;
\r
1975 ulGPUInfoVals[INFO_DRAWEND]=gdata&0xFFFFF;
\r
1976 drawH = (gdata>>10)&0x3ff;
\r
1979 if(drawH>=iGPUHeight) drawH=iGPUHeightMask;
\r
1981 PSXDisplay.DrawArea.y1 = (short)drawH; // for OGL drawing
\r
1982 PSXDisplay.DrawArea.x1 = (short)drawW;
\r
1984 ClampToPSXScreen(&PSXDisplay.DrawArea.x0, // clamp
\r
1985 &PSXDisplay.DrawArea.y0,
\r
1986 &PSXDisplay.DrawArea.x1,
\r
1987 &PSXDisplay.DrawArea.y1);
\r
1989 bDisplayNotSet = TRUE;
\r
1992 ////////////////////////////////////////////////////////////////////////
\r
1993 // cmd: draw offset... will be added to prim coords
\r
1994 ////////////////////////////////////////////////////////////////////////
\r
1996 void cmdDrawOffset(unsigned char * baseAddr)
\r
1998 unsigned long gdata = ((unsigned long*)baseAddr)[0];
\r
2000 PreviousPSXDisplay.DrawOffset.x =
\r
2001 PSXDisplay.DrawOffset.x = (short)(gdata & 0x7ff);
\r
2003 if(dwGPUVersion==2)
\r
2005 ulGPUInfoVals[INFO_DRAWOFF]=gdata&0x7FFFFF;
\r
2006 PSXDisplay.DrawOffset.y = (short)((gdata>>12) & 0x7ff);
\r
2010 ulGPUInfoVals[INFO_DRAWOFF]=gdata&0x3FFFFF;
\r
2011 PSXDisplay.DrawOffset.y = (short)((gdata>>11) & 0x7ff);
\r
2014 PSXDisplay.DrawOffset.x=(short)(((int)PSXDisplay.DrawOffset.x<<21)>>21);
\r
2015 PSXDisplay.DrawOffset.y=(short)(((int)PSXDisplay.DrawOffset.y<<21)>>21);
\r
2017 PSXDisplay.CumulOffset.x = // new OGL prim offsets
\r
2018 PSXDisplay.DrawOffset.x - PSXDisplay.GDrawOffset.x + PreviousPSXDisplay.Range.x0;
\r
2019 PSXDisplay.CumulOffset.y =
\r
2020 PSXDisplay.DrawOffset.y - PSXDisplay.GDrawOffset.y + PreviousPSXDisplay.Range.y0;
\r
2023 ////////////////////////////////////////////////////////////////////////
\r
2024 // cmd: load image to vram
\r
2025 ////////////////////////////////////////////////////////////////////////
\r
2027 void primLoadImage(unsigned char * baseAddr)
\r
2029 unsigned short *sgpuData = ((unsigned short *) baseAddr);
\r
2031 VRAMWrite.x = sgpuData[2]&0x03ff;
\r
2032 VRAMWrite.y = sgpuData[3]&iGPUHeightMask;
\r
2033 VRAMWrite.Width = sgpuData[4];
\r
2034 VRAMWrite.Height = sgpuData[5];
\r
2036 iDataWriteMode = DR_VRAMTRANSFER;
\r
2037 VRAMWrite.ImagePtr = psxVuw + (VRAMWrite.y<<10) + VRAMWrite.x;
\r
2038 VRAMWrite.RowsRemaining = VRAMWrite.Width;
\r
2039 VRAMWrite.ColsRemaining = VRAMWrite.Height;
\r
2041 bNeedWriteUpload=TRUE;
\r
2044 ////////////////////////////////////////////////////////////////////////
\r
2046 void PrepareRGB24Upload(void)
\r
2048 VRAMWrite.x=(VRAMWrite.x*2)/3;
\r
2049 VRAMWrite.Width=(VRAMWrite.Width*2)/3;
\r
2051 if(!PSXDisplay.InterlacedTest && // NEW
\r
2052 CheckAgainstScreen(VRAMWrite.x, VRAMWrite.y, VRAMWrite.Width, VRAMWrite.Height))
\r
2054 xrUploadArea.x0-=PreviousPSXDisplay.DisplayPosition.x;
\r
2055 xrUploadArea.x1-=PreviousPSXDisplay.DisplayPosition.x;
\r
2056 xrUploadArea.y0-=PreviousPSXDisplay.DisplayPosition.y;
\r
2057 xrUploadArea.y1-=PreviousPSXDisplay.DisplayPosition.y;
\r
2060 if(CheckAgainstFrontScreen(VRAMWrite.x, VRAMWrite.y, VRAMWrite.Width, VRAMWrite.Height))
\r
2062 xrUploadArea.x0-=PSXDisplay.DisplayPosition.x;
\r
2063 xrUploadArea.x1-=PSXDisplay.DisplayPosition.x;
\r
2064 xrUploadArea.y0-=PSXDisplay.DisplayPosition.y;
\r
2065 xrUploadArea.y1-=PSXDisplay.DisplayPosition.y;
\r
2069 if(bRenderFrontBuffer)
\r
2071 updateFrontDisplay();
\r
2074 if(bNeedRGB24Update==FALSE)
\r
2076 xrUploadAreaRGB24=xrUploadArea;
\r
2077 bNeedRGB24Update=TRUE;
\r
2081 xrUploadAreaRGB24.x0=min(xrUploadAreaRGB24.x0,xrUploadArea.x0);
\r
2082 xrUploadAreaRGB24.x1=max(xrUploadAreaRGB24.x1,xrUploadArea.x1);
\r
2083 xrUploadAreaRGB24.y0=min(xrUploadAreaRGB24.y0,xrUploadArea.y0);
\r
2084 xrUploadAreaRGB24.y1=max(xrUploadAreaRGB24.y1,xrUploadArea.y1);
\r
2088 ////////////////////////////////////////////////////////////////////////
\r
2090 void CheckWriteUpdate()
\r
2094 if(VRAMWrite.Width) iX=1;
\r
2095 if(VRAMWrite.Height) iY=1;
\r
2097 InvalidateTextureArea(VRAMWrite.x, VRAMWrite.y, VRAMWrite.Width-iX, VRAMWrite.Height-iY);
\r
2099 if(PSXDisplay.Interlaced && !iOffscreenDrawing) return;
\r
2101 if(PSXDisplay.RGB24) {PrepareRGB24Upload();return;}
\r
2103 if(!PSXDisplay.InterlacedTest &&
\r
2104 CheckAgainstScreen(VRAMWrite.x, VRAMWrite.y, VRAMWrite.Width, VRAMWrite.Height))
\r
2106 if(dwActFixes&0x800) return;
\r
2108 if(bRenderFrontBuffer)
\r
2110 updateFrontDisplay();
\r
2113 UploadScreen(FALSE);
\r
2115 bNeedUploadTest=TRUE;
\r
2118 if(iOffscreenDrawing)
\r
2120 if (CheckAgainstFrontScreen(VRAMWrite.x, VRAMWrite.y, VRAMWrite.Width, VRAMWrite.Height))
\r
2122 if(PSXDisplay.InterlacedTest)
\r
2124 if(PreviousPSXDisplay.InterlacedNew)
\r
2126 PreviousPSXDisplay.InterlacedNew=FALSE;
\r
2127 bNeedInterlaceUpdate=TRUE;
\r
2128 xrUploadAreaIL.x0=PSXDisplay.DisplayPosition.x;
\r
2129 xrUploadAreaIL.y0=PSXDisplay.DisplayPosition.y;
\r
2130 xrUploadAreaIL.x1=PSXDisplay.DisplayPosition.x+PSXDisplay.DisplayModeNew.x;
\r
2131 xrUploadAreaIL.y1=PSXDisplay.DisplayPosition.y+PSXDisplay.DisplayModeNew.y;
\r
2132 if(xrUploadAreaIL.x1>1023) xrUploadAreaIL.x1=1023;
\r
2133 if(xrUploadAreaIL.y1>511) xrUploadAreaIL.y1=511;
\r
2136 if(bNeedInterlaceUpdate==FALSE)
\r
2138 xrUploadAreaIL=xrUploadArea;
\r
2139 bNeedInterlaceUpdate=TRUE;
\r
2143 xrUploadAreaIL.x0=min(xrUploadAreaIL.x0,xrUploadArea.x0);
\r
2144 xrUploadAreaIL.x1=max(xrUploadAreaIL.x1,xrUploadArea.x1);
\r
2145 xrUploadAreaIL.y0=min(xrUploadAreaIL.y0,xrUploadArea.y0);
\r
2146 xrUploadAreaIL.y1=max(xrUploadAreaIL.y1,xrUploadArea.y1);
\r
2151 if(!bNeedUploadAfter)
\r
2153 bNeedUploadAfter = TRUE;
\r
2154 xrUploadArea.x0=VRAMWrite.x;
\r
2155 xrUploadArea.x1=VRAMWrite.x+VRAMWrite.Width;
\r
2156 xrUploadArea.y0=VRAMWrite.y;
\r
2157 xrUploadArea.y1=VRAMWrite.y+VRAMWrite.Height;
\r
2161 xrUploadArea.x0=min(xrUploadArea.x0,VRAMWrite.x);
\r
2162 xrUploadArea.x1=max(xrUploadArea.x1,VRAMWrite.x+VRAMWrite.Width);
\r
2163 xrUploadArea.y0=min(xrUploadArea.y0,VRAMWrite.y);
\r
2164 xrUploadArea.y1=max(xrUploadArea.y1,VRAMWrite.y+VRAMWrite.Height);
\r
2167 if(dwActFixes&0x8000)
\r
2169 if((xrUploadArea.x1-xrUploadArea.x0)>=(PSXDisplay.DisplayMode.x-32) &&
\r
2170 (xrUploadArea.y1-xrUploadArea.y0)>=(PSXDisplay.DisplayMode.y-32))
\r
2173 updateFrontDisplay();
\r
2180 ////////////////////////////////////////////////////////////////////////
\r
2181 // cmd: vram -> psx mem
\r
2182 ////////////////////////////////////////////////////////////////////////
\r
2184 void primStoreImage(unsigned char * baseAddr)
\r
2186 unsigned short *sgpuData = ((unsigned short *) baseAddr);
\r
2188 VRAMRead.x = sgpuData[2]&0x03ff;
\r
2189 VRAMRead.y = sgpuData[3]&iGPUHeightMask;
\r
2190 VRAMRead.Width = sgpuData[4];
\r
2191 VRAMRead.Height = sgpuData[5];
\r
2193 VRAMRead.ImagePtr = psxVuw + (VRAMRead.y<<10) + VRAMRead.x;
\r
2194 VRAMRead.RowsRemaining = VRAMRead.Width;
\r
2195 VRAMRead.ColsRemaining = VRAMRead.Height;
\r
2197 iDataReadMode = DR_VRAMTRANSFER;
\r
2199 STATUSREG |= GPUSTATUS_READYFORVRAM;
\r
2202 ////////////////////////////////////////////////////////////////////////
\r
2203 // cmd: blkfill - NO primitive! Doesn't care about draw areas...
\r
2204 ////////////////////////////////////////////////////////////////////////
\r
2206 void primBlkFill(unsigned char * baseAddr)
\r
2208 unsigned long *gpuData = ((unsigned long *) baseAddr);
\r
2209 short *sgpuData = ((short *) baseAddr);
\r
2211 iDrawnSomething=1;
\r
2213 sprtX = sgpuData[2];
\r
2214 sprtY = sgpuData[3];
\r
2215 sprtW = sgpuData[4] & 0x3ff;
\r
2216 sprtH = sgpuData[5] & iGPUHeightMask;
\r
2218 sprtW = (sprtW+15) & ~15;
\r
2220 // Increase H & W if they are one short of full values, because they never can be full values
\r
2221 if (sprtH == iGPUHeightMask) sprtH=iGPUHeight;
\r
2222 if (sprtW == 1023) sprtW=1024;
\r
2224 // x and y of start
\r
2225 ly0 = ly1 = sprtY;
\r
2226 ly2 = ly3 = (sprtY+sprtH);
\r
2227 lx0 = lx3 = sprtX;
\r
2228 lx1 = lx2 = (sprtX+sprtW);
\r
2232 if(ClipVertexListScreen())
\r
2234 PSXDisplay_t * pd;
\r
2235 if(PSXDisplay.InterlacedTest) pd=&PSXDisplay;
\r
2236 else pd=&PreviousPSXDisplay;
\r
2238 if ((lx0 <= pd->DisplayPosition.x+16) &&
\r
2239 (ly0 <= pd->DisplayPosition.y+16) &&
\r
2240 (lx2 >= pd->DisplayEnd.x-16) &&
\r
2241 (ly2 >= pd->DisplayEnd.y-16))
\r
2244 g=((GLclampf)GREEN(gpuData[0]))/255.0f;
\r
2245 b=((GLclampf)BLUE(gpuData[0]))/255.0f;
\r
2246 r=((GLclampf)RED(gpuData[0]))/255.0f;
\r
2248 glDisable(GL_SCISSOR_TEST);
\r
2249 glClearColor(r,g,b,1.0f);
\r
2250 glClear(uiBufferBits);
\r
2253 if(gpuData[0]!=0x02000000 &&
\r
2254 (ly0>pd->DisplayPosition.y ||
\r
2255 ly2<pd->DisplayEnd.y))
\r
2257 bDrawTextured = FALSE;
\r
2258 bDrawSmoothShaded = FALSE;
\r
2259 SetRenderState((unsigned long)0x01000000);
\r
2260 SetRenderMode((unsigned long)0x01000000, FALSE);
\r
2261 vertex[0].c.lcol=0xff000000;
\r
2262 SETCOL(vertex[0]);
\r
2263 if(ly0>pd->DisplayPosition.y)
\r
2265 vertex[0].x=0;vertex[0].y=0;
\r
2266 vertex[1].x=pd->DisplayEnd.x-pd->DisplayPosition.x;vertex[1].y=0;
\r
2267 vertex[2].x=vertex[1].x;vertex[2].y=ly0-pd->DisplayPosition.y;
\r
2268 vertex[3].x=0;vertex[3].y=vertex[2].y;
\r
2269 PRIMdrawQuad(&vertex[0], &vertex[1], &vertex[2], &vertex[3]);
\r
2271 if(ly2<pd->DisplayEnd.y)
\r
2273 vertex[0].x=0;vertex[0].y=(pd->DisplayEnd.y-pd->DisplayPosition.y)-(pd->DisplayEnd.y-ly2);
\r
2274 vertex[1].x=pd->DisplayEnd.x-pd->DisplayPosition.x;vertex[1].y=vertex[0].y;
\r
2275 vertex[2].x=vertex[1].x;vertex[2].y=pd->DisplayEnd.y;
\r
2276 vertex[3].x=0;vertex[3].y=vertex[2].y;
\r
2277 PRIMdrawQuad(&vertex[0], &vertex[1], &vertex[2], &vertex[3]);
\r
2281 glEnable(GL_SCISSOR_TEST);
\r
2285 bDrawTextured = FALSE;
\r
2286 bDrawSmoothShaded = FALSE;
\r
2287 SetRenderState((unsigned long)0x01000000);
\r
2288 SetRenderMode((unsigned long)0x01000000, FALSE);
\r
2289 vertex[0].c.lcol=gpuData[0]|0xff000000;
\r
2290 SETCOL(vertex[0]);
\r
2291 glDisable(GL_SCISSOR_TEST);
\r
2292 PRIMdrawQuad(&vertex[0], &vertex[1], &vertex[2], &vertex[3]);
\r
2293 glEnable(GL_SCISSOR_TEST);
\r
2297 //mmm... will clean all stuff, also if not all _should_ be cleaned...
\r
2298 //if (IsInsideNextScreen(sprtX, sprtY, sprtW, sprtH))
\r
2300 if (IsCompleteInsideNextScreen(sprtX, sprtY, sprtW, sprtH))
\r
2302 lClearOnSwapColor = COLOR(gpuData[0]);
\r
2306 /* if(iOffscreenDrawing)
\r
2308 ClampToPSXScreenOffset( &sprtX, &sprtY, &sprtW, &sprtH);
\r
2309 if ((sprtW == 0) || (sprtH == 0)) return;
\r
2310 InvalidateTextureArea(sprtX, sprtY, sprtW-1, sprtH-1);
\r
2315 FillSoftwareArea(sprtX, sprtY, sprtW, sprtH, BGR24to16(gpuData[0]));
\r
2319 ////////////////////////////////////////////////////////////////////////
\r
2320 // cmd: move image vram -> vram
\r
2321 ////////////////////////////////////////////////////////////////////////
\r
2323 void MoveImageWrapped(short imageX0,short imageY0,
\r
2324 short imageX1,short imageY1,
\r
2325 short imageSX,short imageSY)
\r
2327 int i,j,imageXE,imageYE;
\r
2329 if(iFrameReadType&2)
\r
2331 imageXE=imageX0+imageSX;
\r
2332 imageYE=imageY0+imageSY;
\r
2334 if(imageYE>iGPUHeight && imageXE>1024)
\r
2336 CheckVRamRead(0,0,
\r
2338 (imageY0&iGPUHeightMask),
\r
2344 CheckVRamRead(0,imageY0,
\r
2346 (imageYE>iGPUHeight)?iGPUHeight:imageYE,
\r
2350 if(imageYE>iGPUHeight)
\r
2352 CheckVRamRead(imageX0,0,
\r
2353 (imageXE>1024)?1024:imageXE,
\r
2354 imageYE&iGPUHeightMask,
\r
2358 CheckVRamRead(imageX0,imageY0,
\r
2359 (imageXE>1024)?1024:imageXE,
\r
2360 (imageYE>iGPUHeight)?iGPUHeight:imageYE,
\r
2364 for(j=0;j<imageSY;j++)
\r
2365 for(i=0;i<imageSX;i++)
\r
2366 psxVuw [(1024*((imageY1+j)&iGPUHeightMask))+((imageX1+i)&0x3ff)]=
\r
2367 psxVuw[(1024*((imageY0+j)&iGPUHeightMask))+((imageX0+i)&0x3ff)];
\r
2369 if(!PSXDisplay.RGB24)
\r
2371 imageXE=imageX1+imageSX;
\r
2372 imageYE=imageY1+imageSY;
\r
2374 if(imageYE>iGPUHeight && imageXE>1024)
\r
2376 InvalidateTextureArea(0,0,
\r
2377 (imageXE&0x3ff)-1,
\r
2378 (imageYE&iGPUHeightMask)-1);
\r
2383 InvalidateTextureArea(0,imageY1,
\r
2384 (imageXE&0x3ff)-1,
\r
2385 ((imageYE>iGPUHeight)?iGPUHeight:imageYE)-imageY1-1);
\r
2388 if(imageYE>iGPUHeight)
\r
2390 InvalidateTextureArea(imageX1,0,
\r
2391 ((imageXE>1024)?1024:imageXE)-imageX1-1,
\r
2392 (imageYE&iGPUHeightMask)-1);
\r
2395 InvalidateTextureArea(imageX1,imageY1,
\r
2396 ((imageXE>1024)?1024:imageXE)-imageX1-1,
\r
2397 ((imageYE>iGPUHeight)?iGPUHeight:imageYE)-imageY1-1);
\r
2401 ////////////////////////////////////////////////////////////////////////
\r
2403 void primMoveImage(unsigned char * baseAddr)
\r
2405 short *sgpuData = ((short *) baseAddr);
\r
2406 short imageY0,imageX0,imageY1,imageX1,imageSX,imageSY,i,j;
\r
2408 imageX0 = sgpuData[2]&0x03ff;
\r
2409 imageY0 = sgpuData[3]&iGPUHeightMask;
\r
2410 imageX1 = sgpuData[4]&0x03ff;
\r
2411 imageY1 = sgpuData[5]&iGPUHeightMask;
\r
2412 imageSX = sgpuData[6];
\r
2413 imageSY = sgpuData[7];
\r
2415 if((imageX0 == imageX1) && (imageY0 == imageY1)) return;
\r
2416 if(imageSX<=0) return;
\r
2417 if(imageSY<=0) return;
\r
2419 if(iGPUHeight==1024 && sgpuData[7]>1024) return;
\r
2421 if((imageY0+imageSY)>iGPUHeight ||
\r
2422 (imageX0+imageSX)>1024 ||
\r
2423 (imageY1+imageSY)>iGPUHeight ||
\r
2424 (imageX1+imageSX)>1024)
\r
2426 MoveImageWrapped(imageX0,imageY0,imageX1,imageY1,imageSX,imageSY);
\r
2427 if((imageY0+imageSY)>iGPUHeight) imageSY=iGPUHeight-imageY0;
\r
2428 if((imageX0+imageSX)>1024) imageSX=1024-imageX0;
\r
2429 if((imageY1+imageSY)>iGPUHeight) imageSY=iGPUHeight-imageY1;
\r
2430 if((imageX1+imageSX)>1024) imageSX=1024-imageX1;
\r
2433 if(iFrameReadType&2)
\r
2434 CheckVRamRead(imageX0,imageY0,
\r
2441 unsigned short *SRCPtr, *DSTPtr;
\r
2442 unsigned short LineOffset;
\r
2444 SRCPtr = psxVuw + (1024*imageY0) + imageX0;
\r
2445 DSTPtr = psxVuw + (1024*imageY1) + imageX1;
\r
2447 LineOffset = 1024 - imageSX;
\r
2449 for(j=0;j<imageSY;j++)
\r
2451 for(i=0;i<imageSX;i++) *DSTPtr++ = *SRCPtr++;
\r
2452 SRCPtr += LineOffset;
\r
2453 DSTPtr += LineOffset;
\r
2458 unsigned long *SRCPtr, *DSTPtr;
\r
2459 unsigned short LineOffset;
\r
2460 int dx=imageSX>>1;
\r
2462 SRCPtr = (unsigned long *)(psxVuw + (1024*imageY0) + imageX0);
\r
2463 DSTPtr = (unsigned long *)(psxVuw + (1024*imageY1) + imageX1);
\r
2465 LineOffset = 512 - dx;
\r
2467 for(j=0;j<imageSY;j++)
\r
2469 for(i=0;i<dx;i++) *DSTPtr++ = *SRCPtr++;
\r
2470 SRCPtr += LineOffset;
\r
2471 DSTPtr += LineOffset;
\r
2475 if (!PSXDisplay.RGB24)
\r
2477 InvalidateTextureArea(imageX1,imageY1,imageSX-1,imageSY-1);
\r
2479 if (CheckAgainstScreen(imageX1,imageY1,imageSX,imageSY))
\r
2481 if(imageX1>=PreviousPSXDisplay.DisplayPosition.x &&
\r
2482 imageX1<PreviousPSXDisplay.DisplayEnd.x &&
\r
2483 imageY1>=PreviousPSXDisplay.DisplayPosition.y &&
\r
2484 imageY1<PreviousPSXDisplay.DisplayEnd.y)
\r
2486 imageX1 += imageSX;
\r
2487 imageY1 += imageSY;
\r
2489 if(imageX1>=PreviousPSXDisplay.DisplayPosition.x &&
\r
2490 imageX1<=PreviousPSXDisplay.DisplayEnd.x &&
\r
2491 imageY1>=PreviousPSXDisplay.DisplayPosition.y &&
\r
2492 imageY1<=PreviousPSXDisplay.DisplayEnd.y)
\r
2495 imageX0>=PSXDisplay.DisplayPosition.x &&
\r
2496 imageX0<PSXDisplay.DisplayEnd.x &&
\r
2497 imageY0>=PSXDisplay.DisplayPosition.y &&
\r
2498 imageY0<PSXDisplay.DisplayEnd.y
\r
2501 if(bRenderFrontBuffer)
\r
2503 updateFrontDisplay();
\r
2506 UploadScreen(FALSE);
\r
2508 else bFakeFrontBuffer=TRUE;
\r
2512 bNeedUploadTest=TRUE;
\r
2515 if(iOffscreenDrawing)
\r
2517 if (CheckAgainstFrontScreen(imageX1,imageY1,imageSX,imageSY))
\r
2519 if(!PSXDisplay.InterlacedTest &&
\r
2522 imageX0>=PreviousPSXDisplay.DisplayPosition.x &&
\r
2523 imageX0<PreviousPSXDisplay.DisplayEnd.x &&
\r
2524 imageY0>=PreviousPSXDisplay.DisplayPosition.y &&
\r
2525 imageY0<PreviousPSXDisplay.DisplayEnd.y
\r
2528 imageX0>=PSXDisplay.DisplayPosition.x &&
\r
2529 imageX0<PSXDisplay.DisplayEnd.x &&
\r
2530 imageY0>=PSXDisplay.DisplayPosition.y &&
\r
2531 imageY0<PSXDisplay.DisplayEnd.y
\r
2535 bNeedUploadTest=TRUE;
\r
2537 if(!bNeedUploadAfter)
\r
2539 bNeedUploadAfter = TRUE;
\r
2540 xrUploadArea.x0=imageX0;
\r
2541 xrUploadArea.x1=imageX0+imageSX;
\r
2542 xrUploadArea.y0=imageY0;
\r
2543 xrUploadArea.y1=imageY0+imageSY;
\r
2547 xrUploadArea.x0=min(xrUploadArea.x0,imageX0);
\r
2548 xrUploadArea.x1=max(xrUploadArea.x1,imageX0+imageSX);
\r
2549 xrUploadArea.y0=min(xrUploadArea.y0,imageY0);
\r
2550 xrUploadArea.y1=max(xrUploadArea.y1,imageY0+imageSY);
\r
2558 ////////////////////////////////////////////////////////////////////////
\r
2559 // cmd: draw free-size Tile
\r
2560 ////////////////////////////////////////////////////////////////////////
\r
2562 void primTileS(unsigned char * baseAddr)
\r
2564 unsigned long *gpuData = ((unsigned long*)baseAddr);
\r
2565 short *sgpuData = ((short *) baseAddr);
\r
2567 sprtX = sgpuData[2];
\r
2568 sprtY = sgpuData[3];
\r
2569 sprtW = sgpuData[4] & 0x3ff;
\r
2570 sprtH = sgpuData[5] & iGPUHeightMask;
\r
2572 // x and y of start
\r
2579 if((dwActFixes&1) && // FF7 special game gix (battle cursor)
\r
2580 sprtX==0 && sprtY==0 && sprtW==24 && sprtH==16)
\r
2583 bDrawTextured = FALSE;
\r
2584 bDrawSmoothShaded = FALSE;
\r
2586 SetRenderState(gpuData[0]);
\r
2588 /* if(iOffscreenDrawing)
\r
2590 if(IsPrimCompleteInsideNextScreen(lx0,ly0,lx2,ly2) ||
\r
2591 (ly0==-6 && ly2==10)) // OH MY GOD... I DIDN'T WANT TO DO IT... BUT I'VE FOUND NO OTHER WAY... HACK FOR GRADIUS SHOOTER :(
\r
2593 lClearOnSwapColor = COLOR(gpuData[0]);
\r
2598 if(bDrawOffscreen4())
\r
2600 if(!(iTileCheat && sprtH==32 && gpuData[0]==0x60ffffff)) // special cheat for certain ZiNc games
\r
2602 InvalidateTextureAreaEx();
\r
2603 FillSoftwareAreaTrans(lx0,ly0,lx2,ly2,
\r
2604 BGR24to16(gpuData[0]));
\r
2609 SetRenderMode(gpuData[0], FALSE);
\r
2612 if(bIgnoreNextTile) {bIgnoreNextTile=FALSE;return;}
\r
2614 vertex[0].c.lcol=gpuData[0];
\r
2615 vertex[0].c.col[3]=ubGloColAlpha;
\r
2616 SETCOL(vertex[0]);
\r
2618 PRIMdrawQuad(&vertex[0], &vertex[1], &vertex[2], &vertex[3]);
\r
2620 iDrawnSomething=1;
\r
2623 ////////////////////////////////////////////////////////////////////////
\r
2624 // cmd: draw 1 dot Tile (point)
\r
2625 ////////////////////////////////////////////////////////////////////////
\r
2627 void primTile1(unsigned char * baseAddr)
\r
2629 unsigned long *gpuData = ((unsigned long*)baseAddr);
\r
2630 short *sgpuData = ((short *) baseAddr);
\r
2632 sprtX = sgpuData[2];
\r
2633 sprtY = sgpuData[3];
\r
2642 bDrawTextured = FALSE;
\r
2643 bDrawSmoothShaded = FALSE;
\r
2645 SetRenderState(gpuData[0]);
\r
2647 /* if(iOffscreenDrawing)
\r
2651 if(bDrawOffscreen4())
\r
2653 InvalidateTextureAreaEx();
\r
2654 FillSoftwareAreaTrans(lx0,ly0,lx2,ly2,
\r
2655 BGR24to16(gpuData[0]));
\r
2659 SetRenderMode(gpuData[0], FALSE);
\r
2662 vertex[0].c.lcol=gpuData[0];vertex[0].c.col[3]=ubGloColAlpha;
\r
2663 SETCOL(vertex[0]);
\r
2665 PRIMdrawQuad(&vertex[0], &vertex[1], &vertex[2], &vertex[3]);
\r
2667 iDrawnSomething=1;
\r
2670 ////////////////////////////////////////////////////////////////////////
\r
2671 // cmd: draw 8 dot Tile (small rect)
\r
2672 ////////////////////////////////////////////////////////////////////////
\r
2674 void primTile8(unsigned char * baseAddr)
\r
2676 unsigned long *gpuData = ((unsigned long*)baseAddr);
\r
2677 short *sgpuData = ((short *) baseAddr);
\r
2679 sprtX = sgpuData[2];
\r
2680 sprtY = sgpuData[3];
\r
2689 bDrawTextured = FALSE;
\r
2690 bDrawSmoothShaded = FALSE;
\r
2691 SetRenderState(gpuData[0]);
\r
2693 /* if(iOffscreenDrawing)
\r
2697 if(bDrawOffscreen4())
\r
2699 InvalidateTextureAreaEx();
\r
2700 FillSoftwareAreaTrans(lx0,ly0,lx2,ly2,
\r
2701 BGR24to16(gpuData[0]));
\r
2705 SetRenderMode(gpuData[0], FALSE);
\r
2708 vertex[0].c.lcol=gpuData[0];
\r
2709 vertex[0].c.col[3]=ubGloColAlpha;
\r
2710 SETCOL(vertex[0]);
\r
2712 PRIMdrawQuad(&vertex[0], &vertex[1], &vertex[2], &vertex[3]);
\r
2714 iDrawnSomething=1;
\r
2717 ////////////////////////////////////////////////////////////////////////
\r
2718 // cmd: draw 16 dot Tile (medium rect)
\r
2719 ////////////////////////////////////////////////////////////////////////
\r
2721 void primTile16(unsigned char * baseAddr)
\r
2723 unsigned long *gpuData = ((unsigned long*)baseAddr);
\r
2724 short *sgpuData = ((short *) baseAddr);
\r
2726 sprtX = sgpuData[2];
\r
2727 sprtY = sgpuData[3];
\r
2730 // x and y of start
\r
2736 bDrawTextured = FALSE;
\r
2737 bDrawSmoothShaded = FALSE;
\r
2738 SetRenderState(gpuData[0]);
\r
2740 /* if(iOffscreenDrawing)
\r
2744 if(bDrawOffscreen4())
\r
2746 InvalidateTextureAreaEx();
\r
2747 FillSoftwareAreaTrans(lx0,ly0,lx2,ly2,
\r
2748 BGR24to16(gpuData[0]));
\r
2752 SetRenderMode(gpuData[0], FALSE);
\r
2755 vertex[0].c.lcol=gpuData[0];
\r
2756 vertex[0].c.col[3]=ubGloColAlpha;
\r
2757 SETCOL(vertex[0]);
\r
2759 PRIMdrawQuad(&vertex[0], &vertex[1], &vertex[2], &vertex[3]);
\r
2761 iDrawnSomething=1;
\r
2764 ////////////////////////////////////////////////////////////////////////
\r
2765 // helper: filter effect by multipass rendering
\r
2766 ////////////////////////////////////////////////////////////////////////
\r
2768 /*void DrawMultiBlur(void)
\r
2770 long lABR,lDST;float fx,fy;
\r
2772 lABR=GlobalTextABR;
\r
2773 lDST=DrawSemiTrans;
\r
2775 fx=(float)PSXDisplay.DisplayMode.x/(float)(iResX);
\r
2776 fy=(float)PSXDisplay.DisplayMode.y/(float)(iResY);
\r
2778 vertex[0].x+=fx;vertex[1].x+=fx;
\r
2779 vertex[2].x+=fx;vertex[3].x+=fx;
\r
2785 PRIMdrawTexturedQuad(&vertex[0], &vertex[1], &vertex[2], &vertex[3]);
\r
2787 vertex[0].y+=fy;vertex[1].y+=fy;
\r
2788 vertex[2].y+=fy;vertex[3].y+=fy;
\r
2789 PRIMdrawTexturedQuad(&vertex[0], &vertex[1], &vertex[2], &vertex[3]);
\r
2791 if(bDrawMultiPass) {obm1=obm2=GL_SRC_ALPHA;}
\r
2793 GlobalTextABR=lABR;
\r
2794 DrawSemiTrans=lDST;
\r
2797 ////////////////////////////////////////////////////////////////////////
\r
2799 #define POFF 0.375f
\r
2801 void DrawMultiFilterSprite(void)
\r
2805 if(bUseMultiPass || DrawSemiTrans || ubOpaqueDraw)
\r
2807 PRIMdrawTexturedQuad(&vertex[0], &vertex[1], &vertex[2], &vertex[3]);
\r
2811 lABR=GlobalTextABR;
\r
2812 lDST=DrawSemiTrans;
\r
2813 vertex[0].c.col[3]=ubGloAlpha/2; // -> set color with
\r
2814 SETCOL(vertex[0]); // texture alpha
\r
2815 PRIMdrawTexturedQuad(&vertex[0], &vertex[1], &vertex[2], &vertex[3]);
\r
2816 vertex[0].x+=POFF;vertex[1].x+=POFF;
\r
2817 vertex[2].x+=POFF;vertex[3].x+=POFF;
\r
2818 vertex[0].y+=POFF;vertex[1].y+=POFF;
\r
2819 vertex[2].y+=POFF;vertex[3].y+=POFF;
\r
2823 PRIMdrawTexturedQuad(&vertex[0], &vertex[1], &vertex[2], &vertex[3]);
\r
2824 GlobalTextABR=lABR;
\r
2825 DrawSemiTrans=lDST;
\r
2828 ////////////////////////////////////////////////////////////////////////
\r
2829 // cmd: small sprite (textured rect)
\r
2830 ////////////////////////////////////////////////////////////////////////
\r
2832 void primSprt8(unsigned char * baseAddr)
\r
2834 unsigned long *gpuData = ((unsigned long *) baseAddr);
\r
2835 short *sgpuData = ((short *) baseAddr);
\r
2840 sprtX = sgpuData[2];
\r
2841 sprtY = sgpuData[3];
\r
2850 // do texture stuff
\r
2851 gl_ux[0]=gl_ux[3]=baseAddr[8];//gpuData[2]&0xff;
\r
2853 if(usMirror & 0x1000)
\r
2858 gl_ux[0]=gl_ux[3]=s;
\r
2861 sSprite_ux2=s=gl_ux[0]+sprtW;
\r
2864 gl_ux[1]=gl_ux[2]=s;
\r
2866 gl_vy[0]=gl_vy[1]=baseAddr[9];//(gpuData[2]>>8)&0xff;
\r
2868 if(usMirror & 0x2000)
\r
2873 gl_vy[0]=gl_vy[1]=s;
\r
2876 sSprite_vy2=s=gl_vy[0]+sprtH;
\r
2879 gl_vy[2]=gl_vy[3]=s;
\r
2881 ulClutID=(gpuData[2]>>16);
\r
2883 bDrawTextured = TRUE;
\r
2884 bDrawSmoothShaded = FALSE;
\r
2885 SetRenderState(gpuData[0]);
\r
2887 /* if(iOffscreenDrawing)
\r
2891 if(bDrawOffscreen4())
\r
2893 InvalidateTextureAreaEx();
\r
2894 SetRenderColor(gpuData[0]);
\r
2895 lx0-=PSXDisplay.DrawOffset.x;
\r
2896 ly0-=PSXDisplay.DrawOffset.y;
\r
2898 if(bUsingTWin) DrawSoftwareSpriteTWin(baseAddr,8,8);
\r
2900 if(usMirror) DrawSoftwareSpriteMirror(baseAddr,8,8);
\r
2902 DrawSoftwareSprite(baseAddr,8,8,baseAddr[8],baseAddr[9]);
\r
2906 SetRenderMode(gpuData[0], TRUE);
\r
2909 sSprite_ux2=gl_ux[0]+sprtW;
\r
2910 sSprite_vy2=gl_vy[0]+sprtH;
\r
2912 assignTextureSprite();
\r
2914 if(iFilterType>4)
\r
2915 DrawMultiFilterSprite();
\r
2917 PRIMdrawTexturedQuad(&vertex[0], &vertex[1], &vertex[2], &vertex[3]);
\r
2919 if(bDrawMultiPass)
\r
2921 SetSemiTransMulti(1);
\r
2922 PRIMdrawTexturedQuad(&vertex[0], &vertex[1], &vertex[2], &vertex[3]);
\r
2928 if(bUseMultiPass) SetOpaqueColor(gpuData[0]);
\r
2931 /* if(bSmallAlpha && iFilterType<=2)
\r
2933 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
\r
2934 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
\r
2935 PRIMdrawTexturedQuad(&vertex[0], &vertex[1], &vertex[2], &vertex[3]);
\r
2936 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
\r
2937 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
\r
2941 PRIMdrawTexturedQuad(&vertex[0], &vertex[1], &vertex[2], &vertex[3]);
\r
2946 iDrawnSomething=1;
\r
2949 ////////////////////////////////////////////////////////////////////////
\r
2950 // cmd: medium sprite (textured rect)
\r
2951 ////////////////////////////////////////////////////////////////////////
\r
2953 void primSprt16(unsigned char * baseAddr)
\r
2955 unsigned long *gpuData = ((unsigned long *) baseAddr);
\r
2956 short *sgpuData = ((short *) baseAddr);
\r
2961 sprtX = sgpuData[2];
\r
2962 sprtY = sgpuData[3];
\r
2971 // do texture stuff
\r
2972 gl_ux[0]=gl_ux[3]=baseAddr[8];//gpuData[2]&0xff;
\r
2974 if(usMirror & 0x1000)
\r
2979 gl_ux[0]=gl_ux[3]=s;
\r
2982 sSprite_ux2=s=gl_ux[0]+sprtW;
\r
2985 gl_ux[1]=gl_ux[2]=s;
\r
2987 gl_vy[0]=gl_vy[1]=baseAddr[9];//(gpuData[2]>>8)&0xff;
\r
2989 if(usMirror & 0x2000)
\r
2994 gl_vy[0]=gl_vy[1]=s;
\r
2997 sSprite_vy2=s=gl_vy[0]+sprtH;
\r
3000 gl_vy[2]=gl_vy[3]=s;
\r
3002 ulClutID=(gpuData[2]>>16);
\r
3004 bDrawTextured = TRUE;
\r
3005 bDrawSmoothShaded = FALSE;
\r
3006 SetRenderState(gpuData[0]);
\r
3008 /* if(iOffscreenDrawing)
\r
3012 if(bDrawOffscreen4())
\r
3014 InvalidateTextureAreaEx();
\r
3015 SetRenderColor(gpuData[0]);
\r
3016 lx0-=PSXDisplay.DrawOffset.x;
\r
3017 ly0-=PSXDisplay.DrawOffset.y;
\r
3018 if(bUsingTWin) DrawSoftwareSpriteTWin(baseAddr,16,16);
\r
3020 if(usMirror) DrawSoftwareSpriteMirror(baseAddr,16,16);
\r
3022 DrawSoftwareSprite(baseAddr,16,16,baseAddr[8],baseAddr[9]);
\r
3026 SetRenderMode(gpuData[0], TRUE);
\r
3029 sSprite_ux2=gl_ux[0]+sprtW;
\r
3030 sSprite_vy2=gl_vy[0]+sprtH;
\r
3032 assignTextureSprite();
\r
3034 if(iFilterType>4)
\r
3035 DrawMultiFilterSprite();
\r
3037 PRIMdrawTexturedQuad(&vertex[0], &vertex[1], &vertex[2], &vertex[3]);
\r
3039 if(bDrawMultiPass)
\r
3041 SetSemiTransMulti(1);
\r
3042 PRIMdrawTexturedQuad(&vertex[0], &vertex[1], &vertex[2], &vertex[3]);
\r
3048 if(bUseMultiPass) SetOpaqueColor(gpuData[0]);
\r
3051 /* if(bSmallAlpha && iFilterType<=2)
\r
3053 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
\r
3054 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
\r
3055 PRIMdrawTexturedQuad(&vertex[0], &vertex[1], &vertex[2], &vertex[3]);
\r
3056 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
\r
3057 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
\r
3061 PRIMdrawTexturedQuad(&vertex[0], &vertex[1], &vertex[2], &vertex[3]);
\r
3066 iDrawnSomething=1;
\r
3069 ////////////////////////////////////////////////////////////////////////
\r
3070 // cmd: free-size sprite (textured rect)
\r
3071 ////////////////////////////////////////////////////////////////////////
\r
3073 void primSprtSRest(unsigned char * baseAddr,unsigned short type)
\r
3075 unsigned long *gpuData = ((unsigned long *) baseAddr);
\r
3076 short *sgpuData = ((short *) baseAddr);
\r
3077 short s;unsigned short sTypeRest=0;
\r
3079 sprtX = sgpuData[2];
\r
3080 sprtY = sgpuData[3];
\r
3081 sprtW = sgpuData[6] & 0x3ff;
\r
3082 sprtH = sgpuData[7] & 0x1ff;
\r
3085 // do texture stuff
\r
3089 gl_vy[0]=gl_vy[1]=baseAddr[9];
\r
3090 s=256-baseAddr[8];
\r
3093 gl_ux[0]=gl_ux[3]=0;
\r
3096 gl_ux[0]=gl_ux[3]=baseAddr[8];
\r
3097 s=256-baseAddr[9];
\r
3100 gl_vy[0]=gl_vy[1]=0;
\r
3103 s=256-baseAddr[8];
\r
3106 gl_ux[0]=gl_ux[3]=0;
\r
3107 s=256-baseAddr[9];
\r
3110 gl_vy[0]=gl_vy[1]=0;
\r
3114 gl_vy[0]=gl_vy[1]=baseAddr[9];
\r
3115 s=512-baseAddr[8];
\r
3118 gl_ux[0]=gl_ux[3]=0;
\r
3121 gl_ux[0]=gl_ux[3]=baseAddr[8];
\r
3122 s=512-baseAddr[9];
\r
3125 gl_vy[0]=gl_vy[1]=0;
\r
3128 s=512-baseAddr[8];
\r
3131 gl_ux[0]=gl_ux[3]=0;
\r
3132 s=512-baseAddr[9];
\r
3135 gl_vy[0]=gl_vy[1]=0;
\r
3140 if(usMirror & 0x1000)
\r
3143 s-=sprtW-1;if(s<0) s=0;
\r
3144 gl_ux[0]=gl_ux[3]=s;
\r
3146 if(usMirror & 0x2000)
\r
3149 s-=sprtH-1;if(s<0) {s=0;}
\r
3150 gl_vy[0]=gl_vy[1]=s;
\r
3153 sSprite_ux2=s=gl_ux[0]+sprtW;
\r
3155 gl_ux[1]=gl_ux[2]=s;
\r
3156 sSprite_vy2=s=gl_vy[0]+sprtH;
\r
3158 gl_vy[2]=gl_vy[3]=s;
\r
3162 if(sSprite_ux2>256)
\r
3163 {sprtW=256-gl_ux[0];sSprite_ux2=256;sTypeRest+=1;}
\r
3164 if(sSprite_vy2>256)
\r
3165 {sprtH=256-gl_vy[0];sSprite_vy2=256;sTypeRest+=2;}
\r
3173 ulClutID=(gpuData[2]>>16);
\r
3175 bDrawTextured = TRUE;
\r
3176 bDrawSmoothShaded = FALSE;
\r
3177 SetRenderState(gpuData[0]);
\r
3179 /* if(iOffscreenDrawing)
\r
3183 if(bDrawOffscreen4())
\r
3185 InvalidateTextureAreaEx();
\r
3186 SetRenderColor(gpuData[0]);
\r
3187 lx0-=PSXDisplay.DrawOffset.x;
\r
3188 ly0-=PSXDisplay.DrawOffset.y;
\r
3189 if(bUsingTWin) DrawSoftwareSpriteTWin(baseAddr,sprtW,sprtH);
\r
3191 if(usMirror) DrawSoftwareSpriteMirror(baseAddr,sprtW,sprtH);
\r
3193 DrawSoftwareSprite(baseAddr,sprtW,sprtH,baseAddr[8],baseAddr[9]);
\r
3197 SetRenderMode(gpuData[0], TRUE);
\r
3200 sSprite_ux2=gl_ux[0]+sprtW;
\r
3201 sSprite_vy2=gl_vy[0]+sprtH;
\r
3203 assignTextureSprite();
\r
3205 if(iFilterType>4)
\r
3206 DrawMultiFilterSprite();
\r
3208 PRIMdrawTexturedQuad(&vertex[0], &vertex[1], &vertex[2], &vertex[3]);
\r
3210 if(bDrawMultiPass)
\r
3212 SetSemiTransMulti(1);
\r
3213 PRIMdrawTexturedQuad(&vertex[0], &vertex[1], &vertex[2], &vertex[3]);
\r
3219 if(bUseMultiPass) SetOpaqueColor(gpuData[0]);
\r
3222 /* if(bSmallAlpha && iFilterType<=2)
\r
3224 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
\r
3225 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
\r
3226 PRIMdrawTexturedQuad(&vertex[0], &vertex[1], &vertex[2], &vertex[3]);
\r
3227 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
\r
3228 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
\r
3232 PRIMdrawTexturedQuad(&vertex[0], &vertex[1], &vertex[2], &vertex[3]);
\r
3236 if(sTypeRest && type<4)
\r
3238 if(sTypeRest&1 && type==1) primSprtSRest(baseAddr,4);
\r
3239 if(sTypeRest&2 && type==2) primSprtSRest(baseAddr,5);
\r
3240 if(sTypeRest==3 && type==3) primSprtSRest(baseAddr,6);
\r
3244 void primSprtS(unsigned char * baseAddr)
\r
3246 unsigned long *gpuData = ((unsigned long *) baseAddr);
\r
3247 short *sgpuData = ((short *) baseAddr);
\r
3249 short s;unsigned short sTypeRest=0;
\r
3251 sprtX = sgpuData[2];
\r
3252 sprtY = sgpuData[3];
\r
3253 sprtW = sgpuData[6] & 0x3ff;
\r
3254 sprtH = sgpuData[7] & 0x1ff;
\r
3256 if(!sprtH) return;
\r
3257 if(!sprtW) return;
\r
3261 // do texture stuff
\r
3262 gl_ux[0]=gl_ux[3]=baseAddr[8];//gpuData[2]&0xff;
\r
3263 gl_vy[0]=gl_vy[1]=baseAddr[9];//(gpuData[2]>>8)&0xff;
\r
3265 if(usMirror & 0x1000)
\r
3270 gl_ux[0]=gl_ux[3]=s;
\r
3272 if(usMirror & 0x2000)
\r
3277 gl_vy[0]=gl_vy[1]=s;
\r
3280 sSprite_ux2=s=gl_ux[0]+sprtW;
\r
3283 gl_ux[1]=gl_ux[2]=s;
\r
3284 sSprite_vy2=s=gl_vy[0]+sprtH;
\r
3287 gl_vy[2]=gl_vy[3]=s;
\r
3291 if(sSprite_ux2>256)
\r
3292 {sprtW=256-gl_ux[0];sSprite_ux2=256;sTypeRest+=1;}
\r
3293 if(sSprite_vy2>256)
\r
3294 {sprtH=256-gl_vy[0];sSprite_vy2=256;sTypeRest+=2;}
\r
3302 ulClutID=(gpuData[2]>>16);
\r
3304 bDrawTextured = TRUE;
\r
3305 bDrawSmoothShaded = FALSE;
\r
3306 SetRenderState(gpuData[0]);
\r
3308 /* if(iOffscreenDrawing)
\r
3312 if(bDrawOffscreen4())
\r
3314 InvalidateTextureAreaEx();
\r
3315 SetRenderColor(gpuData[0]);
\r
3316 lx0-=PSXDisplay.DrawOffset.x;
\r
3317 ly0-=PSXDisplay.DrawOffset.y;
\r
3318 if(bUsingTWin) DrawSoftwareSpriteTWin(baseAddr,sprtW,sprtH);
\r
3320 if(usMirror) DrawSoftwareSpriteMirror(baseAddr,sprtW,sprtH);
\r
3322 DrawSoftwareSprite(baseAddr,sprtW,sprtH,baseAddr[8],baseAddr[9]);
\r
3326 SetRenderMode(gpuData[0], TRUE);
\r
3329 if((dwActFixes&1) && gTexFrameName && gTexName==gTexFrameName)
\r
3330 {iSpriteTex=0;return;}
\r
3332 sSprite_ux2=gl_ux[0]+sprtW;
\r
3333 sSprite_vy2=gl_vy[0]+sprtH;
\r
3335 assignTextureSprite();
\r
3337 if(iFilterType>4)
\r
3338 DrawMultiFilterSprite();
\r
3340 PRIMdrawTexturedQuad(&vertex[0], &vertex[1], &vertex[2], &vertex[3]);
\r
3342 if(bDrawMultiPass)
\r
3344 SetSemiTransMulti(1);
\r
3345 PRIMdrawTexturedQuad(&vertex[0], &vertex[1], &vertex[2], &vertex[3]);
\r
3351 if(bUseMultiPass) SetOpaqueColor(gpuData[0]);
\r
3354 /* if(bSmallAlpha && iFilterType<=2)
\r
3356 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
\r
3357 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
\r
3358 PRIMdrawTexturedQuad(&vertex[0], &vertex[1], &vertex[2], &vertex[3]);
\r
3359 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
\r
3360 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
\r
3364 PRIMdrawTexturedQuad(&vertex[0], &vertex[1], &vertex[2], &vertex[3]);
\r
3370 if(sTypeRest&1) primSprtSRest(baseAddr,1);
\r
3371 if(sTypeRest&2) primSprtSRest(baseAddr,2);
\r
3372 if(sTypeRest==3) primSprtSRest(baseAddr,3);
\r
3376 iDrawnSomething=1;
\r
3379 ////////////////////////////////////////////////////////////////////////
\r
3380 // cmd: flat shaded Poly4
\r
3381 ////////////////////////////////////////////////////////////////////////
\r
3383 void primPolyF4(unsigned char *baseAddr)
\r
3385 unsigned long *gpuData = ((unsigned long *) baseAddr);
\r
3386 short *sgpuData = ((short *) baseAddr);
\r
3388 lx0 = sgpuData[2];
\r
3389 ly0 = sgpuData[3];
\r
3390 lx1 = sgpuData[4];
\r
3391 ly1 = sgpuData[5];
\r
3392 lx2 = sgpuData[6];
\r
3393 ly2 = sgpuData[7];
\r
3394 lx3 = sgpuData[8];
\r
3395 ly3 = sgpuData[9];
\r
3397 if(offset4()) return;
\r
3399 bDrawTextured = FALSE;
\r
3400 bDrawSmoothShaded = FALSE;
\r
3401 SetRenderState(gpuData[0]);
\r
3403 /* if(iOffscreenDrawing)
\r
3406 if(bDrawOffscreen4())
\r
3408 InvalidateTextureAreaEx();
\r
3409 drawPoly4F(gpuData[0]);
\r
3413 SetRenderMode(gpuData[0], FALSE);
\r
3416 vertex[0].c.lcol=gpuData[0];vertex[0].c.col[3]=ubGloColAlpha;
\r
3417 SETCOL(vertex[0]);
\r
3419 PRIMdrawTri2(&vertex[0], &vertex[1], &vertex[2],&vertex[3]);
\r
3421 iDrawnSomething=1;
\r
3424 ////////////////////////////////////////////////////////////////////////
\r
3425 // cmd: smooth shaded Poly4
\r
3426 ////////////////////////////////////////////////////////////////////////
\r
3428 void primPolyG4(unsigned char * baseAddr);
\r
3430 BOOL bDrawOffscreenFrontFF9G4(void)
\r
3432 if(lx0< PSXDisplay.DisplayPosition.x) return FALSE; // must be complete in front
\r
3433 if(lx0> PSXDisplay.DisplayEnd.x) return FALSE;
\r
3434 if(ly0< PSXDisplay.DisplayPosition.y) return FALSE;
\r
3435 if(ly0> PSXDisplay.DisplayEnd.y) return FALSE;
\r
3436 if(lx1< PSXDisplay.DisplayPosition.x) return FALSE;
\r
3437 if(lx1> PSXDisplay.DisplayEnd.x) return FALSE;
\r
3438 if(ly1< PSXDisplay.DisplayPosition.y) return FALSE;
\r
3439 if(ly1> PSXDisplay.DisplayEnd.y) return FALSE;
\r
3440 if(lx2< PSXDisplay.DisplayPosition.x) return FALSE;
\r
3441 if(lx2> PSXDisplay.DisplayEnd.x) return FALSE;
\r
3442 if(ly2< PSXDisplay.DisplayPosition.y) return FALSE;
\r
3443 if(ly2> PSXDisplay.DisplayEnd.y) return FALSE;
\r
3444 if(lx3< PSXDisplay.DisplayPosition.x) return FALSE;
\r
3445 if(lx3> PSXDisplay.DisplayEnd.x) return FALSE;
\r
3446 if(ly3< PSXDisplay.DisplayPosition.y) return FALSE;
\r
3447 if(ly3> PSXDisplay.DisplayEnd.y) return FALSE;
\r
3451 BOOL bCheckFF9G4(unsigned char * baseAddr)
\r
3453 static unsigned char pFF9G4Cache[32];
\r
3454 static int iFF9Fix=0;
\r
3460 if(bDrawOffscreenFrontFF9G4())
\r
3462 short *sgpuData = ((short *) pFF9G4Cache);
\r
3464 memcpy(pFF9G4Cache,baseAddr,32);
\r
3466 if(sgpuData[2]==142)
\r
3480 long labr=GlobalTextABR;
\r
3482 primPolyG4(pFF9G4Cache);
\r
3483 GlobalTextABR=labr;
\r
3490 ////////////////////////////////////////////////////////////////////////
\r
3492 void primPolyG4(unsigned char * baseAddr)
\r
3494 unsigned long *gpuData = (unsigned long *)baseAddr;
\r
3495 short *sgpuData = ((short *) baseAddr);
\r
3497 lx0 = sgpuData[2];
\r
3498 ly0 = sgpuData[3];
\r
3499 lx1 = sgpuData[6];
\r
3500 ly1 = sgpuData[7];
\r
3501 lx2 = sgpuData[10];
\r
3502 ly2 = sgpuData[11];
\r
3503 lx3 = sgpuData[14];
\r
3504 ly3 = sgpuData[15];
\r
3506 if(offset4()) return;
\r
3508 bDrawTextured = FALSE;
\r
3509 bDrawSmoothShaded = TRUE;
\r
3510 SetRenderState(gpuData[0]);
\r
3512 /* if(iOffscreenDrawing)
\r
3516 if((dwActFixes&512) && bCheckFF9G4(baseAddr)) return;
\r
3518 if(bDrawOffscreen4())
\r
3520 InvalidateTextureAreaEx();
\r
3521 drawPoly4G(gpuData[0], gpuData[2], gpuData[4], gpuData[6]);
\r
3525 SetRenderMode(gpuData[0], FALSE);
\r
3528 vertex[0].c.lcol=gpuData[0];
\r
3529 vertex[1].c.lcol=gpuData[2];
\r
3530 vertex[2].c.lcol=gpuData[4];
\r
3531 vertex[3].c.lcol=gpuData[6];
\r
3533 vertex[0].c.col[3]=vertex[1].c.col[3]=vertex[2].c.col[3]=vertex[3].c.col[3]=ubGloAlpha;
\r
3536 PRIMdrawGouraudTri2Color(&vertex[0],&vertex[1], &vertex[2], &vertex[3]);
\r
3538 iDrawnSomething=1;
\r
3541 ////////////////////////////////////////////////////////////////////////
\r
3542 // cmd: flat shaded Texture3
\r
3543 ////////////////////////////////////////////////////////////////////////
\r
3545 BOOL DoLineCheck(unsigned long * gpuData)
\r
3547 BOOL bQuad=FALSE;short dx,dy;
\r
3551 dx=lx0-lx2;if(dx<0) dx=-dx;
\r
3555 dy=ly1-ly0;if(dy<0) dy=-dy;
\r
3558 vertex[3]=vertex[2];
\r
3559 vertex[2]=vertex[0];
\r
3560 vertex[2].x=vertex[3].x;
\r
3565 vertex[3]=vertex[2];
\r
3566 vertex[2].y=vertex[0].y;
\r
3568 else return FALSE;
\r
3575 dy=ly0-ly1;if(dy<0) dy=-dy;
\r
3578 vertex[3]=vertex[1];
\r
3579 vertex[3].x=vertex[2].x;
\r
3584 vertex[3]=vertex[2];
\r
3585 vertex[3].y=vertex[1].y;
\r
3587 else return FALSE;
\r
3595 dx=lx0-lx1;if(dx<0) dx=-dx;
\r
3599 dy=ly2-ly0;if(dy<0) dy=-dy;
\r
3602 vertex[3]=vertex[1];
\r
3603 vertex[1]=vertex[0];
\r
3604 vertex[1].x=vertex[3].x;
\r
3609 vertex[3]=vertex[1];
\r
3610 vertex[1].y=vertex[0].y;
\r
3612 else return FALSE;
\r
3619 dy=ly2-ly0;if(dy<0) dy=-dy;
\r
3622 vertex[3]=vertex[2];
\r
3623 vertex[3].x=vertex[1].x;
\r
3628 vertex[3]=vertex[1];
\r
3629 vertex[3].y=vertex[2].y;
\r
3631 else return FALSE;
\r
3639 dx=lx1-lx0;if(dx<0) dx=-dx;
\r
3643 dy=ly1-ly2;if(dy<0) dy=-dy;
\r
3647 vertex[3]=vertex[2];
\r
3648 vertex[2].x=vertex[0].x;
\r
3653 vertex[3]=vertex[2];
\r
3654 vertex[2]=vertex[0];
\r
3655 vertex[2].y=vertex[3].y;
\r
3657 else return FALSE;
\r
3664 dy=ly2-ly1;if(dy<0) dy=-dy;
\r
3668 vertex[3]=vertex[1];
\r
3669 vertex[1].x=vertex[0].x;
\r
3674 vertex[3]=vertex[1];
\r
3675 vertex[1]=vertex[0];
\r
3676 vertex[1].y=vertex[3].y;
\r
3678 else return FALSE;
\r
3684 if(!bQuad) return FALSE;
\r
3686 PRIMdrawTexturedQuad(&vertex[0], &vertex[1], &vertex[3], &vertex[2]);
\r
3688 if(bDrawMultiPass)
\r
3690 SetSemiTransMulti(1);
\r
3691 PRIMdrawTexturedQuad(&vertex[0], &vertex[1], &vertex[3], &vertex[2]);
\r
3697 if(bUseMultiPass) SetOpaqueColor(gpuData[0]);
\r
3699 PRIMdrawTexturedQuad(&vertex[0], &vertex[1], &vertex[3], &vertex[2]);
\r
3703 iDrawnSomething=1;
\r
3708 ////////////////////////////////////////////////////////////////////////
\r
3710 void primPolyFT3(unsigned char * baseAddr)
\r
3712 unsigned long *gpuData = ((unsigned long *) baseAddr);
\r
3713 short *sgpuData = ((short *) baseAddr);
\r
3715 lx0 = sgpuData[2];
\r
3716 ly0 = sgpuData[3];
\r
3717 lx1 = sgpuData[6];
\r
3718 ly1 = sgpuData[7];
\r
3719 lx2 = sgpuData[10];
\r
3720 ly2 = sgpuData[11];
\r
3722 if(offset3()) return;
\r
3724 // do texture UV coordinates stuff
\r
3725 gl_ux[0]=gl_ux[3]=baseAddr[8];//gpuData[2]&0xff;
\r
3726 gl_vy[0]=gl_vy[3]=baseAddr[9];//(gpuData[2]>>8)&0xff;
\r
3727 gl_ux[1]=baseAddr[16];//gpuData[4]&0xff;
\r
3728 gl_vy[1]=baseAddr[17];//(gpuData[4]>>8)&0xff;
\r
3729 gl_ux[2]=baseAddr[24];//gpuData[6]&0xff;
\r
3730 gl_vy[2]=baseAddr[25];//(gpuData[6]>>8)&0xff;
\r
3732 UpdateGlobalTP((unsigned short)(gpuData[4]>>16));
\r
3733 ulClutID=gpuData[2]>>16;
\r
3735 bDrawTextured = TRUE;
\r
3736 bDrawSmoothShaded = FALSE;
\r
3737 SetRenderState(gpuData[0]);
\r
3739 /* if(iOffscreenDrawing)
\r
3742 if(bDrawOffscreen3())
\r
3744 InvalidateTextureAreaEx();
\r
3745 SetRenderColor(gpuData[0]);
\r
3746 drawPoly3FT(baseAddr);
\r
3750 SetRenderMode(gpuData[0], TRUE);
\r
3755 if(!(dwActFixes&0x10))
\r
3757 if(DoLineCheck(gpuData)) return;
\r
3760 PRIMdrawTexturedTri(&vertex[0], &vertex[1], &vertex[2]);
\r
3762 if(bDrawMultiPass)
\r
3764 SetSemiTransMulti(1);
\r
3765 PRIMdrawTexturedTri(&vertex[0], &vertex[1], &vertex[2]);
\r
3771 if(bUseMultiPass) SetOpaqueColor(gpuData[0]);
\r
3773 PRIMdrawTexturedTri(&vertex[0], &vertex[1], &vertex[2]);
\r
3777 iDrawnSomething=1;
\r
3780 ////////////////////////////////////////////////////////////////////////
\r
3781 // cmd: flat shaded Texture4
\r
3782 ////////////////////////////////////////////////////////////////////////
\r
3784 #define ST_FAC 255.99f
\r
3786 void RectTexAlign(void)
\r
3788 int UFlipped = FALSE;
\r
3789 int VFlipped = FALSE;
\r
3791 if(gTexName==gTexFrameName) return;
\r
3795 if(!((lx1==lx3 && ly3==ly2 && lx2==lx0) ||
\r
3796 (lx1==lx2 && ly2==ly3 && lx3==lx0)))
\r
3801 if (vertex[0].tow > vertex[2].tow)
\r
3806 if (vertex[0].tow < vertex[2].tow)
\r
3813 if(!((lx2==lx3 && ly3==ly1 && lx1==lx0) ||
\r
3814 (lx2==lx1 && ly1==ly3 && lx3==lx0)))
\r
3819 if (vertex[0].tow > vertex[1].tow)
\r
3824 if (vertex[0].tow < vertex[1].tow)
\r
3831 if(!((lx3==lx2 && ly2==ly1 && lx1==lx0) ||
\r
3832 (lx3==lx1 && ly1==ly2 && lx2==lx0)))
\r
3837 if (vertex[0].tow > vertex[1].tow)
\r
3842 if (vertex[0].tow < vertex[1].tow)
\r
3852 if (vertex[0].sow > vertex[2].sow)
\r
3857 if (vertex[0].sow < vertex[2].sow)
\r
3866 if (vertex[0].sow > vertex[1].sow)
\r
3871 if (vertex[0].sow < vertex[1].sow)
\r
3880 if (vertex[0].sow > vertex[1].sow)
\r
3885 if (vertex[0].sow < vertex[1].sow)
\r
3898 vertex[2].sow+=0.95f/TWin.UScaleFactor;
\r
3899 vertex[3].sow+=0.95f/TWin.UScaleFactor;
\r
3902 vertex[0].sow+=0.95f/TWin.UScaleFactor;
\r
3903 vertex[1].sow+=0.95f/TWin.UScaleFactor;
\r
3906 vertex[1].sow+=0.95f/TWin.UScaleFactor;
\r
3907 vertex[3].sow+=0.95f/TWin.UScaleFactor;
\r
3910 vertex[0].sow+=0.95f/TWin.UScaleFactor;
\r
3911 vertex[2].sow+=0.95f/TWin.UScaleFactor;
\r
3914 vertex[1].sow+=0.95f/TWin.UScaleFactor;
\r
3915 vertex[2].sow+=0.95f/TWin.UScaleFactor;
\r
3918 vertex[0].sow+=0.95f/TWin.UScaleFactor;
\r
3919 vertex[3].sow+=0.95f/TWin.UScaleFactor;
\r
3928 vertex[2].sow+=1.0f/ST_FAC;
\r
3929 vertex[3].sow+=1.0f/ST_FAC;
\r
3932 vertex[0].sow+=1.0f/ST_FAC;
\r
3933 vertex[1].sow+=1.0f/ST_FAC;
\r
3936 vertex[1].sow+=1.0f/ST_FAC;
\r
3937 vertex[3].sow+=1.0f/ST_FAC;
\r
3940 vertex[0].sow+=1.0f/ST_FAC;
\r
3941 vertex[2].sow+=1.0f/ST_FAC;
\r
3944 vertex[1].sow+=1.0f/ST_FAC;
\r
3945 vertex[2].sow+=1.0f/ST_FAC;
\r
3948 vertex[0].sow+=1.0f/ST_FAC;
\r
3949 vertex[3].sow+=1.0f/ST_FAC;
\r
3959 vertex[2].sow+=1.0f/TWin.UScaleFactor;
\r
3960 vertex[3].sow+=1.0f/TWin.UScaleFactor;
\r
3963 vertex[0].sow+=1.0f/TWin.UScaleFactor;
\r
3964 vertex[1].sow+=1.0f/TWin.UScaleFactor;
\r
3967 vertex[1].sow+=1.0f/TWin.UScaleFactor;
\r
3968 vertex[3].sow+=1.0f/TWin.UScaleFactor;
\r
3971 vertex[0].sow+=1.0f/TWin.UScaleFactor;
\r
3972 vertex[2].sow+=1.0f/TWin.UScaleFactor;
\r
3975 vertex[1].sow+=1.0f/TWin.UScaleFactor;
\r
3976 vertex[2].sow+=1.0f/TWin.UScaleFactor;
\r
3979 vertex[0].sow+=1.0f/TWin.UScaleFactor;
\r
3980 vertex[3].sow+=1.0f/TWin.UScaleFactor;
\r
3989 vertex[2].sow+=1.0f;
\r
3990 vertex[3].sow+=1.0f;
\r
3993 vertex[0].sow+=1.0f;
\r
3994 vertex[1].sow+=1.0f;
\r
3997 vertex[1].sow+=1.0f;
\r
3998 vertex[3].sow+=1.0f;
\r
4001 vertex[0].sow+=1.0f;
\r
4002 vertex[2].sow+=1.0f;
\r
4005 vertex[1].sow+=1.0f;
\r
4006 vertex[2].sow+=1.0f;
\r
4009 vertex[0].sow+=1.0f;
\r
4010 vertex[3].sow+=1.0f;
\r
4025 vertex[2].tow+=0.95f/TWin.VScaleFactor;
\r
4026 vertex[3].tow+=0.95f/TWin.VScaleFactor;
\r
4029 vertex[0].tow+=0.95f/TWin.VScaleFactor;
\r
4030 vertex[1].tow+=0.95f/TWin.VScaleFactor;
\r
4033 vertex[1].tow+=0.95f/TWin.VScaleFactor;
\r
4034 vertex[3].tow+=0.95f/TWin.VScaleFactor;
\r
4037 vertex[0].tow+=0.95f/TWin.VScaleFactor;
\r
4038 vertex[2].tow+=0.95f/TWin.VScaleFactor;
\r
4041 vertex[1].tow+=0.95f/TWin.VScaleFactor;
\r
4042 vertex[2].tow+=0.95f/TWin.VScaleFactor;
\r
4045 vertex[0].tow+=0.95f/TWin.VScaleFactor;
\r
4046 vertex[3].tow+=0.95f/TWin.VScaleFactor;
\r
4055 vertex[2].tow+=1.0f/ST_FAC;
\r
4056 vertex[3].tow+=1.0f/ST_FAC;
\r
4059 vertex[0].tow+=1.0f/ST_FAC;
\r
4060 vertex[1].tow+=1.0f/ST_FAC;
\r
4063 vertex[1].tow+=1.0f/ST_FAC;
\r
4064 vertex[3].tow+=1.0f/ST_FAC;
\r
4067 vertex[0].tow+=1.0f/ST_FAC;
\r
4068 vertex[2].tow+=1.0f/ST_FAC;
\r
4071 vertex[1].tow+=1.0f/ST_FAC;
\r
4072 vertex[2].tow+=1.0f/ST_FAC;
\r
4075 vertex[0].tow+=1.0f/ST_FAC;
\r
4076 vertex[3].tow+=1.0f/ST_FAC;
\r
4086 vertex[2].tow+=1.0f/TWin.VScaleFactor;
\r
4087 vertex[3].tow+=1.0f/TWin.VScaleFactor;
\r
4090 vertex[0].tow+=1.0f/TWin.VScaleFactor;
\r
4091 vertex[1].tow+=1.0f/TWin.VScaleFactor;
\r
4094 vertex[1].tow+=1.0f/TWin.VScaleFactor;
\r
4095 vertex[3].tow+=1.0f/TWin.VScaleFactor;
\r
4098 vertex[0].tow+=1.0f/TWin.VScaleFactor;
\r
4099 vertex[2].tow+=1.0f/TWin.VScaleFactor;
\r
4102 vertex[1].tow+=1.0f/TWin.VScaleFactor;
\r
4103 vertex[2].tow+=1.0f/TWin.VScaleFactor;
\r
4106 vertex[0].tow+=1.0f/TWin.VScaleFactor;
\r
4107 vertex[3].tow+=1.0f/TWin.VScaleFactor;
\r
4116 vertex[2].tow+=1.0f;
\r
4117 vertex[3].tow+=1.0f;
\r
4120 vertex[0].tow+=1.0f;
\r
4121 vertex[1].tow+=1.0f;
\r
4124 vertex[1].tow+=1.0f;
\r
4125 vertex[3].tow+=1.0f;
\r
4128 vertex[0].tow+=1.0f;
\r
4129 vertex[2].tow+=1.0f;
\r
4132 vertex[1].tow+=1.0f;
\r
4133 vertex[2].tow+=1.0f;
\r
4136 vertex[0].tow+=1.0f;
\r
4137 vertex[3].tow+=1.0f;
\r
4146 void primPolyFT4(unsigned char * baseAddr)
\r
4148 unsigned long *gpuData = ((unsigned long *) baseAddr);
\r
4149 short *sgpuData = ((short *) baseAddr);
\r
4151 lx0 = sgpuData[2];
\r
4152 ly0 = sgpuData[3];
\r
4153 lx1 = sgpuData[6];
\r
4154 ly1 = sgpuData[7];
\r
4155 lx2 = sgpuData[10];
\r
4156 ly2 = sgpuData[11];
\r
4157 lx3 = sgpuData[14];
\r
4158 ly3 = sgpuData[15];
\r
4160 if(offset4()) return;
\r
4162 gl_vy[0]=baseAddr[9];//((gpuData[2]>>8)&0xff);
\r
4163 gl_vy[1]=baseAddr[17];//((gpuData[4]>>8)&0xff);
\r
4164 gl_vy[2]=baseAddr[25];//((gpuData[6]>>8)&0xff);
\r
4165 gl_vy[3]=baseAddr[33];//((gpuData[8]>>8)&0xff);
\r
4167 gl_ux[0]=baseAddr[8];//(gpuData[2]&0xff);
\r
4168 gl_ux[1]=baseAddr[16];//(gpuData[4]&0xff);
\r
4169 gl_ux[2]=baseAddr[24];//(gpuData[6]&0xff);
\r
4170 gl_ux[3]=baseAddr[32];//(gpuData[8]&0xff);
\r
4172 UpdateGlobalTP((unsigned short)(gpuData[4]>>16));
\r
4173 ulClutID=(gpuData[2]>>16);
\r
4175 bDrawTextured = TRUE;
\r
4176 bDrawSmoothShaded = FALSE;
\r
4177 SetRenderState(gpuData[0]);
\r
4179 /* if(iOffscreenDrawing)
\r
4182 if(bDrawOffscreen4())
\r
4184 InvalidateTextureAreaEx();
\r
4185 SetRenderColor(gpuData[0]);
\r
4186 drawPoly4FT(baseAddr);
\r
4190 SetRenderMode(gpuData[0], TRUE);
\r
4198 PRIMdrawTexturedQuad(&vertex[0], &vertex[1], &vertex[3], &vertex[2]);
\r
4200 if(bDrawMultiPass)
\r
4202 SetSemiTransMulti(1);
\r
4203 PRIMdrawTexturedQuad(&vertex[0], &vertex[1], &vertex[3], &vertex[2]);
\r
4209 if(bUseMultiPass) SetOpaqueColor(gpuData[0]);
\r
4212 /* if(bSmallAlpha && iFilterType<=2)
\r
4214 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
\r
4215 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
\r
4216 PRIMdrawTexturedQuad(&vertex[0], &vertex[1], &vertex[3], &vertex[2]);
\r
4217 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
\r
4218 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
\r
4223 PRIMdrawTexturedQuad(&vertex[0], &vertex[1], &vertex[3], &vertex[2]);
\r
4227 iDrawnSomething=1;
\r
4230 ////////////////////////////////////////////////////////////////////////
\r
4231 // cmd: smooth shaded Texture3
\r
4232 ////////////////////////////////////////////////////////////////////////
\r
4234 void primPolyGT3(unsigned char *baseAddr)
\r
4236 unsigned long *gpuData = ((unsigned long *) baseAddr);
\r
4237 short *sgpuData = ((short *) baseAddr);
\r
4239 lx0 = sgpuData[2];
\r
4240 ly0 = sgpuData[3];
\r
4241 lx1 = sgpuData[8];
\r
4242 ly1 = sgpuData[9];
\r
4243 lx2 = sgpuData[14];
\r
4244 ly2 = sgpuData[15];
\r
4246 if(offset3()) return;
\r
4248 // do texture stuff
\r
4249 gl_ux[0]=gl_ux[3]=baseAddr[8];//gpuData[2]&0xff;
\r
4250 gl_vy[0]=gl_vy[3]=baseAddr[9];//(gpuData[2]>>8)&0xff;
\r
4251 gl_ux[1]=baseAddr[20];//gpuData[5]&0xff;
\r
4252 gl_vy[1]=baseAddr[21];//(gpuData[5]>>8)&0xff;
\r
4253 gl_ux[2]=baseAddr[32];//gpuData[8]&0xff;
\r
4254 gl_vy[2]=baseAddr[33];//(gpuData[8]>>8)&0xff;
\r
4256 UpdateGlobalTP((unsigned short)(gpuData[5]>>16));
\r
4257 ulClutID=(gpuData[2]>>16);
\r
4259 bDrawTextured = TRUE;
\r
4260 bDrawSmoothShaded = TRUE;
\r
4261 SetRenderState(gpuData[0]);
\r
4263 /* if(iOffscreenDrawing)
\r
4266 if(bDrawOffscreen3())
\r
4268 InvalidateTextureAreaEx();
\r
4269 drawPoly3GT(baseAddr);
\r
4273 SetRenderMode(gpuData[0], FALSE);
\r
4278 if(bDrawNonShaded)
\r
4280 //if(!bUseMultiPass) vertex[0].lcol=DoubleBGR2RGB(gpuData[0]); else vertex[0].lcol=gpuData[0];
\r
4282 /* if(bGLBlend) vertex[0].c.lcol=0x7f7f7f;
\r
4283 else */vertex[0].c.lcol=0xffffff;
\r
4284 vertex[0].c.col[3]=ubGloAlpha;
\r
4285 SETCOL(vertex[0]);
\r
4287 PRIMdrawTexturedTri(&vertex[0], &vertex[1], &vertex[2]);
\r
4293 PRIMdrawTexturedTri(&vertex[0], &vertex[1], &vertex[2]);
\r
4299 /* if(!bUseMultiPass && !bGLBlend)
\r
4301 */ vertex[0].c.lcol=DoubleBGR2RGB(gpuData[0]);
\r
4302 vertex[1].c.lcol=DoubleBGR2RGB(gpuData[3]);
\r
4303 vertex[2].c.lcol=DoubleBGR2RGB(gpuData[6]);
\r
4307 vertex[0].c.lcol=gpuData[0];
\r
4308 vertex[1].c.lcol=gpuData[3];
\r
4309 vertex[2].c.lcol=gpuData[6];
\r
4311 vertex[0].c.col[3]=vertex[1].c.col[3]=vertex[2].c.col[3]=ubGloAlpha;
\r
4313 PRIMdrawTexGouraudTriColor(&vertex[0], &vertex[1], &vertex[2]);
\r
4315 if(bDrawMultiPass)
\r
4317 SetSemiTransMulti(1);
\r
4318 PRIMdrawTexGouraudTriColor(&vertex[0], &vertex[1], &vertex[2]);
\r
4324 if(bUseMultiPass)
\r
4326 vertex[0].c.lcol=DoubleBGR2RGB(gpuData[0]);
\r
4327 vertex[1].c.lcol=DoubleBGR2RGB(gpuData[3]);
\r
4328 vertex[2].c.lcol=DoubleBGR2RGB(gpuData[6]);
\r
4329 vertex[0].c.col[3]=vertex[1].c.col[3]=vertex[2].c.col[3]=ubGloAlpha;
\r
4332 PRIMdrawTexGouraudTriColor(&vertex[0], &vertex[1], &vertex[2]);
\r
4336 iDrawnSomething=1;
\r
4339 ////////////////////////////////////////////////////////////////////////
\r
4340 // cmd: smooth shaded Poly3
\r
4341 ////////////////////////////////////////////////////////////////////////
\r
4343 void primPolyG3(unsigned char *baseAddr)
\r
4345 unsigned long *gpuData = ((unsigned long *) baseAddr);
\r
4346 short *sgpuData = ((short *) baseAddr);
\r
4348 lx0 = sgpuData[2];
\r
4349 ly0 = sgpuData[3];
\r
4350 lx1 = sgpuData[6];
\r
4351 ly1 = sgpuData[7];
\r
4352 lx2 = sgpuData[10];
\r
4353 ly2 = sgpuData[11];
\r
4355 if(offset3()) return;
\r
4357 bDrawTextured = FALSE;
\r
4358 bDrawSmoothShaded = TRUE;
\r
4359 SetRenderState(gpuData[0]);
\r
4361 /* if(iOffscreenDrawing)
\r
4364 if(bDrawOffscreen3())
\r
4366 InvalidateTextureAreaEx();
\r
4367 drawPoly3G(gpuData[0], gpuData[2], gpuData[4]);
\r
4371 SetRenderMode(gpuData[0], FALSE);
\r
4374 vertex[0].c.lcol=gpuData[0];
\r
4375 vertex[1].c.lcol=gpuData[2];
\r
4376 vertex[2].c.lcol=gpuData[4];
\r
4377 vertex[0].c.col[3]=vertex[1].c.col[3]=vertex[2].c.col[3]=ubGloColAlpha;
\r
4379 PRIMdrawGouraudTriColor(&vertex[0], &vertex[1], &vertex[2]);
\r
4381 iDrawnSomething=1;
\r
4384 ////////////////////////////////////////////////////////////////////////
\r
4385 // cmd: smooth shaded Texture4
\r
4386 ////////////////////////////////////////////////////////////////////////
\r
4388 void primPolyGT4(unsigned char *baseAddr)
\r
4390 unsigned long *gpuData = ((unsigned long *) baseAddr);
\r
4391 short *sgpuData = ((short *) baseAddr);
\r
4393 lx0 = sgpuData[2];
\r
4394 ly0 = sgpuData[3];
\r
4395 lx1 = sgpuData[8];
\r
4396 ly1 = sgpuData[9];
\r
4397 lx2 = sgpuData[14];
\r
4398 ly2 = sgpuData[15];
\r
4399 lx3 = sgpuData[20];
\r
4400 ly3 = sgpuData[21];
\r
4402 if(offset4()) return;
\r
4404 // do texture stuff
\r
4405 gl_ux[0]=baseAddr[8];//gpuData[2]&0xff;
\r
4406 gl_vy[0]=baseAddr[9];//(gpuData[2]>>8)&0xff;
\r
4407 gl_ux[1]=baseAddr[20];//gpuData[5]&0xff;
\r
4408 gl_vy[1]=baseAddr[21];//(gpuData[5]>>8)&0xff;
\r
4409 gl_ux[2]=baseAddr[32];//gpuData[8]&0xff;
\r
4410 gl_vy[2]=baseAddr[33];//(gpuData[8]>>8)&0xff;
\r
4411 gl_ux[3]=baseAddr[44];//gpuData[11]&0xff;
\r
4412 gl_vy[3]=baseAddr[45];//(gpuData[11]>>8)&0xff;
\r
4414 UpdateGlobalTP((unsigned short)(gpuData[5]>>16));
\r
4415 ulClutID=(gpuData[2]>>16);
\r
4417 bDrawTextured = TRUE;
\r
4418 bDrawSmoothShaded = TRUE;
\r
4419 SetRenderState(gpuData[0]);
\r
4421 /* if(iOffscreenDrawing)
\r
4424 if(bDrawOffscreen4())
\r
4426 InvalidateTextureAreaEx();
\r
4427 drawPoly4GT(baseAddr);
\r
4431 SetRenderMode(gpuData[0], FALSE);
\r
4438 if(bDrawNonShaded)
\r
4440 //if(!bUseMultiPass) vertex[0].lcol=DoubleBGR2RGB(gpuData[0]); else vertex[0].lcol=gpuData[0];
\r
4441 /* if(bGLBlend) vertex[0].c.lcol=0x7f7f7f;
\r
4442 else */vertex[0].c.lcol=0xffffff;
\r
4443 vertex[0].c.col[3]=ubGloAlpha;
\r
4444 SETCOL(vertex[0]);
\r
4446 PRIMdrawTexturedQuad(&vertex[0], &vertex[1], &vertex[3], &vertex[2]);
\r
4451 ubGloAlpha=ubGloColAlpha=0xff;
\r
4453 PRIMdrawTexturedQuad(&vertex[0], &vertex[1], &vertex[3], &vertex[2]);
\r
4459 // if(!bUseMultiPass && !bGLBlend)
\r
4461 vertex[0].c.lcol=DoubleBGR2RGB(gpuData[0]);
\r
4462 vertex[1].c.lcol=DoubleBGR2RGB(gpuData[3]);
\r
4463 vertex[2].c.lcol=DoubleBGR2RGB(gpuData[6]);
\r
4464 vertex[3].c.lcol=DoubleBGR2RGB(gpuData[9]);
\r
4468 vertex[0].c.lcol=gpuData[0];
\r
4469 vertex[1].c.lcol=gpuData[3];
\r
4470 vertex[2].c.lcol=gpuData[6];
\r
4471 vertex[3].c.lcol=gpuData[9];
\r
4474 vertex[0].c.col[3]=vertex[1].c.col[3]=vertex[2].c.col[3]=vertex[3].c.col[3]=ubGloAlpha;
\r
4476 PRIMdrawTexGouraudTriColorQuad(&vertex[0], &vertex[1], &vertex[3],&vertex[2]);
\r
4478 if(bDrawMultiPass)
\r
4480 SetSemiTransMulti(1);
\r
4481 PRIMdrawTexGouraudTriColorQuad(&vertex[0], &vertex[1], &vertex[3],&vertex[2]);
\r
4487 if(bUseMultiPass)
\r
4489 vertex[0].c.lcol=DoubleBGR2RGB(gpuData[0]);
\r
4490 vertex[1].c.lcol=DoubleBGR2RGB(gpuData[3]);
\r
4491 vertex[2].c.lcol=DoubleBGR2RGB(gpuData[6]);
\r
4492 vertex[3].c.lcol=DoubleBGR2RGB(gpuData[9]);
\r
4493 vertex[0].c.col[3]=vertex[1].c.col[3]=vertex[2].c.col[3]=vertex[3].c.col[3]=ubGloAlpha;
\r
4495 ubGloAlpha=ubGloColAlpha=0xff;
\r
4497 PRIMdrawTexGouraudTriColorQuad(&vertex[0], &vertex[1], &vertex[3],&vertex[2]);
\r
4501 iDrawnSomething=1;
\r
4504 ////////////////////////////////////////////////////////////////////////
\r
4505 // cmd: smooth shaded Poly3
\r
4506 ////////////////////////////////////////////////////////////////////////
\r
4508 void primPolyF3(unsigned char *baseAddr)
\r
4510 unsigned long *gpuData = ((unsigned long *) baseAddr);
\r
4511 short *sgpuData = ((short *) baseAddr);
\r
4513 lx0 = sgpuData[2];
\r
4514 ly0 = sgpuData[3];
\r
4515 lx1 = sgpuData[4];
\r
4516 ly1 = sgpuData[5];
\r
4517 lx2 = sgpuData[6];
\r
4518 ly2 = sgpuData[7];
\r
4520 if(offset3()) return;
\r
4522 bDrawTextured = FALSE;
\r
4523 bDrawSmoothShaded = FALSE;
\r
4524 SetRenderState(gpuData[0]);
\r
4526 /* if(iOffscreenDrawing)
\r
4529 if(bDrawOffscreen3())
\r
4531 InvalidateTextureAreaEx();
\r
4532 drawPoly3F(gpuData[0]);
\r
4536 SetRenderMode(gpuData[0], FALSE);
\r
4539 vertex[0].c.lcol=gpuData[0];
\r
4540 vertex[0].c.col[3]=ubGloColAlpha;
\r
4541 SETCOL(vertex[0]);
\r
4543 PRIMdrawTri(&vertex[0], &vertex[1], &vertex[2]);
\r
4545 iDrawnSomething=1;
\r
4548 ////////////////////////////////////////////////////////////////////////
\r
4549 // cmd: skipping shaded polylines
\r
4550 ////////////////////////////////////////////////////////////////////////
\r
4552 void primLineGSkip(unsigned char *baseAddr)
\r
4554 unsigned long *gpuData = ((unsigned long *) baseAddr);
\r
4555 short *sgpuData = ((short *) baseAddr);
\r
4559 lx1 = sgpuData[2];
\r
4560 ly1 = sgpuData[3];
\r
4562 while(!(((gpuData[i] & 0xF000F000) == 0x50005000) && i>=4))
\r
4566 ly1 = (short)((gpuData[i]>>16) & 0xffff);
\r
4567 lx1 = (short)(gpuData[i] & 0xffff);
\r
4569 i++;if(i>iMax) break;
\r
4573 ////////////////////////////////////////////////////////////////////////
\r
4574 // cmd: shaded polylines
\r
4575 ////////////////////////////////////////////////////////////////////////
\r
4577 void primLineGEx(unsigned char *baseAddr)
\r
4579 unsigned long *gpuData = ((unsigned long *) baseAddr);
\r
4581 short cx0,cx1,cy0,cy1;int i;BOOL bDraw=TRUE;
\r
4583 bDrawTextured = FALSE;
\r
4584 bDrawSmoothShaded = TRUE;
\r
4585 SetRenderState(gpuData[0]);
\r
4586 SetRenderMode(gpuData[0], FALSE);
\r
4589 vertex[0].c.lcol=vertex[3].c.lcol=gpuData[0];
\r
4590 vertex[0].c.col[3]=vertex[3].c.col[3]=ubGloColAlpha;
\r
4591 ly1 = (short)((gpuData[1]>>16) & 0xffff);
\r
4592 lx1 = (short)(gpuData[1] & 0xffff);
\r
4596 //while((gpuData[i]>>24)!=0x55)
\r
4597 //while((gpuData[i]&0x50000000)!=0x50000000)
\r
4598 // currently best way to check for poly line end:
\r
4599 while(!(((gpuData[i] & 0xF000F000) == 0x50005000) && i>=4))
\r
4601 ly0 = ly1;lx0=lx1;
\r
4602 vertex[1].c.lcol=vertex[2].c.lcol=vertex[0].c.lcol;
\r
4603 vertex[0].c.lcol=vertex[3].c.lcol=gpuData[i];
\r
4604 vertex[0].c.col[3]=vertex[3].c.col[3]=ubGloColAlpha;
\r
4608 ly1 = (short)((gpuData[i]>>16) & 0xffff);
\r
4609 lx1 = (short)(gpuData[i] & 0xffff);
\r
4611 if(offsetline()) bDraw=FALSE; else bDraw=TRUE;
\r
4613 if (bDraw && ((lx0 != lx1) || (ly0 != ly1)))
\r
4615 /* if(iOffscreenDrawing)
\r
4617 cx0=lx0;cx1=lx1;cy0=ly0;cy1=ly1;
\r
4619 if(bDrawOffscreen4())
\r
4621 InvalidateTextureAreaEx();
\r
4622 drawPoly4G(gpuData[i-3],gpuData[i-1],gpuData[i-3],gpuData[i-1]);
\r
4624 lx0=cx0;lx1=cx1;ly0=cy0;ly1=cy1;
\r
4627 PRIMdrawGouraudLine(&vertex[0], &vertex[1], &vertex[2], &vertex[3]);
\r
4634 iDrawnSomething=1;
\r
4637 ////////////////////////////////////////////////////////////////////////
\r
4638 // cmd: shaded polyline2
\r
4639 ////////////////////////////////////////////////////////////////////////
\r
4641 void primLineG2(unsigned char *baseAddr)
\r
4643 unsigned long *gpuData = ((unsigned long *) baseAddr);
\r
4644 short *sgpuData = ((short *) baseAddr);
\r
4646 lx0 = sgpuData[2];
\r
4647 ly0 = sgpuData[3];
\r
4648 lx1 = sgpuData[6];
\r
4649 ly1 = sgpuData[7];
\r
4651 vertex[0].c.lcol=vertex[3].c.lcol=gpuData[0];
\r
4652 vertex[1].c.lcol=vertex[2].c.lcol=gpuData[2];
\r
4653 vertex[0].c.col[3]=vertex[1].c.col[3]=vertex[2].c.col[3]=vertex[3].c.col[3]=ubGloColAlpha;
\r
4655 bDrawTextured = FALSE;
\r
4656 bDrawSmoothShaded = TRUE;
\r
4658 if((lx0 == lx1) && (ly0 == ly1)) return;
\r
4660 if(offsetline()) return;
\r
4662 SetRenderState(gpuData[0]);
\r
4663 SetRenderMode(gpuData[0], FALSE);
\r
4666 /* if(iOffscreenDrawing)
\r
4669 if(bDrawOffscreen4())
\r
4671 InvalidateTextureAreaEx();
\r
4672 drawPoly4G(gpuData[0],gpuData[2],gpuData[0],gpuData[2]);
\r
4676 //if(ClipVertexList4())
\r
4677 PRIMdrawGouraudLine(&vertex[0], &vertex[1], &vertex[2], &vertex[3]);
\r
4679 iDrawnSomething=1;
\r
4682 ////////////////////////////////////////////////////////////////////////
\r
4683 // cmd: skipping flat polylines
\r
4684 ////////////////////////////////////////////////////////////////////////
\r
4686 void primLineFSkip(unsigned char *baseAddr)
\r
4688 unsigned long *gpuData = ((unsigned long *) baseAddr);
\r
4691 ly1 = (short)((gpuData[1]>>16) & 0xffff);
\r
4692 lx1 = (short)(gpuData[1] & 0xffff);
\r
4694 while(!(((gpuData[i] & 0xF000F000) == 0x50005000) && i>=3))
\r
4696 ly1 = (short)((gpuData[i]>>16) & 0xffff);
\r
4697 lx1 = (short)(gpuData[i] & 0xffff);
\r
4698 i++;if(i>iMax) break;
\r
4702 ////////////////////////////////////////////////////////////////////////
\r
4703 // cmd: drawing flat polylines
\r
4704 ////////////////////////////////////////////////////////////////////////
\r
4706 void primLineFEx(unsigned char *baseAddr)
\r
4708 unsigned long *gpuData = ((unsigned long *) baseAddr);
\r
4710 short cx0,cx1,cy0,cy1;int i;
\r
4714 bDrawTextured = FALSE;
\r
4715 bDrawSmoothShaded = FALSE;
\r
4716 SetRenderState(gpuData[0]);
\r
4717 SetRenderMode(gpuData[0], FALSE);
\r
4720 vertex[0].c.lcol=gpuData[0];
\r
4721 vertex[0].c.col[3]=ubGloColAlpha;
\r
4723 ly1 = (short)((gpuData[1]>>16) & 0xffff);
\r
4724 lx1 = (short)(gpuData[1] & 0xffff);
\r
4728 // while(!(gpuData[i]&0x40000000))
\r
4729 // while((gpuData[i]>>24)!=0x55)
\r
4730 // while((gpuData[i]&0x50000000)!=0x50000000)
\r
4731 // currently best way to check for poly line end:
\r
4732 while(!(((gpuData[i] & 0xF000F000) == 0x50005000) && i>=3))
\r
4734 ly0 = ly1;lx0=lx1;
\r
4735 ly1 = (short)((gpuData[i]>>16) & 0xffff);
\r
4736 lx1 = (short)(gpuData[i] & 0xffff);
\r
4740 /* if(iOffscreenDrawing)
\r
4742 cx0=lx0;cx1=lx1;cy0=ly0;cy1=ly1;
\r
4744 if(bDrawOffscreen4())
\r
4746 InvalidateTextureAreaEx();
\r
4747 drawPoly4F(gpuData[0]);
\r
4749 lx0=cx0;lx1=cx1;ly0=cy0;ly1=cy1;
\r
4751 PRIMdrawFlatLine(&vertex[0], &vertex[1], &vertex[2], &vertex[3]);
\r
4754 i++;if(i>iMax) break;
\r
4757 iDrawnSomething=1;
\r
4760 ////////////////////////////////////////////////////////////////////////
\r
4761 // cmd: drawing flat polyline2
\r
4762 ////////////////////////////////////////////////////////////////////////
\r
4764 void primLineF2(unsigned char *baseAddr)
\r
4766 unsigned long *gpuData = ((unsigned long *) baseAddr);
\r
4767 short *sgpuData = ((short *) baseAddr);
\r
4769 lx0 = sgpuData[2];
\r
4770 ly0 = sgpuData[3];
\r
4771 lx1 = sgpuData[4];
\r
4772 ly1 = sgpuData[5];
\r
4774 if(offsetline()) return;
\r
4776 bDrawTextured = FALSE;
\r
4777 bDrawSmoothShaded = FALSE;
\r
4778 SetRenderState(gpuData[0]);
\r
4779 SetRenderMode(gpuData[0], FALSE);
\r
4782 vertex[0].c.lcol=gpuData[0];
\r
4783 vertex[0].c.col[3]=ubGloColAlpha;
\r
4785 /* if(iOffscreenDrawing)
\r
4788 if(bDrawOffscreen4())
\r
4790 InvalidateTextureAreaEx();
\r
4791 drawPoly4F(gpuData[0]);
\r
4795 //if(ClipVertexList4())
\r
4796 PRIMdrawFlatLine(&vertex[0], &vertex[1], &vertex[2], &vertex[3]);
\r
4798 iDrawnSomething=1;
\r
4801 ////////////////////////////////////////////////////////////////////////
\r
4802 // cmd: well, easiest command... not implemented
\r
4803 ////////////////////////////////////////////////////////////////////////
\r
4805 void primNI(unsigned char *bA)
\r
4809 ////////////////////////////////////////////////////////////////////////
\r
4810 // cmd func ptr table
\r
4811 ////////////////////////////////////////////////////////////////////////
\r
4813 void (*primTableJ[256])(unsigned char *) =
\r
4816 primNI,primNI,primBlkFill,primNI,primNI,primNI,primNI,primNI,
\r
4818 primNI,primNI,primNI,primNI,primNI,primNI,primNI,primNI,
\r
4820 primNI,primNI,primNI,primNI,primNI,primNI,primNI,primNI,
\r
4822 primNI,primNI,primNI,primNI,primNI,primNI,primNI,primNI,
\r
4824 primPolyF3,primPolyF3,primPolyF3,primPolyF3,primPolyFT3,primPolyFT3,primPolyFT3,primPolyFT3,
\r
4826 primPolyF4,primPolyF4,primPolyF4,primPolyF4,primPolyFT4,primPolyFT4,primPolyFT4,primPolyFT4,
\r
4828 primPolyG3,primPolyG3,primPolyG3,primPolyG3,primPolyGT3,primPolyGT3,primPolyGT3,primPolyGT3,
\r
4830 primPolyG4,primPolyG4,primPolyG4,primPolyG4,primPolyGT4,primPolyGT4,primPolyGT4,primPolyGT4,
\r
4832 primLineF2,primLineF2,primLineF2,primLineF2,primNI,primNI,primNI,primNI,
\r
4834 primLineFEx,primLineFEx,primLineFEx,primLineFEx,primLineFEx,primLineFEx,primLineFEx,primLineFEx,
\r
4836 primLineG2,primLineG2,primLineG2,primLineG2,primNI,primNI,primNI,primNI,
\r
4838 primLineGEx,primLineGEx,primLineGEx,primLineGEx,primLineGEx,primLineGEx,primLineGEx,primLineGEx,
\r
4840 primTileS,primTileS,primTileS,primTileS,primSprtS,primSprtS,primSprtS,primSprtS,
\r
4842 primTile1,primTile1,primTile1,primTile1,primNI,primNI,primNI,primNI,
\r
4844 primTile8,primTile8,primTile8,primTile8,primSprt8,primSprt8,primSprt8,primSprt8,
\r
4846 primTile16,primTile16,primTile16,primTile16,primSprt16,primSprt16,primSprt16,primSprt16,
\r
4848 primMoveImage,primNI,primNI,primNI,primNI,primNI,primNI,primNI,
\r
4850 primNI,primNI,primNI,primNI,primNI,primNI,primNI,primNI,
\r
4852 primNI,primNI,primNI,primNI,primNI,primNI,primNI,primNI,
\r
4854 primNI,primNI,primNI,primNI,primNI,primNI,primNI,primNI,
\r
4856 primLoadImage,primNI,primNI,primNI,primNI,primNI,primNI,primNI,
\r
4858 primNI,primNI,primNI,primNI,primNI,primNI,primNI,primNI,
\r
4860 primNI,primNI,primNI,primNI,primNI,primNI,primNI,primNI,
\r
4862 primNI,primNI,primNI,primNI,primNI,primNI,primNI,primNI,
\r
4864 primStoreImage,primNI,primNI,primNI,primNI,primNI,primNI,primNI,
\r
4866 primNI,primNI,primNI,primNI,primNI,primNI,primNI,primNI,
\r
4868 primNI,primNI,primNI,primNI,primNI,primNI,primNI,primNI,
\r
4870 primNI,primNI,primNI,primNI,primNI,primNI,primNI,primNI,
\r
4872 primNI,cmdTexturePage,cmdTextureWindow,cmdDrawAreaStart,cmdDrawAreaEnd,cmdDrawOffset,cmdSTP,primNI,
\r
4874 primNI,primNI,primNI,primNI,primNI,primNI,primNI,primNI,
\r
4876 primNI,primNI,primNI,primNI,primNI,primNI,primNI,primNI,
\r
4878 primNI,primNI,primNI,primNI,primNI,primNI,primNI,primNI
\r
4881 ////////////////////////////////////////////////////////////////////////
\r
4882 // cmd func ptr table for skipping
\r
4883 ////////////////////////////////////////////////////////////////////////
\r
4885 void (*primTableSkip[256])(unsigned char *) =
\r
4888 primNI,primNI,primBlkFill,primNI,primNI,primNI,primNI,primNI,
\r
4890 primNI,primNI,primNI,primNI,primNI,primNI,primNI,primNI,
\r
4892 primNI,primNI,primNI,primNI,primNI,primNI,primNI,primNI,
\r
4894 primNI,primNI,primNI,primNI,primNI,primNI,primNI,primNI,
\r
4896 primNI,primNI,primNI,primNI,primNI,primNI,primNI,primNI,
\r
4898 primNI,primNI,primNI,primNI,primNI,primNI,primNI,primNI,
\r
4900 primNI,primNI,primNI,primNI,primNI,primNI,primNI,primNI,
\r
4902 primNI,primNI,primNI,primNI,primNI,primNI,primNI,primNI,
\r
4904 primNI,primNI,primNI,primNI,primNI,primNI,primNI,primNI,
\r
4906 primLineFSkip,primLineFSkip,primLineFSkip,primLineFSkip,primLineFSkip,primLineFSkip,primLineFSkip,primLineFSkip,
\r
4908 primNI,primNI,primNI,primNI,primNI,primNI,primNI,primNI,
\r
4910 primLineGSkip,primLineGSkip,primLineGSkip,primLineGSkip,primLineGSkip,primLineGSkip,primLineGSkip,primLineGSkip,
\r
4912 primNI,primNI,primNI,primNI,primNI,primNI,primNI,primNI,
\r
4914 primNI,primNI,primNI,primNI,primNI,primNI,primNI,primNI,
\r
4916 primNI,primNI,primNI,primNI,primNI,primNI,primNI,primNI,
\r
4918 primNI,primNI,primNI,primNI,primNI,primNI,primNI,primNI,
\r
4920 primMoveImage,primNI,primNI,primNI,primNI,primNI,primNI,primNI,
\r
4922 primNI,primNI,primNI,primNI,primNI,primNI,primNI,primNI,
\r
4924 primNI,primNI,primNI,primNI,primNI,primNI,primNI,primNI,
\r
4926 primNI,primNI,primNI,primNI,primNI,primNI,primNI,primNI,
\r
4928 primLoadImage,primNI,primNI,primNI,primNI,primNI,primNI,primNI,
\r
4930 primNI,primNI,primNI,primNI,primNI,primNI,primNI,primNI,
\r
4932 primNI,primNI,primNI,primNI,primNI,primNI,primNI,primNI,
\r
4934 primNI,primNI,primNI,primNI,primNI,primNI,primNI,primNI,
\r
4936 primStoreImage,primNI,primNI,primNI,primNI,primNI,primNI,primNI,
\r
4938 primNI,primNI,primNI,primNI,primNI,primNI,primNI,primNI,
\r
4940 primNI,primNI,primNI,primNI,primNI,primNI,primNI,primNI,
\r
4942 primNI,primNI,primNI,primNI,primNI,primNI,primNI,primNI,
\r
4944 primNI,cmdTexturePage,cmdTextureWindow,cmdDrawAreaStart,cmdDrawAreaEnd,cmdDrawOffset,cmdSTP,primNI,
\r
4946 primNI,primNI,primNI,primNI,primNI,primNI,primNI,primNI,
\r
4948 primNI,primNI,primNI,primNI,primNI,primNI,primNI,primNI,
\r
4950 primNI,primNI,primNI,primNI,primNI,primNI,primNI,primNI
\r