ContextGLES30.cpp

#include "ContextGLES30.h"
 
#include "BuffersGLES30.h"
#include "TexturesGLES30.h"
#include "EffectsGLES30.h"
#include "RenderTargetsGLES30.h"
#include "FormatsGLES30.h"
#include "CapabilitiesGLES30.h"
 
#ifdef EMSCRIPTEN
#include <webgl/webgl2.h>
#endif
 
namespace
{
  Cogs::Logging::Log logger = Cogs::Logging::getLogger("ContextGLES30");
 
  GLenum Blends[] = {
    GL_ZERO,
    GL_ONE,
    GL_SRC_COLOR,
    GL_ONE_MINUS_SRC_COLOR,
    GL_SRC_ALPHA,
    GL_ONE_MINUS_SRC_ALPHA,
    GL_DST_ALPHA,
    GL_ONE_MINUS_DST_ALPHA,
    GL_DST_COLOR,
    GL_ONE_MINUS_DST_COLOR,
    GL_SRC_ALPHA_SATURATE,
    GL_CONSTANT_COLOR,
    GL_ONE_MINUS_CONSTANT_COLOR
  };
  static_assert(sizeof(Blends) == sizeof(Blends[0]) * size_t(Cogs::BlendState::Blend::Count));
 
  GLenum BlendOperations[] = {
  GL_FUNC_ADD,
  GL_FUNC_SUBTRACT,
  GL_FUNC_REVERSE_SUBTRACT,
  GL_MIN,
  GL_MAX
  };
  static_assert(sizeof(BlendOperations) == sizeof(BlendOperations[0]) * size_t(Cogs::BlendState::BlendOperation::Count));
 
  GLenum DepthFunctions[] = {
    GL_NEVER,
    GL_LESS,
    GL_LEQUAL,
    GL_EQUAL,
    GL_GEQUAL,
    GL_GREATER,
    GL_NOTEQUAL,
    GL_ALWAYS,
  };
 
  GLenum glBufferTargets[] = {
    GL_ARRAY_BUFFER,
    GL_ELEMENT_ARRAY_BUFFER,
    GL_UNIFORM_BUFFER,
    GL_PIXEL_PACK_BUFFER,
    GL_COPY_READ_BUFFER,
    GL_COPY_WRITE_BUFFER,
    GL_TRANSFORM_FEEDBACK_BUFFER
  };
  static_assert(sizeof(glBufferTargets) == sizeof(glBufferTargets[0]) * size_t(Cogs::OpenGLES30::BufferTarget::Count));
 
  bool setupFramebuffer(Cogs::TextureGLES30& texture, GLenum framebufferTarget)
  {
    switch (texture.target) {
    case GL_TEXTURE_2D:
      if (texture.textureId == 0) {
        LOG_ERROR_ONCE(logger, "Cannot resolve to/from null texture");
        return false;
      }
      break;
    case GL_RENDERBUFFER:
      if (texture.renderBuffer == 0) {
        LOG_ERROR_ONCE(logger, "Cannot resolve to/from null renderbuffer");
        return false;
      }
      break;
    default:
      LOG_ERROR_ONCE(logger, "Cannot resolve to/from this kind of texture target");
      return false;
    }
 
    glGenFramebuffers(1, &texture.fbo);
    glBindFramebuffer(framebufferTarget, texture.fbo);
 
    GLenum framebufferAttachment = (texture.flags & Cogs::TextureFlags::DepthBuffer) ? GL_DEPTH_ATTACHMENT : GL_COLOR_ATTACHMENT0;
 
    switch (texture.target) {
    case GL_TEXTURE_2D:
      glFramebufferTexture2D(framebufferTarget, framebufferAttachment, GL_TEXTURE_2D, texture.textureId, 0);
      break;
    case GL_RENDERBUFFER:
      glFramebufferRenderbuffer(framebufferTarget, framebufferAttachment, GL_RENDERBUFFER, texture.renderBuffer);
      break;
    default:
      assert(false);
      break;
    }
 
    GLenum status = glCheckFramebufferStatus(framebufferTarget);
    if (status != GL_FRAMEBUFFER_COMPLETE) {
      LOG_ERROR_ONCE(logger, "Failed to set up framebuffer: %s", Cogs::OpenGLES30::framebuffersStatusString(status));
      glBindFramebuffer(GL_FRAMEBUFFER, 0);
      return false;
    }
 
    return true;
  }
 
 
}
 
Cogs::IEffects* Cogs::ContextGLES30::getEffects() { return effects; }
 
void Cogs::ContextGLES30::signal(FenceHandle fenceHandle)
{
  syncObjects->signal(fenceHandle);
}
 
void Cogs::ContextGLES30::setupVertexAttributes(size_t baseVertex)
{
  if (inputLayout.currHandle && currentEffect.ptr) {
    const EffectGLES30* effect = currentEffect.ptr;
 
    const InputLayoutGLES30& layout = buffers->inputLayouts[inputLayout.currHandle];
 
    uint32_t attributeMask = 0;
    if (vertexBuffers.count < layout.numFormats) {
      LOG_ERROR_ONCE(logger, "vertexBufferCount=%u < inputLayout.numFormats=%zu", vertexBuffers.count, layout.numFormats);
    }
    else {
 
      for (size_t b = 0; b < layout.numFormats; ++b) {
        auto& vertexBuffer = vertexBuffers.currItems[b];
 
        BufferGLES30& buffer = buffers->buffers[vertexBuffer.handle];
        const VertexFormat* vertexFormat = layout.formats[b];// buffer.vertexFormat;
        const GLsizei stride = vertexBuffer.stride ? vertexBuffer.stride : getSize(*vertexFormat);
        const GLsizei bufferOffset = static_cast<GLsizei>(baseVertex) * stride + vertexBuffer.offset;
        bindBuffer(OpenGLES30::BufferTarget::ArrayBuffer, buffer.bufferId);
        for (const VertexElement& element : vertexFormat->elements) {
 
          GLint attributeLocation = -1;
          for (size_t i = 0; i < effect->activeAttributes; i++) {
            if (effect->attributeSemantic[i].semantic == uint32_t(element.semantic) &&
                effect->attributeSemantic[i].slot == element.semanticIndex)
            {
              attributeLocation = effect->attributeLocation[i];
              break;
            }
          }
          if (attributeLocation == -1) {
            // Attribute not active
            continue;
          }
 
          const OpenGLES30::DataFormatInfo format = OpenGLES30::DataFormats[size_t(element.format)];
          if (format.isVertexFormat == 0) {
            LOG_WARNING_ONCE(logger, "Encountered unsupported vertex format");
            continue;
          }
 
          const GLvoid* attribOffset = reinterpret_cast<const GLvoid*>((size_t)element.offset + bufferOffset);
 
          if (element.semantic == ElementSemantic::InstanceMatrix) {
            if (format.type == GL_FLOAT && format.components == 4 && format.columns == 4) {
              for (GLuint a = 0; a < 4; a++) {
                GLuint ix = attributeLocation + a;
                glVertexAttribPointer(ix, 4, format.type, GL_TRUE, stride, reinterpret_cast<const GLvoid*>(reinterpret_cast<size_t>(attribOffset) + sizeof(GLfloat) * a * 4));
                glEnableVertexAttribArray(ix);
                glVertexAttribDivisor(ix, element.instanceStep);
                attributeMask |= 1 << ix;
              }
            }
          }
 
          else {
            if (format.columns == 1) {
              if (format.isInteger) {
                glVertexAttribIPointer(attributeLocation, format.components, format.type, stride, attribOffset);
              }
              else {
                glVertexAttribPointer(attributeLocation, format.components, format.type, format.isNormalized ? GL_TRUE : GL_FALSE, stride, attribOffset);
              }
              glEnableVertexAttribArray(attributeLocation);
              glVertexAttribDivisor(attributeLocation, element.instanceStep);
              attributeMask |= 1 << attributeLocation;
            }
          }
 
        }
      }
      vertexBuffers.baseVertex = static_cast<uint32_t>(baseVertex);
    }
 
    uint32_t disable = currentAttributeMask & (~attributeMask);
    while (disable) {
#ifdef _WIN32
      DWORD attributeIndex = 0;
      _BitScanForward(&attributeIndex, disable);
#else
      uint32_t attributeIndex = __builtin_ctz(disable);
#endif
      assert((1 << attributeIndex) & disable);
      disable &= ~(1 << attributeIndex);
      glDisableVertexAttribArray(attributeIndex);
    }
    currentAttributeMask = attributeMask;
 
  }
  inputLayout.prevHandle = inputLayout.currHandle;
 
  needVertexAttributeSetup = false;
}
 
