notaz.gp2x.de / pcsx_rearmed.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
gpu-gles: refactor for caanoo/wiz support
[pcsx_rearmed.git] / plugins / gpu-gles / gpuDraw.c
... / ...
CommitLineData
1/***************************************************************************\r
2 draw.c - description\r
3 -------------------\r
4 begin : Sun Mar 08 2009\r
5 copyright : (C) 1999-2009 by Pete Bernert\r
6 web : www.pbernert.com \r
7 ***************************************************************************/\r
8\r
9/***************************************************************************\r
10 * *\r
11 * This program is free software; you can redistribute it and/or modify *\r
12 * it under the terms of the GNU General Public License as published by *\r
13 * the Free Software Foundation; either version 2 of the License, or *\r
14 * (at your option) any later version. See also the license.txt file for *\r
15 * additional informations. *\r
16 * *\r
17 ***************************************************************************/\r
18\r
19//*************************************************************************// \r
20// History of changes:\r
21//\r
22// 2009/03/08 - Pete \r
23// - generic cleanup for the Peops release\r
24//\r
25//*************************************************************************// \r
26\r
27\r
28#define _IN_DRAW\r
29\r
30\r
31#include "gpuExternals.h"\r
32#include "gpuPlugin.h"\r
33#include "gpuDraw.h"\r
34#include "gpuPrim.h"\r
35#include "gpuTexture.h"\r
36#include "gpuStdafx.h"\r
37\r
38#include <stdio.h>\r
39#include <stdlib.h>\r
40#include <math.h>\r
41//#include "menu.h"\r
42 \r
43////////////////////////////////////////////////////////////////////////////////////\r
44// defines\r
45\r
46#define SIGNBIT 0x800\r
47#define S_MASK 0xf000\r
48#define L_MASK 0xfffff000\r
49\r
50// ownscale: some ogl drivers have buggy texture matrix funcs, so it\r
51// is safer to calc sow/tow ourselves\r
52\r
53#ifdef OWNSCALE\r
54\r
55///////////////////////////////////////////////////////////////\r
56\r
57#define ST_FACSPRITE 255.99f\r
58#define ST_BFFACSPRITE 0.5f/256.0f\r
59#define ST_BFFACSPRITESORT 0.333f/256.0f\r
60\r
61#define ST_OFFSET 0.5f/256.0f;\r
62\r
63#define ST_FAC 255.99f\r
64#define ST_BFFAC 0.5f/256.0f\r
65#define ST_BFFACSORT 0.333f/256.0f\r
66\r
67#define ST_FACTRI 255.99f\r
68#define ST_BFFACTRI 0.5f/256.0f\r
69#define ST_BFFACTRISORT 0.333f/256.0f\r
70\r
71#define ST_FACVRAMX 255.0f\r
72#define ST_FACVRAM 256.0f\r
73\r
74///////////////////////////////////////////////////////////////\r
75\r
76#else\r
77\r
78#define ST_BFFACSPRITE 0.5f\r
79#define ST_BFFACSPRITESORT 0.333f\r
80\r
81#define ST_BFFAC 0.5f\r
82#define ST_BFFACSORT 0.333f\r
83\r
84#define ST_BFFACTRI 0.5f\r
85#define ST_BFFACTRISORT 0.333f\r
86\r
87#define ST_OFFSET 0.5f;\r
88 \r
89#endif\r
90\r
91////////////////////////////////////////////////////////////////////////////////////\r
92// draw globals\r
93\r
94void glBlendEquationEXT(GLenum mode);\r
95void glColorTableEXT(GLenum target, GLenum internalFormat, GLsizei width, GLenum format,GLenum type, const GLvoid *data);\r
96\r
97// draw globals; most will be initialized again later (by config or checks) \r
98\r
99BOOL bIsFirstFrame=TRUE;\r
100\r
101// resolution/ratio vars\r
102\r
103int iResX;\r
104int iResY;\r
105BOOL bKeepRatio=FALSE;\r
106RECT rRatioRect;\r
107\r
108// psx mask related vars\r
109\r
110BOOL bCheckMask=FALSE;\r
111int iUseMask=0;\r
112int iSetMask=0;\r
113unsigned short sSetMask=0;\r
114unsigned long lSetMask=0;\r
115\r
116// drawing/coord vars\r
117\r
118OGLVertex vertex[4];\r
119GLubyte gl_ux[8];\r
120GLubyte gl_vy[8];\r
121short sprtY,sprtX,sprtH,sprtW;\r
122\r
123// drawing options\r
124\r
125BOOL bOpaquePass;\r
126BOOL bAdvancedBlend;\r
127\r
128// OGL extension support\r
129\r
130\r
131// gfx card buffer infos\r
132\r
133int iDepthFunc=0;\r
134int iZBufferDepth=0;\r
135GLbitfield uiBufferBits=GL_COLOR_BUFFER_BIT;\r
136\r
137////////////////////////////////////////////////////////////////////////\r
138////////////////////////////////////////////////////////////////////////\r
139////////////////////////////////////////////////////////////////////////\r
140\r
141////////////////////////////////////////////////////////////////////////\r
142// Set OGL pixel format\r
143////////////////////////////////////////////////////////////////////////\r
144 \r
145\r
146////////////////////////////////////////////////////////////////////////\r
147// Get extension infos (f.e. pal textures / packed pixels)\r
148////////////////////////////////////////////////////////////////////////\r
149\r
150void GetExtInfos(void) \r
151{\r
152 BOOL bPacked=FALSE; // default: no packed pixel support\r
153\r
154 if(strstr((char *)glGetString(GL_EXTENSIONS), // packed pixels available?\r
155 "GL_EXT_packed_pixels")) \r
156 bPacked=TRUE; // -> ok\r
157\r
158 \r
159 iClampType=GL_CLAMP_TO_EDGE;\r
160}\r
161\r
162////////////////////////////////////////////////////////////////////////\r
163// Setup some stuff depending on user settings or in-game toggle\r
164////////////////////////////////////////////////////////////////////////\r
165\r
166void SetExtGLFuncs(void)\r
167{\r
168 //----------------------------------------------------//\r
169\r
170 SetFixes(); // update fix infos\r
171\r
172 //----------------------------------------------------//\r
173\r
174 {\r
175 if(bAdvancedBlend) bUseMultiPass=TRUE; // -> pseudo-advanced with 2 passes\r
176 else bUseMultiPass=FALSE; // -> or simple 'bright color' mode\r
177// bGLBlend=FALSE; // -> no ext blending!\r
178 glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE); glError();\r
179 }\r
180\r
181 if(bOpaquePass) // opaque mode?\r
182 {\r
183 if(dwActFixes&32) \r
184 {\r
185 TCF[0]=CP8RGBA_0;\r
186 PalTexturedColourFn=CP8RGBA; // -> init col func\r
187 }\r
188 else\r
189 {\r
190 TCF[0]=XP8RGBA_0;\r
191 PalTexturedColourFn=XP8RGBA; // -> init col func\r
192 }\r
193\r
194 TCF[1]=XP8RGBA_1;\r
195 glAlphaFuncx(GL_GREATER,0.49f); glError();\r
196\r
197 }\r
198 else // no opaque mode?\r
199 {\r
200 TCF[0]=TCF[1]=P8RGBA;\r
201 PalTexturedColourFn=P8RGBA; // -> init col func\r
202 glAlphaFuncx(GL_NOTEQUAL,0); glError(); // --> set alpha func\r
203\r
204 }\r
205\r
206 //----------------------------------------------------//\r
207\r
208 LoadSubTexFn=LoadSubTexturePageSort; // init load tex ptr\r
209\r
210 bBlendEnable=FALSE; // init blending: off\r
211 glDisable(GL_BLEND); glError();\r
212\r
213\r
214 SetScanTrans(); // init scan lines (if wanted)\r
215}\r
216\r
217////////////////////////////////////////////////////////////////////////\r
218// setup scan lines\r
219////////////////////////////////////////////////////////////////////////\r
220\r
221#define R_TSP 0x00,0x45,0x00,0xff\r
222#define G_TSP 0x00,0x00,0x45,0xff\r
223#define B_TSP 0x45,0x00,0x00,0xff\r
224#define O_TSP 0x45,0x45,0x45,0xff\r
225#define N_TSP 0x00,0x00,0x00,0xff\r
226\r
227GLuint gTexScanName=0;\r
228\r
229GLubyte texscan[4][16]= \r
230{\r
231{R_TSP, G_TSP, B_TSP, N_TSP},\r
232{O_TSP, N_TSP, O_TSP, N_TSP},\r
233{B_TSP, N_TSP, R_TSP, G_TSP},\r
234{O_TSP, N_TSP, O_TSP, N_TSP}\r
235};\r
236\r
237void CreateScanLines(void)\r
238{\r
239}\r
240\r
241////////////////////////////////////////////////////////////////////////\r
242// Initialize OGL\r
243////////////////////////////////////////////////////////////////////////\r
244\r
245#define MODE_RAW 0\r
246#define MODE_X11 1\r
247#define MODE_SDL 2\r
248int use_fsaa = 0;\r
249\r
250EGLDisplay display;\r
251EGLConfig config;\r
252EGLContext context;\r
253EGLSurface surface;\r
254\r
255#if defined(USE_X11)\r
256#include "X11/Xlib.h"\r
257#include "X11/Xutil.h"\r
258#include "X11/Xatom.h"\r
259\r
260Window x11Window = 0;\r
261Display* x11Display = 0;\r
262long x11Screen = 0;\r
263XVisualInfo x11Visual;\r
264XVisualInfo* px11Visual = 0;\r
265Colormap x11Colormap = 0;\r
266#endif\r
267\r
268EGLint attrib_list_fsaa[] =\r
269{\r
270 EGL_SURFACE_TYPE, EGL_WINDOW_BIT,\r
271 EGL_BUFFER_SIZE, 0,\r
272 EGL_DEPTH_SIZE, 16,\r
273 EGL_SAMPLE_BUFFERS, 1,\r
274 EGL_SAMPLES, 4,\r
275 EGL_NONE\r
276};\r
277\r
278EGLint attrib_list[] =\r
279{\r
280// EGL_DEPTH_SIZE, 16,\r
281 EGL_NONE\r
282};\r
283\r
284bool TestEGLError(const char* pszLocation)\r
285{\r
286 /*\r
287 eglGetError returns the last error that has happened using egl,\r
288 not the status of the last called function. The user has to\r
289 check after every single egl call or at least once every frame.\r
290 */\r
291 EGLint iErr = eglGetError();\r
292 if (iErr != EGL_SUCCESS)\r
293 {\r
294 printf("%s failed (0x%x).\n", pszLocation, iErr);\r
295 return FALSE;\r
296 }\r
297\r
298 return TRUE;\r
299}\r
300\r
301static int initEGL(void)\r
302{\r
303 NativeWindowType window = 0;\r
304\r
305 printf ("GL init\n");\r
306\r
307 EGLint numConfigs;\r
308 EGLint majorVersion;\r
309 EGLint minorVersion;\r
310#if defined(USE_X11)\r
311 enum\r
312 {\r
313 _NET_WM_STATE_REMOVE =0,\r
314 _NET_WM_STATE_ADD = 1,\r
315 _NET_WM_STATE_TOGGLE =2\r
316 };\r
317 \r
318 Window sRootWindow;\r
319 XSetWindowAttributes sWA;\r
320 unsigned int ui32Mask;\r
321 int i32Depth;\r
322#endif\r
323 \r
324 EGLint *attribList = NULL;\r
325 if (use_fsaa)\r
326 {\r
327 printf( "GLES: Using Full Scene Antialiasing\n" );\r
328 attribList = attrib_list_fsaa;\r
329 }\r
330 else\r
331 {\r
332 attribList = attrib_list;\r
333 }\r
334\r
335#if defined(USE_X11)\r
336 // Initializes the display and screen\r
337 x11Display = XOpenDisplay( ":0" );\r
338 if (!x11Display)\r
339 {\r
340 printf("GLES Error: Unable to open X display\n");\r
341 return -1;\r
342 }\r
343 x11Screen = XDefaultScreen( x11Display );\r
344\r
345 // Gets the display parameters so we can pass the same parameters to the window to be created.\r
346 sRootWindow = RootWindow(x11Display, x11Screen);\r
347 i32Depth = DefaultDepth(x11Display, x11Screen);\r
348 px11Visual = &x11Visual;\r
349 XMatchVisualInfo( x11Display, x11Screen, i32Depth, TrueColor, px11Visual);\r
350 if (!px11Visual)\r
351 {\r
352 printf("GLES Error: Unable to acquire visual\n");\r
353 return -1;\r
354 }\r
355 // Colormap of the specified visual type for the display.\r
356 x11Colormap = XCreateColormap( x11Display, sRootWindow, px11Visual->visual, AllocNone );\r
357 sWA.colormap = x11Colormap;\r
358\r
359 // List of events to be handled by the application. Add to these for handling other events.\r
360 sWA.event_mask = StructureNotifyMask | ExposureMask | ButtonPressMask | ButtonReleaseMask | KeyPressMask | KeyReleaseMask;\r
361\r
362 // Display capabilities list.\r
363 ui32Mask = CWBackPixel | CWBorderPixel | CWEventMask | CWColormap;\r
364\r
365 // Creates the X11 window\r
366 x11Window = XCreateWindow( x11Display, RootWindow(x11Display, x11Screen), 0, 0, iResX, iResY,\r
367 0, CopyFromParent, InputOutput, CopyFromParent, ui32Mask, &sWA);\r
368\r
369 // Make the window viewable and flush the output buffer.\r
370 XMapWindow(x11Display, x11Window);\r
371 XFlush(x11Display);\r
372\r
373 // Make the window fullscreen\r
374 unsigned char fullScreen = 1;\r
375 Atom wmState = XInternAtom(x11Display, "_NET_WM_STATE", False);\r
376 Atom wmFullScreen = XInternAtom(x11Display,"_NET_WM_STATE_FULLSCREEN", False);\r
377\r
378 XEvent xev;\r
379 xev.xclient.type = ClientMessage;\r
380 xev.xclient.serial = 0;\r
381 xev.xclient.send_event = True;\r
382 xev.xclient.window = x11Window;\r
383 xev.xclient.message_type = wmState;\r
384 xev.xclient.format = 32;\r
385 xev.xclient.data.l[0] = (fullScreen ? _NET_WM_STATE_ADD : _NET_WM_STATE_REMOVE);\r
386 xev.xclient.data.l[1] = wmFullScreen;\r
387 xev.xclient.data.l[2] = 0;\r
388\r
389 XSendEvent(x11Display, DefaultRootWindow(x11Display), False, SubstructureRedirectMask | SubstructureNotifyMask, &xev);\r
390\r
391 display = eglGetDisplay( (EGLNativeDisplayType)x11Display );\r
392 window = x11Window;\r
393#else\r
394 display = eglGetDisplay( (EGLNativeDisplayType)0 );\r
395#endif\r
396\r
397 if( display == EGL_NO_DISPLAY )\r
398 {\r
399 printf( "GLES EGL Error: GL No Display\n" );\r
400 return -1;\r
401 }\r
402\r
403 if( !eglInitialize( display, &majorVersion, &minorVersion ) )\r
404 {\r
405 printf( "GLES EGL Error: eglInitialize failed\n" );\r
406 return -1;\r
407 }\r
408\r
409 if( !eglChooseConfig( display, attribList, &config, 1, &numConfigs ) )\r
410 {\r
411 printf( "GLES EGL Error: eglChooseConfig failed\n" );\r
412 return -1;\r
413 }\r
414\r
415 context = eglCreateContext( display, config, NULL, NULL );\r
416 if( context==0 )\r
417 {\r
418 printf( "GLES EGL Error: eglCreateContext failed\n" );\r
419 return -1;\r
420 }\r
421\r
422#ifdef FAKE_WINDOW\r
423 // broken Caanoo libs won't accept NULL window\r
424 window = (NativeWindowType)1;\r
425#endif\r
426 surface = eglCreateWindowSurface( display, config, window, NULL );\r
427 if (!TestEGLError("eglCreateWindowSurface"))\r
428 return -1;\r
429\r
430 eglMakeCurrent( display, surface, surface, context );\r
431 if (!TestEGLError("eglMakeCurrent"))\r
432 return -1;\r
433\r
434 printf("GLES init ok\n");\r
435 return 0;\r
436}\r
437\r
438int GLinitialize() \r
439{\r
440 if(initEGL()!=0)\r
441 return -1;\r
442\r
443 //----------------------------------------------------// \r
444\r
445 glViewport(rRatioRect.left, // init viewport by ratio rect\r
446 iResY-(rRatioRect.top+rRatioRect.bottom),\r
447 rRatioRect.right, \r
448 rRatioRect.bottom); glError();\r
449 \r
450 glScissor(0, 0, iResX, iResY); glError(); // init clipping (fullscreen)\r
451 glEnable(GL_SCISSOR_TEST); glError();\r
452\r
453#ifndef OWNSCALE\r
454 glMatrixMode(GL_TEXTURE); // init psx tex sow and tow if not "ownscale"\r
455 glLoadIdentity();\r
456 glScalef(1.0f/255.99f,1.0f/255.99f,1.0f); // geforce precision hack\r
457#endif \r
458 glDepthRangef(0.0f, 1.0f);glError();\r
459 \r
460 glPolygonOffset( -0.2f, -0.2f );glError();\r
461\r
462 glMatrixMode(GL_PROJECTION); glError(); // init projection with psx resolution\r
463 glLoadIdentity(); glError();\r
464\r
465 glOrtho(0,PSXDisplay.DisplayMode.x,\r
466 PSXDisplay.DisplayMode.y, 0, -1, 1); glError();\r
467\r
468 if(iZBufferDepth) // zbuffer?\r
469 {\r
470 uiBufferBits=GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT;\r
471 glEnable(GL_DEPTH_TEST); glError();\r
472 glDepthFunc(GL_ALWAYS); glError();\r
473 iDepthFunc=1;\r
474 }\r
475 else // no zbuffer?\r
476 {\r
477 uiBufferBits=GL_COLOR_BUFFER_BIT;\r
478 glDisable(GL_DEPTH_TEST); glError();\r
479 }\r
480\r
481 glClearColor(0.0f, 0.0f, 0.0f, 0.0f); glError(); // first buffer clear\r
482 glClear(uiBufferBits); glError();\r
483\r
484 GetExtInfos(); // get ext infos\r
485 SetExtGLFuncs(); // init all kind of stuff (tex function pointers)\r
486 \r
487 glEnable(GL_ALPHA_TEST); glError(); // wanna alpha test\r
488\r
489 {\r
490 glDisable(GL_LINE_SMOOTH); glError();\r
491 glDisable(GL_POINT_SMOOTH); glError();\r
492 }\r
493\r
494 ubGloAlpha=127; // init some drawing vars\r
495 ubGloColAlpha=127;\r
496 TWin.UScaleFactor = 1;\r
497 TWin.VScaleFactor = 1;\r
498 bDrawMultiPass=FALSE;\r
499 bTexEnabled=FALSE;\r
500 bUsingTWin=FALSE;\r
501 \r
502 if(bDrawDither) glEnable(GL_DITHER); // dither mode\r
503 else glDisable(GL_DITHER); \r
504 glError(); \r
505 glDisable(GL_FOG); glError(); // turn all (currently) unused modes off\r
506 glDisable(GL_LIGHTING); glError(); \r
507 glDisable(GL_STENCIL_TEST); glError(); \r
508 glDisable(GL_TEXTURE_2D); glError();\r
509 glDisable(GL_CULL_FACE);\r
510\r
511 glFlush(); glError(); // we are done...\r
512 glFinish(); glError(); \r
513\r
514 CreateScanLines(); // setup scanline stuff (if wanted)\r
515\r
516 CheckTextureMemory(); // check available tex memory\r
517\r
518 if(bKeepRatio) SetAspectRatio(); // set ratio\r
519\r
520 \r
521 bIsFirstFrame = FALSE; // we have survived the first frame :)\r
522\r
523 return 0;\r
524}\r
525\r
526////////////////////////////////////////////////////////////////////////\r
527// clean up OGL stuff\r
528////////////////////////////////////////////////////////////////////////\r
529\r
530void GLcleanup() \r
531{ \r
532 CleanupTextureStore(); // bye textures\r
533\r
534 eglMakeCurrent( display, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT );\r
535 eglDestroySurface( display, surface );\r
536 eglDestroyContext( display, context );\r
537 eglTerminate( display );\r
538\r
539#if defined(USE_X11)\r
540 if (x11Window) XDestroyWindow(x11Display, x11Window);\r
541 if (x11Colormap) XFreeColormap( x11Display, x11Colormap );\r
542 if (x11Display) XCloseDisplay(x11Display);\r
543#endif\r
544}\r
545\r
546////////////////////////////////////////////////////////////////////////\r
547////////////////////////////////////////////////////////////////////////\r
548////////////////////////////////////////////////////////////////////////\r
549\r
550////////////////////////////////////////////////////////////////////////\r
551////////////////////////////////////////////////////////////////////////\r
552////////////////////////////////////////////////////////////////////////\r
553\r
554////////////////////////////////////////////////////////////////////////\r
555// Offset stuff\r
556////////////////////////////////////////////////////////////////////////\r
557\r
558// please note: it is hardly do-able in a hw/accel plugin to get the \r
559// real psx polygon coord mapping right... the following\r
560// works not to bad with many games, though\r
561\r
562__inline BOOL CheckCoord4()\r
563{\r
564 if(lx0<0)\r
565 {\r
566 if(((lx1-lx0)>CHKMAX_X) ||\r
567 ((lx2-lx0)>CHKMAX_X)) \r
568 {\r
569 if(lx3<0)\r
570 {\r
571 if((lx1-lx3)>CHKMAX_X) return TRUE;\r
572 if((lx2-lx3)>CHKMAX_X) return TRUE;\r
573 }\r
574 }\r
575 }\r
576 if(lx1<0)\r
577 {\r
578 if((lx0-lx1)>CHKMAX_X) return TRUE;\r
579 if((lx2-lx1)>CHKMAX_X) return TRUE;\r
580 if((lx3-lx1)>CHKMAX_X) return TRUE;\r
581 }\r
582 if(lx2<0)\r
583 {\r
584 if((lx0-lx2)>CHKMAX_X) return TRUE;\r
585 if((lx1-lx2)>CHKMAX_X) return TRUE;\r
586 if((lx3-lx2)>CHKMAX_X) return TRUE;\r
587 }\r
588 if(lx3<0)\r
589 {\r
590 if(((lx1-lx3)>CHKMAX_X) ||\r
591 ((lx2-lx3)>CHKMAX_X))\r
592 {\r
593 if(lx0<0)\r
594 {\r
595 if((lx1-lx0)>CHKMAX_X) return TRUE;\r
596 if((lx2-lx0)>CHKMAX_X) return TRUE;\r
597 }\r
598 }\r
599 }\r
600 \r
601\r
602 if(ly0<0)\r
603 {\r
604 if((ly1-ly0)>CHKMAX_Y) return TRUE;\r
605 if((ly2-ly0)>CHKMAX_Y) return TRUE;\r
606 }\r
607 if(ly1<0)\r
608 {\r
609 if((ly0-ly1)>CHKMAX_Y) return TRUE;\r
610 if((ly2-ly1)>CHKMAX_Y) return TRUE;\r
611 if((ly3-ly1)>CHKMAX_Y) return TRUE;\r
612 }\r
613 if(ly2<0)\r
614 {\r
615 if((ly0-ly2)>CHKMAX_Y) return TRUE;\r
616 if((ly1-ly2)>CHKMAX_Y) return TRUE;\r
617 if((ly3-ly2)>CHKMAX_Y) return TRUE;\r
618 }\r
619 if(ly3<0)\r
620 {\r
621 if((ly1-ly3)>CHKMAX_Y) return TRUE;\r
622 if((ly2-ly3)>CHKMAX_Y) return TRUE;\r
623 }\r
624\r
625 return FALSE;\r
626}\r
627\r
628__inline BOOL CheckCoord3()\r
629{\r
630 if(lx0<0)\r
631 {\r
632 if((lx1-lx0)>CHKMAX_X) return TRUE;\r
633 if((lx2-lx0)>CHKMAX_X) return TRUE;\r
634 }\r
635 if(lx1<0)\r
636 {\r
637 if((lx0-lx1)>CHKMAX_X) return TRUE;\r
638 if((lx2-lx1)>CHKMAX_X) return TRUE;\r
639 }\r
640 if(lx2<0)\r
641 {\r
642 if((lx0-lx2)>CHKMAX_X) return TRUE;\r
643 if((lx1-lx2)>CHKMAX_X) return TRUE;\r
644 }\r
645 if(ly0<0)\r
646 {\r
647 if((ly1-ly0)>CHKMAX_Y) return TRUE;\r
648 if((ly2-ly0)>CHKMAX_Y) return TRUE;\r
649 }\r
650 if(ly1<0)\r
651 {\r
652 if((ly0-ly1)>CHKMAX_Y) return TRUE;\r
653 if((ly2-ly1)>CHKMAX_Y) return TRUE;\r
654 }\r
655 if(ly2<0)\r
656 {\r
657 if((ly0-ly2)>CHKMAX_Y) return TRUE;\r
658 if((ly1-ly2)>CHKMAX_Y) return TRUE;\r
659 }\r
660\r
661 return FALSE;\r
662}\r
663\r
664\r
665__inline BOOL CheckCoord2()\r
666{\r
667 if(lx0<0)\r
668 {\r
669 if((lx1-lx0)>CHKMAX_X) return TRUE;\r
670 }\r
671 if(lx1<0)\r
672 {\r
673 if((lx0-lx1)>CHKMAX_X) return TRUE;\r
674 }\r
675 if(ly0<0)\r
676 {\r
677 if((ly1-ly0)>CHKMAX_Y) return TRUE;\r
678 }\r
679 if(ly1<0)\r
680 {\r
681 if((ly0-ly1)>CHKMAX_Y) return TRUE;\r
682 }\r
683\r
684 return FALSE;\r
685}\r
686\r
687// Pete's way: a very easy (and hopefully fast) approach for lines\r
688// without sqrt... using a small float -> short cast trick :)\r
689\r
690#define VERTEX_OFFX 0.2f\r
691#define VERTEX_OFFY 0.2f\r
692\r
693BOOL offsetline(void) \r
694{\r
695 short x0,x1,y0,y1,dx,dy;float px,py;\r
696\r
697 if(bDisplayNotSet)\r
698 SetOGLDisplaySettings(1);\r
699\r
700 if(!(dwActFixes&16))\r
701 {\r
702 lx0=(short)(((int)lx0<<SIGNSHIFT)>>SIGNSHIFT);\r
703 lx1=(short)(((int)lx1<<SIGNSHIFT)>>SIGNSHIFT);\r
704 ly0=(short)(((int)ly0<<SIGNSHIFT)>>SIGNSHIFT);\r
705 ly1=(short)(((int)ly1<<SIGNSHIFT)>>SIGNSHIFT);\r
706\r
707 if(CheckCoord2()) return TRUE;\r
708 }\r
709\r
710 x0 = (lx0 + PSXDisplay.CumulOffset.x)+1;\r
711 x1 = (lx1 + PSXDisplay.CumulOffset.x)+1;\r
712 y0 = (ly0 + PSXDisplay.CumulOffset.y)+1;\r
713 y1 = (ly1 + PSXDisplay.CumulOffset.y)+1;\r
714 \r
715 dx=x1-x0;\r
716 dy=y1-y0;\r
717 \r
718 if(dx>=0)\r
719 {\r
720 if(dy>=0)\r
721 {\r
722 px=0.5f;\r
723 if(dx>dy) py=-0.5f;\r
724 else if(dx<dy) py= 0.5f;\r
725 else py= 0.0f;\r
726 }\r
727 else\r
728 {\r
729 py=-0.5f;\r
730 dy=-dy;\r
731 if(dx>dy) px= 0.5f;\r
732 else if(dx<dy) px=-0.5f;\r
733 else px= 0.0f;\r
734 }\r
735 }\r
736 else\r
737 {\r
738 if(dy>=0)\r
739 {\r
740 py=0.5f;\r
741 dx=-dx;\r
742 if(dx>dy) px=-0.5f;\r
743 else if(dx<dy) px= 0.5f;\r
744 else px= 0.0f;\r
745 }\r
746 else\r
747 {\r
748 px=-0.5f;\r
749 if(dx>dy) py=-0.5f;\r
750 else if(dx<dy) py= 0.5f;\r
751 else py= 0.0f;\r
752 }\r
753 } \r
754 \r
755 vertex[0].x=(short)((float)x0-px);\r
756 vertex[3].x=(short)((float)x0+py);\r
757 \r
758 vertex[0].y=(short)((float)y0-py);\r
759 vertex[3].y=(short)((float)y0-px);\r
760 \r
761 vertex[1].x=(short)((float)x1-py);\r
762 vertex[2].x=(short)((float)x1+px);\r
763\r
764 vertex[1].y=(short)((float)y1+px);\r
765 vertex[2].y=(short)((float)y1+py);\r
766\r
767 if(vertex[0].x==vertex[3].x && // ortho rect? done\r
768 vertex[1].x==vertex[2].x &&\r
769 vertex[0].y==vertex[1].y &&\r
770 vertex[2].y==vertex[3].y) return FALSE;\r
771 if(vertex[0].x==vertex[1].x &&\r
772 vertex[2].x==vertex[3].x &&\r
773 vertex[0].y==vertex[3].y &&\r
774 vertex[1].y==vertex[2].y) return FALSE;\r
775\r
776 vertex[0].x-=VERTEX_OFFX; // otherwise a small offset\r
777 vertex[0].y-=VERTEX_OFFY; // to get better accuracy\r
778 vertex[1].x-=VERTEX_OFFX;\r
779 vertex[1].y-=VERTEX_OFFY;\r
780 vertex[2].x-=VERTEX_OFFX;\r
781 vertex[2].y-=VERTEX_OFFY;\r
782 vertex[3].x-=VERTEX_OFFX;\r
783 vertex[3].y-=VERTEX_OFFY;\r
784\r
785 return FALSE;\r
786}\r
787\r
788///////////////////////////////////////////////////////// \r
789\r
790BOOL offset2(void)\r
791{\r
792 if(bDisplayNotSet)\r
793 SetOGLDisplaySettings(1);\r
794\r
795 if(!(dwActFixes&16))\r
796 {\r
797 lx0=(short)(((int)lx0<<SIGNSHIFT)>>SIGNSHIFT);\r
798 lx1=(short)(((int)lx1<<SIGNSHIFT)>>SIGNSHIFT);\r
799 ly0=(short)(((int)ly0<<SIGNSHIFT)>>SIGNSHIFT);\r
800 ly1=(short)(((int)ly1<<SIGNSHIFT)>>SIGNSHIFT);\r
801\r
802 if(CheckCoord2()) return TRUE;\r
803 }\r
804\r
805 vertex[0].x=lx0+PSXDisplay.CumulOffset.x;\r
806 vertex[1].x=lx1+PSXDisplay.CumulOffset.x;\r
807 vertex[0].y=ly0+PSXDisplay.CumulOffset.y;\r
808 vertex[1].y=ly1+PSXDisplay.CumulOffset.y;\r
809\r
810 return FALSE;\r
811}\r
812\r
813///////////////////////////////////////////////////////// \r
814\r
815BOOL offset3(void)\r
816{\r
817 if(bDisplayNotSet)\r
818 SetOGLDisplaySettings(1);\r
819\r
820 if(!(dwActFixes&16))\r
821 {\r
822 lx0=(short)(((int)lx0<<SIGNSHIFT)>>SIGNSHIFT);\r
823 lx1=(short)(((int)lx1<<SIGNSHIFT)>>SIGNSHIFT);\r
824 lx2=(short)(((int)lx2<<SIGNSHIFT)>>SIGNSHIFT);\r
825 ly0=(short)(((int)ly0<<SIGNSHIFT)>>SIGNSHIFT);\r
826 ly1=(short)(((int)ly1<<SIGNSHIFT)>>SIGNSHIFT);\r
827 ly2=(short)(((int)ly2<<SIGNSHIFT)>>SIGNSHIFT);\r
828\r
829 if(CheckCoord3()) return TRUE;\r
830 }\r
831\r
832 vertex[0].x=lx0+PSXDisplay.CumulOffset.x;\r
833 vertex[1].x=lx1+PSXDisplay.CumulOffset.x;\r
834 vertex[2].x=lx2+PSXDisplay.CumulOffset.x;\r
835 vertex[0].y=ly0+PSXDisplay.CumulOffset.y;\r
836 vertex[1].y=ly1+PSXDisplay.CumulOffset.y;\r
837 vertex[2].y=ly2+PSXDisplay.CumulOffset.y;\r
838\r
839 return FALSE;\r
840}\r
841\r
842///////////////////////////////////////////////////////// \r
843\r
844BOOL offset4(void)\r
845{\r
846 if(bDisplayNotSet)\r
847 SetOGLDisplaySettings(1);\r
848\r
849 if(!(dwActFixes&16))\r
850 {\r
851 lx0=(short)(((int)lx0<<SIGNSHIFT)>>SIGNSHIFT);\r
852 lx1=(short)(((int)lx1<<SIGNSHIFT)>>SIGNSHIFT);\r
853 lx2=(short)(((int)lx2<<SIGNSHIFT)>>SIGNSHIFT);\r
854 lx3=(short)(((int)lx3<<SIGNSHIFT)>>SIGNSHIFT);\r
855 ly0=(short)(((int)ly0<<SIGNSHIFT)>>SIGNSHIFT);\r
856 ly1=(short)(((int)ly1<<SIGNSHIFT)>>SIGNSHIFT);\r
857 ly2=(short)(((int)ly2<<SIGNSHIFT)>>SIGNSHIFT);\r
858 ly3=(short)(((int)ly3<<SIGNSHIFT)>>SIGNSHIFT);\r
859\r
860 if(CheckCoord4()) return TRUE;\r
861 }\r
862\r
863 vertex[0].x=lx0+PSXDisplay.CumulOffset.x;\r
864 vertex[1].x=lx1+PSXDisplay.CumulOffset.x;\r
865 vertex[2].x=lx2+PSXDisplay.CumulOffset.x;\r
866 vertex[3].x=lx3+PSXDisplay.CumulOffset.x;\r
867 vertex[0].y=ly0+PSXDisplay.CumulOffset.y;\r
868 vertex[1].y=ly1+PSXDisplay.CumulOffset.y;\r
869 vertex[2].y=ly2+PSXDisplay.CumulOffset.y;\r
870 vertex[3].y=ly3+PSXDisplay.CumulOffset.y;\r
871\r
872 return FALSE;\r
873}\r
874\r
875///////////////////////////////////////////////////////// \r
876\r
877void offsetST(void)\r
878{\r
879 if(bDisplayNotSet)\r
880 SetOGLDisplaySettings(1);\r
881\r
882 if(!(dwActFixes&16))\r
883 {\r
884 lx0=(short)(((int)lx0<<SIGNSHIFT)>>SIGNSHIFT);\r
885 ly0=(short)(((int)ly0<<SIGNSHIFT)>>SIGNSHIFT);\r
886\r
887 if(lx0<-512 && PSXDisplay.DrawOffset.x<=-512)\r
888 lx0+=2048;\r
889\r
890 if(ly0<-512 && PSXDisplay.DrawOffset.y<=-512)\r
891 ly0+=2048;\r
892 }\r
893\r
894 ly1 = ly0;\r
895 ly2 = ly3 = ly0+sprtH;\r
896 lx3 = lx0;\r
897 lx1 = lx2 = lx0+sprtW;\r
898\r
899 vertex[0].x=lx0+PSXDisplay.CumulOffset.x;\r
900 vertex[1].x=lx1+PSXDisplay.CumulOffset.x;\r
901 vertex[2].x=lx2+PSXDisplay.CumulOffset.x;\r
902 vertex[3].x=lx3+PSXDisplay.CumulOffset.x;\r
903 vertex[0].y=ly0+PSXDisplay.CumulOffset.y;\r
904 vertex[1].y=ly1+PSXDisplay.CumulOffset.y;\r
905 vertex[2].y=ly2+PSXDisplay.CumulOffset.y;\r
906 vertex[3].y=ly3+PSXDisplay.CumulOffset.y;\r
907}\r
908\r
909///////////////////////////////////////////////////////// \r
910\r
911void offsetScreenUpload(long Position)\r
912{\r
913 if(bDisplayNotSet)\r
914 SetOGLDisplaySettings(1);\r
915\r
916 if(Position==-1)\r
917 {\r
918 long lmdx,lmdy;\r
919\r
920 lmdx=xrUploadArea.x0;\r
921 lmdy=xrUploadArea.y0;\r
922\r
923 lx0-=lmdx;\r
924 ly0-=lmdy;\r
925 lx1-=lmdx;\r
926 ly1-=lmdy;\r
927 lx2-=lmdx;\r
928 ly2-=lmdy;\r
929 lx3-=lmdx;\r
930 ly3-=lmdy;\r
931 }\r
932 else\r
933 if(Position)\r
934 {\r
935 lx0-=PSXDisplay.DisplayPosition.x;\r
936 ly0-=PSXDisplay.DisplayPosition.y;\r
937 lx1-=PSXDisplay.DisplayPosition.x;\r
938 ly1-=PSXDisplay.DisplayPosition.y;\r
939 lx2-=PSXDisplay.DisplayPosition.x;\r
940 ly2-=PSXDisplay.DisplayPosition.y;\r
941 lx3-=PSXDisplay.DisplayPosition.x;\r
942 ly3-=PSXDisplay.DisplayPosition.y;\r
943 }\r
944 else\r
945 {\r
946 lx0-=PreviousPSXDisplay.DisplayPosition.x;\r
947 ly0-=PreviousPSXDisplay.DisplayPosition.y;\r
948 lx1-=PreviousPSXDisplay.DisplayPosition.x;\r
949 ly1-=PreviousPSXDisplay.DisplayPosition.y;\r
950 lx2-=PreviousPSXDisplay.DisplayPosition.x;\r
951 ly2-=PreviousPSXDisplay.DisplayPosition.y;\r
952 lx3-=PreviousPSXDisplay.DisplayPosition.x;\r
953 ly3-=PreviousPSXDisplay.DisplayPosition.y;\r
954 }\r
955\r
956 vertex[0].x=lx0 + PreviousPSXDisplay.Range.x0;\r
957 vertex[1].x=lx1 + PreviousPSXDisplay.Range.x0;\r
958 vertex[2].x=lx2 + PreviousPSXDisplay.Range.x0;\r
959 vertex[3].x=lx3 + PreviousPSXDisplay.Range.x0;\r
960 vertex[0].y=ly0 + PreviousPSXDisplay.Range.y0;\r
961 vertex[1].y=ly1 + PreviousPSXDisplay.Range.y0;\r
962 vertex[2].y=ly2 + PreviousPSXDisplay.Range.y0;\r
963 vertex[3].y=ly3 + PreviousPSXDisplay.Range.y0;\r
964\r
965 if(iUseMask)\r
966 {\r
967 vertex[0].z=vertex[1].z=vertex[2].z=vertex[3].z=gl_z;\r
968 gl_z+=0.00004f;\r
969 }\r
970}\r
971 \r
972///////////////////////////////////////////////////////// \r
973\r
974void offsetBlk(void)\r
975{\r
976 if(bDisplayNotSet)\r
977 SetOGLDisplaySettings(1);\r
978 \r
979 vertex[0].x=lx0-PSXDisplay.GDrawOffset.x + PreviousPSXDisplay.Range.x0;\r
980 vertex[1].x=lx1-PSXDisplay.GDrawOffset.x + PreviousPSXDisplay.Range.x0;\r
981 vertex[2].x=lx2-PSXDisplay.GDrawOffset.x + PreviousPSXDisplay.Range.x0;\r
982 vertex[3].x=lx3-PSXDisplay.GDrawOffset.x + PreviousPSXDisplay.Range.x0;\r
983 vertex[0].y=ly0-PSXDisplay.GDrawOffset.y + PreviousPSXDisplay.Range.y0;\r
984 vertex[1].y=ly1-PSXDisplay.GDrawOffset.y + PreviousPSXDisplay.Range.y0;\r
985 vertex[2].y=ly2-PSXDisplay.GDrawOffset.y + PreviousPSXDisplay.Range.y0;\r
986 vertex[3].y=ly3-PSXDisplay.GDrawOffset.y + PreviousPSXDisplay.Range.y0;\r
987\r
988 if(iUseMask)\r
989 {\r
990 vertex[0].z=vertex[1].z=vertex[2].z=vertex[3].z=gl_z;\r
991 gl_z+=0.00004f;\r
992 }\r
993}\r
994\r
995////////////////////////////////////////////////////////////////////////\r
996// texture sow/tow calculations\r
997////////////////////////////////////////////////////////////////////////\r
998\r
999void assignTextureVRAMWrite(void)\r
1000{\r
1001#ifdef OWNSCALE\r
1002\r
1003 vertex[0].sow=0.5f/ ST_FACVRAMX;\r
1004 vertex[0].tow=0.5f/ ST_FACVRAM;\r
1005\r
1006 vertex[1].sow=(float)gl_ux[1]/ ST_FACVRAMX;\r
1007 vertex[1].tow=0.5f/ ST_FACVRAM;\r
1008\r
1009 vertex[2].sow=(float)gl_ux[2]/ ST_FACVRAMX;\r
1010 vertex[2].tow=(float)gl_vy[2]/ ST_FACVRAM;\r
1011\r
1012 vertex[3].sow=0.5f/ ST_FACVRAMX;\r
1013 vertex[3].tow=(float)gl_vy[3]/ ST_FACVRAM;\r
1014\r
1015#else\r
1016\r
1017 if(gl_ux[1]==255)\r
1018 {\r
1019 vertex[0].sow=(gl_ux[0]*255.99f)/255.0f;\r
1020 vertex[1].sow=(gl_ux[1]*255.99f)/255.0f;\r
1021 vertex[2].sow=(gl_ux[2]*255.99f)/255.0f;\r
1022 vertex[3].sow=(gl_ux[3]*255.99f)/255.0f;\r
1023 }\r
1024 else\r
1025 {\r
1026 vertex[0].sow=gl_ux[0];\r
1027 vertex[1].sow=gl_ux[1];\r
1028 vertex[2].sow=gl_ux[2];\r
1029 vertex[3].sow=gl_ux[3];\r
1030 }\r
1031\r
1032 vertex[0].tow=gl_vy[0];\r
1033 vertex[1].tow=gl_vy[1];\r
1034 vertex[2].tow=gl_vy[2];\r
1035 vertex[3].tow=gl_vy[3];\r
1036\r
1037#endif\r
1038}\r
1039\r
1040GLuint gLastTex=0;\r
1041GLuint gLastFMode=(GLuint)-1;\r
1042\r
1043///////////////////////////////////////////////////////// \r
1044\r
1045void assignTextureSprite(void)\r
1046{\r
1047 if(bUsingTWin)\r
1048 {\r
1049 vertex[0].sow=vertex[3].sow=(float)gl_ux[0]/TWin.UScaleFactor;\r
1050 vertex[1].sow=vertex[2].sow=(float)sSprite_ux2/TWin.UScaleFactor;\r
1051 vertex[0].tow=vertex[1].tow=(float)gl_vy[0]/TWin.VScaleFactor;\r
1052 vertex[2].tow=vertex[3].tow=(float)sSprite_vy2/TWin.VScaleFactor;\r
1053 gLastTex=gTexName;\r
1054 }\r
1055 else\r
1056 {\r
1057#ifdef OWNSCALE\r
1058\r
1059 vertex[0].sow=vertex[3].sow=(float)gl_ux[0] / ST_FACSPRITE;\r
1060 vertex[1].sow=vertex[2].sow=(float)sSprite_ux2 / ST_FACSPRITE;\r
1061 vertex[0].tow=vertex[1].tow=(float)gl_vy[0] / ST_FACSPRITE;\r
1062 vertex[2].tow=vertex[3].tow=(float)sSprite_vy2 / ST_FACSPRITE;\r
1063\r
1064#else\r
1065 \r
1066 vertex[0].sow=vertex[3].sow=gl_ux[0];\r
1067 vertex[1].sow=vertex[2].sow=sSprite_ux2;\r
1068 vertex[0].tow=vertex[1].tow=gl_vy[0];\r
1069 vertex[2].tow=vertex[3].tow=sSprite_vy2;\r
1070\r
1071#endif\r
1072\r
1073 if(iFilterType>2) \r
1074 {\r
1075 if(gLastTex!=gTexName || gLastFMode!=0)\r
1076 {\r
1077 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); glError();\r
1078 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glError();\r
1079 gLastTex=gTexName;gLastFMode=0;\r
1080 }\r
1081 }\r
1082 }\r
1083\r
1084 if(usMirror & 0x1000) \r
1085 {\r
1086 vertex[0].sow=vertex[1].sow;\r
1087 vertex[1].sow=vertex[2].sow=vertex[3].sow;\r
1088 vertex[3].sow=vertex[0].sow;\r
1089 }\r
1090\r
1091 if(usMirror & 0x2000) \r
1092 {\r
1093 vertex[0].tow=vertex[3].tow;\r
1094 vertex[2].tow=vertex[3].tow=vertex[1].tow;\r
1095 vertex[1].tow=vertex[0].tow;\r
1096 }\r
1097\r
1098}\r
1099\r
1100///////////////////////////////////////////////////////// \r
1101\r
1102void assignTexture3(void)\r
1103{\r
1104 if(bUsingTWin)\r
1105 {\r
1106 vertex[0].sow=(float)gl_ux[0]/TWin.UScaleFactor;\r
1107 vertex[0].tow=(float)gl_vy[0]/TWin.VScaleFactor;\r
1108 vertex[1].sow=(float)gl_ux[1]/TWin.UScaleFactor;\r
1109 vertex[1].tow=(float)gl_vy[1]/TWin.VScaleFactor;\r
1110 vertex[2].sow=(float)gl_ux[2]/TWin.UScaleFactor;\r
1111 vertex[2].tow=(float)gl_vy[2]/TWin.VScaleFactor;\r
1112 gLastTex=gTexName;\r
1113 }\r
1114 else\r
1115 {\r
1116#ifdef OWNSCALE\r
1117 vertex[0].sow=(float)gl_ux[0] / ST_FACTRI;\r
1118 vertex[0].tow=(float)gl_vy[0] / ST_FACTRI;\r
1119 vertex[1].sow=(float)gl_ux[1] / ST_FACTRI;\r
1120\r
1121 vertex[1].tow=(float)gl_vy[1] / ST_FACTRI;\r
1122 vertex[2].sow=(float)gl_ux[2] / ST_FACTRI;\r
1123 vertex[2].tow=(float)gl_vy[2] / ST_FACTRI;\r
1124#else\r
1125 vertex[0].sow=gl_ux[0];\r
1126 vertex[0].tow=gl_vy[0];\r
1127 vertex[1].sow=gl_ux[1];\r
1128 vertex[1].tow=gl_vy[1];\r
1129 vertex[2].sow=gl_ux[2];\r
1130 vertex[2].tow=gl_vy[2];\r
1131#endif\r
1132\r
1133 if(iFilterType>2) \r
1134 {\r
1135 if(gLastTex!=gTexName || gLastFMode!=1)\r
1136 {\r
1137 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); glError();\r
1138 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glError();\r
1139 gLastTex=gTexName;gLastFMode=1;\r
1140 }\r
1141 }\r
1142\r
1143 if(iFilterType) \r
1144 {\r
1145 float fxmin=256.0f,fxmax=0.0f,fymin=256.0f,fymax=0.0f;int i;\r
1146 for(i=0;i<3;i++)\r
1147 {\r
1148 if(vertex[i].sow<fxmin) fxmin=vertex[i].sow;\r
1149 if(vertex[i].tow<fymin) fymin=vertex[i].tow;\r
1150 if(vertex[i].sow>fxmax) fxmax=vertex[i].sow;\r
1151 if(vertex[i].tow>fymax) fymax=vertex[i].tow; \r
1152 }\r
1153\r
1154 for(i=0;i<3;i++)\r
1155 {\r
1156 if(vertex[i].sow==fxmin) vertex[i].sow+=ST_BFFACSORT;\r
1157 if(vertex[i].sow==fxmax) vertex[i].sow-=ST_BFFACSORT;\r
1158 if(vertex[i].tow==fymin) vertex[i].tow+=ST_BFFACSORT;\r
1159 if(vertex[i].tow==fymax) vertex[i].tow-=ST_BFFACSORT;\r
1160 }\r
1161 }\r
1162 }\r
1163}\r
1164\r
1165///////////////////////////////////////////////////////// \r
1166\r
1167void assignTexture4(void)\r
1168{\r
1169 if(bUsingTWin)\r
1170 {\r
1171 vertex[0].sow=(float)gl_ux[0]/TWin.UScaleFactor;\r
1172 vertex[0].tow=(float)gl_vy[0]/TWin.VScaleFactor;\r
1173 vertex[1].sow=(float)gl_ux[1]/TWin.UScaleFactor;\r
1174 vertex[1].tow=(float)gl_vy[1]/TWin.VScaleFactor;\r
1175 vertex[2].sow=(float)gl_ux[2]/TWin.UScaleFactor;\r
1176 vertex[2].tow=(float)gl_vy[2]/TWin.VScaleFactor;\r
1177 vertex[3].sow=(float)gl_ux[3]/TWin.UScaleFactor;\r
1178 vertex[3].tow=(float)gl_vy[3]/TWin.VScaleFactor;\r
1179 gLastTex=gTexName;\r
1180 }\r
1181 else\r
1182 {\r
1183#ifdef OWNSCALE\r
1184 vertex[0].sow=(float)gl_ux[0] / ST_FAC;\r
1185 vertex[0].tow=(float)gl_vy[0] / ST_FAC;\r
1186 vertex[1].sow=(float)gl_ux[1] / ST_FAC;\r
1187 vertex[1].tow=(float)gl_vy[1] / ST_FAC;\r
1188 vertex[2].sow=(float)gl_ux[2] / ST_FAC;\r
1189 vertex[2].tow=(float)gl_vy[2] / ST_FAC;\r
1190 vertex[3].sow=(float)gl_ux[3] / ST_FAC;\r
1191 vertex[3].tow=(float)gl_vy[3] / ST_FAC;\r
1192#else\r
1193 vertex[0].sow=gl_ux[0];\r
1194 vertex[0].tow=gl_vy[0];\r
1195 vertex[1].sow=gl_ux[1];\r
1196 vertex[1].tow=gl_vy[1];\r
1197 vertex[2].sow=gl_ux[2];\r
1198 vertex[2].tow=gl_vy[2];\r
1199 vertex[3].sow=gl_ux[3];\r
1200 vertex[3].tow=gl_vy[3];\r
1201#endif\r
1202\r
1203 if(iFilterType>2) \r
1204 {\r
1205 if(gLastTex!=gTexName || gLastFMode!=1)\r
1206 {\r
1207 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); glError();\r
1208 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glError();\r
1209 gLastTex=gTexName;gLastFMode=1;\r
1210 }\r
1211 }\r
1212\r
1213 if(iFilterType) \r
1214 {\r
1215 float fxmin=256.0f,fxmax=0.0f,fymin=256.0f,fymax=0.0f;int i;\r
1216 for(i=0;i<4;i++)\r
1217 {\r
1218 if(vertex[i].sow<fxmin) fxmin=vertex[i].sow;\r
1219 if(vertex[i].tow<fymin) fymin=vertex[i].tow;\r
1220 if(vertex[i].sow>fxmax) fxmax=vertex[i].sow;\r
1221 if(vertex[i].tow>fymax) fymax=vertex[i].tow; \r
1222 }\r
1223\r
1224 for(i=0;i<4;i++)\r
1225 {\r
1226 if(vertex[i].sow==fxmin) vertex[i].sow+=ST_BFFACSORT;\r
1227 if(vertex[i].sow==fxmax) vertex[i].sow-=ST_BFFACSORT;\r
1228 if(vertex[i].tow==fymin) vertex[i].tow+=ST_BFFACSORT;\r
1229 if(vertex[i].tow==fymax) vertex[i].tow-=ST_BFFACSORT;\r
1230 }\r
1231 }\r
1232 }\r
1233}\r
1234\r
1235////////////////////////////////////////////////////////////////////////\r
1236////////////////////////////////////////////////////////////////////////\r
1237////////////////////////////////////////////////////////////////////////\r
1238\r
1239////////////////////////////////////////////////////////////////////////\r
1240// render pos / buffers\r
1241////////////////////////////////////////////////////////////////////////\r
1242\r
1243#define EqualRect(pr1,pr2) ((pr1)->left==(pr2)->left && (pr1)->top==(pr2)->top && (pr1)->right==(pr2)->right && (pr1)->bottom==(pr2)->bottom)\r
1244\r
1245////////////////////////////////////////////////////////////////////////\r
1246// SetDisplaySettings: "simply" calcs the new drawing area and updates\r
1247// the ogl clipping (scissor) \r
1248\r
1249BOOL bSetClip=FALSE;\r
1250\r
1251void SetOGLDisplaySettings(BOOL DisplaySet)\r
1252{\r
1253 static RECT rprev={0,0,0,0};\r
1254 static RECT rC ={0,0,0,0};\r
1255 static int iOldX=0;\r
1256 static int iOldY=0;\r
1257 RECT r;float XS,YS;\r
1258\r
1259 bDisplayNotSet = FALSE;\r
1260\r
1261 //----------------------------------------------------// that's a whole screen upload\r
1262 if(!DisplaySet)\r
1263 {\r
1264 RECT rX;\r
1265 PSXDisplay.GDrawOffset.x=0;\r
1266 PSXDisplay.GDrawOffset.y=0;\r
1267\r
1268 PSXDisplay.CumulOffset.x = PSXDisplay.DrawOffset.x+PreviousPSXDisplay.Range.x0;\r
1269 PSXDisplay.CumulOffset.y = PSXDisplay.DrawOffset.y+PreviousPSXDisplay.Range.y0;\r
1270\r
1271 rprev.left=rprev.left+1;\r
1272\r
1273 rX=rRatioRect;\r
1274 rX.top=iResY-(rRatioRect.top+rRatioRect.bottom);\r
1275\r
1276 if(bSetClip || !EqualRect(&rC,&rX))\r
1277 {\r
1278 rC=rX;\r
1279 glScissor(rC.left,rC.top,rC.right,rC.bottom); glError();\r
1280 //LOGE("glscissor:%d %d %d %d",rC.left,rC.top,rC.right,rC.bottom);\r
1281 bSetClip=FALSE; \r
1282 }\r
1283 return;\r
1284 }\r
1285 //----------------------------------------------------// \r
1286\r
1287 PSXDisplay.GDrawOffset.y = PreviousPSXDisplay.DisplayPosition.y;\r
1288 PSXDisplay.GDrawOffset.x = PreviousPSXDisplay.DisplayPosition.x;\r
1289 PSXDisplay.CumulOffset.x = PSXDisplay.DrawOffset.x - PSXDisplay.GDrawOffset.x+PreviousPSXDisplay.Range.x0;\r
1290 PSXDisplay.CumulOffset.y = PSXDisplay.DrawOffset.y - PSXDisplay.GDrawOffset.y+PreviousPSXDisplay.Range.y0;\r
1291\r
1292 r.top =PSXDisplay.DrawArea.y0 - PreviousPSXDisplay.DisplayPosition.y;\r
1293 r.bottom=PSXDisplay.DrawArea.y1 - PreviousPSXDisplay.DisplayPosition.y;\r
1294\r
1295 if(r.bottom<0 || r.top>=PSXDisplay.DisplayMode.y)\r
1296 {\r
1297 r.top =PSXDisplay.DrawArea.y0 - PSXDisplay.DisplayPosition.y;\r
1298 r.bottom=PSXDisplay.DrawArea.y1 - PSXDisplay.DisplayPosition.y;\r
1299 }\r
1300\r
1301 r.left =PSXDisplay.DrawArea.x0 - PreviousPSXDisplay.DisplayPosition.x;\r
1302 r.right =PSXDisplay.DrawArea.x1 - PreviousPSXDisplay.DisplayPosition.x;\r
1303\r
1304 if(r.right<0 || r.left>=PSXDisplay.DisplayMode.x)\r
1305 {\r
1306 r.left =PSXDisplay.DrawArea.x0 - PSXDisplay.DisplayPosition.x;\r
1307 r.right =PSXDisplay.DrawArea.x1 - PSXDisplay.DisplayPosition.x;\r
1308 }\r
1309\r
1310 if(!bSetClip && EqualRect(&r,&rprev) &&\r
1311 iOldX == PSXDisplay.DisplayMode.x &&\r
1312 iOldY == PSXDisplay.DisplayMode.y)\r
1313 return;\r
1314\r
1315 rprev = r;\r
1316 iOldX = PSXDisplay.DisplayMode.x;\r
1317 iOldY = PSXDisplay.DisplayMode.y;\r
1318\r
1319 XS=(float)rRatioRect.right/(float)PSXDisplay.DisplayMode.x;\r
1320 YS=(float)rRatioRect.bottom/(float)PSXDisplay.DisplayMode.y;\r
1321\r
1322 if(PreviousPSXDisplay.Range.x0)\r
1323 {\r
1324 short s=PreviousPSXDisplay.Range.x0+PreviousPSXDisplay.Range.x1;\r
1325\r
1326 r.left+=PreviousPSXDisplay.Range.x0+1;\r
1327\r
1328 r.right+=PreviousPSXDisplay.Range.x0;\r
1329\r
1330 if(r.left>s) r.left=s;\r
1331 if(r.right>s) r.right=s;\r
1332 }\r
1333\r
1334 if(PreviousPSXDisplay.Range.y0)\r
1335 {\r
1336 short s=PreviousPSXDisplay.Range.y0+PreviousPSXDisplay.Range.y1;\r
1337\r
1338 r.top+=PreviousPSXDisplay.Range.y0+1;\r
1339 r.bottom+=PreviousPSXDisplay.Range.y0;\r
1340\r
1341 if(r.top>s) r.top=s;\r
1342 if(r.bottom>s) r.bottom=s;\r
1343 }\r
1344\r
1345 // Set the ClipArea variables to reflect the new screen,\r
1346 // offset from zero (since it is a new display buffer)\r
1347 r.left = (int)(((float)(r.left)) *XS);\r
1348 r.top = (int)(((float)(r.top)) *YS);\r
1349 r.right = (int)(((float)(r.right + 1))*XS);\r
1350 r.bottom = (int)(((float)(r.bottom + 1))*YS);\r
1351\r
1352 // Limit clip area to the screen size\r
1353 if (r.left > iResX) r.left = iResX;\r
1354 if (r.left < 0) r.left = 0;\r
1355 if (r.top > iResY) r.top = iResY;\r
1356 if (r.top < 0) r.top = 0;\r
1357 if (r.right > iResX) r.right = iResX;\r
1358 if (r.right < 0) r.right = 0;\r
1359 if (r.bottom > iResY) r.bottom = iResY;\r
1360 if (r.bottom < 0) r.bottom = 0;\r
1361\r
1362 r.right -=r.left;\r
1363 r.bottom-=r.top;\r
1364 r.top=iResY-(r.top+r.bottom);\r
1365\r
1366 r.left+=rRatioRect.left;\r
1367 r.top -=rRatioRect.top;\r
1368\r
1369 if(bSetClip || !EqualRect(&r,&rC))\r
1370 {\r
1371 glScissor(r.left,r.top,r.right,r.bottom); glError();\r
1372\r
1373 rC=r;\r
1374 bSetClip=FALSE;\r
1375 }\r
1376}\r
1377\r
1378////////////////////////////////////////////////////////////////////////\r
1379////////////////////////////////////////////////////////////////////////\r
1380////////////////////////////////////////////////////////////////////////\r
1381\r
ARM optimized PCSX fork