All surfaces follow D3D Y convention

src/libGLESv2/Context.cpp

 //
 // Copyright (c) 2002-2010 The ANGLE Project Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 //
 
 // Context.cpp: Implements the gl::Context class, managing all GL state and performing
 // rendering operations. It is the GLES2 specific implementation of EGLContext.
 
 #include "libGLESv2/Context.h"
 
 #include <algorithm>
 
 #include "libEGL/Display.h"
 
 #include "libGLESv2/main.h"
 #include "libGLESv2/mathutil.h"
 #include "libGLESv2/utilities.h"
 #include "libGLESv2/Blit.h"
 #include "libGLESv2/ResourceManager.h"
 #include "libGLESv2/Buffer.h"
 #include "libGLESv2/Fence.h"
 #include "libGLESv2/FrameBuffer.h"
 #include "libGLESv2/Program.h"
 #include "libGLESv2/RenderBuffer.h"
 #include "libGLESv2/Shader.h"
 #include "libGLESv2/Texture.h"
-#include "libGLESv2/geometry/backend.h"
 #include "libGLESv2/geometry/VertexDataManager.h"
 #include "libGLESv2/geometry/IndexDataManager.h"
-#include "libGLESv2/geometry/dx9.h"
 
 #undef near
 #undef far
 
 namespace gl
 {
 Context::Context(const egl::Config *config, const gl::Context *shareContext)
     : mConfig(config)
 {
     setClearColor(0.0f, 0.0f, 0.0f, 0.0f);
@@ skipping 90 matching lines @@
     bindTexture2D(0);
     bindReadFramebuffer(0);
     bindDrawFramebuffer(0);
     bindRenderbuffer(0);
 
     mState.currentProgram = 0;
 
     mState.packAlignment = 4;
     mState.unpackAlignment = 4;
 
-    mBufferBackEnd = NULL;
     mVertexDataManager = NULL;
     mIndexDataManager = NULL;
     mBlit = NULL;
 
     mInvalidEnum = false;
     mInvalidValue = false;
     mInvalidOperation = false;
     mOutOfMemory = false;
     mInvalidFramebufferOperation = false;
 
@@ skipping 52 matching lines @@
         mState.vertexAttribute[i].mBoundBuffer.set(NULL);
     }
 
     mState.arrayBuffer.set(NULL);
     mState.elementArrayBuffer.set(NULL);
     mState.renderbuffer.set(NULL);
 
     mTexture2DZero.set(NULL);
     mTextureCubeMapZero.set(NULL);
 
-    delete mBufferBackEnd;
     delete mVertexDataManager;
     delete mIndexDataManager;
     delete mBlit;
 
     if (mMaskedClearSavedState)
     {
         mMaskedClearSavedState->Release();
     }
 
     mResourceManager->release();
 }
 
 void Context::makeCurrent(egl::Display *display, egl::Surface *surface)
 {
     IDirect3DDevice9 *device = display->getDevice();
 
     if (!mHasBeenCurrent)
     {
         mDeviceCaps = display->getDeviceCaps();
 
-        mBufferBackEnd = new Dx9BackEnd(this, device);
-        mVertexDataManager = new VertexDataManager(this, mBufferBackEnd);
-        mIndexDataManager = new IndexDataManager(this, mBufferBackEnd);
+        mVertexDataManager = new VertexDataManager(this, device);
+        mIndexDataManager = new IndexDataManager(this, device);
         mBlit = new Blit(this);
 
         mSupportsShaderModel3 = mDeviceCaps.PixelShaderVersion == D3DPS_VERSION(3, 0);
 
         mMaxTextureDimension = std::min(std::min((int)mDeviceCaps.MaxTextureWidth, (int)mDeviceCaps.MaxTextureHeight),
                                         (int)gl::IMPLEMENTATION_MAX_TEXTURE_SIZE);
         mMaxCubeTextureDimension = std::min(mMaxTextureDimension, (int)gl::IMPLEMENTATION_MAX_CUBE_MAP_TEXTURE_SIZE);
         mMaxRenderbufferDimension = mMaxTextureDimension;
         mMaxTextureLevel = log2(mMaxTextureDimension) + 1;
         TRACE("MaxTextureDimension=%d, MaxCubeTextureDimension=%d, MaxRenderbufferDimension=%d, MaxTextureLevel=%d",
@@ skipping 24 matching lines @@
         }
 
         mMaxSupportedSamples = max;
 
         mSupportsEventQueries = display->getEventQuerySupport();
         mSupportsCompressedTextures = display->getCompressedTextureSupport();
         mSupportsFloatTextures = display->getFloatTextureSupport(&mSupportsFloatLinearFilter, &mSupportsFloatRenderableTextures);
         mSupportsHalfFloatTextures = display->getHalfFloatTextureSupport(&mSupportsHalfFloatLinearFilter, &mSupportsHalfFloatRenderableTextures);
         mSupportsLuminanceTextures = display->getLuminanceTextureSupport();
         mSupportsLuminanceAlphaTextures = display->getLuminanceAlphaTextureSupport();
+
+        mSupports32bitIndices = mDeviceCaps.MaxVertexIndex >= (1 << 16);
 
         initExtensionString();
 
         mState.viewportX = 0;
         mState.viewportY = 0;
         mState.viewportWidth = surface->getWidth();
         mState.viewportHeight = surface->getHeight();
 
         mState.scissorX = 0;
         mState.scissorY = 0;
@@ skipping 39 matching lines @@
     mCullStateDirty = true;
     mDepthStateDirty = true;
     mMaskStateDirty = true;
     mBlendStateDirty = true;
     mStencilStateDirty = true;
     mPolygonOffsetStateDirty = true;
     mScissorStateDirty = true;
     mSampleStateDirty = true;
     mDitherStateDirty = true;
     mFrontFaceDirty = true;
-
-    if (mBufferBackEnd != NULL)
-    {
-        mBufferBackEnd->invalidate();
-    }
 }
 
 void Context::setClearColor(float red, float green, float blue, float alpha)
 {
     mState.colorClearValue.red = red;
     mState.colorClearValue.green = green;
     mState.colorClearValue.blue = blue;
     mState.colorClearValue.alpha = alpha;
 }
 
@@ skipping 379 matching lines @@
 GLuint Context::getRenderbufferHandle() const
 {
     return mState.renderbuffer.id();
 }
 
 GLuint Context::getArrayBufferHandle() const
 {
     return mState.arrayBuffer.id();
 }
 
-void Context::setVertexAttribEnabled(unsigned int attribNum, bool enabled)
-{
-    mState.vertexAttribute[attribNum].mEnabled = enabled;
-}
-
-const AttributeState &Context::getVertexAttribState(unsigned int attribNum)
+void Context::setEnableVertexAttribArray(unsigned int attribNum, bool enabled)
+{
+    mState.vertexAttribute[attribNum].mArrayEnabled = enabled;
+}
+
+const VertexAttribute &Context::getVertexAttribState(unsigned int attribNum)
 {
     return mState.vertexAttribute[attribNum];
 }
 
 void Context::setVertexAttribState(unsigned int attribNum, Buffer *boundBuffer, GLint size, GLenum type, bool normalized,
                                    GLsizei stride, const void *pointer)
 {
     mState.vertexAttribute[attribNum].mBoundBuffer.set(boundBuffer);
     mState.vertexAttribute[attribNum].mSize = size;
     mState.vertexAttribute[attribNum].mType = type;
     mState.vertexAttribute[attribNum].mNormalized = normalized;
     mState.vertexAttribute[attribNum].mStride = stride;
     mState.vertexAttribute[attribNum].mPointer = pointer;
 }
 
 const void *Context::getVertexAttribPointer(unsigned int attribNum) const
 {
     return mState.vertexAttribute[attribNum].mPointer;
 }
 
-// returns entire set of attributes as a block
-const AttributeState *Context::getVertexAttribBlock()
+const VertexAttributeArray &Context::getVertexAttributes()
 {
     return mState.vertexAttribute;
 }
 
 void Context::setPackAlignment(GLint alignment)
 {
     mState.packAlignment = alignment;
 }
 
 GLint Context::getPackAlignment() const
@@ skipping 906 matching lines @@
         }
 
         mScissorStateDirty = false;
     }
 
     if (mState.currentProgram)
     {
         Program *programObject = getCurrentProgram();
 
         GLint halfPixelSize = programObject->getDxHalfPixelSizeLocation();
-        GLfloat xy[2] = {1.0f / viewport.Width, 1.0f / viewport.Height};
+        GLfloat xy[2] = {1.0f / viewport.Width, -1.0f / viewport.Height};
         programObject->setUniform2fv(halfPixelSize, 1, xy);
 
         GLint viewport = programObject->getDxViewportLocation();
         GLfloat whxy[4] = {mState.viewportWidth / 2.0f, mState.viewportHeight / 2.0f,·
                           (float)mState.viewportX + mState.viewportWidth / 2.0f,········
                           (float)mState.viewportY + mState.viewportHeight / 2.0f};
         programObject->setUniform4fv(viewport, 1, whxy);
 
         GLint depth = programObject->getDxDepthLocation();
         GLfloat dz[2] = {(zFar - zNear) / 2.0f, (zNear + zFar) / 2.0f};
@@ skipping 247 matching lines @@
     }
 
     mFrontFaceDirty = false;
 }
 
 // Fill in the semanticIndex field of the array of TranslatedAttributes based on the active GLSL program.
 void Context::lookupAttributeMapping(TranslatedAttribute *attributes)
 {
     for (int i = 0; i < MAX_VERTEX_ATTRIBS; i++)
     {
-        if (attributes[i].enabled)
+        if (attributes[i].active)
         {
             attributes[i].semanticIndex = getCurrentProgram()->getSemanticIndex(i);
         }
     }
 }
 