GLenum Cogs::ContextGLES30::bindBuffer(OpenGLES30::BufferTarget target, GLuint buffer)
{
  GLenum glTarget = glBufferTargets[size_t(target)];
  if (bufferTargets[size_t(target)].buffer != buffer) {
    bufferTargets[size_t(target)].buffer = buffer;
    glBindBuffer(glTarget, buffer);
  }
  return glTarget;
}
 
void Cogs::ContextGLES30::unbindBuffer(GLuint buffer)
{
  for (size_t target = 0; target < size_t(OpenGLES30::BufferTarget::Count); target++) {
      if (bufferTargets[target].buffer == buffer) {
      glBindBuffer(glBufferTargets[target], 0);
      bufferTargets[target].buffer = ~0u;
    }
  }
  for (size_t index = 0; index < size_t(OpenGLES30::maxUniformBuffers); index++) {
    if (uniformBufferTargets[index].buffer == buffer) {
      glBindBufferBase(GL_UNIFORM_BUFFER, GLuint(index), 0);
      uniformBufferTargets[index].buffer = ~0u;
    }
  }
}
 
void Cogs::ContextGLES30::unbindVAO()
{
  if (vertexArrayObject.prevHandle != VertexArrayObjectHandle::NoHandle) {
    vertexArrayObject.prevHandle = VertexArrayObjectHandle::NoHandle;
    glBindVertexArray(0);
 
    vertexArrayObject.indexType = GL_INVALID_ENUM;
    vertexArrayObject.indexCount = 0;
    vertexArrayObject.indexStride = 0;
    bufferTargets[size_t(OpenGLES30::BufferTarget::ArrayBuffer)].buffer = ~0u;
    bufferTargets[size_t(OpenGLES30::BufferTarget::ElementArrayBuffer)].buffer = ~0u;
  }
}
 
 
void Cogs::ContextGLES30::setIndexBuffer(IndexBufferHandle indexBufferHandle, uint32_t stride, uint32_t offset)
{
  if (offset != 0) {
    LOG_ERROR_ONCE(logger, "setIndexBuffer: Cannot bind index buffer with non-zero offset");
    indexBufferHandle = IndexBufferHandle::InvalidHandle;
  }
 
  if (HandleIsValid(indexBufferHandle)) {
    BufferGLES30& ixbuf = buffers->buffers[indexBufferHandle];
    if (ixbuf.isIndexBuffer == 0) {
      LOG_ERROR_ONCE(logger, "setIndexBuffer: Cannot bind non-index buffer as index buffer.");
      indexBufferHandle = IndexBufferHandle::InvalidHandle;
    }
  }
 
  vertexArrayObject.currHandle = VertexArrayObjectHandle::NoHandle;
  indexBuffer.handle = indexBufferHandle;
  indexBuffer.stride = stride;
  indexBuffer.offset = offset;
  needVertexAttributeSetup = true;
}
 
void Cogs::ContextGLES30::setConstantBuffer(const ConstantBufferBindingHandle bufferBindingHandle, const BufferHandle bufferHandle, const uint32_t offset, const uint32_t size)
{
  if (!HandleIsValid(bufferBindingHandle)) return;
  if (!HandleIsValid(currentEffect.handle)) {
    LOG_ERROR_ONCE(logger, "setConstantBuffer: Invalid effect handle");
    return;
  }
  assert(currentEffect.ptr);
 
  if (!HandleIsValid(bufferHandle)) {
    LOG_ERROR_ONCE(logger, "setConstantBuffer: Invalid buffer handle");
    return;
  }
  BufferGLES30& buffer = this->buffers->buffers[bufferHandle];
  const GLuint index = static_cast<GLuint>(bufferBindingHandle.handle & 0xFFFFFFFF) - 1;
  assert(index < OpenGLES30::maxUniformBuffers);
  if ((uniformBufferTargets[index].buffer != buffer.bufferId) ||
      (uniformBufferTargets[index].offset != offset) ||
      (uniformBufferTargets[index].size != size))
  {
    uniformBufferTargets[index].buffer = buffer.bufferId;
    uniformBufferTargets[index].offset = offset;
    uniformBufferTargets[index].size = size;
    if (offset == 0 && size == 0xffffffffu) {
      glBindBufferBase(GL_UNIFORM_BUFFER, index, buffer.bufferId);
    }
    else {
      GLsizeiptr _size = GLsizeiptr(size);
      if (_size == (GLsizeiptr)0xffffffff) {
        _size = GLsizeiptr(buffer.size - std::min(buffer.size, offset));
      }
      glBindBufferRange(GL_UNIFORM_BUFFER, index, buffer.bufferId, offset, _size);
    }
  }
}
 
bool Cogs::ContextGLES30::setupState()
{
  if (currBlendState.handle != nextBlendState.handle) {
 
    // Blending setup has changed
    if (HandleIsValid(nextBlendState.handle)) {
      const BlendStateGLES30& blendState = renderTargets->blendStates[nextBlendState.handle];
 
      if (currBlendState.state.enabled != blendState.enabled) {
        currBlendState.state.enabled = blendState.enabled;
        if (currBlendState.state.enabled) {
          glEnable(GL_BLEND);
        }
        else {
          glDisable(GL_BLEND);
        }
      }
 
      if (currBlendState.state.enabled) {
 
        if ((currBlendState.state.blend.colorSrc != blendState.blend.colorSrc) ||
            (currBlendState.state.blend.colorDst != blendState.blend.colorSrc) ||
            (currBlendState.state.blend.alphaSrc != blendState.blend.alphaSrc) ||
            (currBlendState.state.blend.alphaDst != blendState.blend.alphaDst))
        {
          currBlendState.state.blend = blendState.blend;
          glBlendFuncSeparate(Blends[size_t(currBlendState.state.blend.colorSrc)],
                              Blends[size_t(currBlendState.state.blend.colorDst)],
                              Blends[size_t(currBlendState.state.blend.alphaSrc)],
                              Blends[size_t(currBlendState.state.blend.alphaDst)]);
        }
 
        if ((currBlendState.state.operation.color != blendState.operation.color) ||
            (currBlendState.state.operation.alpha != blendState.operation.alpha))
        {
          currBlendState.state.operation = blendState.operation;
          glBlendEquationSeparate(BlendOperations[size_t(currBlendState.state.operation.color)],
                                  BlendOperations[size_t(currBlendState.state.operation.alpha)]);
        }
 
        if ((currBlendState.constant[0] != nextBlendState.constant[0]) ||
            (currBlendState.constant[1] != nextBlendState.constant[1]) ||
            (currBlendState.constant[2] != nextBlendState.constant[2]) ||
            (currBlendState.constant[3] != nextBlendState.constant[3]))
        {
          for (size_t i = 0; i < 4; i++) {
            currBlendState.constant[i] = nextBlendState.constant[i];
          }
          glBlendColor(currBlendState.constant[0],
                       currBlendState.constant[1],
                       currBlendState.constant[2],
                       currBlendState.constant[3]);
        }
      }
    }
    else if (currBlendState.state.enabled) {
      currBlendState.state.enabled = false;
      glDisable(GL_BLEND);
    }
 
    currBlendState.handle = nextBlendState.handle;
  }
 
  return true;
}
 
