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
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
43 ////////////////////////////////////////////////////////////////////////////////////
\r
46 #define SIGNBIT 0x800
\r
47 #define S_MASK 0xf000
\r
48 #define L_MASK 0xfffff000
\r
50 // ownscale: some ogl drivers have buggy texture matrix funcs, so it
\r
51 // is safer to calc sow/tow ourselves
\r
55 ///////////////////////////////////////////////////////////////
\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
61 #define ST_OFFSET 0.5f/256.0f;
\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
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
71 #define ST_FACVRAMX 255.0f
\r
72 #define ST_FACVRAM 256.0f
\r
74 ///////////////////////////////////////////////////////////////
\r
78 #define ST_BFFACSPRITE 0.5f
\r
79 #define ST_BFFACSPRITESORT 0.333f
\r
81 #define ST_BFFAC 0.5f
\r
82 #define ST_BFFACSORT 0.333f
\r
84 #define ST_BFFACTRI 0.5f
\r
85 #define ST_BFFACTRISORT 0.333f
\r
87 #define ST_OFFSET 0.5f;
\r
91 ////////////////////////////////////////////////////////////////////////////////////
\r
94 void glBlendEquationEXT(GLenum mode);
\r
95 void glColorTableEXT(GLenum target, GLenum internalFormat, GLsizei width, GLenum format,GLenum type, const GLvoid *data);
\r
97 // draw globals; most will be initialized again later (by config or checks)
\r
99 BOOL bIsFirstFrame=TRUE;
\r
101 // resolution/ratio vars
\r
105 BOOL bKeepRatio=FALSE;
\r
108 // psx mask related vars
\r
110 BOOL bCheckMask=FALSE;
\r
113 unsigned short sSetMask=0;
\r
114 unsigned long lSetMask=0;
\r
116 // drawing/coord vars
\r
118 OGLVertex vertex[4];
\r
121 short sprtY,sprtX,sprtH,sprtW;
\r
126 BOOL bAdvancedBlend;
\r
128 // OGL extension support
\r
131 // gfx card buffer infos
\r
134 int iZBufferDepth=0;
\r
135 GLbitfield uiBufferBits=GL_COLOR_BUFFER_BIT;
\r
137 ////////////////////////////////////////////////////////////////////////
\r
138 ////////////////////////////////////////////////////////////////////////
\r
139 ////////////////////////////////////////////////////////////////////////
\r
141 ////////////////////////////////////////////////////////////////////////
\r
142 // Set OGL pixel format
\r
143 ////////////////////////////////////////////////////////////////////////
\r
146 ////////////////////////////////////////////////////////////////////////
\r
147 // Get extension infos (f.e. pal textures / packed pixels)
\r
148 ////////////////////////////////////////////////////////////////////////
\r
150 void GetExtInfos(void)
\r
152 BOOL bPacked=FALSE; // default: no packed pixel support
\r
154 if(strstr((char *)glGetString(GL_EXTENSIONS), // packed pixels available?
\r
155 "GL_EXT_packed_pixels"))
\r
156 bPacked=TRUE; // -> ok
\r
159 iClampType=GL_CLAMP_TO_EDGE;
\r
162 ////////////////////////////////////////////////////////////////////////
\r
163 // Setup some stuff depending on user settings or in-game toggle
\r
164 ////////////////////////////////////////////////////////////////////////
\r
166 void SetExtGLFuncs(void)
\r
168 //----------------------------------------------------//
\r
170 SetFixes(); // update fix infos
\r
172 //----------------------------------------------------//
\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
181 if(bOpaquePass) // opaque mode?
\r
186 PalTexturedColourFn=CP8RGBA; // -> init col func
\r
191 PalTexturedColourFn=XP8RGBA; // -> init col func
\r
195 glAlphaFuncx(GL_GREATER,0.49f); glError();
\r
198 else // no opaque mode?
\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
206 //----------------------------------------------------//
\r
208 LoadSubTexFn=LoadSubTexturePageSort; // init load tex ptr
\r
210 bBlendEnable=FALSE; // init blending: off
\r
211 glDisable(GL_BLEND); glError();
\r
214 SetScanTrans(); // init scan lines (if wanted)
\r
217 ////////////////////////////////////////////////////////////////////////
\r
218 // setup scan lines
\r
219 ////////////////////////////////////////////////////////////////////////
\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
227 GLuint gTexScanName=0;
\r
229 GLubyte texscan[4][16]=
\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
237 void CreateScanLines(void)
\r
241 ////////////////////////////////////////////////////////////////////////
\r
243 ////////////////////////////////////////////////////////////////////////
\r
250 EGLDisplay display;
\r
252 EGLContext context;
\r
253 EGLSurface surface;
\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
260 Window x11Window = 0;
\r
261 Display* x11Display = 0;
\r
262 long x11Screen = 0;
\r
263 XVisualInfo x11Visual;
\r
264 XVisualInfo* px11Visual = 0;
\r
265 Colormap x11Colormap = 0;
\r
268 EGLint attrib_list_fsaa[] =
\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
278 EGLint attrib_list[] =
\r
280 // EGL_DEPTH_SIZE, 16,
\r
284 bool TestEGLError(const char* pszLocation)
\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
291 EGLint iErr = eglGetError();
\r
292 if (iErr != EGL_SUCCESS)
\r
294 printf("%s failed (0x%x).\n", pszLocation, iErr);
\r
301 static int initEGL(void)
\r
303 NativeWindowType window = 0;
\r
305 printf ("GL init\n");
\r
308 EGLint majorVersion;
\r
309 EGLint minorVersion;
\r
310 #if defined(USE_X11)
\r
313 _NET_WM_STATE_REMOVE =0,
\r
314 _NET_WM_STATE_ADD = 1,
\r
315 _NET_WM_STATE_TOGGLE =2
\r
318 Window sRootWindow;
\r
319 XSetWindowAttributes sWA;
\r
320 unsigned int ui32Mask;
\r
324 EGLint *attribList = NULL;
\r
327 printf( "GLES: Using Full Scene Antialiasing\n" );
\r
328 attribList = attrib_list_fsaa;
\r
332 attribList = attrib_list;
\r
335 #if defined(USE_X11)
\r
336 // Initializes the display and screen
\r
337 x11Display = XOpenDisplay( ":0" );
\r
340 printf("GLES Error: Unable to open X display\n");
\r
343 x11Screen = XDefaultScreen( x11Display );
\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
352 printf("GLES Error: Unable to acquire visual\n");
\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
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
362 // Display capabilities list.
\r
363 ui32Mask = CWBackPixel | CWBorderPixel | CWEventMask | CWColormap;
\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
369 // Make the window viewable and flush the output buffer.
\r
370 XMapWindow(x11Display, x11Window);
\r
371 XFlush(x11Display);
\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
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
389 XSendEvent(x11Display, DefaultRootWindow(x11Display), False, SubstructureRedirectMask | SubstructureNotifyMask, &xev);
\r
391 display = eglGetDisplay( (EGLNativeDisplayType)x11Display );
\r
392 window = x11Window;
\r
394 display = eglGetDisplay( (EGLNativeDisplayType)0 );
\r
397 if( display == EGL_NO_DISPLAY )
\r
399 printf( "GLES EGL Error: GL No Display\n" );
\r
403 if( !eglInitialize( display, &majorVersion, &minorVersion ) )
\r
405 printf( "GLES EGL Error: eglInitialize failed\n" );
\r
409 if( !eglChooseConfig( display, attribList, &config, 1, &numConfigs ) )
\r
411 printf( "GLES EGL Error: eglChooseConfig failed\n" );
\r
415 context = eglCreateContext( display, config, NULL, NULL );
\r
418 printf( "GLES EGL Error: eglCreateContext failed\n" );
\r
423 // broken Caanoo libs won't accept NULL window
\r
424 window = (NativeWindowType)1;
\r
426 surface = eglCreateWindowSurface( display, config, window, NULL );
\r
427 if (!TestEGLError("eglCreateWindowSurface"))
\r
430 eglMakeCurrent( display, surface, surface, context );
\r
431 if (!TestEGLError("eglMakeCurrent"))
\r
434 printf("GLES init ok\n");
\r
438 int GLinitialize()
\r
443 //----------------------------------------------------//
\r
445 glDepthRangef(0.0f, 1.0f);glError();
\r
447 glViewport(rRatioRect.left, // init viewport by ratio rect
\r
448 iResY-(rRatioRect.top+rRatioRect.bottom),
\r
450 rRatioRect.bottom); glError();
\r
452 glScissor(0, 0, iResX, iResY); glError(); // init clipping (fullscreen)
\r
453 glEnable(GL_SCISSOR_TEST); glError();
\r
456 glMatrixMode(GL_TEXTURE); // init psx tex sow and tow if not "ownscale"
\r
458 glScalef(1.0f/255.99f,1.0f/255.99f,1.0f); // geforce precision hack
\r
461 //glPolygonOffset( -0.2f, -0.2f );glError();
\r
463 glMatrixMode(GL_PROJECTION); glError(); // init projection with psx resolution
\r
464 glLoadIdentity(); glError();
\r
466 glOrtho(0,PSXDisplay.DisplayMode.x,
\r
467 PSXDisplay.DisplayMode.y, 0, -1, 1); glError();
\r
469 if(iZBufferDepth) // zbuffer?
\r
471 uiBufferBits=GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT;
\r
472 glEnable(GL_DEPTH_TEST); glError();
\r
473 glDepthFunc(GL_ALWAYS); glError();
\r
476 else // no zbuffer?
\r
478 uiBufferBits=GL_COLOR_BUFFER_BIT;
\r
479 glDisable(GL_DEPTH_TEST); glError();
\r
482 glClearColor(0.0f, 0.0f, 0.0f, 0.0f); glError(); // first buffer clear
\r
483 glClear(uiBufferBits); glError();
\r
485 GetExtInfos(); // get ext infos
\r
486 SetExtGLFuncs(); // init all kind of stuff (tex function pointers)
\r
488 glEnable(GL_ALPHA_TEST); glError(); // wanna alpha test
\r
491 glDisable(GL_LINE_SMOOTH); glError();
\r
492 glDisable(GL_POINT_SMOOTH); glError();
\r
495 ubGloAlpha=127; // init some drawing vars
\r
497 TWin.UScaleFactor = 1;
\r
498 TWin.VScaleFactor = 1;
\r
499 bDrawMultiPass=FALSE;
\r
503 if(bDrawDither) glEnable(GL_DITHER); // dither mode
\r
504 else glDisable(GL_DITHER);
\r
506 glDisable(GL_FOG); glError(); // turn all (currently) unused modes off
\r
507 glDisable(GL_LIGHTING); glError();
\r
508 glDisable(GL_STENCIL_TEST); glError();
\r
509 glDisable(GL_TEXTURE_2D); glError();
\r
510 glDisable(GL_CULL_FACE);
\r
512 glFlush(); glError(); // we are done...
\r
513 glFinish(); glError();
\r
515 CreateScanLines(); // setup scanline stuff (if wanted)
\r
517 CheckTextureMemory(); // check available tex memory
\r
519 if(bKeepRatio) SetAspectRatio(); // set ratio
\r
522 bIsFirstFrame = FALSE; // we have survived the first frame :)
\r
527 ////////////////////////////////////////////////////////////////////////
\r
528 // clean up OGL stuff
\r
529 ////////////////////////////////////////////////////////////////////////
\r
533 CleanupTextureStore(); // bye textures
\r
535 eglMakeCurrent( display, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT );
\r
536 eglDestroySurface( display, surface );
\r
537 eglDestroyContext( display, context );
\r
538 eglTerminate( display );
\r
540 #if defined(USE_X11)
\r
541 if (x11Window) XDestroyWindow(x11Display, x11Window);
\r
542 if (x11Colormap) XFreeColormap( x11Display, x11Colormap );
\r
543 if (x11Display) XCloseDisplay(x11Display);
\r
547 ////////////////////////////////////////////////////////////////////////
\r
548 ////////////////////////////////////////////////////////////////////////
\r
549 ////////////////////////////////////////////////////////////////////////
\r
551 ////////////////////////////////////////////////////////////////////////
\r
552 ////////////////////////////////////////////////////////////////////////
\r
553 ////////////////////////////////////////////////////////////////////////
\r
555 ////////////////////////////////////////////////////////////////////////
\r
557 ////////////////////////////////////////////////////////////////////////
\r
559 // please note: it is hardly do-able in a hw/accel plugin to get the
\r
560 // real psx polygon coord mapping right... the following
\r
561 // works not to bad with many games, though
\r
563 __inline BOOL CheckCoord4()
\r
567 if(((lx1-lx0)>CHKMAX_X) ||
\r
568 ((lx2-lx0)>CHKMAX_X))
\r
572 if((lx1-lx3)>CHKMAX_X) return TRUE;
\r
573 if((lx2-lx3)>CHKMAX_X) return TRUE;
\r
579 if((lx0-lx1)>CHKMAX_X) return TRUE;
\r
580 if((lx2-lx1)>CHKMAX_X) return TRUE;
\r
581 if((lx3-lx1)>CHKMAX_X) return TRUE;
\r
585 if((lx0-lx2)>CHKMAX_X) return TRUE;
\r
586 if((lx1-lx2)>CHKMAX_X) return TRUE;
\r
587 if((lx3-lx2)>CHKMAX_X) return TRUE;
\r
591 if(((lx1-lx3)>CHKMAX_X) ||
\r
592 ((lx2-lx3)>CHKMAX_X))
\r
596 if((lx1-lx0)>CHKMAX_X) return TRUE;
\r
597 if((lx2-lx0)>CHKMAX_X) return TRUE;
\r
605 if((ly1-ly0)>CHKMAX_Y) return TRUE;
\r
606 if((ly2-ly0)>CHKMAX_Y) return TRUE;
\r
610 if((ly0-ly1)>CHKMAX_Y) return TRUE;
\r
611 if((ly2-ly1)>CHKMAX_Y) return TRUE;
\r
612 if((ly3-ly1)>CHKMAX_Y) return TRUE;
\r
616 if((ly0-ly2)>CHKMAX_Y) return TRUE;
\r
617 if((ly1-ly2)>CHKMAX_Y) return TRUE;
\r
618 if((ly3-ly2)>CHKMAX_Y) return TRUE;
\r
622 if((ly1-ly3)>CHKMAX_Y) return TRUE;
\r
623 if((ly2-ly3)>CHKMAX_Y) return TRUE;
\r
629 __inline BOOL CheckCoord3()
\r
633 if((lx1-lx0)>CHKMAX_X) return TRUE;
\r
634 if((lx2-lx0)>CHKMAX_X) return TRUE;
\r
638 if((lx0-lx1)>CHKMAX_X) return TRUE;
\r
639 if((lx2-lx1)>CHKMAX_X) return TRUE;
\r
643 if((lx0-lx2)>CHKMAX_X) return TRUE;
\r
644 if((lx1-lx2)>CHKMAX_X) return TRUE;
\r
648 if((ly1-ly0)>CHKMAX_Y) return TRUE;
\r
649 if((ly2-ly0)>CHKMAX_Y) return TRUE;
\r
653 if((ly0-ly1)>CHKMAX_Y) return TRUE;
\r
654 if((ly2-ly1)>CHKMAX_Y) return TRUE;
\r
658 if((ly0-ly2)>CHKMAX_Y) return TRUE;
\r
659 if((ly1-ly2)>CHKMAX_Y) return TRUE;
\r
666 __inline BOOL CheckCoord2()
\r
670 if((lx1-lx0)>CHKMAX_X) return TRUE;
\r
674 if((lx0-lx1)>CHKMAX_X) return TRUE;
\r
678 if((ly1-ly0)>CHKMAX_Y) return TRUE;
\r
682 if((ly0-ly1)>CHKMAX_Y) return TRUE;
\r
688 // Pete's way: a very easy (and hopefully fast) approach for lines
\r
689 // without sqrt... using a small float -> short cast trick :)
\r
691 #define VERTEX_OFFX 0.2f
\r
692 #define VERTEX_OFFY 0.2f
\r
694 BOOL offsetline(void)
\r
696 short x0,x1,y0,y1,dx,dy;float px,py;
\r
699 SetOGLDisplaySettings(1);
\r
701 if(!(dwActFixes&16))
\r
703 lx0=(short)(((int)lx0<<SIGNSHIFT)>>SIGNSHIFT);
\r
704 lx1=(short)(((int)lx1<<SIGNSHIFT)>>SIGNSHIFT);
\r
705 ly0=(short)(((int)ly0<<SIGNSHIFT)>>SIGNSHIFT);
\r
706 ly1=(short)(((int)ly1<<SIGNSHIFT)>>SIGNSHIFT);
\r
708 if(CheckCoord2()) return TRUE;
\r
711 x0 = (lx0 + PSXDisplay.CumulOffset.x)+1;
\r
712 x1 = (lx1 + PSXDisplay.CumulOffset.x)+1;
\r
713 y0 = (ly0 + PSXDisplay.CumulOffset.y)+1;
\r
714 y1 = (ly1 + PSXDisplay.CumulOffset.y)+1;
\r
724 if(dx>dy) py=-0.5f;
\r
725 else if(dx<dy) py= 0.5f;
\r
732 if(dx>dy) px= 0.5f;
\r
733 else if(dx<dy) px=-0.5f;
\r
743 if(dx>dy) px=-0.5f;
\r
744 else if(dx<dy) px= 0.5f;
\r
750 if(dx>dy) py=-0.5f;
\r
751 else if(dx<dy) py= 0.5f;
\r
756 vertex[0].x=(short)((float)x0-px);
\r
757 vertex[3].x=(short)((float)x0+py);
\r
759 vertex[0].y=(short)((float)y0-py);
\r
760 vertex[3].y=(short)((float)y0-px);
\r
762 vertex[1].x=(short)((float)x1-py);
\r
763 vertex[2].x=(short)((float)x1+px);
\r
765 vertex[1].y=(short)((float)y1+px);
\r
766 vertex[2].y=(short)((float)y1+py);
\r
768 if(vertex[0].x==vertex[3].x && // ortho rect? done
\r
769 vertex[1].x==vertex[2].x &&
\r
770 vertex[0].y==vertex[1].y &&
\r
771 vertex[2].y==vertex[3].y) return FALSE;
\r
772 if(vertex[0].x==vertex[1].x &&
\r
773 vertex[2].x==vertex[3].x &&
\r
774 vertex[0].y==vertex[3].y &&
\r
775 vertex[1].y==vertex[2].y) return FALSE;
\r
777 vertex[0].x-=VERTEX_OFFX; // otherwise a small offset
\r
778 vertex[0].y-=VERTEX_OFFY; // to get better accuracy
\r
779 vertex[1].x-=VERTEX_OFFX;
\r
780 vertex[1].y-=VERTEX_OFFY;
\r
781 vertex[2].x-=VERTEX_OFFX;
\r
782 vertex[2].y-=VERTEX_OFFY;
\r
783 vertex[3].x-=VERTEX_OFFX;
\r
784 vertex[3].y-=VERTEX_OFFY;
\r
789 /////////////////////////////////////////////////////////
\r
794 SetOGLDisplaySettings(1);
\r
796 if(!(dwActFixes&16))
\r
798 lx0=(short)(((int)lx0<<SIGNSHIFT)>>SIGNSHIFT);
\r
799 lx1=(short)(((int)lx1<<SIGNSHIFT)>>SIGNSHIFT);
\r
800 ly0=(short)(((int)ly0<<SIGNSHIFT)>>SIGNSHIFT);
\r
801 ly1=(short)(((int)ly1<<SIGNSHIFT)>>SIGNSHIFT);
\r
803 if(CheckCoord2()) return TRUE;
\r
806 vertex[0].x=lx0+PSXDisplay.CumulOffset.x;
\r
807 vertex[1].x=lx1+PSXDisplay.CumulOffset.x;
\r
808 vertex[0].y=ly0+PSXDisplay.CumulOffset.y;
\r
809 vertex[1].y=ly1+PSXDisplay.CumulOffset.y;
\r
814 /////////////////////////////////////////////////////////
\r
819 SetOGLDisplaySettings(1);
\r
821 if(!(dwActFixes&16))
\r
823 lx0=(short)(((int)lx0<<SIGNSHIFT)>>SIGNSHIFT);
\r
824 lx1=(short)(((int)lx1<<SIGNSHIFT)>>SIGNSHIFT);
\r
825 lx2=(short)(((int)lx2<<SIGNSHIFT)>>SIGNSHIFT);
\r
826 ly0=(short)(((int)ly0<<SIGNSHIFT)>>SIGNSHIFT);
\r
827 ly1=(short)(((int)ly1<<SIGNSHIFT)>>SIGNSHIFT);
\r
828 ly2=(short)(((int)ly2<<SIGNSHIFT)>>SIGNSHIFT);
\r
830 if(CheckCoord3()) return TRUE;
\r
833 vertex[0].x=lx0+PSXDisplay.CumulOffset.x;
\r
834 vertex[1].x=lx1+PSXDisplay.CumulOffset.x;
\r
835 vertex[2].x=lx2+PSXDisplay.CumulOffset.x;
\r
836 vertex[0].y=ly0+PSXDisplay.CumulOffset.y;
\r
837 vertex[1].y=ly1+PSXDisplay.CumulOffset.y;
\r
838 vertex[2].y=ly2+PSXDisplay.CumulOffset.y;
\r
843 /////////////////////////////////////////////////////////
\r
848 SetOGLDisplaySettings(1);
\r
850 if(!(dwActFixes&16))
\r
852 lx0=(short)(((int)lx0<<SIGNSHIFT)>>SIGNSHIFT);
\r
853 lx1=(short)(((int)lx1<<SIGNSHIFT)>>SIGNSHIFT);
\r
854 lx2=(short)(((int)lx2<<SIGNSHIFT)>>SIGNSHIFT);
\r
855 lx3=(short)(((int)lx3<<SIGNSHIFT)>>SIGNSHIFT);
\r
856 ly0=(short)(((int)ly0<<SIGNSHIFT)>>SIGNSHIFT);
\r
857 ly1=(short)(((int)ly1<<SIGNSHIFT)>>SIGNSHIFT);
\r
858 ly2=(short)(((int)ly2<<SIGNSHIFT)>>SIGNSHIFT);
\r
859 ly3=(short)(((int)ly3<<SIGNSHIFT)>>SIGNSHIFT);
\r
861 if(CheckCoord4()) return TRUE;
\r
864 vertex[0].x=lx0+PSXDisplay.CumulOffset.x;
\r
865 vertex[1].x=lx1+PSXDisplay.CumulOffset.x;
\r
866 vertex[2].x=lx2+PSXDisplay.CumulOffset.x;
\r
867 vertex[3].x=lx3+PSXDisplay.CumulOffset.x;
\r
868 vertex[0].y=ly0+PSXDisplay.CumulOffset.y;
\r
869 vertex[1].y=ly1+PSXDisplay.CumulOffset.y;
\r
870 vertex[2].y=ly2+PSXDisplay.CumulOffset.y;
\r
871 vertex[3].y=ly3+PSXDisplay.CumulOffset.y;
\r
876 /////////////////////////////////////////////////////////
\r
878 void offsetST(void)
\r
881 SetOGLDisplaySettings(1);
\r
883 if(!(dwActFixes&16))
\r
885 lx0=(short)(((int)lx0<<SIGNSHIFT)>>SIGNSHIFT);
\r
886 ly0=(short)(((int)ly0<<SIGNSHIFT)>>SIGNSHIFT);
\r
888 if(lx0<-512 && PSXDisplay.DrawOffset.x<=-512)
\r
891 if(ly0<-512 && PSXDisplay.DrawOffset.y<=-512)
\r
896 ly2 = ly3 = ly0+sprtH;
\r
898 lx1 = lx2 = lx0+sprtW;
\r
900 vertex[0].x=lx0+PSXDisplay.CumulOffset.x;
\r
901 vertex[1].x=lx1+PSXDisplay.CumulOffset.x;
\r
902 vertex[2].x=lx2+PSXDisplay.CumulOffset.x;
\r
903 vertex[3].x=lx3+PSXDisplay.CumulOffset.x;
\r
904 vertex[0].y=ly0+PSXDisplay.CumulOffset.y;
\r
905 vertex[1].y=ly1+PSXDisplay.CumulOffset.y;
\r
906 vertex[2].y=ly2+PSXDisplay.CumulOffset.y;
\r
907 vertex[3].y=ly3+PSXDisplay.CumulOffset.y;
\r
910 /////////////////////////////////////////////////////////
\r
912 void offsetScreenUpload(long Position)
\r
915 SetOGLDisplaySettings(1);
\r
921 lmdx=xrUploadArea.x0;
\r
922 lmdy=xrUploadArea.y0;
\r
936 lx0-=PSXDisplay.DisplayPosition.x;
\r
937 ly0-=PSXDisplay.DisplayPosition.y;
\r
938 lx1-=PSXDisplay.DisplayPosition.x;
\r
939 ly1-=PSXDisplay.DisplayPosition.y;
\r
940 lx2-=PSXDisplay.DisplayPosition.x;
\r
941 ly2-=PSXDisplay.DisplayPosition.y;
\r
942 lx3-=PSXDisplay.DisplayPosition.x;
\r
943 ly3-=PSXDisplay.DisplayPosition.y;
\r
947 lx0-=PreviousPSXDisplay.DisplayPosition.x;
\r
948 ly0-=PreviousPSXDisplay.DisplayPosition.y;
\r
949 lx1-=PreviousPSXDisplay.DisplayPosition.x;
\r
950 ly1-=PreviousPSXDisplay.DisplayPosition.y;
\r
951 lx2-=PreviousPSXDisplay.DisplayPosition.x;
\r
952 ly2-=PreviousPSXDisplay.DisplayPosition.y;
\r
953 lx3-=PreviousPSXDisplay.DisplayPosition.x;
\r
954 ly3-=PreviousPSXDisplay.DisplayPosition.y;
\r
957 vertex[0].x=lx0 + PreviousPSXDisplay.Range.x0;
\r
958 vertex[1].x=lx1 + PreviousPSXDisplay.Range.x0;
\r
959 vertex[2].x=lx2 + PreviousPSXDisplay.Range.x0;
\r
960 vertex[3].x=lx3 + PreviousPSXDisplay.Range.x0;
\r
961 vertex[0].y=ly0 + PreviousPSXDisplay.Range.y0;
\r
962 vertex[1].y=ly1 + PreviousPSXDisplay.Range.y0;
\r
963 vertex[2].y=ly2 + PreviousPSXDisplay.Range.y0;
\r
964 vertex[3].y=ly3 + PreviousPSXDisplay.Range.y0;
\r
968 vertex[0].z=vertex[1].z=vertex[2].z=vertex[3].z=gl_z;
\r
973 /////////////////////////////////////////////////////////
\r
975 void offsetBlk(void)
\r
978 SetOGLDisplaySettings(1);
\r
980 vertex[0].x=lx0-PSXDisplay.GDrawOffset.x + PreviousPSXDisplay.Range.x0;
\r
981 vertex[1].x=lx1-PSXDisplay.GDrawOffset.x + PreviousPSXDisplay.Range.x0;
\r
982 vertex[2].x=lx2-PSXDisplay.GDrawOffset.x + PreviousPSXDisplay.Range.x0;
\r
983 vertex[3].x=lx3-PSXDisplay.GDrawOffset.x + PreviousPSXDisplay.Range.x0;
\r
984 vertex[0].y=ly0-PSXDisplay.GDrawOffset.y + PreviousPSXDisplay.Range.y0;
\r
985 vertex[1].y=ly1-PSXDisplay.GDrawOffset.y + PreviousPSXDisplay.Range.y0;
\r
986 vertex[2].y=ly2-PSXDisplay.GDrawOffset.y + PreviousPSXDisplay.Range.y0;
\r
987 vertex[3].y=ly3-PSXDisplay.GDrawOffset.y + PreviousPSXDisplay.Range.y0;
\r
991 vertex[0].z=vertex[1].z=vertex[2].z=vertex[3].z=gl_z;
\r
996 ////////////////////////////////////////////////////////////////////////
\r
997 // texture sow/tow calculations
\r
998 ////////////////////////////////////////////////////////////////////////
\r
1000 void assignTextureVRAMWrite(void)
\r
1004 vertex[0].sow=0.5f/ ST_FACVRAMX;
\r
1005 vertex[0].tow=0.5f/ ST_FACVRAM;
\r
1007 vertex[1].sow=(float)gl_ux[1]/ ST_FACVRAMX;
\r
1008 vertex[1].tow=0.5f/ ST_FACVRAM;
\r
1010 vertex[2].sow=(float)gl_ux[2]/ ST_FACVRAMX;
\r
1011 vertex[2].tow=(float)gl_vy[2]/ ST_FACVRAM;
\r
1013 vertex[3].sow=0.5f/ ST_FACVRAMX;
\r
1014 vertex[3].tow=(float)gl_vy[3]/ ST_FACVRAM;
\r
1020 vertex[0].sow=(gl_ux[0]*255.99f)/255.0f;
\r
1021 vertex[1].sow=(gl_ux[1]*255.99f)/255.0f;
\r
1022 vertex[2].sow=(gl_ux[2]*255.99f)/255.0f;
\r
1023 vertex[3].sow=(gl_ux[3]*255.99f)/255.0f;
\r
1027 vertex[0].sow=gl_ux[0];
\r
1028 vertex[1].sow=gl_ux[1];
\r
1029 vertex[2].sow=gl_ux[2];
\r
1030 vertex[3].sow=gl_ux[3];
\r
1033 vertex[0].tow=gl_vy[0];
\r
1034 vertex[1].tow=gl_vy[1];
\r
1035 vertex[2].tow=gl_vy[2];
\r
1036 vertex[3].tow=gl_vy[3];
\r
1041 GLuint gLastTex=0;
\r
1042 GLuint gLastFMode=(GLuint)-1;
\r
1044 /////////////////////////////////////////////////////////
\r
1046 void assignTextureSprite(void)
\r
1050 vertex[0].sow=vertex[3].sow=(float)gl_ux[0]/TWin.UScaleFactor;
\r
1051 vertex[1].sow=vertex[2].sow=(float)sSprite_ux2/TWin.UScaleFactor;
\r
1052 vertex[0].tow=vertex[1].tow=(float)gl_vy[0]/TWin.VScaleFactor;
\r
1053 vertex[2].tow=vertex[3].tow=(float)sSprite_vy2/TWin.VScaleFactor;
\r
1054 gLastTex=gTexName;
\r
1060 vertex[0].sow=vertex[3].sow=(float)gl_ux[0] / ST_FACSPRITE;
\r
1061 vertex[1].sow=vertex[2].sow=(float)sSprite_ux2 / ST_FACSPRITE;
\r
1062 vertex[0].tow=vertex[1].tow=(float)gl_vy[0] / ST_FACSPRITE;
\r
1063 vertex[2].tow=vertex[3].tow=(float)sSprite_vy2 / ST_FACSPRITE;
\r
1067 vertex[0].sow=vertex[3].sow=gl_ux[0];
\r
1068 vertex[1].sow=vertex[2].sow=sSprite_ux2;
\r
1069 vertex[0].tow=vertex[1].tow=gl_vy[0];
\r
1070 vertex[2].tow=vertex[3].tow=sSprite_vy2;
\r
1074 if(iFilterType>2)
\r
1076 if(gLastTex!=gTexName || gLastFMode!=0)
\r
1078 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); glError();
\r
1079 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glError();
\r
1080 gLastTex=gTexName;gLastFMode=0;
\r
1085 if(usMirror & 0x1000)
\r
1087 vertex[0].sow=vertex[1].sow;
\r
1088 vertex[1].sow=vertex[2].sow=vertex[3].sow;
\r
1089 vertex[3].sow=vertex[0].sow;
\r
1092 if(usMirror & 0x2000)
\r
1094 vertex[0].tow=vertex[3].tow;
\r
1095 vertex[2].tow=vertex[3].tow=vertex[1].tow;
\r
1096 vertex[1].tow=vertex[0].tow;
\r
1101 /////////////////////////////////////////////////////////
\r
1103 void assignTexture3(void)
\r
1107 vertex[0].sow=(float)gl_ux[0]/TWin.UScaleFactor;
\r
1108 vertex[0].tow=(float)gl_vy[0]/TWin.VScaleFactor;
\r
1109 vertex[1].sow=(float)gl_ux[1]/TWin.UScaleFactor;
\r
1110 vertex[1].tow=(float)gl_vy[1]/TWin.VScaleFactor;
\r
1111 vertex[2].sow=(float)gl_ux[2]/TWin.UScaleFactor;
\r
1112 vertex[2].tow=(float)gl_vy[2]/TWin.VScaleFactor;
\r
1113 gLastTex=gTexName;
\r
1118 vertex[0].sow=(float)gl_ux[0] / ST_FACTRI;
\r
1119 vertex[0].tow=(float)gl_vy[0] / ST_FACTRI;
\r
1120 vertex[1].sow=(float)gl_ux[1] / ST_FACTRI;
\r
1122 vertex[1].tow=(float)gl_vy[1] / ST_FACTRI;
\r
1123 vertex[2].sow=(float)gl_ux[2] / ST_FACTRI;
\r
1124 vertex[2].tow=(float)gl_vy[2] / ST_FACTRI;
\r
1126 vertex[0].sow=gl_ux[0];
\r
1127 vertex[0].tow=gl_vy[0];
\r
1128 vertex[1].sow=gl_ux[1];
\r
1129 vertex[1].tow=gl_vy[1];
\r
1130 vertex[2].sow=gl_ux[2];
\r
1131 vertex[2].tow=gl_vy[2];
\r
1134 if(iFilterType>2)
\r
1136 if(gLastTex!=gTexName || gLastFMode!=1)
\r
1138 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); glError();
\r
1139 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glError();
\r
1140 gLastTex=gTexName;gLastFMode=1;
\r
1146 float fxmin=256.0f,fxmax=0.0f,fymin=256.0f,fymax=0.0f;int i;
\r
1149 if(vertex[i].sow<fxmin) fxmin=vertex[i].sow;
\r
1150 if(vertex[i].tow<fymin) fymin=vertex[i].tow;
\r
1151 if(vertex[i].sow>fxmax) fxmax=vertex[i].sow;
\r
1152 if(vertex[i].tow>fymax) fymax=vertex[i].tow;
\r
1157 if(vertex[i].sow==fxmin) vertex[i].sow+=ST_BFFACSORT;
\r
1158 if(vertex[i].sow==fxmax) vertex[i].sow-=ST_BFFACSORT;
\r
1159 if(vertex[i].tow==fymin) vertex[i].tow+=ST_BFFACSORT;
\r
1160 if(vertex[i].tow==fymax) vertex[i].tow-=ST_BFFACSORT;
\r
1166 /////////////////////////////////////////////////////////
\r
1168 void assignTexture4(void)
\r
1172 vertex[0].sow=(float)gl_ux[0]/TWin.UScaleFactor;
\r
1173 vertex[0].tow=(float)gl_vy[0]/TWin.VScaleFactor;
\r
1174 vertex[1].sow=(float)gl_ux[1]/TWin.UScaleFactor;
\r
1175 vertex[1].tow=(float)gl_vy[1]/TWin.VScaleFactor;
\r
1176 vertex[2].sow=(float)gl_ux[2]/TWin.UScaleFactor;
\r
1177 vertex[2].tow=(float)gl_vy[2]/TWin.VScaleFactor;
\r
1178 vertex[3].sow=(float)gl_ux[3]/TWin.UScaleFactor;
\r
1179 vertex[3].tow=(float)gl_vy[3]/TWin.VScaleFactor;
\r
1180 gLastTex=gTexName;
\r
1185 vertex[0].sow=(float)gl_ux[0] / ST_FAC;
\r
1186 vertex[0].tow=(float)gl_vy[0] / ST_FAC;
\r
1187 vertex[1].sow=(float)gl_ux[1] / ST_FAC;
\r
1188 vertex[1].tow=(float)gl_vy[1] / ST_FAC;
\r
1189 vertex[2].sow=(float)gl_ux[2] / ST_FAC;
\r
1190 vertex[2].tow=(float)gl_vy[2] / ST_FAC;
\r
1191 vertex[3].sow=(float)gl_ux[3] / ST_FAC;
\r
1192 vertex[3].tow=(float)gl_vy[3] / ST_FAC;
\r
1194 vertex[0].sow=gl_ux[0];
\r
1195 vertex[0].tow=gl_vy[0];
\r
1196 vertex[1].sow=gl_ux[1];
\r
1197 vertex[1].tow=gl_vy[1];
\r
1198 vertex[2].sow=gl_ux[2];
\r
1199 vertex[2].tow=gl_vy[2];
\r
1200 vertex[3].sow=gl_ux[3];
\r
1201 vertex[3].tow=gl_vy[3];
\r
1204 if(iFilterType>2)
\r
1206 if(gLastTex!=gTexName || gLastFMode!=1)
\r
1208 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); glError();
\r
1209 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glError();
\r
1210 gLastTex=gTexName;gLastFMode=1;
\r
1216 float fxmin=256.0f,fxmax=0.0f,fymin=256.0f,fymax=0.0f;int i;
\r
1219 if(vertex[i].sow<fxmin) fxmin=vertex[i].sow;
\r
1220 if(vertex[i].tow<fymin) fymin=vertex[i].tow;
\r
1221 if(vertex[i].sow>fxmax) fxmax=vertex[i].sow;
\r
1222 if(vertex[i].tow>fymax) fymax=vertex[i].tow;
\r
1227 if(vertex[i].sow==fxmin) vertex[i].sow+=ST_BFFACSORT;
\r
1228 if(vertex[i].sow==fxmax) vertex[i].sow-=ST_BFFACSORT;
\r
1229 if(vertex[i].tow==fymin) vertex[i].tow+=ST_BFFACSORT;
\r
1230 if(vertex[i].tow==fymax) vertex[i].tow-=ST_BFFACSORT;
\r
1236 ////////////////////////////////////////////////////////////////////////
\r
1237 ////////////////////////////////////////////////////////////////////////
\r
1238 ////////////////////////////////////////////////////////////////////////
\r
1240 ////////////////////////////////////////////////////////////////////////
\r
1241 // render pos / buffers
\r
1242 ////////////////////////////////////////////////////////////////////////
\r
1244 #define EqualRect(pr1,pr2) ((pr1)->left==(pr2)->left && (pr1)->top==(pr2)->top && (pr1)->right==(pr2)->right && (pr1)->bottom==(pr2)->bottom)
\r
1246 ////////////////////////////////////////////////////////////////////////
\r
1247 // SetDisplaySettings: "simply" calcs the new drawing area and updates
\r
1248 // the ogl clipping (scissor)
\r
1250 BOOL bSetClip=FALSE;
\r
1252 void SetOGLDisplaySettings(BOOL DisplaySet)
\r
1254 static RECT rprev={0,0,0,0};
\r
1255 static RECT rC ={0,0,0,0};
\r
1256 static int iOldX=0;
\r
1257 static int iOldY=0;
\r
1258 RECT r;float XS,YS;
\r
1260 bDisplayNotSet = FALSE;
\r
1262 //----------------------------------------------------// that's a whole screen upload
\r
1266 PSXDisplay.GDrawOffset.x=0;
\r
1267 PSXDisplay.GDrawOffset.y=0;
\r
1269 PSXDisplay.CumulOffset.x = PSXDisplay.DrawOffset.x+PreviousPSXDisplay.Range.x0;
\r
1270 PSXDisplay.CumulOffset.y = PSXDisplay.DrawOffset.y+PreviousPSXDisplay.Range.y0;
\r
1272 rprev.left=rprev.left+1;
\r
1275 rX.top=iResY-(rRatioRect.top+rRatioRect.bottom);
\r
1277 if(bSetClip || !EqualRect(&rC,&rX))
\r
1280 glScissor(rC.left,rC.top,rC.right,rC.bottom); glError();
\r
1281 //LOGE("glscissor:%d %d %d %d",rC.left,rC.top,rC.right,rC.bottom);
\r
1286 //----------------------------------------------------//
\r
1288 PSXDisplay.GDrawOffset.y = PreviousPSXDisplay.DisplayPosition.y;
\r
1289 PSXDisplay.GDrawOffset.x = PreviousPSXDisplay.DisplayPosition.x;
\r
1290 PSXDisplay.CumulOffset.x = PSXDisplay.DrawOffset.x - PSXDisplay.GDrawOffset.x+PreviousPSXDisplay.Range.x0;
\r
1291 PSXDisplay.CumulOffset.y = PSXDisplay.DrawOffset.y - PSXDisplay.GDrawOffset.y+PreviousPSXDisplay.Range.y0;
\r
1293 r.top =PSXDisplay.DrawArea.y0 - PreviousPSXDisplay.DisplayPosition.y;
\r
1294 r.bottom=PSXDisplay.DrawArea.y1 - PreviousPSXDisplay.DisplayPosition.y;
\r
1296 if(r.bottom<0 || r.top>=PSXDisplay.DisplayMode.y)
\r
1298 r.top =PSXDisplay.DrawArea.y0 - PSXDisplay.DisplayPosition.y;
\r
1299 r.bottom=PSXDisplay.DrawArea.y1 - PSXDisplay.DisplayPosition.y;
\r
1302 r.left =PSXDisplay.DrawArea.x0 - PreviousPSXDisplay.DisplayPosition.x;
\r
1303 r.right =PSXDisplay.DrawArea.x1 - PreviousPSXDisplay.DisplayPosition.x;
\r
1305 if(r.right<0 || r.left>=PSXDisplay.DisplayMode.x)
\r
1307 r.left =PSXDisplay.DrawArea.x0 - PSXDisplay.DisplayPosition.x;
\r
1308 r.right =PSXDisplay.DrawArea.x1 - PSXDisplay.DisplayPosition.x;
\r
1311 if(!bSetClip && EqualRect(&r,&rprev) &&
\r
1312 iOldX == PSXDisplay.DisplayMode.x &&
\r
1313 iOldY == PSXDisplay.DisplayMode.y)
\r
1317 iOldX = PSXDisplay.DisplayMode.x;
\r
1318 iOldY = PSXDisplay.DisplayMode.y;
\r
1320 XS=(float)rRatioRect.right/(float)PSXDisplay.DisplayMode.x;
\r
1321 YS=(float)rRatioRect.bottom/(float)PSXDisplay.DisplayMode.y;
\r
1323 if(PreviousPSXDisplay.Range.x0)
\r
1325 short s=PreviousPSXDisplay.Range.x0+PreviousPSXDisplay.Range.x1;
\r
1327 r.left+=PreviousPSXDisplay.Range.x0+1;
\r
1329 r.right+=PreviousPSXDisplay.Range.x0;
\r
1331 if(r.left>s) r.left=s;
\r
1332 if(r.right>s) r.right=s;
\r
1335 if(PreviousPSXDisplay.Range.y0)
\r
1337 short s=PreviousPSXDisplay.Range.y0+PreviousPSXDisplay.Range.y1;
\r
1339 r.top+=PreviousPSXDisplay.Range.y0+1;
\r
1340 r.bottom+=PreviousPSXDisplay.Range.y0;
\r
1342 if(r.top>s) r.top=s;
\r
1343 if(r.bottom>s) r.bottom=s;
\r
1346 // Set the ClipArea variables to reflect the new screen,
\r
1347 // offset from zero (since it is a new display buffer)
\r
1348 r.left = (int)(((float)(r.left)) *XS);
\r
1349 r.top = (int)(((float)(r.top)) *YS);
\r
1350 r.right = (int)(((float)(r.right + 1))*XS);
\r
1351 r.bottom = (int)(((float)(r.bottom + 1))*YS);
\r
1353 // Limit clip area to the screen size
\r
1354 if (r.left > iResX) r.left = iResX;
\r
1355 if (r.left < 0) r.left = 0;
\r
1356 if (r.top > iResY) r.top = iResY;
\r
1357 if (r.top < 0) r.top = 0;
\r
1358 if (r.right > iResX) r.right = iResX;
\r
1359 if (r.right < 0) r.right = 0;
\r
1360 if (r.bottom > iResY) r.bottom = iResY;
\r
1361 if (r.bottom < 0) r.bottom = 0;
\r
1365 r.top=iResY-(r.top+r.bottom);
\r
1367 r.left+=rRatioRect.left;
\r
1368 r.top -=rRatioRect.top;
\r
1370 if(bSetClip || !EqualRect(&r,&rC))
\r
1372 glScissor(r.left,r.top,r.right,r.bottom); glError();
\r
1379 ////////////////////////////////////////////////////////////////////////
\r
1380 ////////////////////////////////////////////////////////////////////////
\r
1381 ////////////////////////////////////////////////////////////////////////
\r