notaz.gp2x.de / mupen64plus-pandora.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
GLES11RICE: Some fixes on multi texturing
[mupen64plus-pandora.git] / source / rice_gles / src / OGLRender.cpp
CommitLineData
d07c171f 1/*
2Copyright (C) 2003 Rice1964
3
4This program is free software; you can redistribute it and/or
5modify it under the terms of the GNU General Public License
6as published by the Free Software Foundation; either version 2
7of the License, or (at your option) any later version.
8
9This program is distributed in the hope that it will be useful,
10but WITHOUT ANY WARRANTY; without even the implied warranty of
11MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12GNU General Public License for more details.
13
14You should have received a copy of the GNU General Public License
15along with this program; if not, write to the Free Software
16Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
17*/
18
19#include "osal_opengl.h"
20
21#if SDL_VIDEO_OPENGL
22#include "OGLExtensions.h"
23#elif SDL_VIDEO_OPENGL_ES2
24#include "OGLES2FragmentShaders.h"
25#endif
26#include "OGLDebug.h"
27#include "OGLRender.h"
28#include "OGLGraphicsContext.h"
29#include "OGLTexture.h"
30#include "TextureManager.h"
31
32#ifdef PAULSCODE
33//include "ae_bridge.h"
34//static int hardwareType = HARDWARE_TYPE_UNKNOWN;
35#endif
36
37// FIXME: Use OGL internal L/T and matrix stack
38// FIXME: Use OGL lookupAt function
39// FIXME: Use OGL DisplayList
40
41UVFlagMap OGLXUVFlagMaps[] =
42{
43 {TEXTURE_UV_FLAG_WRAP, GL_REPEAT},
44 {TEXTURE_UV_FLAG_MIRROR, GL_MIRRORED_REPEAT_ARB},
45 {TEXTURE_UV_FLAG_CLAMP, GL_CLAMP},
46};
47
48#if SDL_VIDEO_OPENGL_ES2
49 static GLuint disabledTextureID;
50#endif
51
52//===================================================================
53OGLRender::OGLRender()
54{
55 COGLGraphicsContext *pcontext = (COGLGraphicsContext *)(CGraphicsContext::g_pGraphicsContext);
56 m_bSupportFogCoordExt = pcontext->m_bSupportFogCoord;
57 m_bMultiTexture = pcontext->m_bSupportMultiTexture;
58#ifdef HAVE_GLES
59 m_bSupportClampToEdge = true;
60#else
61 m_bSupportClampToEdge = false;
62#endif
63 for( int i=0; i<8; i++ )
64 {
65 m_curBoundTex[i]=0;
66 m_texUnitEnabled[i]=FALSE;
67 }
68
69#if SDL_VIDEO_OPENGL
70/*#ifdef HAVE_GLES
71 m_bEnableMultiTexture = true;
72#else*/
73 m_bEnableMultiTexture = false;
74//#endif
75
76#elif SDL_VIDEO_OPENGL_ES2
77 m_bEnableMultiTexture = true;
78
79 //Create a texture as replacement for glEnable/Disable(GL_TEXTURE_2D)
80 unsigned int white[8*8];
81 for (int i=0; i<8*8; i++) {
82 //white[i].r = white[i].g = white[i].b = 0;
83 //white[i].a = 0;
84 white[i] = 0;
85 }
86 glGenTextures(1,&disabledTextureID);
87 OPENGL_CHECK_ERRORS;
88 glBindTexture(GL_TEXTURE_2D, disabledTextureID);
89 OPENGL_CHECK_ERRORS;
90 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
91 OPENGL_CHECK_ERRORS;
92 glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 8, 8, 0, GL_RGBA, GL_UNSIGNED_BYTE, white);
93 OPENGL_CHECK_ERRORS;
94#endif
95}
96
97OGLRender::~OGLRender()
98{
99 ClearDeviceObjects();
100}
101
102bool OGLRender::InitDeviceObjects()
103{
104 // enable Z-buffer by default
105 ZBufferEnable(true);
106 return true;
107}
108
109bool OGLRender::ClearDeviceObjects()
110{
111 return true;
112}
113
114void OGLRender::Initialize(void)
115{
116 glMatrixMode(GL_MODELVIEW);
117 OPENGL_CHECK_ERRORS;
118 glLoadIdentity();
119 OPENGL_CHECK_ERRORS;
120
121 glViewportWrapper(0, windowSetting.statusBarHeightToUse, windowSetting.uDisplayWidth, windowSetting.uDisplayHeight);
122 OPENGL_CHECK_ERRORS;
123
124#if SDL_VIDEO_OPENGL
125 COGLGraphicsContext *pcontext = (COGLGraphicsContext *)(CGraphicsContext::g_pGraphicsContext);
126#ifndef HAVE_GLES
127 if( pcontext->IsExtensionSupported("GL_IBM_texture_mirrored_repeat") )
128 {
129 OGLXUVFlagMaps[TEXTURE_UV_FLAG_MIRROR].realFlag = GL_MIRRORED_REPEAT_IBM;
130 }
131 else if( pcontext->IsExtensionSupported("ARB_texture_mirrored_repeat") )
132#endif
133 {
134 OGLXUVFlagMaps[TEXTURE_UV_FLAG_MIRROR].realFlag = GL_MIRRORED_REPEAT_ARB;
135 }
136#ifndef HAVE_GLES
137 else
138 {
139 OGLXUVFlagMaps[TEXTURE_UV_FLAG_MIRROR].realFlag = GL_REPEAT;
140 }
141 if( pcontext->IsExtensionSupported("GL_ARB_texture_border_clamp") || pcontext->IsExtensionSupported("GL_EXT_texture_edge_clamp") )
142#endif
143 {
144 m_bSupportClampToEdge = true;
145 OGLXUVFlagMaps[TEXTURE_UV_FLAG_CLAMP].realFlag = GL_CLAMP_TO_EDGE;
146 }
147#ifndef HAVE_GLES
148 else
149 {
150 m_bSupportClampToEdge = false;
151 OGLXUVFlagMaps[TEXTURE_UV_FLAG_CLAMP].realFlag = GL_CLAMP;
152 }
153#endif
154 glVertexPointer( 4, GL_FLOAT, sizeof(float)*5, &(g_vtxProjected5[0][0]) );
155 OPENGL_CHECK_ERRORS;
156 glEnableClientState( GL_VERTEX_ARRAY );
157 OPENGL_CHECK_ERRORS;
158
159 if( m_bMultiTexture )
160 {
161 pglClientActiveTextureARB( GL_TEXTURE0_ARB );
162 OPENGL_CHECK_ERRORS;
163 glTexCoordPointer( 2, GL_FLOAT, sizeof( TLITVERTEX ), &(g_vtxBuffer[0].tcord[0].u) );
164 OPENGL_CHECK_ERRORS;
165 glEnableClientState( GL_TEXTURE_COORD_ARRAY );
166 OPENGL_CHECK_ERRORS;
167
168 pglClientActiveTextureARB( GL_TEXTURE1_ARB );
169 OPENGL_CHECK_ERRORS;
170 glTexCoordPointer( 2, GL_FLOAT, sizeof( TLITVERTEX ), &(g_vtxBuffer[0].tcord[1].u) );
171 OPENGL_CHECK_ERRORS;
172 glEnableClientState( GL_TEXTURE_COORD_ARRAY );
173 OPENGL_CHECK_ERRORS;
174 }
175 else
176 {
177 glTexCoordPointer( 2, GL_FLOAT, sizeof( TLITVERTEX ), &(g_vtxBuffer[0].tcord[0].u) );
178 OPENGL_CHECK_ERRORS;
179 glEnableClientState( GL_TEXTURE_COORD_ARRAY );
180 OPENGL_CHECK_ERRORS;
181 }
182#ifndef HAVE_GLES
183 if (m_bSupportFogCoordExt)
184 {
185 pglFogCoordPointerEXT( GL_FLOAT, sizeof(float)*5, &(g_vtxProjected5[0][4]) );
186 OPENGL_CHECK_ERRORS;
187 glEnableClientState( GL_FOG_COORDINATE_ARRAY_EXT );
188 OPENGL_CHECK_ERRORS;
189 glFogi( GL_FOG_COORDINATE_SOURCE_EXT, GL_FOG_COORDINATE_EXT );
190 OPENGL_CHECK_ERRORS;
191 glFogi(GL_FOG_MODE, GL_LINEAR); // Fog Mode
192 OPENGL_CHECK_ERRORS;
193 glFogf(GL_FOG_DENSITY, 1.0f); // How Dense Will The Fog Be
194 OPENGL_CHECK_ERRORS;
195 glHint(GL_FOG_HINT, GL_FASTEST); // Fog Hint Value
196 OPENGL_CHECK_ERRORS;
197 glFogi( GL_FOG_COORDINATE_SOURCE_EXT, GL_FOG_COORDINATE_EXT );
198 OPENGL_CHECK_ERRORS;
199 glFogf( GL_FOG_START, 0.0f );
200 OPENGL_CHECK_ERRORS;
201 glFogf( GL_FOG_END, 1.0f );
202 OPENGL_CHECK_ERRORS;
203 }
204#endif
205 //glColorPointer( 1, GL_UNSIGNED_BYTE, sizeof(TLITVERTEX), &g_vtxBuffer[0].r);
206 glColorPointer( 4, GL_UNSIGNED_BYTE, sizeof(uint8)*4, &(g_oglVtxColors[0][0]) );
207 OPENGL_CHECK_ERRORS;
208 glEnableClientState( GL_COLOR_ARRAY );
209 OPENGL_CHECK_ERRORS;
210#ifndef HAVE_GLES
211 if( pcontext->IsExtensionSupported("GL_NV_depth_clamp") )
212 {
213 glEnable(GL_DEPTH_CLAMP_NV);
214 OPENGL_CHECK_ERRORS;
215 }
216#endif
217#elif SDL_VIDEO_OPENGL_ES2
218 OGLXUVFlagMaps[TEXTURE_UV_FLAG_MIRROR].realFlag = GL_MIRRORED_REPEAT;
219 m_bSupportClampToEdge = true;
220 OGLXUVFlagMaps[TEXTURE_UV_FLAG_CLAMP].realFlag = GL_CLAMP_TO_EDGE;
221#endif
222
223#ifdef PAULSCODE
224// hardwareType = Android_JNI_GetHardwareType();
225#endif
226}
227//===================================================================
228TextureFilterMap OglTexFilterMap[2]=
229{
230 {FILTER_POINT, GL_NEAREST},
231 {FILTER_LINEAR, GL_LINEAR},
232};
233
234void OGLRender::ApplyTextureFilter()
235{
236 static uint32 minflag=0xFFFF, magflag=0xFFFF;
237 static uint32 mtex;
238
239 if( m_texUnitEnabled[0] )
240 {
241 if( mtex != m_curBoundTex[0] )
242 {
243 mtex = m_curBoundTex[0];
244 minflag = m_dwMinFilter;
245 magflag = m_dwMagFilter;
246 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, OglTexFilterMap[m_dwMinFilter].realFilter);
247 OPENGL_CHECK_ERRORS;
248 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, OglTexFilterMap[m_dwMagFilter].realFilter);
249 OPENGL_CHECK_ERRORS;
250 }
251 else
252 {
253 if( minflag != (unsigned int)m_dwMinFilter )
254 {
255 minflag = m_dwMinFilter;
256 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, OglTexFilterMap[m_dwMinFilter].realFilter);
257 OPENGL_CHECK_ERRORS;
258 }
259 if( magflag != (unsigned int)m_dwMagFilter )
260 {
261 magflag = m_dwMagFilter;
262 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, OglTexFilterMap[m_dwMagFilter].realFilter);
263 OPENGL_CHECK_ERRORS;
264 }
265 }
266 }
267}
268
269void OGLRender::SetShadeMode(RenderShadeMode mode)
270{
271#if SDL_VIDEO_OPENGL
272 if( mode == SHADE_SMOOTH )
273 glShadeModel(GL_SMOOTH);
274 else
275 glShadeModel(GL_FLAT);
276 OPENGL_CHECK_ERRORS;
277#endif
278}
279
280void OGLRender::ZBufferEnable(BOOL bZBuffer)
281{
282 gRSP.bZBufferEnabled = bZBuffer;
283 if( g_curRomInfo.bForceDepthBuffer )
284 bZBuffer = TRUE;
285 if( bZBuffer )
286 {
287 glDepthMask(GL_TRUE);
288 OPENGL_CHECK_ERRORS;
289 //glEnable(GL_DEPTH_TEST);
290 glDepthFunc( GL_LEQUAL );
291 OPENGL_CHECK_ERRORS;
292 }
293 else
294 {
295 glDepthMask(GL_FALSE);
296 OPENGL_CHECK_ERRORS;
297 //glDisable(GL_DEPTH_TEST);
298 glDepthFunc( GL_ALWAYS );
299 OPENGL_CHECK_ERRORS;
300 }
301}
302
303void OGLRender::ClearBuffer(bool cbuffer, bool zbuffer)
304{
305 uint32 flag=0;
306 if( cbuffer ) flag |= GL_COLOR_BUFFER_BIT;
307 if( zbuffer ) flag |= GL_DEPTH_BUFFER_BIT;
308 float depth = ((gRDP.originalFillColor&0xFFFF)>>2)/(float)0x3FFF;
309 glClearDepth(depth);
310 OPENGL_CHECK_ERRORS;
311 glClear(flag);
312 OPENGL_CHECK_ERRORS;
313}
314
315void OGLRender::ClearZBuffer(float depth)
316{
317 uint32 flag=GL_DEPTH_BUFFER_BIT;
318 glClearDepth(depth);
319 OPENGL_CHECK_ERRORS;
320 glClear(flag);
321 OPENGL_CHECK_ERRORS;
322}
323
324void OGLRender::SetZCompare(BOOL bZCompare)
325{
326 if( g_curRomInfo.bForceDepthBuffer )
327 bZCompare = TRUE;
328
329 gRSP.bZBufferEnabled = bZCompare;
330 if( bZCompare == TRUE )
331 {
332 //glEnable(GL_DEPTH_TEST);
333 glDepthFunc( GL_LEQUAL );
334 OPENGL_CHECK_ERRORS;
335 }
336 else
337 {
338 //glDisable(GL_DEPTH_TEST);
339 glDepthFunc( GL_ALWAYS );
340 OPENGL_CHECK_ERRORS;
341 }
342}
343
344void OGLRender::SetZUpdate(BOOL bZUpdate)
345{
346 if( g_curRomInfo.bForceDepthBuffer )
347 bZUpdate = TRUE;
348
349 if( bZUpdate )
350 {
351 //glEnable(GL_DEPTH_TEST);
352 glDepthMask(GL_TRUE);
353 OPENGL_CHECK_ERRORS;
354 }
355 else
356 {
357 glDepthMask(GL_FALSE);
358 OPENGL_CHECK_ERRORS;
359 }
360}
361
362void OGLRender::ApplyZBias(int bias)
363{
364 float f1 = bias > 0 ? -3.0f : 0.0f; // z offset = -3.0 * max(abs(dz/dx),abs(dz/dy)) per pixel delta z slope
365 float f2 = bias > 0 ? -3.0f : 0.0f; // z offset += -3.0 * 1 bit
366
367#ifdef PAULSCODE
368// Android_JNI_GetPolygonOffset(hardwareType, bias, &f1, &f2);
369// glPolygonOffset(0.2f, 0.2f);
370#endif
371
372 if (bias > 0)
373 {
374 glEnable(GL_POLYGON_OFFSET_FILL); // enable z offsets
375 OPENGL_CHECK_ERRORS;
376 }
377 else
378 {
379 glDisable(GL_POLYGON_OFFSET_FILL); // disable z offsets
380 OPENGL_CHECK_ERRORS;
381 }
382 glPolygonOffset(f1, f2); // set bias functions
383 OPENGL_CHECK_ERRORS;
384}
385
386void OGLRender::SetZBias(int bias)
387{
388#if defined(DEBUGGER)
389 if( pauseAtNext == true )
390 DebuggerAppendMsg("Set zbias = %d", bias);
391#endif
392 // set member variable and apply the setting in opengl
393 m_dwZBias = bias;
394 ApplyZBias(bias);
395}
396
397void OGLRender::SetAlphaRef(uint32 dwAlpha)
398{
399 if (m_dwAlpha != dwAlpha)
400 {
401 m_dwAlpha = dwAlpha;
402#if SDL_VIDEO_OPENGL
403 glAlphaFunc(GL_GEQUAL, (float)dwAlpha);
404 OPENGL_CHECK_ERRORS;
405#endif
406 }
407}
408
409void OGLRender::ForceAlphaRef(uint32 dwAlpha)
410{
411#if SDL_VIDEO_OPENGL
412 float ref = dwAlpha/255.0f;
413 glAlphaFunc(GL_GEQUAL, ref);
414 OPENGL_CHECK_ERRORS;
415#elif SDL_VIDEO_OPENGL_ES2
416 m_dwAlpha = dwAlpha;
417#endif
418}
419
420void OGLRender::SetFillMode(FillMode mode)
421{
422#if SDL_VIDEO_OPENGL
423#ifndef HAVE_GLES
424 if( mode == RICE_FILLMODE_WINFRAME )
425 {
426 glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
427 OPENGL_CHECK_ERRORS;
428 }
429 else
430 {
431 glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
432 OPENGL_CHECK_ERRORS;
433 }
434#endif
435#endif
436}
437
438void OGLRender::SetCullMode(bool bCullFront, bool bCullBack)
439{
440 CRender::SetCullMode(bCullFront, bCullBack);
441 if( bCullFront && bCullBack )
442 {
443 glCullFace(GL_FRONT_AND_BACK);
444 OPENGL_CHECK_ERRORS;
445 glEnable(GL_CULL_FACE);
446 OPENGL_CHECK_ERRORS;
447 }
448 else if( bCullFront )
449 {
450 glCullFace(GL_FRONT);
451 OPENGL_CHECK_ERRORS;
452 glEnable(GL_CULL_FACE);
453 OPENGL_CHECK_ERRORS;
454 }
455 else if( bCullBack )
456 {
457 glCullFace(GL_BACK);
458 OPENGL_CHECK_ERRORS;
459 glEnable(GL_CULL_FACE);
460 OPENGL_CHECK_ERRORS;
461 }
462 else
463 {
464 glDisable(GL_CULL_FACE);
465 OPENGL_CHECK_ERRORS;
466 }
467}
468
469bool OGLRender::SetCurrentTexture(int tile, CTexture *handler,uint32 dwTileWidth, uint32 dwTileHeight, TxtrCacheEntry *pTextureEntry)
470{
471 RenderTexture &texture = g_textures[tile];
472 texture.pTextureEntry = pTextureEntry;
473
474 if( handler!= NULL && texture.m_lpsTexturePtr != handler->GetTexture() )
475 {
476 texture.m_pCTexture = handler;
477 texture.m_lpsTexturePtr = handler->GetTexture();
478
479 texture.m_dwTileWidth = dwTileWidth;
480 texture.m_dwTileHeight = dwTileHeight;
481
482 if( handler->m_bIsEnhancedTexture )
483 {
484 texture.m_fTexWidth = (float)pTextureEntry->pTexture->m_dwCreatedTextureWidth;
485 texture.m_fTexHeight = (float)pTextureEntry->pTexture->m_dwCreatedTextureHeight;
486 }
487 else
488 {
489 texture.m_fTexWidth = (float)handler->m_dwCreatedTextureWidth;
490 texture.m_fTexHeight = (float)handler->m_dwCreatedTextureHeight;
491 }
492 }
493
494 return true;
495}
496
497bool OGLRender::SetCurrentTexture(int tile, TxtrCacheEntry *pEntry)
498{
499 if (pEntry != NULL && pEntry->pTexture != NULL)
500 {
501 SetCurrentTexture( tile, pEntry->pTexture, pEntry->ti.WidthToCreate, pEntry->ti.HeightToCreate, pEntry);
502 return true;
503 }
504 else
505 {
506 SetCurrentTexture( tile, NULL, 64, 64, NULL );
507 return false;
508 }
509 return true;
510}
511
512void OGLRender::SetAddressUAllStages(uint32 dwTile, TextureUVFlag dwFlag)
513{
514 SetTextureUFlag(dwFlag, dwTile);
515}
516
517void OGLRender::SetAddressVAllStages(uint32 dwTile, TextureUVFlag dwFlag)
518{
519 SetTextureVFlag(dwFlag, dwTile);
520}
521
522void OGLRender::SetTexWrapS(int unitno,GLuint flag)
523{
524 static GLuint mflag;
525 static GLuint mtex;
526#ifdef DEBUGGER
527 if( unitno != 0 )
528 {
529 DebuggerAppendMsg("Check me, unitno != 0 in base ogl");
530 }
531#endif
532 if( m_curBoundTex[0] != mtex || mflag != flag )
533 {
534 mtex = m_curBoundTex[0];
535 mflag = flag;
536 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, flag);
537 OPENGL_CHECK_ERRORS;
538 }
539}
540void OGLRender::SetTexWrapT(int unitno,GLuint flag)
541{
542 static GLuint mflag;
543 static GLuint mtex;
544 if( m_curBoundTex[0] != mtex || mflag != flag )
545 {
546 mtex = m_curBoundTex[0];
547 mflag = flag;
548 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, flag);
549 OPENGL_CHECK_ERRORS;
550 }
551}
552
553void OGLRender::SetTextureUFlag(TextureUVFlag dwFlag, uint32 dwTile)
554{
555 TileUFlags[dwTile] = dwFlag;
556 if( dwTile == gRSP.curTile ) // For basic OGL, only support the 1st texel
557 {
558 COGLTexture* pTexture = g_textures[gRSP.curTile].m_pCOGLTexture;
559 if( pTexture )
560 {
561 EnableTexUnit(0,TRUE);
562 BindTexture(pTexture->m_dwTextureName, 0);
563 }
564 SetTexWrapS(0, OGLXUVFlagMaps[dwFlag].realFlag);
565 }
566}
567void OGLRender::SetTextureVFlag(TextureUVFlag dwFlag, uint32 dwTile)
568{
569 TileVFlags[dwTile] = dwFlag;
570 if( dwTile == gRSP.curTile ) // For basic OGL, only support the 1st texel
571 {
572 COGLTexture* pTexture = g_textures[gRSP.curTile].m_pCOGLTexture;
573 if( pTexture )
574 {
575 EnableTexUnit(0,TRUE);
576 BindTexture(pTexture->m_dwTextureName, 0);
577 }
578 SetTexWrapT(0, OGLXUVFlagMaps[dwFlag].realFlag);
579 }
580}
581
582// Basic render drawing functions
583
584bool OGLRender::RenderTexRect()
585{
586 glViewportWrapper(0, windowSetting.statusBarHeightToUse, windowSetting.uDisplayWidth, windowSetting.uDisplayHeight);
587 OPENGL_CHECK_ERRORS;
588
589 GLboolean cullface = glIsEnabled(GL_CULL_FACE);
590 glDisable(GL_CULL_FACE);
591 OPENGL_CHECK_ERRORS;
592
593 float depth = -(g_texRectTVtx[3].z*2-1);
594
595#if SDL_VIDEO_OPENGL
596#ifdef HAVE_GLES
597 GLfloat colour[] = {
598 g_texRectTVtx[3].r, g_texRectTVtx[3].g, g_texRectTVtx[3].b, g_texRectTVtx[3].a,
599 g_texRectTVtx[2].r, g_texRectTVtx[2].g, g_texRectTVtx[2].b, g_texRectTVtx[2].a,
600 g_texRectTVtx[1].r, g_texRectTVtx[1].g, g_texRectTVtx[1].b, g_texRectTVtx[1].a,
601 g_texRectTVtx[0].r, g_texRectTVtx[0].g, g_texRectTVtx[0].b, g_texRectTVtx[0].a
602 };
603
604 GLfloat tex[] = {
605 g_texRectTVtx[3].tcord[0].u,g_texRectTVtx[3].tcord[0].v,
606 g_texRectTVtx[2].tcord[0].u,g_texRectTVtx[2].tcord[0].v,
607 g_texRectTVtx[1].tcord[0].u,g_texRectTVtx[1].tcord[0].v,
608 g_texRectTVtx[0].tcord[0].u,g_texRectTVtx[0].tcord[0].v
609 };
610 GLfloat tex2[] = {
611 g_texRectTVtx[3].tcord[1].u,g_texRectTVtx[3].tcord[1].v,
612 g_texRectTVtx[2].tcord[1].u,g_texRectTVtx[2].tcord[1].v,
613 g_texRectTVtx[1].tcord[1].u,g_texRectTVtx[1].tcord[1].v,
614 g_texRectTVtx[0].tcord[1].u,g_texRectTVtx[0].tcord[1].v
615 };
616
617 GLfloat vertices[] = {
618 g_texRectTVtx[3].x, g_texRectTVtx[3].y, depth, 1,
619 g_texRectTVtx[2].x, g_texRectTVtx[2].y, depth, 1,
620 g_texRectTVtx[1].x, g_texRectTVtx[1].y, depth, 1,
621 g_texRectTVtx[0].x, g_texRectTVtx[0].y, depth, 1
622 };
623
624 if( m_bMultiTexture )
625 {
626 glClientActiveTexture( GL_TEXTURE1 );
2f75cc30 627 glTexCoordPointer(2, GL_FLOAT, 0, &tex2);
d07c171f 628 glClientActiveTexture( GL_TEXTURE0 );
629 }
2f75cc30 630 glTexCoordPointer(2, GL_FLOAT, 0, &tex);
d07c171f 631
632 glColorPointer(4, GL_FLOAT,0, &colour );
633 glVertexPointer(4,GL_FLOAT, 0, &vertices);
634 glTexCoordPointer(2, GL_FLOAT, 0, &tex);
635 OPENGL_CHECK_ERRORS;
636 glDrawArrays(GL_TRIANGLE_FAN,0,4);
637 OPENGL_CHECK_ERRORS;
638
639 //Restore old pointers
640 glColorPointer( 4, GL_UNSIGNED_BYTE, sizeof(uint8)*4, &(g_oglVtxColors[0][0]) );
641
642 glVertexPointer( 4, GL_FLOAT, sizeof(float)*5, &(g_vtxProjected5[0][0]) );
2f75cc30 643 glTexCoordPointer( 2, GL_FLOAT, sizeof( TLITVERTEX ), &(g_vtxBuffer[0].tcord[0].u) );
d07c171f 644 if( m_bMultiTexture )
645 {
646 glClientActiveTexture( GL_TEXTURE1 );
2f75cc30 647 glTexCoordPointer( 2, GL_FLOAT, sizeof( TLITVERTEX ), &(g_vtxBuffer[0].tcord[1].u) );
d07c171f 648 }
649#else
650
651 glBegin(GL_TRIANGLE_FAN);
652
653 glColor4f(g_texRectTVtx[3].r, g_texRectTVtx[3].g, g_texRectTVtx[3].b, g_texRectTVtx[3].a);
654 TexCoord(g_texRectTVtx[3]);
655 glVertex3f(g_texRectTVtx[3].x, g_texRectTVtx[3].y, depth);
656
657 glColor4f(g_texRectTVtx[2].r, g_texRectTVtx[2].g, g_texRectTVtx[2].b, g_texRectTVtx[2].a);
658 TexCoord(g_texRectTVtx[2]);
659 glVertex3f(g_texRectTVtx[2].x, g_texRectTVtx[2].y, depth);
660
661 glColor4f(g_texRectTVtx[1].r, g_texRectTVtx[1].g, g_texRectTVtx[1].b, g_texRectTVtx[1].a);
662 TexCoord(g_texRectTVtx[1]);
663 glVertex3f(g_texRectTVtx[1].x, g_texRectTVtx[1].y, depth);
664
665 glColor4f(g_texRectTVtx[0].r, g_texRectTVtx[0].g, g_texRectTVtx[0].b, g_texRectTVtx[0].a);
666 TexCoord(g_texRectTVtx[0]);
667 glVertex3f(g_texRectTVtx[0].x, g_texRectTVtx[0].y, depth);
668
669 glEnd();
670#endif
671 OPENGL_CHECK_ERRORS;
672
673#elif SDL_VIDEO_OPENGL_ES2
674 GLfloat colour[] = {
675 g_texRectTVtx[3].r, g_texRectTVtx[3].g, g_texRectTVtx[3].b, g_texRectTVtx[3].a,
676 g_texRectTVtx[2].r, g_texRectTVtx[2].g, g_texRectTVtx[2].b, g_texRectTVtx[2].a,
677 g_texRectTVtx[1].r, g_texRectTVtx[1].g, g_texRectTVtx[1].b, g_texRectTVtx[1].a,
678 g_texRectTVtx[0].r, g_texRectTVtx[0].g, g_texRectTVtx[0].b, g_texRectTVtx[0].a
679 };
680
681 GLfloat tex[] = {
682 g_texRectTVtx[3].tcord[0].u,g_texRectTVtx[3].tcord[0].v,
683 g_texRectTVtx[2].tcord[0].u,g_texRectTVtx[2].tcord[0].v,
684 g_texRectTVtx[1].tcord[0].u,g_texRectTVtx[1].tcord[0].v,
685 g_texRectTVtx[0].tcord[0].u,g_texRectTVtx[0].tcord[0].v
686 };
687
688 float w = windowSetting.uDisplayWidth / 2.0f, h = windowSetting.uDisplayHeight / 2.0f, inv = 1.0f;
689
690 GLfloat vertices[] = {
691 -inv + g_texRectTVtx[3].x / w, inv - g_texRectTVtx[3].y / h, depth, 1,
692 -inv + g_texRectTVtx[2].x / w, inv - g_texRectTVtx[2].y / h, depth, 1,
693 -inv + g_texRectTVtx[1].x / w, inv - g_texRectTVtx[1].y / h, depth, 1,
694 -inv + g_texRectTVtx[0].x / w, inv - g_texRectTVtx[0].y / h, depth, 1
695 };
696
697 glVertexAttribPointer(VS_COLOR, 4, GL_FLOAT,GL_TRUE, 0, &colour );
698 glVertexAttribPointer(VS_POSITION,4,GL_FLOAT,GL_FALSE,0,&vertices);
699 glVertexAttribPointer(VS_TEXCOORD0,2,GL_FLOAT,GL_FALSE, 0, &tex);
700 OPENGL_CHECK_ERRORS;
701 glDrawArrays(GL_TRIANGLE_FAN,0,4);
702 OPENGL_CHECK_ERRORS;
703
704 //Restore old pointers
705 glVertexAttribPointer(VS_COLOR, 4, GL_UNSIGNED_BYTE,GL_TRUE, sizeof(uint8)*4, &(g_oglVtxColors[0][0]) );
706 glVertexAttribPointer(VS_POSITION,4,GL_FLOAT,GL_FALSE,sizeof(float)*5,&(g_vtxProjected5[0][0]));
707 glVertexAttribPointer(VS_TEXCOORD0,2,GL_FLOAT,GL_FALSE, sizeof( TLITVERTEX ), &(g_vtxBuffer[0].tcord[0].u));
708#endif
709
710 if( cullface ) glEnable(GL_CULL_FACE);
711 OPENGL_CHECK_ERRORS;
712
713 return true;
714}
715
716bool OGLRender::RenderFillRect(uint32 dwColor, float depth)
717{
718 float a = (dwColor>>24)/255.0f;
719 float r = ((dwColor>>16)&0xFF)/255.0f;
720 float g = ((dwColor>>8)&0xFF)/255.0f;
721 float b = (dwColor&0xFF)/255.0f;
722 glViewportWrapper(0, windowSetting.statusBarHeightToUse, windowSetting.uDisplayWidth, windowSetting.uDisplayHeight);
723 OPENGL_CHECK_ERRORS;
724
725 GLboolean cullface = glIsEnabled(GL_CULL_FACE);
726 glDisable(GL_CULL_FACE);
727 OPENGL_CHECK_ERRORS;
728
729#if SDL_VIDEO_OPENGL
730#ifdef HAVE_GLES
731 GLfloat colour[] = {
732 r,g,b,a,
733 r,g,b,a,
734 r,g,b,a,
735 r,g,b,a};
736
737 GLfloat vertices[] = {
738 m_fillRectVtx[0].x, m_fillRectVtx[1].y, depth, 1,
739 m_fillRectVtx[1].x, m_fillRectVtx[1].y, depth, 1,
740 m_fillRectVtx[1].x, m_fillRectVtx[0].y, depth, 1,
741 m_fillRectVtx[0].x, m_fillRectVtx[0].y, depth, 1
742 };
743
744 glColorPointer(4, GL_FLOAT, 0, &colour );
745 glVertexPointer(4,GL_FLOAT, 0,&vertices);
746 if( m_bMultiTexture ) {
747 if (m_texUnitEnabled[1])
748 {
749 glClientActiveTexture( GL_TEXTURE1 );
750 glActiveTexture( GL_TEXTURE1 );
751 glDisableClientState( GL_TEXTURE_COORD_ARRAY );
752 glDisable(GL_TEXTURE_2D);
753 }
754 }
755 if (m_texUnitEnabled[0]) {
756 glClientActiveTexture( GL_TEXTURE0 );
757 glActiveTexture( GL_TEXTURE0 );
758 glDisableClientState( GL_TEXTURE_COORD_ARRAY );
759 glDisable(GL_TEXTURE_2D);
760 }
761 OPENGL_CHECK_ERRORS;
762 glColor4f(r,g,b,a);
763 glDrawArrays(GL_TRIANGLE_FAN,0,4);
764 OPENGL_CHECK_ERRORS;
765 //Restore old pointers
766 glColorPointer( 4, GL_UNSIGNED_BYTE, sizeof(uint8)*4, &(g_oglVtxColors[0][0]) );
767 glVertexPointer( 4, GL_FLOAT, sizeof(float)*5, &(g_vtxProjected5[0][0]) );
768 if (m_texUnitEnabled[0]) {
769 glEnableClientState( GL_TEXTURE_COORD_ARRAY );
770 glEnable(GL_TEXTURE_2D);
771 }
772 if( m_bMultiTexture ) {
773 glClientActiveTexture( GL_TEXTURE1 );
774 glActiveTexture( GL_TEXTURE1 );
775 if (m_texUnitEnabled[1])
776 {
777 glEnable(GL_TEXTURE_2D);
778 glEnableClientState( GL_TEXTURE_COORD_ARRAY );
779 }
780 glActiveTexture( GL_TEXTURE0 );
781 }
782#else
783
784 glBegin(GL_TRIANGLE_FAN);
785 glColor4f(r,g,b,a);
786 glVertex4f(m_fillRectVtx[0].x, m_fillRectVtx[1].y, depth, 1);
787 glVertex4f(m_fillRectVtx[1].x, m_fillRectVtx[1].y, depth, 1);
788 glVertex4f(m_fillRectVtx[1].x, m_fillRectVtx[0].y, depth, 1);
789 glVertex4f(m_fillRectVtx[0].x, m_fillRectVtx[0].y, depth, 1);
790 glEnd();
791 OPENGL_CHECK_ERRORS;
792#endif
793#elif SDL_VIDEO_OPENGL_ES2
794
795 GLfloat colour[] = {
796 r,g,b,a,
797 r,g,b,a,
798 r,g,b,a,
799 r,g,b,a};
800
801 float w = windowSetting.uDisplayWidth / 2.0f, h = windowSetting.uDisplayHeight / 2.0f, inv = 1.0f;
802
803 GLfloat vertices[] = {
804 -inv + m_fillRectVtx[0].x / w, inv - m_fillRectVtx[1].y / h, depth, 1,
805 -inv + m_fillRectVtx[1].x / w, inv - m_fillRectVtx[1].y / h, depth, 1,
806 -inv + m_fillRectVtx[1].x / w, inv - m_fillRectVtx[0].y / h, depth, 1,
807 -inv + m_fillRectVtx[0].x / w, inv - m_fillRectVtx[0].y / h, depth, 1
808 };
809
810 glVertexAttribPointer(VS_COLOR, 4, GL_FLOAT,GL_FALSE, 0, &colour );
811 glVertexAttribPointer(VS_POSITION,4,GL_FLOAT,GL_FALSE,0,&vertices);
812 glDisableVertexAttribArray(VS_TEXCOORD0);
813 OPENGL_CHECK_ERRORS;
814 glDrawArrays(GL_TRIANGLE_FAN,0,4);
815 OPENGL_CHECK_ERRORS;
816
817 //Restore old pointers
818 glVertexAttribPointer(VS_COLOR, 4, GL_UNSIGNED_BYTE,GL_TRUE, sizeof(uint8)*4, &(g_oglVtxColors[0][0]) );
819 glVertexAttribPointer(VS_POSITION,4,GL_FLOAT,GL_FALSE,sizeof(float)*5,&(g_vtxProjected5[0][0]));
820 glEnableVertexAttribArray(VS_TEXCOORD0);
821
822#endif
823
824 if( cullface ) glEnable(GL_CULL_FACE);
825 OPENGL_CHECK_ERRORS;
826
827 return true;
828}
829
830bool OGLRender::RenderLine3D()
831{
832#if SDL_VIDEO_OPENGL
833 ApplyZBias(0); // disable z offsets
834
835#ifdef HAVE_GLES
836 GLfloat colour[] = {
837 m_line3DVtx[1].r,m_line3DVtx[1].g,m_line3DVtx[1].b,m_line3DVtx[1].a,
838 m_line3DVtx[1].r,m_line3DVtx[1].g,m_line3DVtx[1].b,m_line3DVtx[1].a,
839 m_line3DVtx[0].r,m_line3DVtx[0].g,m_line3DVtx[0].b,m_line3DVtx[0].a,
840 m_line3DVtx[0].r,m_line3DVtx[0].g,m_line3DVtx[0].b,m_line3DVtx[0].a};
841
842 GLfloat vertices[] = {
843 m_line3DVector[3].x, m_line3DVector[3].y, -m_line3DVtx[1].z, 1,
844 m_line3DVector[2].x, m_line3DVector[2].y, -m_line3DVtx[0].z, 1,
845 m_line3DVector[1].x, m_line3DVector[1].y, -m_line3DVtx[1].z, 1,
846 m_line3DVector[0].x, m_line3DVector[0].y, -m_line3DVtx[0].z, 1
847 };
848
849 glColorPointer(4, GL_FLOAT, 0, &colour );
850 glVertexPointer(4,GL_FLOAT, 0,&vertices);
851 if( m_bMultiTexture )
852 {
853 glClientActiveTexture( GL_TEXTURE1 );
854 glDisableClientState( GL_TEXTURE_COORD_ARRAY );
855 glClientActiveTexture( GL_TEXTURE0 );
856 }
857 glDisableClientState( GL_TEXTURE_COORD_ARRAY );
858 OPENGL_CHECK_ERRORS;
859 glDrawArrays(GL_TRIANGLE_FAN,0,4);
860 OPENGL_CHECK_ERRORS;
861 //Restore old pointers
862 glColorPointer( 4, GL_UNSIGNED_BYTE, sizeof(uint8)*4, &(g_oglVtxColors[0][0]) );
863 glEnableClientState( GL_TEXTURE_COORD_ARRAY );
864 glVertexPointer( 4, GL_FLOAT, sizeof(float)*5, &(g_vtxProjected5[0][0]) );
865 if( m_bMultiTexture )
866 {
867 glClientActiveTexture( GL_TEXTURE1 );
868 glEnableClientState( GL_TEXTURE_COORD_ARRAY );
869 }
870#else
871 glBegin(GL_TRIANGLE_FAN);
872
873 glColor4f(m_line3DVtx[1].r, m_line3DVtx[1].g, m_line3DVtx[1].b, m_line3DVtx[1].a);
874 glVertex3f(m_line3DVector[3].x, m_line3DVector[3].y, -m_line3DVtx[1].z);
875 glVertex3f(m_line3DVector[2].x, m_line3DVector[2].y, -m_line3DVtx[0].z);
876
877 glColor4ub(m_line3DVtx[0].r, m_line3DVtx[0].g, m_line3DVtx[0].b, m_line3DVtx[0].a);
878 glVertex3f(m_line3DVector[1].x, m_line3DVector[1].y, -m_line3DVtx[1].z);
879 glVertex3f(m_line3DVector[0].x, m_line3DVector[0].y, -m_line3DVtx[0].z);
880
881 glEnd();
882#endif
883 OPENGL_CHECK_ERRORS;
884
885 ApplyZBias(m_dwZBias); // set Z offset back to previous value
886#endif
887
888 return true;
889}
890
891extern FiddledVtx * g_pVtxBase;
892
893// This is so weired that I can not do vertex transform by myself. I have to use
894// OpenGL internal transform
895bool OGLRender::RenderFlushTris()
896{
897 if( !m_bSupportFogCoordExt )
898 SetFogFlagForNegativeW();
899 else
900 {
901 if( !gRDP.bFogEnableInBlender && gRSP.bFogEnabled )
902 {
903 TurnFogOnOff(false);
904 }
905 }
906
907 ApplyZBias(m_dwZBias); // set the bias factors
908
909 glViewportWrapper(windowSetting.vpLeftW, windowSetting.uDisplayHeight-windowSetting.vpTopW-windowSetting.vpHeightW+windowSetting.statusBarHeightToUse, windowSetting.vpWidthW, windowSetting.vpHeightW, false);
910 OPENGL_CHECK_ERRORS;
911
912// if (options.bOGLVertexClipper == FALSE )
913 {
914 glDrawElements( GL_TRIANGLES, gRSP.numVertices, GL_UNSIGNED_SHORT, g_vtxIndex );
915 OPENGL_CHECK_ERRORS;
916 }
917/* else
918 {
919 //ClipVertexesOpenGL();
920 // Redo the index
921 // Set the array
922 glVertexPointer( 4, GL_FLOAT, sizeof(float)*5, &(g_vtxProjected5Clipped[0][0]) );
923 glEnableClientState( GL_VERTEX_ARRAY );
924
925 pglClientActiveTextureARB( GL_TEXTURE0_ARB );
926 glTexCoordPointer( 2, GL_FLOAT, sizeof( TLITVERTEX ), &(g_clippedVtxBuffer[0].tcord[0].u) );
927 glEnableClientState( GL_TEXTURE_COORD_ARRAY );
928
929 pglClientActiveTextureARB( GL_TEXTURE1_ARB );
930 glTexCoordPointer( 2, GL_FLOAT, sizeof( TLITVERTEX ), &(g_clippedVtxBuffer[0].tcord[1].u) );
931 glEnableClientState( GL_TEXTURE_COORD_ARRAY );
932
933 glDrawElements( GL_TRIANGLES, gRSP.numVertices, GL_UNSIGNED_SHORT, g_vtxIndex );
934
935 // Reset the array
936 pglClientActiveTextureARB( GL_TEXTURE0_ARB );
937 glTexCoordPointer( 2, GL_FLOAT, sizeof( TLITVERTEX ), &(g_vtxBuffer[0].tcord[0].u) );
938 glEnableClientState( GL_TEXTURE_COORD_ARRAY );
939
940 pglClientActiveTextureARB( GL_TEXTURE1_ARB );
941 glTexCoordPointer( 2, GL_FLOAT, sizeof( TLITVERTEX ), &(g_vtxBuffer[0].tcord[1].u) );
942 glEnableClientState( GL_TEXTURE_COORD_ARRAY );
943
944 glVertexPointer( 4, GL_FLOAT, sizeof(float)*5, &(g_vtxProjected5[0][0]) );
945 glEnableClientState( GL_VERTEX_ARRAY );
946 }
947*/
948
949 if( !m_bSupportFogCoordExt )
950 RestoreFogFlag();
951 else
952 {
953 if( !gRDP.bFogEnableInBlender && gRSP.bFogEnabled )
954 {
955 TurnFogOnOff(true);
956 }
957 }
958 return true;
959}
960
961void OGLRender::DrawSimple2DTexture(float x0, float y0, float x1, float y1, float u0, float v0, float u1, float v1, COLOR dif, COLOR spe, float z, float rhw)
962{
963 if( status.bVIOriginIsUpdated == true && currentRomOptions.screenUpdateSetting==SCREEN_UPDATE_AT_1ST_PRIMITIVE )
964 {
965 status.bVIOriginIsUpdated=false;
966 CGraphicsContext::Get()->UpdateFrame();
967 DEBUGGER_PAUSE_AND_DUMP_NO_UPDATE(NEXT_SET_CIMG,{DebuggerAppendMsg("Screen Update at 1st Simple2DTexture");});
968 }
969
970 StartDrawSimple2DTexture(x0, y0, x1, y1, u0, v0, u1, v1, dif, spe, z, rhw);
971
972 GLboolean cullface = glIsEnabled(GL_CULL_FACE);
973 glDisable(GL_CULL_FACE);
974 OPENGL_CHECK_ERRORS;
975
976 glViewportWrapper(0, windowSetting.statusBarHeightToUse, windowSetting.uDisplayWidth, windowSetting.uDisplayHeight);
977 OPENGL_CHECK_ERRORS;
978
979 float a = (g_texRectTVtx[0].dcDiffuse >>24)/255.0f;
980 float r = ((g_texRectTVtx[0].dcDiffuse>>16)&0xFF)/255.0f;
981 float g = ((g_texRectTVtx[0].dcDiffuse>>8)&0xFF)/255.0f;
982 float b = (g_texRectTVtx[0].dcDiffuse&0xFF)/255.0f;
983
984#if SDL_VIDEO_OPENGL
985
986#ifdef HAVE_GLES
987 GLfloat colour[] = {
988 r,g,b,a,
989 r,g,b,a,
990 r,g,b,a,
991 r,g,b,a,
992 r,g,b,a,
993 r,g,b,a};
994
995 GLfloat tex[] = {
996 g_texRectTVtx[0].tcord[0].u,g_texRectTVtx[0].tcord[0].v,
997 g_texRectTVtx[1].tcord[0].u,g_texRectTVtx[1].tcord[0].v,
998 g_texRectTVtx[2].tcord[0].u,g_texRectTVtx[2].tcord[0].v,
999 g_texRectTVtx[0].tcord[0].u,g_texRectTVtx[0].tcord[0].v,
1000 g_texRectTVtx[2].tcord[0].u,g_texRectTVtx[2].tcord[0].v,
1001 g_texRectTVtx[3].tcord[0].u,g_texRectTVtx[3].tcord[0].v
1002 };
1003
2f75cc30 1004 GLfloat tex2[] = {
1005 g_texRectTVtx[0].tcord[1].u,g_texRectTVtx[0].tcord[1].v,
1006 g_texRectTVtx[1].tcord[1].u,g_texRectTVtx[1].tcord[1].v,
1007 g_texRectTVtx[2].tcord[1].u,g_texRectTVtx[2].tcord[1].v,
1008 g_texRectTVtx[0].tcord[1].u,g_texRectTVtx[0].tcord[1].v,
1009 g_texRectTVtx[2].tcord[1].u,g_texRectTVtx[2].tcord[1].v,
1010 g_texRectTVtx[3].tcord[1].u,g_texRectTVtx[3].tcord[1].v
1011 };
1012
d07c171f 1013 GLfloat vertices[] = {
1014 g_texRectTVtx[0].x, g_texRectTVtx[0].y, -g_texRectTVtx[0].z, 1,
1015 g_texRectTVtx[1].x, g_texRectTVtx[1].y, -g_texRectTVtx[1].z, 1,
1016 g_texRectTVtx[2].x, g_texRectTVtx[2].y, -g_texRectTVtx[2].z, 1,
1017 g_texRectTVtx[0].x, g_texRectTVtx[0].y, -g_texRectTVtx[0].z, 1,
1018 g_texRectTVtx[2].x, g_texRectTVtx[2].y, -g_texRectTVtx[2].z, 1,
1019 g_texRectTVtx[3].x, g_texRectTVtx[3].y, -g_texRectTVtx[3].z, 1
1020 };
1021
1022 glColorPointer(4, GL_FLOAT, 0, &colour );
1023 glVertexPointer(4,GL_FLOAT, 0,&vertices);
1024 if( m_bMultiTexture )
1025 {
1026 glClientActiveTexture( GL_TEXTURE1 );
2f75cc30 1027 glTexCoordPointer(2, GL_FLOAT, 0, &tex2);
d07c171f 1028 glClientActiveTexture( GL_TEXTURE0 );
1029 }
2f75cc30 1030 glTexCoordPointer(2, GL_FLOAT, 0, &tex);
d07c171f 1031 glDrawArrays(GL_TRIANGLES,0,6);
1032 //Restore old pointers
1033 glColorPointer( 4, GL_UNSIGNED_BYTE, sizeof(uint8)*4, &(g_oglVtxColors[0][0]) );
1034 glTexCoordPointer( 2, GL_FLOAT, sizeof( TLITVERTEX ), &(g_vtxBuffer[0].tcord[0].u) );
2f75cc30 1035 glVertexPointer( 4, GL_FLOAT, sizeof(float)*5, &(g_vtxProjected5[0][0]) );
d07c171f 1036 if( m_bMultiTexture )
1037 {
1038 glClientActiveTexture( GL_TEXTURE1 );
2f75cc30 1039 glTexCoordPointer( 2, GL_FLOAT, sizeof( TLITVERTEX ), &(g_vtxBuffer[0].tcord[1].u) );
d07c171f 1040 }
1041#else
1042 glBegin(GL_TRIANGLES);
1043
1044 glColor4f(r,g,b,a);
1045
1046 OGLRender::TexCoord(g_texRectTVtx[0]);
1047 glVertex3f(g_texRectTVtx[0].x, g_texRectTVtx[0].y, -g_texRectTVtx[0].z);
1048
1049 OGLRender::TexCoord(g_texRectTVtx[1]);
1050 glVertex3f(g_texRectTVtx[1].x, g_texRectTVtx[1].y, -g_texRectTVtx[1].z);
1051
1052 OGLRender::TexCoord(g_texRectTVtx[2]);
1053 glVertex3f(g_texRectTVtx[2].x, g_texRectTVtx[2].y, -g_texRectTVtx[2].z);
1054
1055 OGLRender::TexCoord(g_texRectTVtx[0]);
1056 glVertex3f(g_texRectTVtx[0].x, g_texRectTVtx[0].y, -g_texRectTVtx[0].z);
1057
1058 OGLRender::TexCoord(g_texRectTVtx[2]);
1059 glVertex3f(g_texRectTVtx[2].x, g_texRectTVtx[2].y, -g_texRectTVtx[2].z);
1060
1061 OGLRender::TexCoord(g_texRectTVtx[3]);
1062 glVertex3f(g_texRectTVtx[3].x, g_texRectTVtx[3].y, -g_texRectTVtx[3].z);
1063 glEnd();
1064#endif
1065 OPENGL_CHECK_ERRORS;
1066
1067#elif SDL_VIDEO_OPENGL_ES2
1068
1069 GLfloat colour[] = {
1070 r,g,b,a,
1071 r,g,b,a,
1072 r,g,b,a,
1073 r,g,b,a,
1074 r,g,b,a,
1075 r,g,b,a
1076 };
1077
1078 GLfloat tex[] = {
1079 g_texRectTVtx[0].tcord[0].u,g_texRectTVtx[0].tcord[0].v,
1080 g_texRectTVtx[1].tcord[0].u,g_texRectTVtx[1].tcord[0].v,
1081 g_texRectTVtx[2].tcord[0].u,g_texRectTVtx[2].tcord[0].v,
1082
1083 g_texRectTVtx[0].tcord[0].u,g_texRectTVtx[0].tcord[0].v,
1084 g_texRectTVtx[2].tcord[0].u,g_texRectTVtx[2].tcord[0].v,
1085 g_texRectTVtx[3].tcord[0].u,g_texRectTVtx[3].tcord[0].v,
1086 };
1087
1088 float w = windowSetting.uDisplayWidth / 2.0f, h = windowSetting.uDisplayHeight / 2.0f, inv = 1.0f;
1089
1090 GLfloat vertices[] = {
1091 -inv + g_texRectTVtx[0].x/ w, inv - g_texRectTVtx[0].y/ h, -g_texRectTVtx[0].z,1,
1092 -inv + g_texRectTVtx[1].x/ w, inv - g_texRectTVtx[1].y/ h, -g_texRectTVtx[1].z,1,
1093 -inv + g_texRectTVtx[2].x/ w, inv - g_texRectTVtx[2].y/ h, -g_texRectTVtx[2].z,1,
1094
1095 -inv + g_texRectTVtx[0].x/ w, inv - g_texRectTVtx[0].y/ h, -g_texRectTVtx[0].z,1,
1096 -inv + g_texRectTVtx[2].x/ w, inv - g_texRectTVtx[2].y/ h, -g_texRectTVtx[2].z,1,
1097 -inv + g_texRectTVtx[3].x/ w, inv - g_texRectTVtx[3].y/ h, -g_texRectTVtx[3].z,1
1098 };
1099
1100 glVertexAttribPointer(VS_COLOR, 4, GL_FLOAT,GL_FALSE, 0, &colour );
1101 glVertexAttribPointer(VS_POSITION,4,GL_FLOAT,GL_FALSE,0,&vertices);
1102 glVertexAttribPointer(VS_TEXCOORD0,2,GL_FLOAT,GL_FALSE, 0, &tex);
1103 OPENGL_CHECK_ERRORS;
1104 glDrawArrays(GL_TRIANGLES,0,6);
1105 OPENGL_CHECK_ERRORS;
1106
1107 //Restore old pointers
1108 glVertexAttribPointer(VS_COLOR, 4, GL_UNSIGNED_BYTE,GL_TRUE, sizeof(uint8)*4, &(g_oglVtxColors[0][0]) );
1109 glVertexAttribPointer(VS_POSITION,4,GL_FLOAT,GL_FALSE,sizeof(float)*5,&(g_vtxProjected5[0][0]));
1110 glVertexAttribPointer(VS_TEXCOORD0,2,GL_FLOAT,GL_FALSE, sizeof( TLITVERTEX ), &(g_vtxBuffer[0].tcord[0].u));
1111
1112#endif
1113
1114 if( cullface ) glEnable(GL_CULL_FACE);
1115 OPENGL_CHECK_ERRORS;
1116}
1117
1118void OGLRender::DrawSimpleRect(int nX0, int nY0, int nX1, int nY1, uint32 dwColor, float depth, float rhw)
1119{
1120 StartDrawSimpleRect(nX0, nY0, nX1, nY1, dwColor, depth, rhw);
1121
1122 GLboolean cullface = glIsEnabled(GL_CULL_FACE);
1123 glDisable(GL_CULL_FACE);
1124 OPENGL_CHECK_ERRORS;
1125
1126 float a = (dwColor>>24)/255.0f;
1127 float r = ((dwColor>>16)&0xFF)/255.0f;
1128 float g = ((dwColor>>8)&0xFF)/255.0f;
1129 float b = (dwColor&0xFF)/255.0f;
1130
1131#if SDL_VIDEO_OPENGL
1132
1133#ifdef HAVE_GLES
1134 GLfloat colour[] = {
1135 r,g,b,a,
1136 r,g,b,a,
1137 r,g,b,a,
1138 r,g,b,a};
1139
1140 GLfloat vertices[] = {
1141 m_simpleRectVtx[1].x, m_simpleRectVtx[0].y, -depth, 1,
1142 m_simpleRectVtx[1].x, m_simpleRectVtx[1].y, -depth, 1,
1143 m_simpleRectVtx[0].x, m_simpleRectVtx[1].y, -depth, 1,
1144 m_simpleRectVtx[0].x, m_simpleRectVtx[0].y, -depth, 1
1145 };
1146
1147 glColorPointer(4, GL_FLOAT, 0, &colour );
1148 glVertexPointer(4,GL_FLOAT, 0,&vertices);
1149 if( m_bMultiTexture )
1150 {
1151 glClientActiveTexture( GL_TEXTURE1 );
2f75cc30 1152 glActiveTexture( GL_TEXTURE1 );
1153 glDisable(GL_TEXTURE_2D);
d07c171f 1154 glDisableClientState( GL_TEXTURE_COORD_ARRAY );
1155 glClientActiveTexture( GL_TEXTURE0 );
1156 }
2f75cc30 1157 glActiveTexture( GL_TEXTURE0 );
1158 glDisable(GL_TEXTURE_2D);
1159
d07c171f 1160 glDisableClientState( GL_TEXTURE_COORD_ARRAY );
1161 OPENGL_CHECK_ERRORS;
1162 glColor4f(r,g,b,a);
1163 glDrawArrays(GL_TRIANGLE_FAN,0,4);
1164 OPENGL_CHECK_ERRORS;
1165 //Restore old pointers
1166 glColorPointer( 4, GL_UNSIGNED_BYTE, sizeof(uint8)*4, &(g_oglVtxColors[0][0]) );
1167 glEnableClientState( GL_TEXTURE_COORD_ARRAY );
1168 glVertexPointer( 4, GL_FLOAT, sizeof(float)*5, &(g_vtxProjected5[0][0]) );
2f75cc30 1169 glEnable(GL_TEXTURE_2D);
d07c171f 1170 if( m_bMultiTexture )
1171 {
2f75cc30 1172 glActiveTexture( GL_TEXTURE1 );
1173 glEnable(GL_TEXTURE_2D);
d07c171f 1174 glClientActiveTexture( GL_TEXTURE1 );
1175 glEnableClientState( GL_TEXTURE_COORD_ARRAY );
1176 }
1177#else
1178 glBegin(GL_TRIANGLE_FAN);
1179
1180 glColor4f(r,g,b,a);
1181 glVertex3f(m_simpleRectVtx[1].x, m_simpleRectVtx[0].y, -depth);
1182 glVertex3f(m_simpleRectVtx[1].x, m_simpleRectVtx[1].y, -depth);
1183 glVertex3f(m_simpleRectVtx[0].x, m_simpleRectVtx[1].y, -depth);
1184 glVertex3f(m_simpleRectVtx[0].x, m_simpleRectVtx[0].y, -depth);
1185
1186 glEnd();
1187#endif
1188 OPENGL_CHECK_ERRORS;
1189
1190#elif SDL_VIDEO_OPENGL_ES2
1191
1192 GLfloat colour[] = {
1193 r,g,b,a,
1194 r,g,b,a,
1195 r,g,b,a,
1196 r,g,b,a};
1197 float w = windowSetting.uDisplayWidth / 2.0f, h = windowSetting.uDisplayHeight / 2.0f, inv = 1.0f;
1198
1199 GLfloat vertices[] = {
1200 -inv + m_simpleRectVtx[1].x / w, inv - m_simpleRectVtx[0].y / h, -depth, 1,
1201 -inv + m_simpleRectVtx[1].x / w, inv - m_simpleRectVtx[1].y / h, -depth, 1,
1202 -inv + m_simpleRectVtx[0].x / w, inv - m_simpleRectVtx[1].y / h, -depth, 1,
1203 -inv + m_simpleRectVtx[0].x / w, inv - m_simpleRectVtx[0].y / h, -depth, 1
1204 };
1205
1206 glVertexAttribPointer(VS_COLOR, 4, GL_FLOAT,GL_FALSE, 0, &colour );
1207 glVertexAttribPointer(VS_POSITION,4,GL_FLOAT,GL_FALSE,0,&vertices);
1208 glDisableVertexAttribArray(VS_TEXCOORD0);
1209 OPENGL_CHECK_ERRORS;
1210 glDrawArrays(GL_TRIANGLE_FAN,0,4);
1211 OPENGL_CHECK_ERRORS;
1212
1213 //Restore old pointers
1214 glVertexAttribPointer(VS_COLOR, 4, GL_UNSIGNED_BYTE,GL_TRUE, sizeof(uint8)*4, &(g_oglVtxColors[0][0]) );
1215 glVertexAttribPointer(VS_POSITION,4,GL_FLOAT,GL_FALSE,sizeof(float)*5,&(g_vtxProjected5[0][0]));
1216 glEnableVertexAttribArray(VS_TEXCOORD0);
1217
1218#endif
1219
1220 if( cullface ) glEnable(GL_CULL_FACE);
1221 OPENGL_CHECK_ERRORS;
1222}
1223
1224void OGLRender::InitCombinerBlenderForSimpleRectDraw(uint32 tile)
1225{
1226 //glEnable(GL_CULL_FACE);
1227 EnableTexUnit(0,FALSE);
1228 OPENGL_CHECK_ERRORS;
1229 glEnable(GL_BLEND);
1230 OPENGL_CHECK_ERRORS;
1231 glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
1232 OPENGL_CHECK_ERRORS;
1233 //glEnable(GL_ALPHA_TEST);
1234}
1235
1236COLOR OGLRender::PostProcessDiffuseColor(COLOR curDiffuseColor)
1237{
1238 uint32 color = curDiffuseColor;
1239 uint32 colorflag = m_pColorCombiner->m_pDecodedMux->m_dwShadeColorChannelFlag;
1240 uint32 alphaflag = m_pColorCombiner->m_pDecodedMux->m_dwShadeAlphaChannelFlag;
1241 if( colorflag+alphaflag != MUX_0 )
1242 {
1243 if( (colorflag & 0xFFFFFF00) == 0 && (alphaflag & 0xFFFFFF00) == 0 )
1244 {
1245 color = (m_pColorCombiner->GetConstFactor(colorflag, alphaflag, curDiffuseColor));
1246 }
1247 else
1248 color = (CalculateConstFactor(colorflag, alphaflag, curDiffuseColor));
1249 }
1250
1251 //return (color<<8)|(color>>24);
1252 return color;
1253}
1254
1255COLOR OGLRender::PostProcessSpecularColor()
1256{
1257 return 0;
1258}
1259
1260void OGLRender::SetViewportRender()
1261{
1262 glViewportWrapper(windowSetting.vpLeftW, windowSetting.uDisplayHeight-windowSetting.vpTopW-windowSetting.vpHeightW+windowSetting.statusBarHeightToUse, windowSetting.vpWidthW, windowSetting.vpHeightW);
1263 OPENGL_CHECK_ERRORS;
1264}
1265
1266void OGLRender::RenderReset()
1267{
1268 CRender::RenderReset();
1269
1270 glMatrixMode(GL_PROJECTION);
1271 OPENGL_CHECK_ERRORS;
1272 glLoadIdentity();
1273 OPENGL_CHECK_ERRORS;
1274 glOrtho(0, windowSetting.uDisplayWidth, windowSetting.uDisplayHeight, 0, -1, 1);
1275 OPENGL_CHECK_ERRORS;
1276
1277 // position viewer
1278 glMatrixMode(GL_MODELVIEW);
1279 OPENGL_CHECK_ERRORS;
1280 glLoadIdentity();
1281 OPENGL_CHECK_ERRORS;
1282}
1283
1284void OGLRender::SetAlphaTestEnable(BOOL bAlphaTestEnable)
1285{
1286#ifdef DEBUGGER
1287 if( bAlphaTestEnable && debuggerEnableAlphaTest )
1288#else
1289 if( bAlphaTestEnable )
1290#endif
1291#if SDL_VIDEO_OPENGL
1292 glEnable(GL_ALPHA_TEST);
1293 else
1294 glDisable(GL_ALPHA_TEST);
1295#elif SDL_VIDEO_OPENGL_ES2
1296 {
1297 COGL_FragmentProgramCombiner* frag = (COGL_FragmentProgramCombiner*)m_pColorCombiner;
1298 frag->m_AlphaRef = m_dwAlpha / 255.0f;
1299 }
1300 else
1301 {
1302 COGL_FragmentProgramCombiner* frag = (COGL_FragmentProgramCombiner*)m_pColorCombiner;
1303 frag->m_AlphaRef = 0.0f;
1304 }
1305#endif
1306 OPENGL_CHECK_ERRORS;
1307}
1308
1309void OGLRender::BindTexture(GLuint texture, int unitno)
1310{
1311#ifdef DEBUGGER
1312 if( unitno != 0 )
1313 {
1314 DebuggerAppendMsg("Check me, base ogl bind texture, unit no != 0");
1315 }
1316#endif
1317 if( m_curBoundTex[0] != texture )
1318 {
1319 glBindTexture(GL_TEXTURE_2D,texture);
1320 OPENGL_CHECK_ERRORS;
1321 m_curBoundTex[0] = texture;
1322 }
1323}
1324
1325void OGLRender::DisBindTexture(GLuint texture, int unitno)
1326{
1327 //EnableTexUnit(0,FALSE);
1328 //glBindTexture(GL_TEXTURE_2D, 0); //Not to bind any texture
1329}
1330
1331void OGLRender::EnableTexUnit(int unitno, BOOL flag)
1332{
1333#ifdef DEBUGGER
1334 if( unitno != 0 )
1335 {
1336 DebuggerAppendMsg("Check me, in the base ogl render, unitno!=0");
1337 }
1338#endif
1339 if( m_texUnitEnabled[0] != flag ) //strange, why 0 and not unitno?
1340 {
1341 m_texUnitEnabled[0] = flag;
1342#if SDL_VIDEO_OPENGL
1343 if( flag == TRUE ) {
1344// pglActiveTexture(GL_TEXTURE0_ARB + unitno);
1345 glEnable(GL_TEXTURE_2D);
1346 } else {
1347// pglActiveTexture(GL_TEXTURE0_ARB + unitno);
1348 glDisable(GL_TEXTURE_2D);
1349 }
1350/* if (m_bMultiTexture)
1351 pglActiveTexture(GL_TEXTURE1_ARB);*/
1352#elif SDL_VIDEO_OPENGL_ES2
1353 if(flag)
1354 {
1355 pglActiveTexture(GL_TEXTURE0_ARB + unitno);
1356 OPENGL_CHECK_ERRORS;
1357 glBindTexture(GL_TEXTURE_2D,m_curBoundTex[unitno]);
1358 }
1359 else
1360 {
1361 pglActiveTexture(GL_TEXTURE0_ARB + unitno);
1362 OPENGL_CHECK_ERRORS;
1363 glEnable(GL_BLEND); //Need blend for transparent disabled texture
1364 glBindTexture(GL_TEXTURE_2D,disabledTextureID);
1365 }
1366#endif
1367 OPENGL_CHECK_ERRORS;
1368 }
1369}
1370
1371void OGLRender::TexCoord2f(float u, float v)
1372{
1373#ifdef HAVE_GLES
1374 printf("*SEB* TexCoord2f(%f, %f)\n", u, v);
1375#else
1376 glTexCoord2f(u, v);
1377#endif
1378}
1379
1380void OGLRender::TexCoord(TLITVERTEX &vtxInfo)
1381{
1382#ifdef HAVE_GLES
1383 printf("*SEB* TexCoord(%f, %f)\n", vtxInfo.tcord[0].u, vtxInfo.tcord[0].v);
1384#else
1385 glTexCoord2f(vtxInfo.tcord[0].u, vtxInfo.tcord[0].v);
1386#endif
1387}
1388
1389void OGLRender::UpdateScissor()
1390{
1391 if( options.bEnableHacks && g_CI.dwWidth == 0x200 && gRDP.scissor.right == 0x200 && g_CI.dwWidth>(*g_GraphicsInfo.VI_WIDTH_REG & 0xFFF) )
1392 {
1393 // Hack for RE2
1394 uint32 width = *g_GraphicsInfo.VI_WIDTH_REG & 0xFFF;
1395 uint32 height = (gRDP.scissor.right*gRDP.scissor.bottom)/width;
1396 glEnable(GL_SCISSOR_TEST);
1397 OPENGL_CHECK_ERRORS;
e18935a7 1398 glScissor(windowSetting.uDisplayX, windowSetting.uDisplayY+int(height*windowSetting.fMultY+windowSetting.statusBarHeightToUse),
d07c171f 1399 int(width*windowSetting.fMultX), int(height*windowSetting.fMultY) );
1400 OPENGL_CHECK_ERRORS;
1401 }
1402 else
1403 {
1404 UpdateScissorWithClipRatio();
1405 }
1406}
1407
1408void OGLRender::ApplyRDPScissor(bool force)
1409{
1410 if( !force && status.curScissor == RDP_SCISSOR ) return;
1411
1412 if( options.bEnableHacks && g_CI.dwWidth == 0x200 && gRDP.scissor.right == 0x200 && g_CI.dwWidth>(*g_GraphicsInfo.VI_WIDTH_REG & 0xFFF) )
1413 {
1414 // Hack for RE2
1415 uint32 width = *g_GraphicsInfo.VI_WIDTH_REG & 0xFFF;
1416 uint32 height = (gRDP.scissor.right*gRDP.scissor.bottom)/width;
1417 glEnable(GL_SCISSOR_TEST);
1418 OPENGL_CHECK_ERRORS;
e18935a7 1419 glScissor(windowSetting.uDisplayX, windowSetting.uDisplayY+int(height*windowSetting.fMultY+windowSetting.statusBarHeightToUse),
d07c171f 1420 int(width*windowSetting.fMultX), int(height*windowSetting.fMultY) );
1421 OPENGL_CHECK_ERRORS;
1422 }
1423 else
1424 {
e18935a7 1425 glScissor(windowSetting.uDisplayX+int(gRDP.scissor.left*windowSetting.fMultX), windowSetting.uDisplayY+int((windowSetting.uViHeight-gRDP.scissor.bottom)*windowSetting.fMultY+windowSetting.statusBarHeightToUse),
d07c171f 1426 int((gRDP.scissor.right-gRDP.scissor.left)*windowSetting.fMultX), int((gRDP.scissor.bottom-gRDP.scissor.top)*windowSetting.fMultY ));
1427 OPENGL_CHECK_ERRORS;
1428 }
1429
1430 status.curScissor = RDP_SCISSOR;
1431}
1432
1433void OGLRender::ApplyScissorWithClipRatio(bool force)
1434{
1435 if( !force && status.curScissor == RSP_SCISSOR ) return;
1436
1437 glEnable(GL_SCISSOR_TEST);
1438 OPENGL_CHECK_ERRORS;
e18935a7 1439 glScissor(windowSetting.uDisplayX+windowSetting.clipping.left, windowSetting.uDisplayY+int((windowSetting.uViHeight-gRSP.real_clip_scissor_bottom)*windowSetting.fMultY)+windowSetting.statusBarHeightToUse,
d07c171f 1440 windowSetting.clipping.width, windowSetting.clipping.height);
1441 OPENGL_CHECK_ERRORS;
1442
1443 status.curScissor = RSP_SCISSOR;
1444}
1445
1446void OGLRender::SetFogMinMax(float fMin, float fMax)
1447{
1448#if SDL_VIDEO_OPENGL
1449 glFogf(GL_FOG_START, gRSPfFogMin); // Fog Start Depth
1450 OPENGL_CHECK_ERRORS;
1451 glFogf(GL_FOG_END, gRSPfFogMax); // Fog End Depth
1452 OPENGL_CHECK_ERRORS;
1453#elif SDL_VIDEO_OPENGL_ES2
1454 ((COGL_FragmentProgramCombiner*)m_pColorCombiner)->UpdateFog(gRSP.bFogEnabled);
1455 OPENGL_CHECK_ERRORS;
1456#endif
1457}
1458
1459void OGLRender::TurnFogOnOff(bool flag)
1460{
1461#if SDL_VIDEO_OPENGL
1462 if( flag )
1463 glEnable(GL_FOG);
1464 else
1465 glDisable(GL_FOG);
1466 OPENGL_CHECK_ERRORS;
1467#elif SDL_VIDEO_OPENGL_ES2
1468 ((COGL_FragmentProgramCombiner*)m_pColorCombiner)->UpdateFog(flag);
1469 OPENGL_CHECK_ERRORS;
1470#endif
1471}
1472
1473void OGLRender::SetFogEnable(bool bEnable)
1474{
1475 DEBUGGER_IF_DUMP( (gRSP.bFogEnabled != (bEnable==TRUE) && logFog ), TRACE1("Set Fog %s", bEnable? "enable":"disable"));
1476
1477 gRSP.bFogEnabled = bEnable&&(options.fogMethod == 1);
1478
1479 // If force fog
1480 if(options.fogMethod == 2)
1481 {
1482 gRSP.bFogEnabled = true;
1483 }
1484
1485#if SDL_VIDEO_OPENGL
1486 if( gRSP.bFogEnabled )
1487 {
1488 //TRACE2("Enable fog, min=%f, max=%f",gRSPfFogMin,gRSPfFogMax );
1489 glFogfv(GL_FOG_COLOR, gRDP.fvFogColor); // Set Fog Color
1490 OPENGL_CHECK_ERRORS;
1491 glFogf(GL_FOG_START, gRSPfFogMin); // Fog Start Depth
1492 OPENGL_CHECK_ERRORS;
1493 glFogf(GL_FOG_END, gRSPfFogMax); // Fog End Depth
1494 OPENGL_CHECK_ERRORS;
1495 glEnable(GL_FOG);
1496 OPENGL_CHECK_ERRORS;
1497 }
1498 else
1499 {
1500 glDisable(GL_FOG);
1501 OPENGL_CHECK_ERRORS;
1502 }
1503#elif SDL_VIDEO_OPENGL_ES2
1504 ((COGL_FragmentProgramCombiner*)m_pColorCombiner)->UpdateFog(gRSP.bFogEnabled);
1505 OPENGL_CHECK_ERRORS;
1506#endif
1507}
1508
1509void OGLRender::SetFogColor(uint32 r, uint32 g, uint32 b, uint32 a)
1510{
1511 gRDP.fogColor = COLOR_RGBA(r, g, b, a);
1512 gRDP.fvFogColor[0] = r/255.0f; //r
1513 gRDP.fvFogColor[1] = g/255.0f; //g
1514 gRDP.fvFogColor[2] = b/255.0f; //b
1515 gRDP.fvFogColor[3] = a/255.0f; //a
1516#if SDL_VIDEO_OPENGL
1517 glFogfv(GL_FOG_COLOR, gRDP.fvFogColor); // Set Fog Color
1518#endif
1519 OPENGL_CHECK_ERRORS;
1520}
1521
1522void OGLRender::DisableMultiTexture()
1523{
1524 pglActiveTexture(GL_TEXTURE1_ARB);
1525 OPENGL_CHECK_ERRORS;
1526 EnableTexUnit(1,FALSE);
1527 pglActiveTexture(GL_TEXTURE0_ARB);
1528 OPENGL_CHECK_ERRORS;
1529 EnableTexUnit(0,FALSE);
1530 pglActiveTexture(GL_TEXTURE0_ARB);
1531 OPENGL_CHECK_ERRORS;
1532 EnableTexUnit(0,TRUE);
1533}
1534
1535void OGLRender::EndRendering(void)
1536{
1537#if SDL_VIDEO_OPENGL
1538 glFlush();
1539 OPENGL_CHECK_ERRORS;
1540#endif
1541 if( CRender::gRenderReferenceCount > 0 )
1542 CRender::gRenderReferenceCount--;
1543}
1544
1545void OGLRender::glViewportWrapper(GLint x, GLint y, GLsizei width, GLsizei height, bool flag)
1546{
1547 static GLint mx=0,my=0;
1548 static GLsizei m_width=0, m_height=0;
1549 static bool mflag=true;
ac4f8e43 1550
e18935a7 1551 x+=windowSetting.uDisplayX;
1552 y+=windowSetting.uDisplayY;
d07c171f 1553
1554 if( x!=mx || y!=my || width!=m_width || height!=m_height || mflag!=flag)
1555 {
1556 mx=x;
1557 my=y;
1558 m_width=width;
1559 m_height=height;
1560 mflag=flag;
1561 glMatrixMode(GL_PROJECTION);
1562 OPENGL_CHECK_ERRORS;
1563 glLoadIdentity();
1564 OPENGL_CHECK_ERRORS;
1565 if( flag ) glOrtho(0, windowSetting.uDisplayWidth, windowSetting.uDisplayHeight, 0, -1, 1);
1566 OPENGL_CHECK_ERRORS;
1567 glViewport(x,y,width,height);
1568//printf("glViewport(%i, %i, %i, %i)\n", x, y, width, height);
1569 OPENGL_CHECK_ERRORS;
1570 }
1571}
Unnamed repository; edit this file 'description' to name the repository.