bool Cogs::ContextGLES30::setupDraw(size_t baseVertex)
{
  if (!setupState()) {
    return false;
  }
 
  // --- Give up with no effect
  if (!HandleIsValid(currentEffect.handle)) {
    LOG_ERROR_ONCE(logger, "setupIndexedDraw: No valid effect.");
    return false;
  }
 
  // --- Give up with invalid VAO
  if (vertexArrayObject.currHandle == VertexArrayObjectHandle::InvalidHandle) {
    LOG_ERROR_ONCE(logger, "setupIndexedDraw: Invalid vertex array object");
    return false;
  }
 
  // --- Set up VAO rendering
  else if (vertexArrayObject.currHandle != VertexArrayObjectHandle::NoHandle) {
 
    if (baseVertex != 0) {
      LOG_ERROR_ONCE(logger, "Unhandled VAO rendering with base vertex %zu != 0", baseVertex);
    }
 
    if (vertexArrayObject.prevHandle != vertexArrayObject.currHandle) {
      vertexArrayObject.prevHandle = vertexArrayObject.currHandle;
      VertexArrayObjectGLES30& vao = buffers->vertexArrayObjects[vertexArrayObject.currHandle];
      glBindVertexArray(vao.glName);
      vertexArrayObject.indexType = vao.indexType;
      vertexArrayObject.indexCount = vao.indexCount;
      vertexArrayObject.indexStride = vao.indexStride;
    }
  }
 
  // --- Set up non-VAO rendering with data from setVertexBuffer / set IndexBuffer
  else {
    unbindVAO();
    
    needVertexAttributeSetup = needVertexAttributeSetup || (vertexBuffers.baseVertex != baseVertex);
    if (needVertexAttributeSetup) { setupVertexAttributes(baseVertex); }
  }
 
  return true;
}
 
bool Cogs::ContextGLES30::setupIndexedDraw(GLenum& indexType, GLsizei& indexCount, const GLvoid*& indexOffset, const size_t startIndex, const size_t numIndices, const size_t baseVertex)
{
  if (!setupState()) {
    return false;
  }
 
  indexType = GL_INVALID_ENUM;
  indexCount = 0;
  indexOffset = nullptr;
 
  // --- Give up with no effect
  if (!HandleIsValid(currentEffect.handle)) {
    LOG_ERROR_ONCE(logger, "setupIndexedDraw: No valid effect.");
    return false;
  }
 
  // --- Give up with invalid VAO
  if (vertexArrayObject.currHandle == VertexArrayObjectHandle::InvalidHandle) {
    LOG_ERROR_ONCE(logger, "setupIndexedDraw: Invalid vertex array object");
    return false;
  }
 
  // --- Set up VAO rendering
  else if (vertexArrayObject.currHandle != VertexArrayObjectHandle::NoHandle) {
 
    if (vertexArrayObject.prevHandle != vertexArrayObject.currHandle) {
      VertexArrayObjectGLES30& vao = buffers->vertexArrayObjects[vertexArrayObject.currHandle];
      if (!((vao.indexType == GL_UNSIGNED_SHORT) || (vao.indexType == GL_UNSIGNED_INT))) {
        LOG_ERROR_ONCE(logger, "setupIndexedDraw: Vertex array object does not contain an index buffer");
        return false;
      }
      vertexArrayObject.prevHandle = vertexArrayObject.currHandle;
      glBindVertexArray(vao.glName);
      vertexArrayObject.indexType = vao.indexType;
      vertexArrayObject.indexCount = vao.indexCount;
      vertexArrayObject.indexStride = vao.indexStride;
    }
 
    const size_t stride = vertexArrayObject.indexStride ? vertexArrayObject.indexStride : (vertexArrayObject.indexType == GL_UNSIGNED_INT ? sizeof(GLuint) : sizeof(GLushort));
    indexType = vertexArrayObject.indexType;
    indexCount = static_cast<GLsizei>(numIndices ? numIndices : vertexArrayObject.indexCount);
    indexOffset = reinterpret_cast<const GLvoid*>(startIndex * stride);
  }
 
  // --- Set up non-VAO rendering with data from setVertexBuffer / set IndexBuffer
  else {
    unbindVAO();
    needVertexAttributeSetup = needVertexAttributeSetup || (vertexBuffers.baseVertex != baseVertex);
    if (needVertexAttributeSetup) { setupVertexAttributes(baseVertex); }
 
    if (!indexBuffer.handle) {
      LOG_ERROR_ONCE(logger, "setupIndexedDraw: No index buffer bound.");
      return false;
    }
 
    const auto& buffer = buffers->buffers[indexBuffer.handle];
    bindBuffer(OpenGLES30::BufferTarget::ElementArrayBuffer, buffer.bufferId);
    const size_t stride = indexBuffer.stride ? indexBuffer.stride : (indexType == GL_UNSIGNED_INT ? sizeof(GLuint) : sizeof(GLushort));
    indexType = buffer.indexType;
    indexCount = static_cast<GLsizei>(numIndices ? numIndices : buffer.size / stride);
    indexOffset = reinterpret_cast<const GLvoid*>(startIndex * stride);
  }
 
  return true;
}
 
void Cogs::ContextGLES30::draw(PrimitiveType primitiveType, const size_t startVertex, const size_t numVertexes)
{
  if (!setupDraw(0)) return;
 
  const GLenum glPrimitiveType = OpenGLES30::PrimitiveFormats[static_cast<uint32_t>(primitiveType)];
  glDrawArrays(currentRasterizerState.wireFrame ? GL_LINES : glPrimitiveType, static_cast<GLint>(startVertex), static_cast<GLsizei>(numVertexes));
 
  if (frameStatisticsEnabled) { frameStatisticsAccountDrawCall(numVertexes, false); }
}
 
void Cogs::ContextGLES30::drawIndexed(PrimitiveType primitiveType, const size_t startIndex, const size_t numIndices, const size_t baseVertex)
{
  GLenum indexType = GL_INVALID_ENUM;
  GLsizei indexCount = 0;
  const GLvoid* indexOffset = nullptr;
  if (!setupIndexedDraw(indexType, indexCount, indexOffset, startIndex, numIndices, baseVertex)) return;
 
  const GLenum glPrimitiveType = OpenGLES30::PrimitiveFormats[static_cast<uint32_t>(primitiveType)];
  glDrawElements(currentRasterizerState.wireFrame ? GL_LINES : glPrimitiveType, indexCount, indexType, indexOffset);
 
  if (frameStatisticsEnabled) { frameStatisticsAccountDrawCall(numIndices, true); }
}
 
void Cogs::ContextGLES30::drawInstanced(PrimitiveType primitiveType, const size_t startVertex, const size_t numVertexes, const size_t startInstance, const size_t numInstances)
{
  if (startInstance != 0) {
    LOG_ERROR_ONCE(logger, "drawInstanced: GLES30 does not support nonzero start instance");
    return;
  }
 
  if (!setupDraw(0)) return;
 
  const GLenum glPrimitiveType = OpenGLES30::PrimitiveFormats[static_cast<uint32_t>(primitiveType)];
  glDrawArraysInstanced(currentRasterizerState.wireFrame ? GL_LINES : glPrimitiveType, static_cast<GLint>(startVertex), static_cast<GLsizei>(numVertexes), static_cast<GLsizei>(numInstances));
 
  if (frameStatisticsEnabled) { frameStatisticsAccountDrawCall(numVertexes, false); }
}
 
