source/gles2rice/src/OGLRender.cpp

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