-GLenum Context::applyVertexBuffer(GLenum mode, GLint first, GLsizei count, bool *useIndexing, TranslatedIndexData *indexInfo)
+GLenum Context::applyVertexBuffer(GLint first, GLsizei count)
 {
     TranslatedAttribute translated[MAX_VERTEX_ATTRIBS];
 
-    GLenum err = mVertexDataManager->preRenderValidate(first, count, translated);
+    GLenum err = mVertexDataManager->prepareVertexData(first, count, translated);
     if (err != GL_NO_ERROR)
     {
         return err;
     }
 
     lookupAttributeMapping(translated);
 
-    mBufferBackEnd->setupAttributesPreDraw(translated);
-
-    for (int i = 0; i < MAX_VERTEX_ATTRIBS; i++)
-    {
-        if (translated[i].enabled && translated[i].nonArray)
-        {
-            err = mIndexDataManager->preRenderValidateUnindexed(mode, count, indexInfo);
-            if (err != GL_NO_ERROR)
-            {
-                return err;
-            }
-
-            mBufferBackEnd->setupIndicesPreDraw(*indexInfo);
-
-            *useIndexing = true;
-            return GL_NO_ERROR;
-        }
-    }
-
-    *useIndexing = false;
+    mVertexDataManager->setupAttributes(translated);
+
     return GL_NO_ERROR;
-}
-
-GLenum Context::applyVertexBuffer(const TranslatedIndexData &indexInfo)
-{
-    TranslatedAttribute translated[MAX_VERTEX_ATTRIBS];
-
-    GLenum err = mVertexDataManager->preRenderValidate(indexInfo.minIndex, indexInfo.maxIndex-indexInfo.minIndex+1, translated);
-
-    if (err == GL_NO_ERROR)
-    {
-        lookupAttributeMapping(translated);
-
-        mBufferBackEnd->setupAttributesPreDraw(translated);
-    }
-
-    return err;
 }
 
 // Applies the indices and element array bindings to the Direct3D 9 device
 GLenum Context::applyIndexBuffer(const void *indices, GLsizei count, GLenum mode, GLenum type, TranslatedIndexData *indexInfo)
 {
-    GLenum err = mIndexDataManager->preRenderValidate(mode, type, count, mState.elementArrayBuffer.get(), indices, indexInfo);
+    IDirect3DDevice9 *device = getDevice();
+    GLenum err = mIndexDataManager->prepareIndexData(type, count, mState.elementArrayBuffer.get(), indices, indexInfo);
 
     if (err == GL_NO_ERROR)
     {
-        mBufferBackEnd->setupIndicesPreDraw(*indexInfo);
+        device->SetIndices(indexInfo->indexBuffer);
     }
 
     return err;
 }
 
 // Applies the shaders and shader constants to the Direct3D 9 device
 void Context::applyShaders()
 {
     IDirect3DDevice9 *device = getDevice();
     Program *programObject = getCurrentProgram();
@@ skipping 151 matching lines @@
     for (int j = 0; j < rect.bottom - rect.top; j++)
     {
         if (desc.Format == D3DFMT_A8R8G8B8 &&
             format == GL_BGRA_EXT &&
             type == GL_UNSIGNED_BYTE)
         {
             // Fast path for EXT_read_format_bgra, given
             // an RGBA source buffer.  Note that buffers with no
             // alpha go through the slow path below.
             memcpy(dest + j * outputPitch,
-                   source + j * lock.Pitch,
+                   source + j * inputPitch,
                    (rect.right - rect.left) * 4);
             continue;
         }
 
         for (int i = 0; i < rect.right - rect.left; i++)
         {
             float r;
             float g;
             float b;
             float a;
@@ skipping 266 matching lines @@
             device->SetRenderState(D3DRS_CULLMODE, D3DCULL_NONE);
             device->SetRenderState(D3DRS_FILLMODE, D3DFILL_SOLID);
             device->SetRenderState(D3DRS_ALPHATESTENABLE, FALSE);
             device->SetRenderState(D3DRS_ALPHABLENDENABLE, FALSE);
             device->SetRenderState(D3DRS_CLIPPLANEENABLE, 0);
             device->SetRenderState(D3DRS_COLORWRITEENABLE, 0);
             device->SetRenderState(D3DRS_STENCILENABLE, FALSE);
             device->SetPixelShader(NULL);
             device->SetVertexShader(NULL);
             device->SetFVF(D3DFVF_XYZRHW | D3DFVF_DIFFUSE);
-            device->SetStreamSourceFreq(0, 1);
             device->SetTextureStageState(0, D3DTSS_COLOROP, D3DTOP_DISABLE);
 
             hr = device->EndStateBlock(&mMaskedClearSavedState);
             ASSERT(SUCCEEDED(hr) || hr == D3DERR_OUTOFVIDEOMEMORY || hr == E_OUTOFMEMORY);
         }
 
         ASSERT(mMaskedClearSavedState != NULL);
 
         if (mMaskedClearSavedState != NULL)
         {
@@ skipping 35 matching lines @@
             mStencilStateDirty = true;
         }
         else
         {
             device->SetRenderState(D3DRS_STENCILENABLE, FALSE);
         }
 
         device->SetPixelShader(NULL);
         device->SetVertexShader(NULL);
         device->SetFVF(D3DFVF_XYZRHW | D3DFVF_DIFFUSE);
-        device->SetStreamSourceFreq(0, 1);
         device->SetTextureStageState(0, D3DTSS_COLOROP, D3DTOP_DISABLE);
 
         struct Vertex
         {
             float x, y, z, w;
             D3DCOLOR diffuse;
         };
 
         Vertex quad[4];
         quad[0].x = 0.0f;
@@ skipping 61 matching lines @@
         return;
     }
 
     if (!applyRenderTarget(false))
     {
         return;
     }
 
     applyState(mode);
 
-    TranslatedIndexData indexInfo;
-    bool useIndexing;
-    GLenum err = applyVertexBuffer(mode, first, count, &useIndexing, &indexInfo);
+    GLenum err = applyVertexBuffer(first, count);
     if (err != GL_NO_ERROR)
     {
         return error(err);
     }
 
     applyShaders();
     applyTextures();
 
     if (!getCurrentProgram()->validateSamplers())
     {
         return error(GL_INVALID_OPERATION);
     }
 
     if (!cullSkipsDraw(mode))
     {
         display->startScene();
-        if (useIndexing)
-        {
-            device->DrawIndexedPrimitive(primitiveType, -(INT)indexInfo.minIndex, indexInfo.minIndex, indexInfo.maxIndex-indexInfo.minIndex+1, indexInfo.offset/indexInfo.indexSize, primitiveCount);
-        }
-        else
-        {
-            device->DrawPrimitive(primitiveType, 0, primitiveCount);
-        }
-    }
-}
-
-void Context::drawElements(GLenum mode, GLsizei count, GLenum type, const void* indices)
+········
+        device->DrawPrimitive(primitiveType, 0, primitiveCount);
+
+        if (mode == GL_LINE_LOOP)   // Draw the last segment separately
+        {
+            drawClosingLine(first, first + count - 1);
+        }
+    }
+}
+
+void Context::drawElements(GLenum mode, GLsizei count, GLenum type, const void *indices)
 {
     if (!mState.currentProgram)
     {
         return error(GL_INVALID_OPERATION);
     }
 
     if (!indices && !mState.elementArrayBuffer)
     {
         return error(GL_INVALID_OPERATION);
     }
@@ skipping 18 matching lines @@
 
     applyState(mode);
 
     TranslatedIndexData indexInfo;
     GLenum err = applyIndexBuffer(indices, count, mode, type, &indexInfo);
     if (err != GL_NO_ERROR)
     {
         return error(err);
     }
 
-    err = applyVertexBuffer(indexInfo);
+    GLsizei vertexCount = indexInfo.maxIndex - indexInfo.minIndex + 1;
+    err = applyVertexBuffer(indexInfo.minIndex, vertexCount);
     if (err != GL_NO_ERROR)
     {
         return error(err);
     }
 
     applyShaders();
     applyTextures();
 
     if (!getCurrentProgram()->validateSamplers())
     {
         return error(GL_INVALID_OPERATION);
     }
 
     if (!cullSkipsDraw(mode))
     {
         display->startScene();
-        device->DrawIndexedPrimitive(primitiveType, -(INT)indexInfo.minIndex, indexInfo.minIndex, indexInfo.maxIndex-indexInfo.minIndex+1, indexInfo.offset/indexInfo.indexSize, primitiveCount);
+
+        device->DrawIndexedPrimitive(primitiveType, -(INT)indexInfo.minIndex, indexInfo.minIndex, vertexCount, indexInfo.startIndex, primitiveCount);
+
+        if (mode == GL_LINE_LOOP)   // Draw the last segment separately
+        {
+            drawClosingLine(count, type, indices);
+        }
     }
 }
 
 void Context::finish()
 {
     egl::Display *display = getDisplay();
     IDirect3DDevice9 *device = getDevice();
     IDirect3DQuery9 *occlusionQuery = NULL;
 
     HRESULT result = device->CreateQuery(D3DQUERYTYPE_OCCLUSION, &occlusionQuery);
 
     if (result == D3DERR_OUTOFVIDEOMEMORY || result == E_OUTOFMEMORY)
     {
         return error(GL_OUT_OF_MEMORY);
     }
 
     ASSERT(SUCCEEDED(result));
 
     if (occlusionQuery)
     {
         IDirect3DStateBlock9 *savedState = NULL;
         device->CreateStateBlock(D3DSBT_ALL, &savedState);
 
         HRESULT result = occlusionQuery->Issue(D3DISSUE_BEGIN);
         ASSERT(SUCCEEDED(result));
 
         // Render something outside the render target
-        device->SetStreamSourceFreq(0, 1);
         device->SetPixelShader(NULL);
         device->SetVertexShader(NULL);
         device->SetFVF(D3DFVF_XYZRHW);
         float data[4] = {-1.0f, -1.0f, -1.0f, 1.0f};
         display->startScene();
         device->DrawPrimitiveUP(D3DPT_POINTLIST, 1, data, sizeof(data));
 
         result = occlusionQuery->Issue(D3DISSUE_END);
         ASSERT(SUCCEEDED(result));
 
@@ skipping 35 matching lines @@
         result = eventQuery->GetData(NULL, 0, D3DGETDATA_FLUSH);
         eventQuery->Release();
 
         if (result == D3DERR_DEVICELOST)
         {
             error(GL_OUT_OF_MEMORY);
         }
     }
 }
 