void Cogs::ContextGLES30::drawInstancedIndexed(PrimitiveType primitiveType, const size_t startInstance, const size_t numInstances, const size_t startIndex, const size_t numIndices)
{
  if (startInstance != 0) {
    LOG_ERROR_ONCE(logger, "drawInstancedIndexed: GLES30 does not support nonzero start instance");
    return;
  }
 
  GLenum indexType = GL_INVALID_ENUM;
  GLsizei indexCount = 0;
  const GLvoid* indexOffset = nullptr;
  if (!setupIndexedDraw(indexType, indexCount, indexOffset, startIndex, numIndices, 0)) return;
 
  const GLenum glPrimitiveType = OpenGLES30::PrimitiveFormats[static_cast<uint32_t>(primitiveType)];
  glDrawElementsInstanced(currentRasterizerState.wireFrame ? GL_LINES : glPrimitiveType, indexCount, indexType, indexOffset, static_cast<GLsizei>(numInstances));
 
  if (frameStatisticsEnabled) { frameStatisticsAccountDrawCall(numIndices, true); }
}
 
void Cogs::ContextGLES30::setVertexBuffers(const VertexBufferHandle * handles, const size_t count)
{
  vertexArrayObject.currHandle = VertexArrayObjectHandle::NoHandle;
  vertexBuffers.count = uint32_t(count);
  for (size_t i = 0; i < count; i++) {
    vertexBuffers.currItems[i].handle = handles[i];
    vertexBuffers.currItems[i].stride = 0;
    vertexBuffers.currItems[i].offset = 0;
  }
  needVertexAttributeSetup = true;
}
 
void Cogs::ContextGLES30::setVertexBuffers(const VertexBufferHandle* handles, const size_t count, const uint32_t* strides, const uint32_t* offsets)
{
  vertexArrayObject.currHandle = VertexArrayObjectHandle::NoHandle;
  vertexBuffers.count = uint32_t(count);
  for (size_t i = 0; i < count; i++) {
    vertexBuffers.currItems[i].handle = handles[i];
    vertexBuffers.currItems[i].stride = strides[i];
    vertexBuffers.currItems[i].offset = offsets ? offsets[i] : 0;
  }
  needVertexAttributeSetup = true;
}
 
void Cogs::ContextGLES30::setVertexArrayObject(VertexArrayObjectHandle vertexArrayObjectHandle)
{
  vertexArrayObject.currHandle = vertexArrayObjectHandle;
  needVertexAttributeSetup = true;
}
 
void Cogs::ContextGLES30::setBlendState(const BlendStateHandle handle, const float* constant)
{
  nextBlendState.handle = handle;
  for (size_t i = 0; i < 4; i++) {
    nextBlendState.constant[i] = constant ? constant[i] : 0.f;
  }
}
 
void Cogs::ContextGLES30::beginRenderPass(const RenderPassInfo &info)
{
  assert(!inRenderPass);
  if (renderTargets->bindRenderTargets(info.renderTargetHandle, info.depthStencilHandle)) {
    currentRenderTarget = info.renderTargetHandle;
    currentDepthStencilTarget = info.depthStencilHandle;
  }
  else {
    currentRenderTarget = RenderTargetHandle::InvalidHandle;
    currentDepthStencilTarget = DepthStencilHandle::InvalidHandle;
    glBindFramebuffer(GL_FRAMEBUFFER, 0);
  }
  {
    auto & renderTarget = renderTargets->renderTargets[currentRenderTarget];
    for (int i = 0; i < renderTarget.numViews; ++i) {
      if(info.loadOp[i] == LoadOp::Clear){
        glClearBufferfv(GL_COLOR, i, info.clearValue[i]);
      }
    }
  }
  if(info.depthLoadOp == LoadOp::Clear){
    clearDepth(info.depthClearValue);
  }
  inRenderPass = true;
  renderPassInfo = info;
}
 
void Cogs::ContextGLES30::endRenderPass()
{
  assert(inRenderPass);
  if(HandleIsValid(renderPassInfo.renderTargetHandle)){
    RenderTargetGLES30 &target = renderTargets->renderTargets[renderPassInfo.renderTargetHandle];
    for(size_t i=0; i<target.numViews; i++){
      if(HandleIsValid(renderPassInfo.resolveHandle[i])){
        TextureViewDescription &view = textures->views[renderPassInfo.resolveHandle[i]];
        // Only resolve of default views is supported at the moment for GLES30
        assert(view.layerIndex == 0);
        assert(view.numLayers == 1);
        assert(view.levelIndex == 0);
        assert(view.numLevels == 1);
        assert(target.views[i].layerIndex == 0);
        assert(target.views[i].numLayers == 1);
        assert(target.views[i].levelIndex == 0);
        resolveResource(target.views[i].texture, view.texture);
      }
    }
  }
  inRenderPass = false;
  renderPassInfo = {};
}
 
void Cogs::ContextGLES30::setRenderTarget(const RenderTargetHandle renderTargetHandle, const DepthStencilHandle depthStencilHandle)
{
  if (currentRenderTarget != renderTargetHandle || currentDepthStencilTarget != depthStencilHandle) {
 
    if (renderTargets->bindRenderTargets(renderTargetHandle, depthStencilHandle)) {
      currentRenderTarget = renderTargetHandle;
      currentDepthStencilTarget = depthStencilHandle;
    }
    else {
      currentRenderTarget = RenderTargetHandle::InvalidHandle;
      currentDepthStencilTarget = DepthStencilHandle::InvalidHandle;
      glBindFramebuffer(GL_FRAMEBUFFER, 0);
    }
  }
}
 
void Cogs::ContextGLES30::setViewport(const float x, const float y, const float width, const float height)
{
  // NOTE: There seems to be a problem when setting the window framebuffer viewport outside an actual context resize.
  glViewport(static_cast<GLsizei>(x), static_cast<GLsizei>(y), static_cast<GLsizei>(width), static_cast<GLsizei>(height));
}
 
void Cogs::ContextGLES30::setScissor(const int x, const int y, const int width, const int height)
{
  glScissor(x, y, width, height);
}
 
void Cogs::ContextGLES30::clearRenderTarget(const float * color)
{
  size_t bufferCount = 1;
  if (HandleIsValid(currentRenderTarget)) {
    RenderTargetGLES30& renderTarget = renderTargets->renderTargets[currentRenderTarget];
    bufferCount = renderTarget.numViews;
  }
  for (size_t i = 0; i < bufferCount; i++) {
    glClearBufferfv(GL_COLOR, GLint(i), color);
  }
}
 
void Cogs::ContextGLES30::clearRenderTarget(const float ** colors, int count)
{
  if (count < 1) return;
 
  if (HandleIsValid(currentRenderTarget)) {
    RenderTargetGLES30& renderTarget = renderTargets->renderTargets[currentRenderTarget];
 
    GLint n = std::min(GLint(renderTarget.numViews), GLint(count));
 
    for (GLint i = 0; i < n; ++i) {
      switch (renderTarget.viewData[i].basicType) {
      case 0:
        break;
      case 1:
        glClearBufferfv(GL_COLOR, i, colors[i]);
        break;
      case 2: {
        uint32_t ucolors[4] = {
          static_cast<uint32_t>(colors[i][0]),
          static_cast<uint32_t>(colors[i][1]),
          static_cast<uint32_t>(colors[i][2]),
          static_cast<uint32_t>(colors[i][3])
        };
        glClearBufferuiv(GL_COLOR, i, ucolors);
        break;
      }
      case 3: // sint
        int32_t icolors[4] = {
          static_cast<int32_t>(colors[i][0]),
          static_cast<int32_t>(colors[i][1]),
          static_cast<int32_t>(colors[i][2]),
          static_cast<int32_t>(colors[i][3])
        };
        glClearBufferiv(GL_COLOR, i, icolors);
        break;
      }
    }
  }
  else {
    glClearBufferfv(GL_COLOR, 0, colors[0]);
  }
}
 
