Engine/source/gfx/gl/gfxGLDevice.cpp

   1 //-----------------------------------------------------------------------------
   2 // Copyright (c) 2012 GarageGames, LLC
   3 //
   4 // Permission is hereby granted, free of charge, to any person obtaining a copy
   5 // of this software and associated documentation files (the "Software"), to
   6 // deal in the Software without restriction, including without limitation the
   7 // rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
   8 // sell copies of the Software, and to permit persons to whom the Software is
   9 // furnished to do so, subject to the following conditions:
  10 //
  11 // The above copyright notice and this permission notice shall be included in
  12 // all copies or substantial portions of the Software.
  13 //
  14 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  15 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  16 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  17 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  18 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  19 // FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
  20 // IN THE SOFTWARE.
  21 //-----------------------------------------------------------------------------
  22
  23 #include "platform/platform.h"
  24 #include "gfx/gl/gfxGLDevice.h"
  25 #include "platform/platformGL.h"
  26
  27 #include "gfx/gfxCubemap.h"
  28 #include "gfx/screenshot.h"
  29 #include "gfx/gfxDrawUtil.h"
  30
  31 #include "gfx/gl/gfxGLEnumTranslate.h"
  32 #include "gfx/gl/gfxGLVertexBuffer.h"
  33 #include "gfx/gl/gfxGLPrimitiveBuffer.h"
  34 #include "gfx/gl/gfxGLTextureTarget.h"
  35 #include "gfx/gl/gfxGLTextureManager.h"
  36 #include "gfx/gl/gfxGLTextureObject.h"
  37 #include "gfx/gl/gfxGLCubemap.h"
  38 #include "gfx/gl/gfxGLCardProfiler.h"
  39 #include "gfx/gl/gfxGLWindowTarget.h"
  40 #include "platform/platformDlibrary.h"
  41 #include "gfx/gl/gfxGLShader.h"
  42 #include "gfx/primBuilder.h"
  43 #include "console/console.h"
  44 #include "gfx/gl/gfxGLOcclusionQuery.h"
  45 #include "materials/shaderData.h"
  46 #include "gfx/gl/gfxGLStateCache.h"
  47 #include "gfx/gl/gfxGLVertexAttribLocation.h"
  48 #include "gfx/gl/gfxGLVertexDecl.h"
  49
  50 GFXAdapter::CreateDeviceInstanceDelegate GFXGLDevice::mCreateDeviceInstance(GFXGLDevice::createInstance);
  51
  52 GFXDevice *GFXGLDevice::createInstance( U32 adapterIndex )
  53 {
  54    return new GFXGLDevice(adapterIndex);
  55 }
  56
  57 namespace GL
  58 {
  59    extern void gglPerformBinds();
  60    extern void gglPerformExtensionBinds(void *context);
  61 }
  62
  63 void loadGLCore()
  64 {
  65    static bool coreLoaded = false; // Guess what this is for.
  66    if(coreLoaded)
  67       return;
  68    coreLoaded = true;
  69
  70    // Make sure we've got our GL bindings.
  71    GL::gglPerformBinds();
  72 }
  73
  74 void loadGLExtensions(void *context)
  75 {
  76    static bool extensionsLoaded = false;
  77    if(extensionsLoaded)
  78       return;
  79    extensionsLoaded = true;
  80
  81    GL::gglPerformExtensionBinds(context);
  82 }
  83
  84 void STDCALL glDebugCallback(GLenum source, GLenum type, GLuint id,
  85     GLenum severity, GLsizei length, const GLchar* message, void* userParam)
  86 {
  87     if (severity == GL_DEBUG_SEVERITY_HIGH)
  88         Con::errorf("OPENGL: %s", message);
  89     else if (severity == GL_DEBUG_SEVERITY_MEDIUM)
  90         Con::warnf("OPENGL: %s", message);
  91     else if (severity == GL_DEBUG_SEVERITY_LOW)
  92         Con::printf("OPENGL: %s", message);
  93 }
  94
  95 void STDCALL glAmdDebugCallback(GLuint id, GLenum category, GLenum severity, GLsizei length,
  96     const GLchar* message, GLvoid* userParam)
  97 {
  98     if (severity == GL_DEBUG_SEVERITY_HIGH)
  99         Con::errorf("AMDOPENGL: %s", message);
 100     else if (severity == GL_DEBUG_SEVERITY_MEDIUM)
 101         Con::warnf("AMDOPENGL: %s", message);
 102     else if (severity == GL_DEBUG_SEVERITY_LOW)
 103         Con::printf("AMDOPENGL: %s", message);
 104 }
 105
 106
 107 // >>>> OPENGL INTEL WORKAROUND @todo OPENGL INTEL remove
 108 PFNGLBINDFRAMEBUFFERPROC __openglBindFramebuffer = NULL;
 109
 110 void STDCALL _t3d_glBindFramebuffer(GLenum target, GLuint framebuffer)
 111 {
 112     if( target == GL_FRAMEBUFFER )
 113     {
 114         if( GFXGL->getOpenglCache()->getCacheBinded( GL_DRAW_FRAMEBUFFER ) == framebuffer
 115             && GFXGL->getOpenglCache()->getCacheBinded( GL_READ_FRAMEBUFFER ) == framebuffer )
 116             return;
 117     }
 118     else if( GFXGL->getOpenglCache()->getCacheBinded( target ) == framebuffer )
 119         return;
 120
 121     __openglBindFramebuffer(target, framebuffer);
 122     GFXGL->getOpenglCache()->setCacheBinded( target, framebuffer);
 123 }
 124 // <<<< OPENGL INTEL WORKAROUND
 125
 126
 127 void GFXGLDevice::initGLState()
 128 {
 129    // We don't currently need to sync device state with a known good place because we are
 130    // going to set everything in GFXGLStateBlock, but if we change our GFXGLStateBlock strategy, this may
 131    // need to happen.
 132
 133    // Deal with the card profiler here when we know we have a valid context.
 134    mCardProfiler = new GFXGLCardProfiler();
 135    mCardProfiler->init();
 136    glGetIntegerv(GL_MAX_TEXTURE_IMAGE_UNITS, (GLint*)&mMaxShaderTextures);
 137    glGetIntegerv(GL_MAX_TEXTURE_UNITS, (GLint*)&mMaxFFTextures);
 138    glGetIntegerv(GL_MAX_COLOR_ATTACHMENTS, (GLint*)&mMaxTRColors);
 139    mMaxTRColors = getMin( mMaxTRColors, (U32)(GFXTextureTarget::MaxRenderSlotId-1) );
 140
 141    glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
 142
 143    // Setting mPixelShaderVersion to 3.0 will allow Advanced Lighting to run.
 144    mPixelShaderVersion = 3.0;
 145
 146    mSupportsAnisotropic = mCardProfiler->queryProfile( "GL::suppAnisotropic" );
 147
 148    String vendorStr = (const char*)glGetString( GL_VENDOR );
 149    if( vendorStr.find("NVIDIA", 0, String::NoCase | String::Left) != String::NPos)
 150       mUseGlMap = false;
 151
 152
 153    if( vendorStr.find("INTEL", 0, String::NoCase | String::Left ) != String::NPos)
 154    {
 155       // @todo OPENGL INTEL - This is a workaround for a warning spam or even crashes with actual framebuffer code, remove when implemented TGL layer.
 156       __openglBindFramebuffer = glBindFramebuffer;
 157       glBindFramebuffer = &_t3d_glBindFramebuffer;
 158    }
 159
 160 #ifdef TORQUE_NSIGHT_WORKAROUND
 161    __GLEW_ARB_buffer_storage = false;
 162 #endif
 163 #if TORQUE_DEBUG
 164    if( gglHasExtension(ARB_debug_output) )
 165    {
 166       glEnable(GL_DEBUG_OUTPUT);
 167       glDebugMessageCallbackARB(glDebugCallback, NULL);
 168       glEnable(GL_DEBUG_OUTPUT_SYNCHRONOUS_ARB);
 169       GLuint unusedIds = 0;
 170       glDebugMessageControlARB(GL_DONT_CARE,
 171             GL_DONT_CARE,
 172             GL_DONT_CARE,
 173             0,
 174             &unusedIds,
 175             GL_TRUE);
 176    }
 177    else if(gglHasExtension(AMD_debug_output))
 178    {
 179       glEnable(GL_DEBUG_OUTPUT);
 180       glDebugMessageCallbackAMD(glAmdDebugCallback, NULL);
 181       //glEnable(GL_DEBUG_OUTPUT_SYNCHRONOUS_ARB);
 182       GLuint unusedIds = 0;
 183       glDebugMessageEnableAMD(GL_DONT_CARE, GL_DONT_CARE, 0,&unusedIds, GL_TRUE);
 184    }
 185 #endif
 186
 187    PlatformGL::setVSync(smDisableVSync ? 0 : 1);
 188
 189    //OpenGL 3 need a binded VAO for render
 190    GLuint vao;
 191    glGenVertexArrays(1, &vao);
 192    glBindVertexArray(vao);
 193 }
 194
 195 GFXGLDevice::GFXGLDevice(U32 adapterIndex) :
 196    mAdapterIndex(adapterIndex),
 197    mCurrentPB(NULL),
 198    mDrawInstancesCount(0),
 199    m_mCurrentWorld(true),
 200    m_mCurrentView(true),
 201    mContext(NULL),
 202    mPixelFormat(NULL),
 203    mPixelShaderVersion(0.0f),
 204    mMaxShaderTextures(2),
 205    mMaxFFTextures(2),
 206    mMaxTRColors(1),
 207    mClip(0, 0, 0, 0),
 208    mCurrentShader( NULL ),
 209    mNeedUpdateVertexAttrib(false),
 210    mWindowRT(NULL),
 211    mUseGlMap(true)
 212 {
 213    for(int i = 0; i < VERTEX_STREAM_COUNT; ++i)
 214    {
 215       mCurrentVB[i] = NULL;
 216       mCurrentVB_Divisor[i] = 0;
 217    }
 218
 219    loadGLCore();
 220
 221    GFXGLEnumTranslate::init();
 222
 223    GFXVertexColor::setSwizzle( &Swizzles::rgba );
 224
 225    // OpenGL have native RGB, no need swizzle
 226    mDeviceSwizzle32 = &Swizzles::rgba;
 227    mDeviceSwizzle24 = &Swizzles::rgb;
 228
 229    mTextureManager = new GFXGLTextureManager();
 230    gScreenShot = new ScreenShot();
 231
 232    for(U32 i = 0; i < TEXTURE_STAGE_COUNT; i++)
 233       mActiveTextureType[i] = GL_ZERO;
 234
 235    mNumVertexStream = 2;
 236
 237    for(int i = 0; i < GS_COUNT; ++i)
 238       mModelViewProjSC[i] = NULL;
 239
 240    mOpenglStateCache = new GFXGLStateCache;
 241 }
 242
 243 GFXGLDevice::~GFXGLDevice()
 244 {
 245    mCurrentStateBlock = NULL;
 246
 247    for(int i = 0; i < VERTEX_STREAM_COUNT; ++i)
 248       mCurrentVB[i] = NULL;
 249    mCurrentPB = NULL;
 250
 251    for(U32 i = 0; i < mVolatileVBs.size(); i++)
 252       mVolatileVBs[i] = NULL;
 253    for(U32 i = 0; i < mVolatilePBs.size(); i++)
 254       mVolatilePBs[i] = NULL;
 255
 256    // Clear out our current texture references
 257    for (U32 i = 0; i < TEXTURE_STAGE_COUNT; i++)
 258    {
 259       mCurrentTexture[i] = NULL;
 260       mNewTexture[i] = NULL;
 261       mCurrentCubemap[i] = NULL;
 262       mNewCubemap[i] = NULL;
 263    }
 264
 265    mRTStack.clear();
 266    mCurrentRT = NULL;
 267
 268    if( mTextureManager )
 269    {
 270       mTextureManager->zombify();
 271       mTextureManager->kill();
 272    }
 273
 274    GFXResource* walk = mResourceListHead;
 275    while(walk)
 276    {
 277       walk->zombify();
 278       walk = walk->getNextResource();
 279    }
 280
 281    if( mCardProfiler )
 282       SAFE_DELETE( mCardProfiler );
 283
 284    SAFE_DELETE( gScreenShot );
 285
 286    SAFE_DELETE( mOpenglStateCache );
 287 }
 288
 289 void GFXGLDevice::zombify()
 290 {
 291    mTextureManager->zombify();
 292
 293    for(int i = 0; i < VERTEX_STREAM_COUNT; ++i)
 294       if(mCurrentVB[i])
 295          mCurrentVB[i]->finish();
 296    if(mCurrentPB)
 297          mCurrentPB->finish();
 298
 299    //mVolatileVBs.clear();
 300    //mVolatilePBs.clear();
 301    GFXResource* walk = mResourceListHead;
 302    while(walk)
 303    {
 304       walk->zombify();
 305       walk = walk->getNextResource();
 306    }
 307 }
 308
 309 void GFXGLDevice::resurrect()
 310 {
 311    GFXResource* walk = mResourceListHead;
 312    while(walk)
 313    {
 314       walk->resurrect();
 315       walk = walk->getNextResource();
 316    }
 317    for(int i = 0; i < VERTEX_STREAM_COUNT; ++i)
 318       if(mCurrentVB[i])
 319          mCurrentVB[i]->prepare();
 320    if(mCurrentPB)
 321       mCurrentPB->prepare();
 322
 323    mTextureManager->resurrect();
 324 }
 325
 326 GFXVertexBuffer* GFXGLDevice::findVolatileVBO(U32 numVerts, const GFXVertexFormat *vertexFormat, U32 vertSize)
 327 {
 328    for(U32 i = 0; i < mVolatileVBs.size(); i++)
 329       if (  mVolatileVBs[i]->mNumVerts >= numVerts &&
 330             mVolatileVBs[i]->mVertexFormat.isEqual( *vertexFormat ) &&
 331             mVolatileVBs[i]->mVertexSize == vertSize &&
 332             mVolatileVBs[i]->getRefCount() == 1 )
 333          return mVolatileVBs[i];
 334
 335    // No existing VB, so create one
 336    StrongRefPtr<GFXGLVertexBuffer> buf(new GFXGLVertexBuffer(GFX, numVerts, vertexFormat, vertSize, GFXBufferTypeVolatile));
 337    buf->registerResourceWithDevice(this);
 338    mVolatileVBs.push_back(buf);
 339    return buf.getPointer();
 340 }
 341
 342 GFXPrimitiveBuffer* GFXGLDevice::findVolatilePBO(U32 numIndices, U32 numPrimitives)
 343 {
 344    for(U32 i = 0; i < mVolatilePBs.size(); i++)
 345       if((mVolatilePBs[i]->mIndexCount >= numIndices) && (mVolatilePBs[i]->getRefCount() == 1))
 346          return mVolatilePBs[i];
 347
 348    // No existing PB, so create one
 349    StrongRefPtr<GFXGLPrimitiveBuffer> buf(new GFXGLPrimitiveBuffer(GFX, numIndices, numPrimitives, GFXBufferTypeVolatile));
 350    buf->registerResourceWithDevice(this);
 351    mVolatilePBs.push_back(buf);
 352    return buf.getPointer();
 353 }
 354
 355 GFXVertexBuffer *GFXGLDevice::allocVertexBuffer(   U32 numVerts,
 356                                                    const GFXVertexFormat *vertexFormat,
 357                                                    U32 vertSize,
 358                                                    GFXBufferType bufferType,
 359                                                    void* data )
 360 {
 361    if(bufferType == GFXBufferTypeVolatile)
 362       return findVolatileVBO(numVerts, vertexFormat, vertSize);
 363
 364    GFXGLVertexBuffer* buf = new GFXGLVertexBuffer( GFX, numVerts, vertexFormat, vertSize, bufferType );
 365    buf->registerResourceWithDevice(this);
 366
 367    if(data)
 368    {
 369       void* dest;
 370       buf->lock(0, numVerts, &dest);
 371       dMemcpy(dest, data, vertSize * numVerts);
 372       buf->unlock();
 373    }
 374
 375    return buf;
 376 }
 377
 378 GFXPrimitiveBuffer *GFXGLDevice::allocPrimitiveBuffer( U32 numIndices, U32 numPrimitives, GFXBufferType bufferType, void* data )
 379 {
 380    GFXPrimitiveBuffer* buf;
 381
 382    if(bufferType == GFXBufferTypeVolatile)
 383    {
 384       buf = findVolatilePBO(numIndices, numPrimitives);
 385    }
 386    else
 387    {
 388       buf = new GFXGLPrimitiveBuffer(GFX, numIndices, numPrimitives, bufferType);
 389       buf->registerResourceWithDevice(this);
 390    }
 391
 392    if(data)
 393    {
 394       void* dest;
 395       buf->lock(0, numIndices, &dest);
 396       dMemcpy(dest, data, sizeof(U16) * numIndices);
 397       buf->unlock();
 398    }
 399    return buf;
 400 }
 401
 402 void GFXGLDevice::setVertexStream( U32 stream, GFXVertexBuffer *buffer )
 403 {
 404    AssertFatal(stream <= 1, "GFXGLDevice::setVertexStream only support 2 stream (0: data, 1: instancing)");
 405
 406    //if(mCurrentVB[stream] != buffer)
 407    {
 408       // Reset the state the old VB required, then set the state the new VB requires.
 409       if( mCurrentVB[stream] )
 410       {
 411          mCurrentVB[stream]->finish();
 412       }
 413
 414       mCurrentVB[stream] = static_cast<GFXGLVertexBuffer*>( buffer );
 415
 416       mNeedUpdateVertexAttrib = true;
 417    }
 418 }
 419
 420 void GFXGLDevice::setVertexStreamFrequency( U32 stream, U32 frequency )
 421 {
 422    if( stream == 0 )
 423    {
 424       mCurrentVB_Divisor[stream] = 0; // non instanced, is vertex buffer
 425       mDrawInstancesCount = frequency; // instances count
 426    }
 427    else
 428    {
 429       AssertFatal(frequency <= 1, "GFXGLDevice::setVertexStreamFrequency only support 0/1 for this stream" );
 430       if( stream == 1 && frequency == 1 )
 431          mCurrentVB_Divisor[stream] = 1; // instances data need a frequency of 1
 432       else
 433          mCurrentVB_Divisor[stream] = 0;
 434    }
 435
 436    mNeedUpdateVertexAttrib = true;
 437 }
 438
 439 GFXCubemap* GFXGLDevice::createCubemap()
 440 {
 441    GFXGLCubemap* cube = new GFXGLCubemap();
 442    cube->registerResourceWithDevice(this);
 443    return cube;
 444 };
 445
 446 void GFXGLDevice::endSceneInternal()
 447 {
 448    // nothing to do for opengl
 449    mCanCurrentlyRender = false;
 450 }
 451
 452 void GFXGLDevice::clear(U32 flags, ColorI color, F32 z, U32 stencil)
 453 {
 454    // Make sure we have flushed our render target state.
 455    _updateRenderTargets();
 456
 457    bool writeAllColors = true;
 458    bool zwrite = true;
 459    bool writeAllStencil = true;
 460    const GFXStateBlockDesc *desc = NULL;
 461    if (mCurrentGLStateBlock)
 462    {
 463       desc = &mCurrentGLStateBlock->getDesc();
 464       zwrite = desc->zWriteEnable;
 465       writeAllColors = desc->colorWriteRed && desc->colorWriteGreen && desc->colorWriteBlue && desc->colorWriteAlpha;
 466       writeAllStencil = desc->stencilWriteMask == 0xFFFFFFFF;
 467    }
 468
 469    glColorMask(true, true, true, true);
 470    glDepthMask(true);
 471    glStencilMask(0xFFFFFFFF);
 472
 473
 474    ColorF c = color;
 475    glClearColor(c.red, c.green, c.blue, c.alpha);
 476    glClearDepth(z);
 477    glClearStencil(stencil);
 478
 479    GLbitfield clearflags = 0;
 480    clearflags |= (flags & GFXClearTarget)   ? GL_COLOR_BUFFER_BIT : 0;
 481    clearflags |= (flags & GFXClearZBuffer)  ? GL_DEPTH_BUFFER_BIT : 0;
 482    clearflags |= (flags & GFXClearStencil)  ? GL_STENCIL_BUFFER_BIT : 0;
 483
 484    glClear(clearflags);
 485
 486    if(!writeAllColors)
 487       glColorMask(desc->colorWriteRed, desc->colorWriteGreen, desc->colorWriteBlue, desc->colorWriteAlpha);
 488
 489    if(!zwrite)
 490       glDepthMask(false);
 491
 492    if(!writeAllStencil)
 493       glStencilMask(desc->stencilWriteMask);
 494 }
 495
 496 // Given a primitive type and a number of primitives, return the number of indexes/vertexes used.
 497 inline GLsizei GFXGLDevice::primCountToIndexCount(GFXPrimitiveType primType, U32 primitiveCount)
 498 {
 499    switch (primType)
 500    {
 501       case GFXPointList :
 502          return primitiveCount;
 503          break;
 504       case GFXLineList :
 505          return primitiveCount * 2;
 506          break;
 507       case GFXLineStrip :
 508          return primitiveCount + 1;
 509          break;
 510       case GFXTriangleList :
 511          return primitiveCount * 3;
 512          break;
 513       case GFXTriangleStrip :
 514          return 2 + primitiveCount;
 515          break;
 516       case GFXTriangleFan :
 517          return 2 + primitiveCount;
 518          break;
 519       default:
 520          AssertFatal(false, "GFXGLDevice::primCountToIndexCount - unrecognized prim type");
 521          break;
 522    }
 523
 524    return 0;
 525 }
 526
 527 GFXVertexDecl* GFXGLDevice::allocVertexDecl( const GFXVertexFormat *vertexFormat )
 528 {
 529    typedef Map<void*, GFXGLVertexDecl> GFXGLVertexDeclMap;
 530    static GFXGLVertexDeclMap declMap;
 531    GFXGLVertexDeclMap::Iterator itr = declMap.find( (void*)vertexFormat->getDescription().c_str() ); // description string are interned, safe to use c_str()
 532    if(itr != declMap.end())
 533       return &itr->value;
 534
 535    GFXGLVertexDecl &decl = declMap[(void*)vertexFormat->getDescription().c_str()];
 536    decl.init(vertexFormat);
 537    return &decl;
 538 }
 539
 540 void GFXGLDevice::setVertexDecl( const GFXVertexDecl *decl )
 541 {
 542    static_cast<const GFXGLVertexDecl*>(decl)->prepareVertexFormat();
 543 }
 544
 545 inline void GFXGLDevice::preDrawPrimitive()
 546 {
 547    if( mStateDirty )
 548    {
 549       updateStates();
 550    }
 551
 552    if(mCurrentShaderConstBuffer)
 553       setShaderConstBufferInternal(mCurrentShaderConstBuffer);
 554
 555    if( mNeedUpdateVertexAttrib )
 556    {
 557       AssertFatal(mCurrVertexDecl, "");
 558       const GFXGLVertexDecl* decl = static_cast<const GFXGLVertexDecl*>(mCurrVertexDecl);
 559
 560       for(int i = 0; i < getNumVertexStreams(); ++i)
 561       {
 562          if(mCurrentVB[i])
 563          {
 564             mCurrentVB[i]->prepare(i, mCurrentVB_Divisor[i]);    // GL_ARB_vertex_attrib_binding
 565             decl->prepareBuffer_old( i, mCurrentVB[i]->mBuffer, mCurrentVB_Divisor[i] ); // old vertex buffer/format
 566          }
 567       }
 568
 569       decl->updateActiveVertexAttrib( GFXGL->getOpenglCache()->getCacheVertexAttribActive() );
 570    }
 571
 572    mNeedUpdateVertexAttrib = false;
 573 }
 574
 575 inline void GFXGLDevice::postDrawPrimitive(U32 primitiveCount)
 576 {
 577    mDeviceStatistics.mDrawCalls++;
 578    mDeviceStatistics.mPolyCount += primitiveCount;
 579 }
 580
 581 void GFXGLDevice::drawPrimitive( GFXPrimitiveType primType, U32 vertexStart, U32 primitiveCount )
 582 {
 583    preDrawPrimitive();
 584
 585    vertexStart += mCurrentVB[0]->mBufferVertexOffset;
 586
 587    if(mDrawInstancesCount)
 588       glDrawArraysInstanced(GFXGLPrimType[primType], vertexStart, primCountToIndexCount(primType, primitiveCount), mDrawInstancesCount);
 589    else
 590       glDrawArrays(GFXGLPrimType[primType], vertexStart, primCountToIndexCount(primType, primitiveCount));
 591
 592    postDrawPrimitive(primitiveCount);
 593 }
 594
 595 void GFXGLDevice::drawIndexedPrimitive(   GFXPrimitiveType primType,
 596                                           U32 startVertex,
 597                                           U32 minIndex,
 598                                           U32 numVerts,
 599                                           U32 startIndex,
 600                                           U32 primitiveCount )
 601 {
 602    AssertFatal( startVertex == 0, "GFXGLDevice::drawIndexedPrimitive() - Non-zero startVertex unsupported!" );
 603
 604    preDrawPrimitive();
 605
 606    U16* buf = (U16*)static_cast<GFXGLPrimitiveBuffer*>(mCurrentPrimitiveBuffer.getPointer())->getBuffer() + startIndex;
 607
 608    const U32 baseVertex = mCurrentVB[0]->mBufferVertexOffset;
 609
 610    if(mDrawInstancesCount)
 611       glDrawElementsInstancedBaseVertex(GFXGLPrimType[primType], primCountToIndexCount(primType, primitiveCount), GL_UNSIGNED_SHORT, buf, mDrawInstancesCount, baseVertex);
 612    else
 613       glDrawElementsBaseVertex(GFXGLPrimType[primType], primCountToIndexCount(primType, primitiveCount), GL_UNSIGNED_SHORT, buf, baseVertex);
 614
 615    postDrawPrimitive(primitiveCount);
 616 }
 617
 618 void GFXGLDevice::setPB(GFXGLPrimitiveBuffer* pb)
 619 {
 620    if(mCurrentPB)
 621       mCurrentPB->finish();
 622    mCurrentPB = pb;
 623 }
 624
 625 void GFXGLDevice::setLightInternal(U32 lightStage, const GFXLightInfo light, bool lightEnable)
 626 {
 627    // ONLY NEEDED ON FFP
 628 }
 629
 630 void GFXGLDevice::setLightMaterialInternal(const GFXLightMaterial mat)
 631 {
 632    // ONLY NEEDED ON FFP
 633 }
 634
 635 void GFXGLDevice::setGlobalAmbientInternal(ColorF color)
 636 {
 637    glLightModelfv(GL_LIGHT_MODEL_AMBIENT, (GLfloat*)&color);
 638 }
 639
 640 void GFXGLDevice::setTextureInternal(U32 textureUnit, const GFXTextureObject*texture)
 641 {
 642    GFXGLTextureObject *tex = static_cast<GFXGLTextureObject*>(const_cast<GFXTextureObject*>(texture));
 643    if (tex)
 644    {
 645       mActiveTextureType[textureUnit] = tex->getBinding();
 646       tex->bind(textureUnit);
 647    }
 648    else if(mActiveTextureType[textureUnit] != GL_ZERO)
 649    {
 650       glActiveTexture(GL_TEXTURE0 + textureUnit);
 651       glBindTexture(mActiveTextureType[textureUnit], 0);
 652       getOpenglCache()->setCacheBindedTex(textureUnit, mActiveTextureType[textureUnit], 0);
 653       mActiveTextureType[textureUnit] = GL_ZERO;
 654    }
 655 }
 656
 657 void GFXGLDevice::setCubemapInternal(U32 textureUnit, const GFXGLCubemap* texture)
 658 {
 659    if(texture)
 660    {
 661       mActiveTextureType[textureUnit] = GL_TEXTURE_CUBE_MAP;
 662       texture->bind(textureUnit);
 663    }
 664    else if(mActiveTextureType[textureUnit] != GL_ZERO)
 665    {
 666       glActiveTexture(GL_TEXTURE0 + textureUnit);
 667       glBindTexture(mActiveTextureType[textureUnit], 0);
 668       getOpenglCache()->setCacheBindedTex(textureUnit, mActiveTextureType[textureUnit], 0);
 669       mActiveTextureType[textureUnit] = GL_ZERO;
 670    }
 671 }
 672
 673 void GFXGLDevice::setMatrix( GFXMatrixType mtype, const MatrixF &mat )
 674 {
 675    // ONLY NEEDED ON FFP
 676 }
 677
 678 void GFXGLDevice::setClipRect( const RectI &inRect )
 679 {
 680    AssertFatal(mCurrentRT.isValid(), "GFXGLDevice::setClipRect - must have a render target set to do any rendering operations!");
 681
 682    // Clip the rect against the renderable size.
 683    Point2I size = mCurrentRT->getSize();
 684    RectI maxRect(Point2I(0,0), size);
 685    mClip = inRect;
 686    mClip.intersect(maxRect);
 687
 688    // Create projection matrix.  See http://www.opengl.org/documentation/specs/man_pages/hardcopy/GL/html/gl/ortho.html
 689    const F32 left = mClip.point.x;
 690    const F32 right = mClip.point.x + mClip.extent.x;
 691    const F32 bottom = mClip.extent.y;
 692    const F32 top = 0.0f;
 693    const F32 near = 0.0f;
 694    const F32 far = 1.0f;
 695
 696    const F32 tx = -(right + left)/(right - left);
 697    const F32 ty = -(top + bottom)/(top - bottom);
 698    const F32 tz = -(far + near)/(far - near);
 699
 700    static Point4F pt;
 701    pt.set(2.0f / (right - left), 0.0f, 0.0f, 0.0f);
 702    mProjectionMatrix.setColumn(0, pt);
 703
 704    pt.set(0.0f, 2.0f/(top - bottom), 0.0f, 0.0f);
 705    mProjectionMatrix.setColumn(1, pt);
 706
 707    pt.set(0.0f, 0.0f, -2.0f/(far - near), 0.0f);
 708    mProjectionMatrix.setColumn(2, pt);
 709
 710    pt.set(tx, ty, tz, 1.0f);
 711    mProjectionMatrix.setColumn(3, pt);
 712
 713    // Translate projection matrix.
 714    static MatrixF translate(true);
 715    pt.set(0.0f, -mClip.point.y, 0.0f, 1.0f);
 716    translate.setColumn(3, pt);
 717
 718    mProjectionMatrix *= translate;
 719
 720    setMatrix(GFXMatrixProjection, mProjectionMatrix);
 721
 722    MatrixF mTempMatrix(true);
 723    setViewMatrix( mTempMatrix );
 724    setWorldMatrix( mTempMatrix );
 725
 726    // Set the viewport to the clip rect
 727    RectI viewport(mClip.point.x, mClip.point.y, mClip.extent.x, mClip.extent.y);
 728    setViewport(viewport);
 729 }
 730
 731 /// Creates a state block object based on the desc passed in.  This object
 732 /// represents an immutable state.
 733 GFXStateBlockRef GFXGLDevice::createStateBlockInternal(const GFXStateBlockDesc& desc)
 734 {
 735    return GFXStateBlockRef(new GFXGLStateBlock(desc));
 736 }
 737
 738 /// Activates a stateblock
 739 void GFXGLDevice::setStateBlockInternal(GFXStateBlock* block, bool force)
 740 {
 741    AssertFatal(dynamic_cast<GFXGLStateBlock*>(block), "GFXGLDevice::setStateBlockInternal - Incorrect stateblock type for this device!");
 742    GFXGLStateBlock* glBlock = static_cast<GFXGLStateBlock*>(block);
 743    GFXGLStateBlock* glCurrent = static_cast<GFXGLStateBlock*>(mCurrentStateBlock.getPointer());
 744    if (force)
 745       glCurrent = NULL;
 746
 747    glBlock->activate(glCurrent); // Doesn't use current yet.
 748    mCurrentGLStateBlock = glBlock;
 749 }
 750
 751 //------------------------------------------------------------------------------
 752
 753 GFXTextureTarget * GFXGLDevice::allocRenderToTextureTarget()
 754 {
 755    GFXGLTextureTarget *targ = new GFXGLTextureTarget();
 756    targ->registerResourceWithDevice(this);
 757    return targ;
 758 }
 759
 760 GFXFence * GFXGLDevice::createFence()
 761 {
 762    GFXFence* fence = _createPlatformSpecificFence();
 763    if(!fence)
 764       fence = new GFXGeneralFence( this );
 765
 766    fence->registerResourceWithDevice(this);
 767    return fence;
 768 }
 769
 770 GFXOcclusionQuery* GFXGLDevice::createOcclusionQuery()
 771 {
 772    GFXOcclusionQuery *query = new GFXGLOcclusionQuery( this );
 773    query->registerResourceWithDevice(this);
 774    return query;
 775 }
 776
 777 void GFXGLDevice::setupGenericShaders( GenericShaderType type )
 778 {
 779    AssertFatal(type != GSTargetRestore, "");
 780
 781    if( mGenericShader[GSColor] == NULL )
 782    {
 783       ShaderData *shaderData;
 784
 785       shaderData = new ShaderData();
 786       shaderData->setField("OGLVertexShaderFile", "shaders/common/fixedFunction/gl/colorV.glsl");
 787       shaderData->setField("OGLPixelShaderFile", "shaders/common/fixedFunction/gl/colorP.glsl");
 788       shaderData->setField("pixVersion", "2.0");
 789       shaderData->registerObject();
 790       mGenericShader[GSColor] =  shaderData->getShader();
 791       mGenericShaderBuffer[GSColor] = mGenericShader[GSColor]->allocConstBuffer();
 792       mModelViewProjSC[GSColor] = mGenericShader[GSColor]->getShaderConstHandle( "$modelView" );
 793
 794       shaderData = new ShaderData();
 795       shaderData->setField("OGLVertexShaderFile", "shaders/common/fixedFunction/gl/modColorTextureV.glsl");
 796       shaderData->setField("OGLPixelShaderFile", "shaders/common/fixedFunction/gl/modColorTextureP.glsl");
 797       shaderData->setSamplerName("$diffuseMap", 0);
 798       shaderData->setField("pixVersion", "2.0");
 799       shaderData->registerObject();
 800       mGenericShader[GSModColorTexture] = shaderData->getShader();
 801       mGenericShaderBuffer[GSModColorTexture] = mGenericShader[GSModColorTexture]->allocConstBuffer();
 802       mModelViewProjSC[GSModColorTexture] = mGenericShader[GSModColorTexture]->getShaderConstHandle( "$modelView" );
 803
 804       shaderData = new ShaderData();
 805       shaderData->setField("OGLVertexShaderFile", "shaders/common/fixedFunction/gl/addColorTextureV.glsl");
 806       shaderData->setField("OGLPixelShaderFile", "shaders/common/fixedFunction/gl/addColorTextureP.glsl");
 807       shaderData->setSamplerName("$diffuseMap", 0);
 808       shaderData->setField("pixVersion", "2.0");
 809       shaderData->registerObject();
 810       mGenericShader[GSAddColorTexture] = shaderData->getShader();
 811       mGenericShaderBuffer[GSAddColorTexture] = mGenericShader[GSAddColorTexture]->allocConstBuffer();
 812       mModelViewProjSC[GSAddColorTexture] = mGenericShader[GSAddColorTexture]->getShaderConstHandle( "$modelView" );
 813
 814       shaderData = new ShaderData();
 815       shaderData->setField("OGLVertexShaderFile", "shaders/common/fixedFunction/gl/textureV.glsl");
 816       shaderData->setField("OGLPixelShaderFile", "shaders/common/fixedFunction/gl/textureP.glsl");
 817       shaderData->setSamplerName("$diffuseMap", 0);
 818       shaderData->setField("pixVersion", "2.0");
 819       shaderData->registerObject();
 820       mGenericShader[GSTexture] = shaderData->getShader();
 821       mGenericShaderBuffer[GSTexture] = mGenericShader[GSTexture]->allocConstBuffer();
 822       mModelViewProjSC[GSTexture] = mGenericShader[GSTexture]->getShaderConstHandle( "$modelView" );
 823    }
 824
 825    MatrixF tempMatrix =  mProjectionMatrix * mViewMatrix * mWorldMatrix[mWorldStackSize];
 826    mGenericShaderBuffer[type]->setSafe(mModelViewProjSC[type], tempMatrix);
 827
 828    setShader( mGenericShader[type] );
 829    setShaderConstBuffer( mGenericShaderBuffer[type] );
 830 }
 831 GFXShader* GFXGLDevice::createShader()
 832 {
 833    GFXGLShader* shader = new GFXGLShader();
 834    shader->registerResourceWithDevice( this );
 835    return shader;
 836 }
 837
 838 void GFXGLDevice::setShader(GFXShader *shader, bool force)
 839 {
 840    if(mCurrentShader == shader && !force)
 841       return;
 842
 843    if ( shader )
 844    {
 845       GFXGLShader *glShader = static_cast<GFXGLShader*>( shader );
 846       glShader->useProgram();
 847       mCurrentShader = shader;
 848    }
 849    else
 850    {
 851       setupGenericShaders();
 852    }
 853 }
 854
 855 void GFXGLDevice::setShaderConstBufferInternal(GFXShaderConstBuffer* buffer)
 856 {
 857    static_cast<GFXGLShaderConstBuffer*>(buffer)->activate();
 858 }
 859
 860 U32 GFXGLDevice::getNumSamplers() const
 861 {
 862    return getMin((U32)TEXTURE_STAGE_COUNT,mPixelShaderVersion > 0.001f ? mMaxShaderTextures : mMaxFFTextures);
 863 }
 864
 865 GFXTextureObject* GFXGLDevice::getDefaultDepthTex() const
 866 {
 867    if(mWindowRT && mWindowRT->getPointer())
 868       return static_cast<GFXGLWindowTarget*>( mWindowRT->getPointer() )->mBackBufferDepthTex.getPointer();
 869
 870    return NULL;
 871 }
 872
 873 U32 GFXGLDevice::getNumRenderTargets() const
 874 {
 875    return mMaxTRColors;
 876 }
 877
 878 void GFXGLDevice::_updateRenderTargets()
 879 {
 880    if ( mRTDirty || mCurrentRT->isPendingState() )
 881    {
 882       if ( mRTDeactivate )
 883       {
 884          mRTDeactivate->deactivate();
 885          mRTDeactivate = NULL;
 886       }
 887
 888       // NOTE: The render target changes is not really accurate
 889       // as the GFXTextureTarget supports MRT internally.  So when
 890       // we activate a GFXTarget it could result in multiple calls
 891       // to SetRenderTarget on the actual device.
 892       mDeviceStatistics.mRenderTargetChanges++;
 893
 894       GFXGLTextureTarget *tex = dynamic_cast<GFXGLTextureTarget*>( mCurrentRT.getPointer() );
 895       if ( tex )
 896       {
 897          tex->applyState();
 898          tex->makeActive();
 899       }
 900       else
 901       {
 902          GFXGLWindowTarget *win = dynamic_cast<GFXGLWindowTarget*>( mCurrentRT.getPointer() );
 903          AssertFatal( win != NULL,
 904                      "GFXGLDevice::_updateRenderTargets() - invalid target subclass passed!" );
 905
 906          win->makeActive();
 907
 908          if( win->mContext != static_cast<GFXGLDevice*>(GFX)->mContext )
 909          {
 910             mRTDirty = false;
 911             GFX->updateStates(true);
 912          }
 913       }
 914
 915       mRTDirty = false;
 916    }
 917
 918    if ( mViewportDirty )
 919    {
 920       glViewport( mViewport.point.x, mViewport.point.y, mViewport.extent.x, mViewport.extent.y );
 921       mViewportDirty = false;
 922    }
 923 }
 924
 925 GFXFormat GFXGLDevice::selectSupportedFormat(   GFXTextureProfile* profile,
 926                                                 const Vector<GFXFormat>& formats,
 927                                                 bool texture,
 928                                                 bool mustblend,
 929                                                 bool mustfilter )
 930 {
 931    for(U32 i = 0; i < formats.size(); i++)
 932    {
 933       // Single channel textures are not supported by FBOs.
 934       if(profile->testFlag(GFXTextureProfile::RenderTarget) && (formats[i] == GFXFormatA8 || formats[i] == GFXFormatL8 || formats[i] == GFXFormatL16))
 935          continue;
 936       if(GFXGLTextureInternalFormat[formats[i]] == GL_ZERO)
 937          continue;
 938
 939       return formats[i];
 940    }
 941
 942    return GFXFormatR8G8B8A8;
 943 }
 944
 945 U32 GFXGLDevice::getTotalVideoMemory_GL_EXT()
 946 {
 947    // Source: http://www.opengl.org/registry/specs/ATI/meminfo.txt
 948    if( gglHasExtension(ATI_meminfo) )
 949    {
 950       GLint mem[4] = {0};
 951       glGetIntegerv(GL_TEXTURE_FREE_MEMORY_ATI, mem);  // Retrieve the texture pool
 952
 953       /* With mem[0] i get only the total memory free in the pool in KB
 954       *
 955       * mem[0] - total memory free in the pool
 956       * mem[1] - largest available free block in the pool
 957       * mem[2] - total auxiliary memory free
 958       * mem[3] - largest auxiliary free block
 959       */
 960
 961       return  mem[0] / 1024;
 962    }
 963
 964    //source http://www.opengl.org/registry/specs/NVX/gpu_memory_info.txt
 965    else if( gglHasExtension(NVX_gpu_memory_info) )
 966    {
 967       GLint mem = 0;
 968       glGetIntegerv(GL_GPU_MEMORY_INFO_TOTAL_AVAILABLE_MEMORY_NVX, &mem);
 969       return mem / 1024;
 970    }
 971
 972    // TODO OPENGL, add supprt for INTEL cards.
 973
 974    return 0;
 975 }
 976
 977 //
 978 // Register this device with GFXInit
 979 //
 980 class GFXGLRegisterDevice
 981 {
 982 public:
 983    GFXGLRegisterDevice()
 984    {
 985       GFXInit::getRegisterDeviceSignal().notify(&GFXGLDevice::enumerateAdapters);
 986    }
 987 };
 988
 989 static GFXGLRegisterDevice pGLRegisterDevice;
 990
 991 ConsoleFunction(cycleResources, void, 1, 1, "")
 992 {
 993    static_cast<GFXGLDevice*>(GFX)->zombify();
 994    static_cast<GFXGLDevice*>(GFX)->resurrect();
 995 }