+void Context::drawClosingLine(unsigned int first, unsigned int last)
+{
+    IDirect3DDevice9 *device = getDevice();
+    IDirect3DIndexBuffer9 *indexBuffer = NULL;
+    HRESULT result = D3DERR_INVALIDCALL;
+
+    if (supports32bitIndices())
+    {
+        result = device->CreateIndexBuffer(8, D3DUSAGE_WRITEONLY, D3DFMT_INDEX32, D3DPOOL_DEFAULT, &indexBuffer, 0);
+
+        if (SUCCEEDED(result))
+        {
+            unsigned int *data;
+            result = indexBuffer->Lock(0, 0, (void**)&data, 0);
+
+            if (SUCCEEDED(result))
+            {
+                data[0] = last;
+                data[1] = first;
+            }
+        }
+    }
+    else
+    {
+        result = device->CreateIndexBuffer(4, D3DUSAGE_WRITEONLY, D3DFMT_INDEX16, D3DPOOL_DEFAULT, &indexBuffer, 0);
+
+        if (SUCCEEDED(result))
+        {
+            unsigned short *data;
+            result = indexBuffer->Lock(0, 0, (void**)&data, 0);
+
+            if (SUCCEEDED(result))
+            {
+                data[0] = last;
+                data[1] = first;
+            }
+        }
+    }
+····
+    if (SUCCEEDED(result))
+    {
+        indexBuffer->Unlock();
+        device->SetIndices(indexBuffer);
+
+        device->DrawIndexedPrimitive(D3DPT_LINELIST, 0, 0, 2, 0, 1);
+
+        indexBuffer->Release();
+    }
+    else
+    {
+        ERR("Could not create an index buffer for closing a line loop.");
+        error(GL_OUT_OF_MEMORY);
+    }
+}
+
+void Context::drawClosingLine(GLsizei count, GLenum type, const void *indices)
+{
+    unsigned int first = 0;
+    unsigned int last = 0;
+
+    if (mState.elementArrayBuffer.get())
+    {
+        Buffer *indexBuffer = mState.elementArrayBuffer.get();
+        intptr_t offset = reinterpret_cast<intptr_t>(indices);
+        indices = static_cast<const GLubyte*>(indexBuffer->data()) + offset;
+    }
+
+    switch (type)
+    {
+      case GL_UNSIGNED_BYTE:
+        first = static_cast<const GLubyte*>(indices)[0];
+        last = static_cast<const GLubyte*>(indices)[count - 1];
+        break;
+      case GL_UNSIGNED_SHORT:
+        first = static_cast<const GLushort*>(indices)[0];
+        last = static_cast<const GLushort*>(indices)[count - 1];
+        break;
+      case GL_UNSIGNED_INT:
+        first = static_cast<const GLuint*>(indices)[0];
+        last = static_cast<const GLuint*>(indices)[count - 1];
+        break;
+      default: UNREACHABLE();
+    }
+
+    drawClosingLine(first, last);
+}
+
 void Context::recordInvalidEnum()
 {
     mInvalidEnum = true;
 }
 
 void Context::recordInvalidValue()
 {
     mInvalidValue = true;
 }
 