void Cogs::ContextGLES30::clearDepth(const float depth)
{
  glDepthMask(GL_TRUE);
  glClearBufferfv(GL_DEPTH, 0, &depth);
}
 
 
void Cogs::ContextGLES30::setEffect(EffectHandle effectHandle)
{
  if (currentEffect.handle == effectHandle) return;
 
  if (effectHandle == EffectHandle::InvalidHandle) {
    LOG_ERROR_ONCE(logger, "Cannot set invalid effect.");
    currentEffect.handle = EffectHandle::NoHandle;
    currentEffect.ptr = nullptr;
    return;
  }
  assert((effects->delayFrames == 0 || effects->checkEffect(effectHandle) == ResourceStatus::Ready) &&
         "Effect used before it finished (fake-async) loading");
 
  currentEffect.handle = effectHandle;
  if (effectHandle) {
    currentEffect.ptr = &effects->effects[effectHandle];
    glUseProgram(currentEffect.ptr->programId);
  }
  else {
    currentEffect.ptr = nullptr;
    glUseProgram(0);
  }
  needVertexAttributeSetup = true;
}
 
 
void Cogs::ContextGLES30::setTexture(const TextureBindingHandle textureBindingHandle, const TextureHandle textureHandle)
{
  if (!HandleIsValid(currentEffect.handle)) {
    LOG_ERROR_ONCE(logger, "setTexture: Current effect handle is invalid");
    return;
  }
  if (textureBindingHandle == TextureBindingHandle::NoHandle) {
    return;
  }
  else if (textureBindingHandle == TextureBindingHandle::InvalidHandle) {
    LOG_ERROR_ONCE(logger, "setTexture: Texture binding handle is invalid");
    return;
  }
 
  GLint unit = GLint(textureBindingHandle.handle - 1);
  assert(0 <= unit && unit < GLint(OpenGLES30::maxTexUnits));
  bindTexture(textureHandle, unit);
}
 
void Cogs::ContextGLES30::setTexture(const TextureBindingHandle textureBindingHandle, TextureViewHandle textureViewHandle)
{
  if (!HandleIsValid(currentEffect.handle) || !HandleIsValid(textureBindingHandle) || !HandleIsValid(textureViewHandle)) return;
 
  TextureViewDescription& view = textures->views[textureViewHandle];
 
  GLint unit = GLint(textureBindingHandle.handle - 1);
  assert(0 <= unit && unit < GLint(OpenGLES30::maxTexUnits));
 
  TextureGLES30* texture = bindTexture(view.texture, unit);
  if (texture) {
    glTexParameteri(texture->target, GL_TEXTURE_BASE_LEVEL, view.levelIndex);
    glTexParameteri(texture->target, GL_TEXTURE_MAX_LEVEL, view.levelIndex + view.numLevels - 1);
    texture->boundAsView = 1;
  }
}
 
Cogs::TextureGLES30* Cogs::ContextGLES30::bindTexture(TextureHandle textureHandle, GLuint unit)
{
  if (unit == GLuint(~0u)) {
    unit = activeTexUnit;
  }
  assert(unit < OpenGLES30::maxTexUnits);
 
  TextureGLES30* texture = nullptr;
  if (HandleIsValid(textureHandle)) {
    texture = &textures->textures[textureHandle];
  }
  if (texture && texture->target == GL_RENDERBUFFER) {
    LOG_ERROR_ONCE(logger, "Cannot bind a renderBuffer as a texture sampler");
    return nullptr;
  }
 
  // Early out if we do not change any state
  if (texUnits[unit].texture == textureHandle && (texture == nullptr || texture->boundAsView == 0)) {
    return texture;
  }
 
  // Switch texture unit if needed
  if (activeTexUnit != unit) {
    glActiveTexture(GL_TEXTURE0 + unit);
    activeTexUnit = unit;
  }
 
  // We are binding to a texture
  if (texture) {
 
    // If a texture was bound to the unit but to a different target, set the old target to null
    if (HandleIsValid(texUnits[unit].texture) && texUnits[unit].target != texture->target) {
      glBindTexture(texUnits[unit].target, 0);
    }
 
    glBindTexture(texture->target, texture->textureId);
    texUnits[unit].target = texture->target;
    texUnits[unit].texture = textureHandle;
 
    // If the texture was bound as a view, we remove the view
    if (texture->boundAsView) {
      glTexParameteri(texture->target, GL_TEXTURE_BASE_LEVEL, 0);
      glTexParameteri(texture->target, GL_TEXTURE_MAX_LEVEL, 1000);
      texture->boundAsView = 0;
    }
 
    return texture;
  }
 
  // Unbind a unit
  else if (textureHandle == TextureHandle::InvalidHandle) {
    LOG_WARNING_ONCE(logger, "setTexture: Invalid texture handle");
  }
 
  if (HandleIsValid(texUnits[unit].texture)) {
    glBindTexture(texUnits[unit].target, 0);
  }
  texUnits[unit].target = GL_TEXTURE_2D;
  texUnits[unit].texture = TextureHandle::NoHandle;
 
  return nullptr;
}
 
void Cogs::ContextGLES30::setSamplerState(const SamplerStateBindingHandle samplerStateBindingHandle, const SamplerStateHandle samplerStateHandle)
{
  if (!samplerStateBindingHandle) return;
 
  const GLint unit = static_cast<GLint>(samplerStateBindingHandle.handle - 1);
  assert(0 <= unit && unit < GLint(OpenGLES30::maxTexUnits));
 
  if (texUnits[unit].sampler != samplerStateHandle) {
    texUnits[unit].sampler = samplerStateHandle;
    if (HandleIsValid(samplerStateHandle)) {
      const SamplerGLES30& sampler = textures->samplers[samplerStateHandle];
      glBindSampler(unit, sampler.glName);
    }
    else {
      glBindSampler(unit, 0);
    }
  }
}
 
void Cogs::ContextGLES30::setRasterizerState(const RasterizerStateHandle handle)
{
  const RasterizerState & rasterizerState = (handle == RasterizerStateHandle::NoHandle) ? RasterizerState::DefaultState() : this->renderTargets->rasterizerStates[handle];
 
  currentRasterizerState.wireFrame = rasterizerState.wireFrame;
 
  if (currentRasterizerState.frontCounterClockwise != rasterizerState.frontCounterClockwise) {
    currentRasterizerState.frontCounterClockwise = rasterizerState.frontCounterClockwise;
    glFrontFace(currentRasterizerState.frontCounterClockwise ? GL_CCW : GL_CW);
  }
 
  if (currentRasterizerState.cullMode != rasterizerState.cullMode) {
    currentRasterizerState.cullMode = rasterizerState.cullMode;
    switch (rasterizerState.cullMode)
    {
    case RasterizerState::None:
      glDisable(GL_CULL_FACE);
      break;
 
    case RasterizerState::Front:
      glEnable(GL_CULL_FACE);
      glCullFace(GL_FRONT);
      break;
 
    default:
      glEnable(GL_CULL_FACE);
      glCullFace(GL_BACK);
      break;
    }
  }
 
  if (currentRasterizerState.noDepthClip != rasterizerState.noDepthClip) {
    currentRasterizerState.noDepthClip = rasterizerState.noDepthClip;
    if (capabilities->getDeviceCapabilities().NoDepthClip) {
      if (currentRasterizerState.noDepthClip) {
        glEnable(GL_DEPTH_CLAMP_EXT);
      }
      else {
        glDisable(GL_DEPTH_CLAMP_EXT);
      }
    }
  }
 
  if ((currentRasterizerState.depthBias != rasterizerState.depthBias) ||
      (currentRasterizerState.slopeScaledDepthBias != rasterizerState.slopeScaledDepthBias))
  {
    currentRasterizerState.depthBias = rasterizerState.depthBias;
    currentRasterizerState.slopeScaledDepthBias = rasterizerState.slopeScaledDepthBias;
    if ((currentRasterizerState.depthBias != 0.f) || (currentRasterizerState.slopeScaledDepthBias != 0.f))
    {
      glEnable(GL_POLYGON_OFFSET_FILL);
      glPolygonOffset(currentRasterizerState.slopeScaledDepthBias, currentRasterizerState.depthBias);
    }
    else {
      glPolygonOffset(0, 0);
      glDisable(GL_POLYGON_OFFSET_FILL);
    }
  }
 
  if (currentRasterizerState.scissor != rasterizerState.scissor) {
    currentRasterizerState.scissor = rasterizerState.scissor;
    if (currentRasterizerState.scissor) {
      glEnable(GL_SCISSOR_TEST);
    }
    else {
      glDisable(GL_SCISSOR_TEST);
    }
  }
}
 
void Cogs::ContextGLES30::setInputLayout(const InputLayoutHandle handle)
{
  inputLayout.currHandle = handle;
}
 
void Cogs::ContextGLES30::resolveResource(TextureHandle sourceTextureHandle, TextureHandle targetTextureHandle)
{
  TextureGLES30 & sourceTexture = this->textures->textures[sourceTextureHandle];
  TextureGLES30 & targetTexture = this->textures->textures[targetTextureHandle];
 
  if (1 < targetTexture.numSamples) {
    LOG_ERROR_ONCE(logger, "Cannot resolve to multisample target");
    return;
  }
  if (sourceTexture.width != targetTexture.width || sourceTexture.height != targetTexture.height) {
    LOG_ERROR_ONCE(logger, "Cannot resolve to texture of different size");
    return;
  }
  if (targetTexture.textureId == 0) {
    LOG_ERROR_ONCE(logger, "Cannot resolve to null texture");
    return;
  }
 
  // Set up source for resolve blit
  if (sourceTexture.fbo) {
    glBindFramebuffer(GL_READ_FRAMEBUFFER, sourceTexture.fbo);
  }
  else if (!setupFramebuffer(sourceTexture, GL_READ_FRAMEBUFFER)) {
    return; // Failed
  }
 
  // Set up target for resolve blit
  if (targetTexture.fbo) {
    glBindFramebuffer(GL_DRAW_FRAMEBUFFER, targetTexture.fbo);
  }
  else if (!setupFramebuffer(targetTexture, GL_DRAW_FRAMEBUFFER)) {
    return; // Failed
  }
 
  // Do resolve
  if (targetTexture.flags & TextureFlags::DepthBuffer) {
 
    glClear(GL_DEPTH_BUFFER_BIT); // Break dependency chain
    glBlitFramebuffer(0, 0, sourceTexture.width, sourceTexture.height,
                      0, 0, targetTexture.width, targetTexture.height,
                      GL_DEPTH_BUFFER_BIT, GL_NEAREST);
  }
  else {
    glClear(GL_COLOR_BUFFER_BIT); // Break dependency chain
    glBlitFramebuffer(0, 0, sourceTexture.width, sourceTexture.height,
                      0, 0, targetTexture.width, targetTexture.height,
                      GL_COLOR_BUFFER_BIT, GL_NEAREST);
  }
  glBindFramebuffer(GL_FRAMEBUFFER, 0);
}
 
void Cogs::ContextGLES30::setDefaults()
{
  if (emptyUniformBuffer == BufferHandle::NoHandle) {
    emptyUniformBuffer = buffers->loadBuffer(nullptr,
                                             0x4000, // GL minimum size
                                             Usage::Static,
                                             AccessMode::None,
                                             BindFlags::ConstantBuffer);
  }
  setRenderTarget(RenderTargetHandle::NoHandle, DepthStencilHandle::NoHandle);
 
  setRasterizerState(RasterizerStateHandle::NoHandle);
  currentRasterizerState.frontCounterClockwise = false;
  currentRasterizerState.cullMode = RasterizerState::CullMode::None;
  currentRasterizerState.depthBias = 0.0;
  currentRasterizerState.slopeScaledDepthBias = 0.0;
  currentRasterizerState.scissor = false;
  currentRasterizerState.wireFrame = false;
  currentRasterizerState.noDepthClip = false;
  glFrontFace(GL_CW);
  glDisable(GL_CULL_FACE);
  glDisable(GL_POLYGON_OFFSET_FILL);
  glDisable(GL_SCISSOR_TEST);
  if (capabilities->getDeviceCapabilities().NoDepthClip) {
    glDisable(GL_DEPTH_CLAMP_EXT);
  }
 
  { // Blend state
    currBlendState.handle = BlendStateHandle::NoHandle;
    currBlendState.state.blend = { BlendState::Blend::One, BlendState::Blend::Zero, BlendState::Blend::One, BlendState::Blend::Zero };
    currBlendState.state.operation = { BlendState::BlendOperation::Add, BlendState::BlendOperation::Add };
    currBlendState.state.enabled = false;
    nextBlendState.handle = BlendStateHandle::NoHandle;
    glDisable(GL_BLEND);
    glBlendFuncSeparate(GL_ONE, GL_ZERO, GL_ONE, GL_ZERO);
    glBlendEquationSeparate(GL_FUNC_ADD, GL_FUNC_ADD);
    glBlendColor(0.f, 0.f, 0.f, 0.f);
  }
 
  setDepthStencilState(DepthStencilStateHandle::NoHandle);
  currentDepthStencilState.depthEnabled = true;
  currentDepthStencilState.writeEnabled = true;
  currentDepthStencilState.depthFunction = DepthStencilState::DepthFunction::Less;
  glEnable(GL_DEPTH_TEST);
  glDepthMask(GL_TRUE);
  glDepthFunc(GL_LESS);
 
  activeTexUnit = 0;
  glActiveTexture(GL_TEXTURE0);
 
  vertexArrayObject.prevHandle = VertexArrayObjectHandle::NoHandle;
  vertexArrayObject.currHandle = VertexArrayObjectHandle::NoHandle;
  glBindVertexArray(0);
 
  inputLayout.prevHandle = InputLayoutHandle::NoHandle;
  inputLayout.currHandle = InputLayoutHandle::NoHandle;
 
  indexBuffer.handle = IndexBufferHandle::NoHandle;
 
  currentEffect.handle = EffectHandle::NoHandle;
  currentEffect.ptr = nullptr;
  glUseProgram(0);
 
  for (size_t i = 0; i < size_t(OpenGLES30::BufferTarget::Count); i++) {
    glBindBuffer(glBufferTargets[i], 0);
    bufferTargets[i].buffer = 0;
  }
 
  for (GLuint i = 0; i < OpenGLES30::maxUniformBuffers; i++) {
    if (uniformBufferTargets[i].buffer) {
      glBindBufferBase(GL_UNIFORM_BUFFER, i, 0);
    }
    uniformBufferTargets[i].buffer = 0;
    uniformBufferTargets[i].offset = 0;
    uniformBufferTargets[i].size = ~0u;
  }
 
  // Bind empty uniform buffer to slot index 0, which is the slot-index
  // which we use for unused buffers.
  if (HandleIsValid(emptyUniformBuffer)) {
    const BufferGLES30& buffer = buffers->buffers[emptyUniformBuffer];
    glBindBufferBase(GL_UNIFORM_BUFFER, 0, buffer.bufferId);
  }
 
}
 