@@ skipping 159 matching lines @@
 }
 
 bool Context::supportsLuminanceTextures() const
 {
     return mSupportsLuminanceTextures;
 }
 
 bool Context::supportsLuminanceAlphaTextures() const
 {
     return mSupportsLuminanceAlphaTextures;
+}
+
+bool Context::supports32bitIndices() const
+{
+    return mSupports32bitIndices;
 }
 
 void Context::detachBuffer(GLuint buffer)
 {
     // [OpenGL ES 2.0.24] section 2.9 page 22:
     // If a buffer object is deleted while it is bound, all bindings to that object in the current context
     // (i.e. in the thread that called Delete-Buffers) are reset to zero.
 
     if (mState.arrayBuffer.id() == buffer)
     {
@@ skipping 167 matching lines @@
 
 void Context::setVertexAttrib(GLuint index, const GLfloat *values)
 {
     ASSERT(index < gl::MAX_VERTEX_ATTRIBS);
 
     mState.vertexAttribute[index].mCurrentValue[0] = values[0];
     mState.vertexAttribute[index].mCurrentValue[1] = values[1];
     mState.vertexAttribute[index].mCurrentValue[2] = values[2];
     mState.vertexAttribute[index].mCurrentValue[3] = values[3];
 
-    mVertexDataManager->dirtyCurrentValues();
+    mVertexDataManager->dirtyCurrentValue(index);
 }
 
 void Context::initExtensionString()
 {
     mExtensionString += "GL_OES_packed_depth_stencil ";
     mExtensionString += "GL_EXT_texture_format_BGRA8888 ";
     mExtensionString += "GL_EXT_read_format_bgra ";
     mExtensionString += "GL_ANGLE_framebuffer_blit ";
     mExtensionString += "GL_OES_rgb8_rgba8 ";
     mExtensionString += "GL_OES_standard_derivatives ";
@@ skipping 26 matching lines @@
     if (supportsHalfFloatLinearFilter())
     {
         mExtensionString += "GL_OES_texture_half_float_linear ";
     }
 
     if (getMaxSupportedSamples() != 0)
     {
         mExtensionString += "GL_ANGLE_framebuffer_multisample ";
     }
 
-    if (mBufferBackEnd->supportIntIndices())
+    if (supports32bitIndices())
     {
         mExtensionString += "GL_OES_element_index_uint ";
     }
 
     std::string::size_type end = mExtensionString.find_last_not_of(' ');
     if (end != std::string::npos)
     {
         mExtensionString.resize(end+1);
     }
 }
@@ skipping 156 matching lines @@
     }
 
     if (destTrimmedRect.bottom > drawBufferHeight)
     {
         int yDiff = destTrimmedRect.bottom - drawBufferHeight;
         destTrimmedRect.bottom = drawBufferHeight;
         sourceTrimmedRect.bottom -= yDiff;
     }
 
     bool partialBufferCopy = false;
-    if (sourceTrimmedRect.bottom - sourceTrimmedRect.top < readFramebuffer->getColorbuffer()->getHeight() ||
-        sourceTrimmedRect.right - sourceTrimmedRect.left < readFramebuffer->getColorbuffer()->getWidth() ||·
-        destTrimmedRect.bottom - destTrimmedRect.top < drawFramebuffer->getColorbuffer()->getHeight() ||
-        destTrimmedRect.right - destTrimmedRect.left < drawFramebuffer->getColorbuffer()->getWidth() ||
+    if (sourceTrimmedRect.bottom - sourceTrimmedRect.top < readBufferHeight ||
+        sourceTrimmedRect.right - sourceTrimmedRect.left < readBufferWidth ||·
+        destTrimmedRect.bottom - destTrimmedRect.top < drawBufferHeight ||
+        destTrimmedRect.right - destTrimmedRect.left < drawBufferWidth ||
         sourceTrimmedRect.top != 0 || destTrimmedRect.top != 0 || sourceTrimmedRect.left != 0 || destTrimmedRect.left != 0)
     {
         partialBufferCopy = true;
     }
 
     if (mask & GL_COLOR_BUFFER_BIT)
     {
         const bool validReadType = readFramebuffer->getColorbufferType() == GL_TEXTURE_2D ||
             readFramebuffer->getColorbufferType() == GL_RENDERBUFFER;
         const bool validDrawType = drawFramebuffer->getColorbufferType() == GL_TEXTURE_2D ||
@@ skipping 119 matching lines @@
 void glMakeCurrent(gl::Context *context, egl::Display *display, egl::Surface *surface)
 {
     gl::makeCurrent(context, display, surface);
 }
 
 gl::Context *glGetCurrentContext()
 {
     return gl::getContext();
 }
 }