void Cogs::ContextGLES30::clearCachedState()
{
  for (GLuint i = 0; i < OpenGLES30::maxTexUnits; i++) {
    if (texUnits[i].texture != TextureHandle::NoHandle || texUnits[i].sampler != SamplerStateHandle::NoHandle) {
      glActiveTexture(GL_TEXTURE0 + i);
      glBindTexture(texUnits[i].target, 0);
      texUnits[i].target = GL_TEXTURE_2D;
      texUnits[i].texture = TextureHandle::NoHandle;
 
      glBindSampler(i, 0);
      texUnits[i].sampler = SamplerStateHandle::NoHandle;
    }
  }
  activeTexUnit = 0;
  glActiveTexture(GL_TEXTURE0);
 
  vertexArrayObject.prevHandle = VertexArrayObjectHandle::NoHandle;
  vertexArrayObject.currHandle = VertexArrayObjectHandle::NoHandle;
  glBindVertexArray(0);
 
  for (GLenum i = 0; i < OpenGLES30::maxVertexAttributes; i++) {
    vertexBuffers.currItems[i].handle = VertexBufferHandle::NoHandle;
    if (currentAttributeMask & (1 << i)) {
      glDisableVertexAttribArray(i);
    }
  }
  vertexBuffers.count = 0;
  currentAttributeMask = 0;
 
  currentEffect.handle = EffectHandle::NoHandle;
  currentEffect.ptr = nullptr;
  glUseProgram(0);
}
 
void Cogs::ContextGLES30::setDepthStencilState(const DepthStencilStateHandle handle)
{
  DepthStencilState depthStencilState = (handle == DepthStencilStateHandle::NoHandle) ? DepthStencilState::DefaultState() : this->renderTargets->depthStencilStates[handle];
 
  if (currentDepthStencilState.depthEnabled != depthStencilState.depthEnabled) {
    currentDepthStencilState.depthEnabled = depthStencilState.depthEnabled;
    if (currentDepthStencilState.depthEnabled) {
      glEnable(GL_DEPTH_TEST);
    }
    else {
      glDisable(GL_DEPTH_TEST);
    }
  }
 
  if (currentDepthStencilState.depthEnabled) {
 
    // Depth is never written with depth test enabled, use ALWAYS test to write unconditionally.
    if (currentDepthStencilState.writeEnabled != depthStencilState.writeEnabled) {
      currentDepthStencilState.writeEnabled = depthStencilState.writeEnabled;
      if (currentDepthStencilState.writeEnabled) {
        glDepthMask(GL_TRUE);
      }
      else {
        glDepthMask(GL_FALSE);
      }
    }
 
    // Depth test function only necessary to set when depth test is enabled
    if (currentDepthStencilState.depthFunction != depthStencilState.depthFunction) {
      currentDepthStencilState.depthFunction = depthStencilState.depthFunction;
      glDepthFunc(DepthFunctions[currentDepthStencilState.depthFunction]);
    }
  }
}
 
void Cogs::ContextGLES30::readDepthBuffer(BufferHandle /*bufferHandle*/, int /*x*/, int /*y*/, int /*width*/, int /*height*/, Framebuffer /*framebuffer*/)
{
  LOG_ERROR_ONCE(logger, "Reading of depth buffer is not supported");
}
 
void Cogs::ContextGLES30::readColorBuffer(BufferHandle bufferHandle, int x, int y, int width, int height, Framebuffer /*framebuffer*/)
{
 
  if (!HandleIsValid(bufferHandle)) return;
  BufferGLES30& buffer = this->buffers->buffers[bufferHandle];
 
  size_t elementSize = 4;
  GLenum source = GL_BACK;
  GLenum format = GL_RGBA;
  GLenum type = GL_UNSIGNED_BYTE;
 
  if (currentRenderTarget == RenderTargetHandle::InvalidHandle) {
    LOG_ERROR_ONCE(logger, "Reading color buffer of invalid render target");
    return;
  }
 
  if (HandleIsValid(currentRenderTarget)) {
    const RenderTargetGLES30& renderTarget = this->renderTargets->renderTargets[this->currentRenderTarget];
 
    source = GL_COLOR_ATTACHMENT0;
 
    if (renderTarget.numViews && HandleIsValid(renderTarget.views[0].texture)) {
      const TextureGLES30& texture = textures->textures[renderTarget.views[0].texture];
      elementSize = getFormatInfo(texture.format)->blockSize;
      format = OpenGLES30::DataFormats[size_t(texture.format)].format;
      type = OpenGLES30::DataFormats[size_t(texture.format)].type;
    }
  }
 
  if (buffer.size < elementSize * width * height) {
    LOG_ERROR_ONCE(logger, "Color buffer read is larger than buffer size.");
    return;
  }
 
  glReadBuffer(source);
  bindBuffer(OpenGLES30::BufferTarget::PixelPackBuffer, buffer.bufferId);
  glReadPixels(x, y, width, height, format, type, nullptr);
}
 
void* Cogs::ContextGLES30::map(BufferHandle bufferHandle, MapMode::EMapMode mapMode, uint32_t* /*stride*/)
{
  if (!HandleIsValid(bufferHandle)) return nullptr;
 
 
  BufferGLES30& buffer = this->buffers->buffers[bufferHandle];
  if (buffer.isMapped) {
    LOG_ERROR_ONCE(logger, "Buffers can only be mapped once at a time");
    return nullptr;
  }
 
 
  if (buffer.mappedData.size() != buffer.size) {
    buffer.mappedData.resize(buffer.size, false);
  }
 
  if (mapMode == MapMode::Read || mapMode == MapMode::ReadWrite) {
 
#ifdef EMSCRIPTEN
 
    // Not available on ES3.x, only WebGL
 
    GLenum glTarget = bindBuffer(OpenGLES30::BufferTarget::CopyReadBuffer, buffer.bufferId);
    emscripten_glGetBufferSubData(glTarget, 0, buffer.size, buffer.mappedData.data());
 
#else
 
    GLenum glTarget = bindBuffer(buffer.target, buffer.bufferId);
    const void* ptr = glMapBufferRange(glTarget, 0, GLsizei(buffer.size), GL_MAP_READ_BIT);
    if (ptr) {
      std::memcpy(buffer.mappedData.data(), ptr, buffer.size);
    }
    glUnmapBuffer(glTarget);
 
#endif
 
  }
 
  buffer.writeBackMap = (mapMode == MapMode::Write || mapMode == MapMode::WriteDiscard || mapMode == MapMode::ReadWrite);
  buffer.isMapped = true;
  return buffer.mappedData.data();
}
 
void Cogs::ContextGLES30::unmap(BufferHandle bufferHandle)
{
  BufferGLES30& buffer = this->buffers->buffers[bufferHandle];
 
  if (!buffer.isMapped) {
    LOG_ERROR_ONCE(logger, "Unmapping buffer that is not mapped");
    return;
  }
 
  if (buffer.writeBackMap) {
    GLenum glTarget = bindBufferCopy(OpenGLES30::BufferTarget::CopyWriteBuffer, buffer);
    glBufferSubData(glTarget, 0, GLsizeiptr(buffer.mappedData.size()), buffer.mappedData.data());
    if(uploadStatisticsEnabled) uploadStatisticsBufferUpload(buffer.mappedData.size());
  }
 
  if (buffer.keepMapBacking == false) {
    buffer.mappedData.resize(0, false, true);
  }
 
  buffer.isMapped = false;
}
 
void Cogs::ContextGLES30::updateBuffer(BufferHandle bufferHandle, const void* data, size_t size)
{
  if (!HandleIsValid(bufferHandle)) {
    LOG_ERROR_ONCE(logger, "updateSubBuffer: invalid handle");
    return;
  }
  BufferGLES30& buffer = buffers->buffers[bufferHandle];
  GLenum glTarget = bindBufferCopy(OpenGLES30::BufferTarget::CopyWriteBuffer, buffer);
  if (size < buffer.size) {
    // Not enough data to fill the buffer, we invalidate the whole buffer to allow driver to rename buffer.
    glBufferSubData(glTarget, 0, buffer.size, nullptr);
    glBufferSubData(glTarget, 0, static_cast<GLsizei>(size), data);
  }
  else {
    glBufferSubData(glTarget, 0, buffer.size, data);
  }
  if(uploadStatisticsEnabled) uploadStatisticsBufferUpload(buffer.size);
 
}
 
void Cogs::ContextGLES30::updateSubTexture(TextureHandle textureHandle, const size_t level, const void * data)
{
  TextureGLES30* texture = bindTexture(textureHandle);
  if (texture) {
    const OpenGLES30::DataFormatInfo& fmt = OpenGLES30::DataFormats[size_t(texture->format)];
    if (fmt.isTextureFormat && fmt.isCompressed == 0) {
      glTexSubImage2D(texture->target, static_cast<GLint>(level), 0, 0, texture->width, texture->height, fmt.format, fmt.type, data);
      if(uploadStatisticsEnabled) uploadStatisticsTextureUpload(texture->estimatedByteSize); // TODO size?
    }
  }
}
 
void Cogs::ContextGLES30::copyTexture(TextureHandle dstHandle, unsigned dstSub, unsigned dstX, unsigned dstY, unsigned dstZ, TextureHandle srcHandle, unsigned srcSub)
{
  TextureGLES30* dstTexture = bindTexture(dstHandle);
  if (!dstTexture) {
    LOG_ERROR_ONCE(logger, "copyTexture: invalid destination texture");
    return;
  }
 
  if (!HandleIsValid(srcHandle)) {
    LOG_ERROR_ONCE(logger, "copyTexture: invalid source texture");
    return;
  }
 
  bool checkCompleteness = false;
  GLuint srcFbo = 0; // Source FBO if needed
 
  TextureGLES30& srcTexture = textures->textures[srcHandle];
  if (srcTexture.textureId == 0) {
    LOG_ERROR_ONCE(logger, "copyTexture: Cannot copy from null texture");
    return;
  }
 
  if (srcTexture.target == GL_TEXTURE_2D && srcSub == 0) {
    if (srcTexture.fbo) {
      glBindFramebuffer(GL_READ_FRAMEBUFFER, srcTexture.fbo);
    }
    else {
      glGenFramebuffers(1, &srcTexture.fbo);
      glBindFramebuffer(GL_READ_FRAMEBUFFER, srcTexture.fbo);
      glFramebufferTexture2D(GL_READ_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, srcTexture.textureId, 0);
      checkCompleteness = true;
    }
  }
 
  else if (srcTexture.target == GL_TEXTURE_2D_ARRAY || srcTexture.target == GL_TEXTURE_3D) {
    // For 3D/array textures the fbo is specific to subresource, so we don't bother to try
    // recycling it like we do for 2D textures, and just create a temporary fbo
    glGenFramebuffers(1, &srcFbo);
    glBindFramebuffer(GL_READ_FRAMEBUFFER, srcFbo);
    glFramebufferTextureLayer(GL_READ_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, srcTexture.textureId, 0, srcSub);
    checkCompleteness = true;
  }
 
  
  if (checkCompleteness) {
    GLenum status = glCheckFramebufferStatus(GL_DRAW_FRAMEBUFFER);
    if (status != GL_FRAMEBUFFER_COMPLETE) {
      LOG_ERROR_ONCE(logger, "copyTexture: Failed to create source framebuffer: %s", OpenGLES30::framebuffersStatusString(status));
      glBindFramebuffer(GL_FRAMEBUFFER, 0);
      currentRenderTarget = RenderTargetHandle::InvalidHandle;
      currentDepthStencilTarget = DepthStencilHandle::InvalidHandle;
      return;
    }
  }
 
 
  if (dstTexture->target == GL_TEXTURE_2D) {
    glCopyTexSubImage2D(GL_TEXTURE_2D,
                        dstSub,
                        dstX, dstY,
                        0, 0, srcTexture.width, srcTexture.height);
  }
 
  else if (dstTexture->target == GL_TEXTURE_2D_ARRAY || dstTexture->target == GL_TEXTURE_3D) {
    unsigned dstLevel = 0;      // TODO dstSub%LevelCount
    unsigned dstLayer = dstSub; // TODO dstSub/LevelCount
    glCopyTexSubImage3D(dstTexture->target, dstLevel,
                        dstX, dstY, dstZ + dstLayer,
                        0, 0, srcTexture.width, srcTexture.height);
 
  }
 
  else {
    LOG_ERROR_ONCE(logger, "copyTexture: unsupported combination of source and destination texture");
  }
 
 
  glBindFramebuffer(GL_FRAMEBUFFER, 0);
  currentRenderTarget = RenderTargetHandle::InvalidHandle;
  currentDepthStencilTarget = DepthStencilHandle::InvalidHandle;
 
  if (srcFbo != 0) {
    glDeleteFramebuffers(1, &srcFbo);
  }
 
  return;
}
 
 
 
void Cogs::ContextGLES30::updateSubBuffer(BufferHandle bufferHandle, const size_t offset, const size_t size, const void * data)
{
  if (!HandleIsValid(bufferHandle)) {
    LOG_ERROR_ONCE(logger, "updateSubBuffer: invalid handle");
    return;
  }
  BufferGLES30& buffer = buffers->buffers[bufferHandle];
  if (buffer.size < offset + size) {
    LOG_ERROR_ONCE(logger, "updateSubBuffer: updating outside of buffer bounds");
    return;
  }
  GLenum glTarget = bindBufferCopy(buffer.target, buffer);
  glBufferSubData(glTarget, static_cast<GLintptr>(offset), static_cast<GLsizei>(size), data);
  if(uploadStatisticsEnabled) uploadStatisticsBufferUpload(size);
}
 
void Cogs::ContextGLES30::setBuffer(const BufferBindingHandle /*bufferBindingHandle*/, BufferHandle /*bufferHandle*/)
{
  return;
}
 
void Cogs::ContextGLES30::setBufferCounter(BufferHandle /*bufferHandle*/, uint32_t /*value*/)
{
  return;
}
 
void Cogs::ContextGLES30::setBufferCounter(BufferHandle /*bufferHandle*/, BufferHandle /*sourceBufferHandle*/)
{
  return;
}
 
void Cogs::ContextGLES30::getBufferCounter(BufferHandle /*bufferHandle*/, BufferHandle /*destinationBufferHandle*/)
{
  return;
}
 
uint32_t Cogs::ContextGLES30::getBufferCounter(BufferHandle /*bufferHandle*/)
{
  return 0;
}
 
void Cogs::ContextGLES30::copyResource(BufferHandle destinationHandle, BufferHandle sourceHandle)
{
  if (!HandleIsValid(destinationHandle)) {
    LOG_ERROR_ONCE(logger, "copyResource: destination buffer is invalid");
    return;
  }
  BufferGLES30& dstBuffer = buffers->buffers[destinationHandle];
  GLenum dstTarget = bindBufferCopy(OpenGLES30::BufferTarget::CopyWriteBuffer, dstBuffer);
 
  if (!HandleIsValid(sourceHandle)) {
    LOG_ERROR_ONCE(logger, "copyResource: source buffer is invalid");
    return;
  }
  BufferGLES30& srcBuffer = buffers->buffers[sourceHandle];
  GLenum srcTarget = bindBuffer(OpenGLES30::BufferTarget::CopyReadBuffer, srcBuffer.bufferId);
 
  if (srcTarget == dstTarget) {
    LOG_ERROR_ONCE(logger, "copyResource: Ending up copying from and to the same target (0x%04x)", srcTarget);
    return;
  }
 
  glCopyBufferSubData(srcTarget, dstTarget, 0, 0, srcBuffer.size);
}
 
void Cogs::ContextGLES30::copyResource(TextureHandle targetTextureHandle, TextureHandle sourceTextureHandle)
{
  // Reuse the resolveResource() for texture copies (uses glBlitFramebuffer()...)
  resolveResource(sourceTextureHandle, targetTextureHandle);
}
 
void Cogs::ContextGLES30::reset()
{
  return;
}