ContextGL20.cpp

#include "ContextGL20.h"
 
#include "BuffersGL20.h"
#include "TexturesGL20.h"
#include "EffectsGL20.h"
#include "RenderTargetsGL20.h"
#include "FormatsGL20.h"
 
#include "Foundation/Logging/Logger.h"
 
using namespace Cogs;
 
namespace
{
  static Cogs::Logging::Log logger = Cogs::Logging::getLogger("ContextGL20");
 
  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));
 
}
 
namespace Cogs
{
  namespace OpenGL20
  {
    
    GLenum DepthFunctions[] = {
      GL_NEVER,
      GL_LESS,
      GL_LEQUAL,
      GL_EQUAL,
      GL_GEQUAL,
      GL_GREATER,
      GL_NOTEQUAL,
      GL_ALWAYS,
    };
 
    const GLenum Framebuffers[] = {
      GL_FRONT,
      GL_BACK,
    };
 
    GLenum MappingModes[] = {
      GL_READ_ONLY,
      GL_WRITE_ONLY,
      GL_READ_WRITE,
      GL_INVALID_ENUM,
    };
  }
 
  void copySubBuffer(GLenum /*dstTarget*/, GLuint dstBuffer, GLintptr dstOffset,
                     GLenum /*srcTarget*/, GLuint srcBuffer, GLintptr srcOffset, GLsizeiptr size)
  {
#ifndef __APPLE__
    if (glCopyNamedBufferSubData) {
      glCopyNamedBufferSubData(srcBuffer, dstBuffer, srcOffset, dstOffset, size);
    } else
#endif
    {
      glBindBuffer(GL_COPY_READ_BUFFER, srcBuffer);
      glBindBuffer(GL_COPY_WRITE_BUFFER, dstBuffer);
      glCopyBufferSubData(GL_COPY_READ_BUFFER, GL_COPY_WRITE_BUFFER, srcOffset, dstOffset, size);
      glBindBuffer(GL_COPY_READ_BUFFER, 0);
      glBindBuffer(GL_COPY_WRITE_BUFFER, 0);
    }
  }
}
 
Cogs::ContextGL20::ContextGL20() :
  defaultSamplerStateHandle(SamplerStateHandle::NoHandle),
  currentEffect(EffectHandle::NoHandle),
  currentRenderTarget(RenderTargetHandle::NoHandle)
{
  for (size_t i = 0; i < sizeof(boundTextures)/sizeof(boundTextures[0]); ++i) {
    boundTextures[i] = TextureHandle::NoHandle;
    boundTarget[i] = 0;
  }
  for (size_t i = 0; i < sizeof(boundSamplerStates)/sizeof(boundSamplerStates[0]); ++i) {
    boundSamplerStates[i] = SamplerStateHandle::NoHandle;
  }
}
 
void Cogs::ContextGL20::initialize(CapabilitiesGL20 * capabilities, BuffersGL20 * buffers, TexturesGL20 * textures, EffectsGL20 * effects, RenderTargetsGL20 * renderTargets, GLSyncObjects* sync) {
  this->capabilities = capabilities;
  this->buffers = buffers;
  this->textures = textures;
  this->effects = effects;
  this->renderTargets = renderTargets;
  this->syncObjects = sync;
  glGenVertexArrays(1, &vao);
}
 
void Cogs::ContextGL20::releaseResources() {
  glDeleteVertexArrays(1, &vao);
  vao = GL_ZERO;
}
 
// Avoid warnings from packing integer offset in GLvoid argument.
#ifdef _WIN32
#pragma warning(push)
#pragma warning(disable : 4312)
#endif
 
void Cogs::ContextGL20::signal(FenceHandle fenceHandle)
{
  syncObjects->signal(fenceHandle);
}
 
void Cogs::ContextGL20::setupVertexAttributes()
{
  for (size_t b = 0; b < iaState.numVertexBuffers; ++b) {
    BufferGL20 &buffer = *iaState.currentVertexBuffers[b];
    const VertexFormat &vertexFormat = *iaState.formats[b];
    const GLsizei structSize = static_cast<GLsizei>(iaState.strides[b]);
    const GLuint bufferId = static_cast<GLuint>(buffer.bufferId);
 
    glBindBuffer(GL_ARRAY_BUFFER, bufferId);
 
    for (size_t i = 0; i < vertexFormat.elements.size(); ++i) {
      const VertexElement &element = vertexFormat.elements[i];
      const GLint index = static_cast<GLint>(element.semanticIndex * NumAttributeSemanticsGL20 + static_cast<int>(element.semantic));
 
      assert(this->currentAttributeMap && "Attribute map not valid.");
      const GLint attributeIndex = this->currentAttributeMap[index];
 
      if (attributeIndex != InvalidAttributeLocationGL20) {
        const GLvoid * offset = reinterpret_cast<const GLvoid *>(element.offset);
        const GLenum format = OpenGL20::ElementFormats[(int)element.format];
        const unsigned int size = getFormatInfo(element.format)->elements;
 
        if (element.inputType == InputType::InstanceData) {
          if (element.semantic == ElementSemantic::InstanceMatrix) {
            for (GLuint a = 0; a < 4; ++a) {
              glVertexAttribPointer(attributeIndex + a, 4, format, GLboolean(GL_TRUE), structSize, reinterpret_cast<const GLvoid *>(sizeof(GLfloat) * a * 4));
              glEnableVertexAttribArray(attributeIndex + a);
              glVertexAttribDivisor(attributeIndex + a, element.instanceStep);
 
              this->enabledAttributes.push_back(attributeIndex);
            }
          } else {
            glVertexAttribPointer(attributeIndex, size, format, GLboolean(GL_TRUE), structSize, offset);
            glEnableVertexAttribArray(attributeIndex);
            glVertexAttribDivisor(attributeIndex, element.instanceStep);
            this->enabledAttributes.push_back(attributeIndex);
          }
        } else {
          if(format == GL_UNSIGNED_INT_2_10_10_10_REV)
            glVertexAttribPointer(attributeIndex, size, format, GLboolean(GL_TRUE), structSize, offset);
          else
            glVertexAttribPointer(attributeIndex, size, format, GLboolean(GL_TRUE), structSize, offset);
          glEnableVertexAttribArray(attributeIndex);
          this->enabledAttributes.push_back(attributeIndex);
 
          glVertexAttribDivisor(attributeIndex, element.instanceStep);
        }
      }
    }
  }
 
  if(iaState.currentIndexBuffer)
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, iaState.currentIndexBuffer->bufferId);
  else
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
 
  this->needVertexAttributeSetup = false;
}
 
#ifdef _WIN32
#pragma warning(pop)
#endif
 
void Cogs::ContextGL20::setIndexBuffer(IndexBufferHandle indexBufferHandle, uint32_t stride, uint32_t offset)
{
  assert(offset == 0);
  if(indexBufferHandle == IndexBufferHandle::NoHandle){
    iaState.currentIndexBuffer = nullptr;
    iaState.indexBufferStride = 0;
    return;
  }
  auto & buffer = this->buffers->buffers[indexBufferHandle];
  iaState.currentIndexBuffer = &buffer;
  iaState.indexBufferStride = stride ? stride : buffer.indexSize;
}
 
void Cogs::ContextGL20::setConstantBuffer(const ConstantBufferBindingHandle bufferBindingHandle, const BufferHandle bufferHandle, const uint32_t offset, const uint32_t /*size*/)
{
  assert(offset == 0);
  auto & effect = effects->effects[currentEffect];
 
  const auto index = static_cast<GLuint>(bufferBindingHandle.handle & 0xFFFFFFFF);
 
  if (HandleIsValid(bufferHandle) && index != GL_INVALID_INDEX) {
    auto & buffer = this->buffers->buffers[bufferHandle];
 
    glBindBufferBase(GL_UNIFORM_BUFFER, index, buffer.bufferId);
    glUniformBlockBinding(this->currentProgramId, index, index);
 
    for (size_t i = 0; i < ShaderType::NumShaderTypes; ++i) {
      for (auto & constantBuffer : effect.shaders[i].reflection.constantBuffers) {
        if (constantBuffer.slot == index) {
          constantBuffer.manual = true;
        }
      }
    }
  } else {
    if (index != GL_INVALID_INDEX) {
      glBindBufferBase(GL_UNIFORM_BUFFER, index, 0);
      glUniformBlockBinding(this->currentProgramId, index, index);
    }
  }
}
 
void Cogs::ContextGL20::drawIndexed(PrimitiveType primitiveType, const size_t startIndex, const size_t numIndexes, const size_t startVertex)
{
  if(!HandleIsValid(this->currentEffect)){
    LOG_INFO(logger, "Draw with no effect active.");
    return;
  }
  if (this->needVertexAttributeSetup) {
    this->setupVertexAttributes();
  }
  assert(iaState.currentIndexBuffer); // Must have index buffer bound
 
  GLenum indexType = GL_UNSIGNED_INT;
  if (iaState.indexBufferStride == 2) {
    indexType = GL_UNSIGNED_SHORT;
  }
 
  const GLenum glPrimitiveType = OpenGL20::PrimitiveFormats[static_cast<uint32_t>(primitiveType)];
  const GLsizei count = static_cast<GLsizei>(numIndexes ? numIndexes : iaState.currentIndexBuffer->count);
  const GLvoid * indexOffset = reinterpret_cast<const GLvoid *>(startIndex * ((indexType == GL_UNSIGNED_INT) ? sizeof(GLuint) : sizeof(GLushort)));
 
  preDraw();
  glDrawElementsBaseVertex(glPrimitiveType, count, indexType, (void*)indexOffset, static_cast<GLint>(startVertex));
  postDraw();
 
  if (frameStatisticsEnabled) { frameStatisticsAccountDrawCall(count, true); }
}
 
void Cogs::ContextGL20::draw(PrimitiveType primitiveType, const size_t startVertex, const size_t numVertexes)
{
  if(!HandleIsValid(this->currentEffect)){
    LOG_INFO(logger, "Draw with no effect active.");
    return;
  }
  if (this->needVertexAttributeSetup) {
    this->setupVertexAttributes();
  }
 
  const GLenum glPrimitiveType = OpenGL20::PrimitiveFormats[static_cast<uint32_t>(primitiveType)];
 
  preDraw();
  glDrawArrays(glPrimitiveType, static_cast<GLint>(startVertex), static_cast<GLsizei>(numVertexes));
  postDraw();
 
  if (frameStatisticsEnabled) { frameStatisticsAccountDrawCall(numVertexes, false); }
}
 
void Cogs::ContextGL20::drawInstanced(PrimitiveType primitiveType, const size_t startVertex, const size_t numVertexes, const size_t startInstance, const size_t numInstances)
{
  if(!HandleIsValid(this->currentEffect)){
    LOG_INFO(logger, "Draw with no effect active.");
    return;
  }
  if (this->needVertexAttributeSetup) {
    this->setupVertexAttributes();
  }
 
  const GLenum glPrimitiveType = OpenGL20::PrimitiveFormats[static_cast<uint32_t>(primitiveType)];
 
  preDraw();
#ifndef __APPLE__
  if (glDrawArraysInstancedBaseInstance) {
    glDrawArraysInstancedBaseInstance(glPrimitiveType, static_cast<GLint>(startVertex), static_cast<GLsizei>(numVertexes), static_cast<GLsizei>(numInstances), static_cast<GLuint>(startInstance));
  } else
#endif
  {
    assert(startInstance == 0);
    glDrawArraysInstanced(glPrimitiveType, static_cast<GLint>(startVertex), static_cast<GLsizei>(numVertexes), static_cast<GLsizei>(numInstances));
  }
  postDraw();
 
  if (frameStatisticsEnabled) { frameStatisticsAccountDrawCall(numVertexes * numInstances, false); }
}
 
void Cogs::ContextGL20::drawInstancedIndexed(PrimitiveType primitiveType, const size_t startInstance, const size_t numInstances, const size_t startIndex, const size_t numIndexes)
{
  if(!HandleIsValid(this->currentEffect)){
    LOG_INFO(logger, "Draw with no effect active.");
    return;
  }
  if (this->needVertexAttributeSetup) {
    this->setupVertexAttributes();
  }
  assert(iaState.currentIndexBuffer); // Must have index buffer bound
 
  const GLenum    glPrimitiveType = OpenGL20::PrimitiveFormats[static_cast<uint32_t>(primitiveType)];
  const GLsizei   count = static_cast<GLsizei>(numIndexes ? numIndexes : iaState.currentIndexBuffer->count);
  const GLvoid *  indexOffset = reinterpret_cast<const GLvoid *>(startIndex * iaState.indexBufferStride);
  GLenum          indexType = (iaState.indexBufferStride == 2) ? GL_UNSIGNED_SHORT : GL_UNSIGNED_INT;
 
  preDraw();
#ifndef __APPLE__
  if (glDrawElementsInstancedBaseInstance) {
    glDrawElementsInstancedBaseInstance(glPrimitiveType, count, indexType, indexOffset, static_cast<GLsizei>(numInstances), static_cast<GLuint>(startInstance));
  } else
#endif
  {
    assert(startInstance == 0);
    glDrawElementsInstanced(glPrimitiveType, count, indexType, indexOffset, static_cast<GLsizei>(numInstances));
  }
  postDraw();
 
  if (frameStatisticsEnabled) { frameStatisticsAccountDrawCall(count * numInstances, true); }
}
 
void Cogs::ContextGL20::setVertexBuffers(const VertexBufferHandle * handles, const size_t count)
{
  uint32_t strides[kMaxVertexInputSlots];
  uint32_t offsets[kMaxVertexInputSlots];
 
  for (size_t i = 0; i < count; i++) {
    auto & buffer = buffers->buffers[BufferHandle(handles[i].handle)];
 
    assert(buffer.vertexFormat && "Vertex buffer must have been created with format information attached.");
 
    strides[i] = getSize(*buffer.vertexFormat);
    offsets[i] = 0;
  }
 
  setVertexBuffers(handles, count, strides, offsets);
}
 
void Cogs::ContextGL20::setVertexBuffers(const VertexBufferHandle * handles, const size_t count, const uint32_t * strides, const uint32_t * offsets)
{
  clearInputState();
 
  iaState.numVertexBuffers = count;
 
  for (size_t i = 0; i < count; i++) {
    BufferGL20 &buffer = buffers->buffers[BufferHandle(handles[i].handle)];
    iaState.currentVertexBuffers[i] = &buffer;
    iaState.strides[i] = strides[i];
    iaState.offsets[i] = offsets ? offsets[i] : 0;
  }
 
  needVertexAttributeSetup = true;
}
 
void Cogs::ContextGL20::setBlendState(const BlendStateHandle handle, const float* constant)
{
  if (!HandleIsValid(handle)) {
    glDisable(GL_BLEND);
    return;
  }
 
  const BlendStateGL20 & blendState = renderTargets->blendStates[handle];
 
  if (blendState.color.enabled || blendState.alpha.enabled) {
    glEnable(GL_BLEND);
    glBlendFuncSeparate(Blends[size_t(blendState.color.enabled ? blendState.color.sourceBlend : BlendState::Blend::One)],
                        Blends[size_t(blendState.color.enabled ? blendState.color.destinationBlend : BlendState::Blend::Zero)],
                        Blends[size_t(blendState.alpha.enabled ? blendState.alpha.sourceBlend : BlendState::Blend::One)],
                        Blends[size_t(blendState.alpha.enabled ? blendState.alpha.destinationBlend : BlendState::Blend::Zero)]);
    glBlendEquationSeparate(BlendOperations[size_t(blendState.color.enabled ? blendState.color.operation : BlendState::BlendOperation::Add)],
                            BlendOperations[size_t(blendState.alpha.enabled ? blendState.alpha.operation : BlendState::BlendOperation::Add)]);
    if (constant) {
      glBlendColor(constant[0], constant[1], constant[2], constant[3]);
    }
  } else {
    glDisable(GL_BLEND);
  }
}
 
 
 
 
Cogs::EffectHandle Cogs::ContextGL20::getCurrentEffect()
{
  return this->currentEffect;
}
 
Cogs::IEffects * Cogs::ContextGL20::getEffects() { return effects; }
 
void Cogs::ContextGL20::beginRenderPass(const RenderPassInfo &info)
{
  assert(!inRenderPass);
  setRenderTarget(info.renderTargetHandle, info.depthStencilHandle);
  {
    auto & renderTarget = renderTargets->renderTargets[currentRenderTarget];
    for (uint32_t i = 0; i < renderTarget.numTextures; ++i) {
      if(info.loadOp[i] == LoadOp::Clear){
        glClearBufferfv(GL_COLOR, i, info.clearValue[i]);
      }
    }
  }
  if(info.depthLoadOp == LoadOp::Clear){
    glClearBufferfv(GL_DEPTH, 0, &info.depthClearValue);
  }
  inRenderPass = true;
  renderPassInfo = info;
}
 
void Cogs::ContextGL20::endRenderPass()
{
  assert(inRenderPass);
  if(HandleIsValid(renderPassInfo.renderTargetHandle)){
    RenderTargetGL20 &target = renderTargets->renderTargets[renderPassInfo.renderTargetHandle];
    for(size_t i=0; i<target.numTextures; i++){
      if(HandleIsValid(renderPassInfo.resolveHandle[i])){
        resolveResource(target.textures[i], TextureHandle(renderPassInfo.resolveHandle[i].handle));
      }
    }
  }
  inRenderPass = false;
  renderPassInfo = {};
}
 
void Cogs::ContextGL20::setRenderTarget(const RenderTargetHandle handle, const DepthStencilHandle depthStencilHandle)
{
  // TODO: Here we need to generate combinations of RenderTargetHandle and DepthStencilHandle.
  this->currentRenderTarget = handle;
 
  static GLenum buffers[OpenGL20::kMaxRenderTargets];
  if (HandleIsValid(handle)) {
    const RenderTargetGL20 & renderTarget = this->renderTargets->renderTargets[handle];
 
    glBindFramebuffer(GL_FRAMEBUFFER, renderTarget.frameBuffer);
 
    if (renderTarget.numTextures) {
      for (GLint i = 0; i < static_cast<GLint>(renderTarget.numTextures); ++i) {
        buffers[i] = GL_COLOR_ATTACHMENT0 + i;
      }
 
      glDrawBuffers(static_cast<GLsizei>(renderTarget.numTextures), buffers);
    } else {
      buffers[0] = GL_NONE;
      glDrawBuffers(1, buffers);
    }
  } else if(HandleIsValid(depthStencilHandle)) {
    const DepthStencilTargetGL20 & depthTarget = this->renderTargets->depthStencils[depthStencilHandle];
    const RenderTargetGL20 & renderTarget = this->renderTargets->renderTargets[depthTarget.renderTarget];
    glBindFramebuffer(GL_FRAMEBUFFER, renderTarget.frameBuffer);
    {
      buffers[0] = GL_NONE;
      glDrawBuffers(1, buffers);
    }
  } else {
    glBindFramebuffer(GL_FRAMEBUFFER, 0);
 
    glDrawBuffer(GL_BACK);
  }
}
 
void Cogs::ContextGL20::setViewport(const float x, const float y, const float width, const float height)
{
  glViewport(static_cast<GLint>(x), static_cast<GLint>(y), static_cast<GLint>(width), static_cast<GLint>(height));
}
 
void Cogs::ContextGL20::setScissor(const int x, const int y, const int width, const int height)
{
  glScissor(x, y, width, height);
}
 
void Cogs::ContextGL20::clearRenderTarget(const float * color)
{
  glClearColor(color[0], color[1], color[2], color[3]);
 
  glClear(GL_COLOR_BUFFER_BIT);
}
 
void Cogs::ContextGL20::clearRenderTarget(const float ** colors, const int /*count*/)
{
  auto color = colors[0];
 
  glClearColor(color[0], color[1], color[2], color[3]);
 
  glClear(GL_COLOR_BUFFER_BIT);
}
 
void Cogs::ContextGL20::clearDepth(const float depth)
{
  if (HandleIsValid(currentDepthStencilState)) {
    const auto & depthState = renderTargets->depthStencilStates[currentDepthStencilState];
 
    if (!depthState.writeEnabled) {
      // Enable depth writes, since disabled depth writes makes glClearDepth ineffective.
      glDepthMask(GLboolean(GL_TRUE));
    }
  }
 
  glClearDepth(depth);
 
  glClear(GL_DEPTH_BUFFER_BIT);
}
 
void Cogs::ContextGL20::setTexture(const TextureBindingHandle textureBindingHandle, const TextureHandle textureHandle)
{
  if (!textureBindingHandle) return;
 
  auto slot = static_cast<unsigned>(textureBindingHandle.handle & 0xFFFF);
  assert(slot < sizeof(this->boundTextures)/sizeof(this->boundTextures[0]));
  if (this->boundTextures[slot] == textureHandle) return;
 
  glActiveTexture(GL_TEXTURE0 + slot);
 
  if (HandleIsValid(textureHandle)) {
    auto & texture = this->textures->textures[textureHandle];
    if(boundTarget[slot] && (boundTarget[slot] != texture.type))
      glBindTexture(boundTarget[slot], 0);
    glBindTexture(texture.type, texture.textureId);
    boundTarget[slot] = texture.type;
 
#ifndef __APPLE__
    if (glBindImageTexture && texture.flags & TextureFlags::ReadWriteTexture) {
      assert(slot < maxImageUnits);
      glBindImageTexture(slot, texture.textureId, 0, GLboolean(GL_FALSE), 0, GL_READ_WRITE, GL_RGBA8);
    }
#endif
  } else {
    if(boundTarget[slot])
      glBindTexture(boundTarget[slot], 0);
#ifndef __APPLE__
    if (glBindImageTexture && slot<maxImageUnits) {
      glBindImageTexture(slot, 0, 0, GLboolean(GL_FALSE), 0, GL_READ_WRITE, GL_RGBA8);
    }
#endif
  }
 
  this->boundTextures[slot] = textureHandle;
}
void Cogs::ContextGL20::setTexture(const TextureBindingHandle textureBindingHandle, TextureViewHandle textureViewHandle)
{
  setTexture(textureBindingHandle, TextureHandle(textureViewHandle.handle));
}
void Cogs::ContextGL20::setSamplerState(const SamplerStateBindingHandle samplerStateBindingHandle, const SamplerStateHandle samplerStateHandle)
{
  if (!samplerStateBindingHandle) return;
 
  auto ptr = (SamplerMapGL20*)(size_t)samplerStateBindingHandle.handle;
 
  EffectHandle effectHandle = ptr->effectHandle;
  auto & effect = effects->effects[effectHandle];
  auto hash = ptr->name;
 
  auto &samplers = effect.real_sampler[hash];
  for(auto h2 : samplers){
    if (!effect.samplers.count(h2)) {
      continue;
    }
    auto tmp = effect.samplers[h2];
    uint32_t base_slot = tmp.first;
    uint32_t count = tmp.second;
    for(uint32_t i=0; i<count; i++){
      uint32_t slot = base_slot+i;
      assert(slot < sizeof(this->boundSamplerStates)/sizeof(this->boundSamplerStates[0]));
      if (HandleIsValid(samplerStateHandle) &&
          samplerStateHandle == this->boundSamplerStates[slot]) continue;
      this->boundSamplerStates[slot] = samplerStateHandle;
 
      GLuint sampler;
      if (HandleIsValid(samplerStateHandle)) {
        sampler = static_cast<GLuint>(samplerStateHandle.handle);
      } else {
        if (defaultSamplerStateHandle == SamplerStateHandle::NoHandle) {
          defaultSamplerStateHandle = this->textures->loadSamplerState(SamplerState::DefaultState());
        }
        sampler = static_cast<GLuint>(defaultSamplerStateHandle.handle);
      }
      glBindSampler(slot, sampler);
    }
  }
}
 
void Cogs::ContextGL20::setRasterizerState(const RasterizerStateHandle handle)
{
  const RasterizerState & rasterizerState = (handle == RasterizerStateHandle::NoHandle) ? RasterizerState::DefaultState() : this->renderTargets->rasterizerStates[handle];
 
  glPolygonMode(GL_FRONT_AND_BACK, rasterizerState.wireFrame ? GL_LINE : GL_FILL);
  glFrontFace(rasterizerState.frontCounterClockwise ? GL_CCW : GL_CW);
 
  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 (rasterizerState.depthBias != 0 || rasterizerState.slopeScaledDepthBias != 0) {
    glEnable(GL_POLYGON_OFFSET_FILL);
    glPolygonOffset(rasterizerState.slopeScaledDepthBias, rasterizerState.depthBias);
  } else {
    glDisable(GL_POLYGON_OFFSET_FILL);
  }
 
  rasterizerState.scissor ? glEnable(GL_SCISSOR_TEST) : glDisable(GL_SCISSOR_TEST);
 
  rasterizerState.noDepthClip ? glEnable(GL_DEPTH_CLAMP) : glDisable(GL_DEPTH_CLAMP);
}
 
void Cogs::ContextGL20::setDepthStencilState(const DepthStencilStateHandle handle)
{
  currentDepthStencilState = handle;
 
  const DepthStencilState & depthStencilState = (handle == DepthStencilStateHandle::NoHandle) ? DepthStencilState::DefaultState() : this->renderTargets->depthStencilStates[handle];
 
  depthStencilState.depthEnabled ? glEnable(GL_DEPTH_TEST) : glDisable(GL_DEPTH_TEST);
  depthStencilState.writeEnabled ? glDepthMask(GLboolean(GL_TRUE)) : glDepthMask(GLboolean(GL_FALSE));
  glDepthFunc(OpenGL20::DepthFunctions[depthStencilState.depthFunction]);
}
 
void Cogs::ContextGL20::setEffect(EffectHandle effectHandle)
{
  if (effectHandle == currentEffect) return;
 
  state = {};
 
  // Copy atomic counters from effect atomic counter store to buffer store.
  if (HandleIsValid(currentEffect)) {
    for (const auto & mapping : atomicCounterMappings) {
      syncCounterFromEffect(mapping);
    }
  }
  atomicCounterMappings.clear();
 
  for (size_t i = 0; i < sizeof(boundTextures)/sizeof(boundTextures[0]); ++i) {
    if (HandleIsValid(boundTextures[i])) {
      glActiveTexture(static_cast<GLenum>(GL_TEXTURE0 + i));
      if(boundTarget[i])
        glBindTexture(boundTarget[i], 0);
#ifndef __APPLE__
      if(glBindImageTexture && i < maxImageUnits) {
        glBindImageTexture(static_cast<GLuint>(i), 0, 0, GLboolean(GL_FALSE), 0, GL_READ_WRITE, GL_RGBA8);
      }
#endif
      boundTextures[i] = TextureHandle::NoHandle;
    }
  }
  for (size_t i = 0; i < sizeof(boundSamplerStates)/sizeof(boundSamplerStates[0]); ++i) {
    if (HandleIsValid(boundSamplerStates[i])) {
      glBindSampler(static_cast<GLuint>(i), 0);
      boundSamplerStates[i] = SamplerStateHandle::NoHandle;
    }
  }
 
  this->currentEffect = effectHandle;
 
  if (HandleIsValid(effectHandle)) {
    auto & effect = this->effects->effects[effectHandle];
    ContextCommon::setCurrentEffect(&effect);
 
    glUseProgram(this->effects->effects[effectHandle].programId);
 
    this->currentAttributeMap = effect.attributeMap;
    this->currentProgramId = effect.programId;
 
    atomicCounterMappings.clear();
    for (const auto & b : effect.atomicCounterBuffers) {
      glBindBufferBase(GL_ATOMIC_COUNTER_BUFFER, b.binding, effects->backingBuffers[b.backingBuffer]);
    }
 
  } else {
    glUseProgram(0);
 
    this->currentAttributeMap = nullptr;
    this->currentProgramId = GL_INVALID_INDEX;
  }
 
  this->needVertexAttributeSetup = true;
}
 
void Cogs::ContextGL20::setInputLayout(const InputLayoutHandle inputLayoutHandle)
{
  if(HandleIsValid(inputLayoutHandle)){
    InputLayoutGL20 &inputLayout = buffers->inputLayouts[inputLayoutHandle];
 
    this->clearInputState();
 
    iaState.numVertexBuffers = inputLayout.numFormats;
    for (size_t i = 0; i < inputLayout.numFormats; ++i) {
      iaState.formats[i] = inputLayout.formats[i];
    }
 
    this->needVertexAttributeSetup = true;
  }
  else{
    this->clearInputState();
  }
}
 
void Cogs::ContextGL20::clearInputState()
{
  for (size_t i = 0; i < this->enabledAttributes.size(); ++i) {
    glDisableVertexAttribArray(this->enabledAttributes[i]);
  }
  this->enabledAttributes.clear();
 
  this->needVertexAttributeSetup = true;
}
 
void Cogs::ContextGL20::resolveResource(TextureHandle source, TextureHandle destination)
{
  bool depth = false;
 
  auto & sourceTexture = this->textures->textures[source];
  auto & targetTexture = this->textures->textures[destination];
 
  RenderTargetGL20 * sourceTarget = nullptr;
 
  for (auto & rt : renderTargets->renderTargets) {
    for (size_t i = 0; i < rt.numTextures; ++i) {
      if (rt.textures[i] == source) {
        sourceTarget = &rt;
        break;
      }
    }
  }
 
  if (!sourceTarget) return;
 
  assert(targetTexture.numSamples == 1 && "Cannot resolve to multisample target.");
  glBindTexture(GL_TEXTURE_2D, targetTexture.textureId);
 
  GLuint targetFrameBuffer = 0;
  glGenFramebuffers(1, &targetFrameBuffer);
 
  assert(sourceTexture.width == targetTexture.width && "Source and target texture dimensions not equal.");
 
  glDisable(GL_SCISSOR_TEST);
 
  if (sourceTexture.numSamples > 1 && !depth) {
    glBindFramebuffer(GL_READ_FRAMEBUFFER, sourceTarget->frameBuffer);
    glBindFramebuffer(GL_DRAW_FRAMEBUFFER, targetFrameBuffer);
 
    if (!depth) {
      glFramebufferTexture2D(GL_DRAW_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, targetTexture.textureId, 0);
      glBlitFramebuffer(0, 0, sourceTexture.width, sourceTexture.height, 0, 0, targetTexture.width, targetTexture.height, GL_COLOR_BUFFER_BIT, GL_NEAREST);
    }
    else {
      glFramebufferTexture2D(GL_DRAW_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_TEXTURE_2D, targetTexture.textureId, 0);
      glBlitFramebuffer(0, 0, sourceTexture.width, sourceTexture.height, 0, 0, targetTexture.width, targetTexture.height, GL_DEPTH_BUFFER_BIT, GL_NEAREST);
    }
 
    glBindFramebuffer(GL_READ_FRAMEBUFFER, 0);
    glBindFramebuffer(GL_DRAW_FRAMEBUFFER, 0);
  }
  else if (sourceTexture.numSamples > 1 && depth) {
    // NOTE: Resolving multisampled depth textures are not supported.
    assert(depth == false && "Cannot resolve from multisample depth target.");
  }
  else {
    glBindFramebuffer(GL_FRAMEBUFFER, sourceTarget->frameBuffer);
 
    if (!depth) {
      glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, sourceTexture.textureId, 0);
    }
    else {
      glFramebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_TEXTURE_2D, sourceTexture.textureId, 0);
    }
 
    glCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 0, 0, sourceTexture.width, sourceTexture.height);
    glBindFramebuffer(GL_FRAMEBUFFER, 0);
  }
 
  glBindTexture(GL_TEXTURE_2D, 0);
  glDeleteFramebuffers(1, &targetFrameBuffer);
}
 
void Cogs::ContextGL20::setDefaults()
{
  glBindVertexArray(vao);
 
  state = {};
 
  setBlendState(BlendStateHandle::NoHandle, nullptr);
  setDepthStencilState(DepthStencilStateHandle::NoHandle);
  setRasterizerState(RasterizerStateHandle::NoHandle);
 
  setEffect(EffectHandle::NoHandle);
}
 
Cogs::EffectHandle Cogs::ContextGL20::getEffect() const
{
  return this->currentEffect;
}
 
void Cogs::ContextGL20::readDepthBuffer(BufferHandle bufferHandle, int x, int y, int width, int height, Framebuffer /*framebuffer*/)
{
  auto & buffer = this->buffers->buffers[bufferHandle];
 
  if (buffer.size < width * height * sizeof(float)) {
    LOG_ERROR(logger, "Cannot read depth buffer into buffer of smaller size.");
 
    return;
  }
 
  glReadBuffer(GL_BACK);
 
  glBindBuffer(GL_PIXEL_PACK_BUFFER, buffer.bufferId);
 
  glReadPixels(x, y, width, height, GL_DEPTH_COMPONENT, GL_FLOAT, nullptr);
 
  glBindBuffer(GL_PIXEL_PACK_BUFFER, 0);
}
 
void * Cogs::ContextGL20::map(BufferHandle bufferHandle, MapMode::EMapMode mapMode, uint32_t *)
{
  auto & buffer = this->buffers->buffers[bufferHandle];
 
  if (this->enableMappingWorkaround && (mapMode == MapMode::WriteDiscard)) {
    buffer.mapFlags = mapMode;
 
    if (buffer.mappedData.size() != buffer.size) {
      buffer.mappedData.resize(buffer.size);
    }
 
    return buffer.mappedData.data();
  } else {
    glBindBuffer(buffer.target, buffer.bufferId);
 
    GLbitfield access = 0;
    access |= (mapMode == MapMode::Read) ? GL_MAP_READ_BIT : 0;
    access |= (mapMode == MapMode::Write) ? GL_MAP_WRITE_BIT : 0;
    access |= (mapMode == MapMode::WriteDiscard) ? GL_MAP_WRITE_BIT | GL_MAP_INVALIDATE_BUFFER_BIT : 0;
 
    return glMapBufferRange(buffer.target, 0, static_cast<GLsizeiptr>(buffer.size), access);
  }
}
 
void Cogs::ContextGL20::unmap(BufferHandle bufferHandle)
{
  auto & buffer = this->buffers->buffers[bufferHandle];
 
  glBindBuffer(buffer.target, buffer.bufferId);
 
  if (this->enableMappingWorkaround && (buffer.mapFlags == MapMode::WriteDiscard)) {
    glBufferData(buffer.target, static_cast<GLsizeiptr>(buffer.mappedData.size()), buffer.mappedData.data(), GL_STREAM_DRAW);
  } else {
    GLboolean result = glUnmapBuffer(buffer.target);
 
    if (!result) {
      LOG_WARNING(logger, "Unmapping the buffer was unsuccessful.");
    }
  }
 
  glBindBuffer(buffer.target, GL_ZERO);
}
 
void Cogs::ContextGL20::updateSubTexture(TextureHandle textureHandle, const size_t level, const void * data)
{
  assert(HandleIsValid(textureHandle) && "Texture handle must be valid.");
 
  const auto & texture = this->textures->textures[textureHandle];
 
  const GLenum pixelType = OpenGL20::PixelTypes[(int)texture.format];
  const GLenum pixelFormat = OpenGL20::PixelFormats[(int)texture.format];
  const GLboolean isCompressed = OpenGL20::CompressedFormats[(int)texture.format];
  if (isCompressed)
  {
    LOG_WARNING(logger, "Updating subtexture is unsupported for compressed textures.");
  }
  else {
    glBindTexture(texture.type, texture.textureId);
 
    glTexSubImage2D(texture.type, static_cast<GLint>(level), 0, 0, texture.width, texture.height, pixelFormat, pixelType, data);
  }
}
 
void Cogs::ContextGL20::updateSubBuffer(BufferHandle bufferHandle, const size_t offset, const size_t size, const void * data)
{
  assert(HandleIsValid(bufferHandle) && "Buffer handle must be valid.");
 
  const auto & buffer = this->buffers->buffers[bufferHandle];
 
  assert(buffer.size >= offset + size && "Buffer size not sufficient to hold new data.");
 
  glBindBuffer(buffer.target, buffer.bufferId);
  glBufferSubData(buffer.target, static_cast<GLintptr>(offset), static_cast<GLsizeiptr>(size), data);
  glBindBuffer(buffer.target, 0);
}
 
void Cogs::ContextGL20::copyResource(BufferHandle destinationHandle, BufferHandle sourceHandle)
{
  assert(HandleIsValid(destinationHandle) && "Destination buffer handle must be valid.");
  const auto & destinationBuffer = this->buffers->buffers[destinationHandle];
 
  assert(HandleIsValid(sourceHandle) && "Source buffer handle must be valid.");
  const auto & sourceBuffer = this->buffers->buffers[sourceHandle];
 
  assert(sourceBuffer.size == destinationBuffer.size);
 
  copySubBuffer(destinationBuffer.target, destinationBuffer.bufferId, 0,
                sourceBuffer.target, sourceBuffer.bufferId, 0,
                static_cast<GLsizeiptr>(sourceBuffer.size));
}
 
void Cogs::ContextGL20::copyResource(TextureHandle /*destinationHandle*/, TextureHandle /*sourceHandle*/)
{
 
}
 
void Cogs::ContextGL20::copySubResource(BufferHandle destinationHandle, size_t destinationOffset, BufferHandle sourceHandle, size_t sourceOffset, size_t size)
{
  assert(HandleIsValid(destinationHandle) && "Destination buffer handle must be valid.");
  const auto & destinationBuffer = this->buffers->buffers[destinationHandle];
  assert(destinationOffset + size <= destinationBuffer.size);
 
  assert(HandleIsValid(sourceHandle) && "Source buffer handle must be valid.");
  const auto & sourceBuffer = this->buffers->buffers[sourceHandle];
  assert(sourceOffset + size <= sourceBuffer.size);
 
  copySubBuffer(destinationBuffer.target, destinationBuffer.bufferId, static_cast<GLintptr>(destinationOffset),
                sourceBuffer.target, sourceBuffer.bufferId, static_cast<GLintptr>(sourceOffset),
                static_cast<GLsizeiptr>(size));
}
 
void Cogs::ContextGL20::readColorBuffer(BufferHandle bufferHandle, int x, int y, int width, int height, Framebuffer framebuffer)
{
  auto & buffer = this->buffers->buffers[bufferHandle];
 
  if (buffer.size < static_cast<size_t>(width) * static_cast<size_t>(height) * 4) {
    //TODO: Get actual frame buffer size.
    LOG_ERROR(logger, "Cannot read color buffer into buffer of smaller size.");
 
    return;
  }
 
  glBindBuffer(GL_PIXEL_PACK_BUFFER, buffer.bufferId);
 
  if (currentRenderTarget == RenderTargetHandle::NoHandle) {
    glReadBuffer(OpenGL20::Framebuffers[static_cast<uint32_t>(framebuffer)]);
    glReadPixels(x, y, width, height, GL_RGBA, GL_UNSIGNED_BYTE, nullptr);
  } else {
    // If a render target is currently bound, we read from the color attachment of this target.
    auto & renderTarget = this->renderTargets->renderTargets[this->currentRenderTarget];
    auto & texture = this->textures->textures[renderTarget.textures[0]];
 
    glReadBuffer(GL_COLOR_ATTACHMENT0);
 
    glReadPixels(x, y, width, height, OpenGL20::PixelFormats[(int)texture.format], OpenGL20::PixelTypes[(int)texture.format], nullptr);
  }
 
  glBindBuffer(GL_PIXEL_PACK_BUFFER, 0);
}
 
void Cogs::ContextGL20::reset()
{
}
 
void Cogs::ContextGL20::dispatchCompute(const unsigned int threadGroupsX, const unsigned int threadGroupsY, const unsigned int threadGroupsZ)
{
  ContextCommon::updateConstantBuffers();
 
  if (!HandleIsValid(currentEffect)) return;
 
  auto & effect = effects->effects[currentEffect];
 
  for (auto & constantBuffer : effect.computeShader.reflection.constantBuffers) {
    if (HandleIsValid(constantBuffer.buffer) && !constantBuffer.manual && constantBuffer.buffer != state.csCBs[constantBuffer.slot]) {
      auto & buffer = buffers->buffers[constantBuffer.buffer];
      if (constantBuffer.index != GL_INVALID_INDEX) {
        glBindBufferBase(GL_UNIFORM_BUFFER, constantBuffer.index, buffer.bufferId);
        glUniformBlockBinding(currentProgramId, constantBuffer.index, constantBuffer.index);
      }
      state.csCBs[constantBuffer.slot] = constantBuffer.buffer;
    }
  }
  
#ifndef __APPLE__
  glDispatchCompute(threadGroupsX, threadGroupsY, threadGroupsZ);
#else
  (void)threadGroupsX;
  (void)threadGroupsY;
  (void)threadGroupsZ;
  assert(false);
#endif
  postDraw();
  
}
 
void Cogs::ContextGL20::setBuffer(const BufferBindingHandle bufferBindingHandle, BufferHandle bufferHandle)
{
 
  if (HandleIsValid(bufferHandle)) {
    auto & buffer = buffers->buffers[bufferHandle];
 
    if (HandleIsValid(bufferBindingHandle)) {
 
      if (HandleIsValid(currentEffect)) {
        auto & effect = this->effects->effects[currentEffect];
 
        auto binding = static_cast<GLint>(bufferBindingHandle.handle >> 32) - 1;
        glBindBufferBase(GL_SHADER_STORAGE_BUFFER, binding, buffer.bufferId);
 
        if (buffer.counterBufferId != GL_INVALID_INDEX) {
          auto index = static_cast<GLint>(bufferBindingHandle.handle & 0xFFFFFFFF) - 1;
          if (size_t(index) < effect.atomicCounterVariables.size()) {
            AtomicCounterMapGL20 mapping;
            mapping.backingBuffer = buffer.counterBufferId;
            mapping.effectAtomicCounterVariableIndex = index;
            this->atomicCounterMappings.push_back(mapping);
 
            syncCounterToEffect(mapping);
          }
        }
      }
    }
  }
}
 
void Cogs::ContextGL20::syncCounterToEffect(const AtomicCounterMapGL20 mapping)
{
  const auto & effect = this->effects->effects[currentEffect];
  const auto & effectVariable = effect.atomicCounterVariables[mapping.effectAtomicCounterVariableIndex];
  const auto & effectBuffer = effect.atomicCounterBuffers[effectVariable.bufferIndex];
 
  glBindBuffer(GL_COPY_READ_BUFFER, mapping.backingBuffer);
  glBindBuffer(GL_COPY_WRITE_BUFFER, effects->backingBuffers[effectBuffer.backingBuffer]);
  glCopyBufferSubData(GL_COPY_READ_BUFFER, GL_COPY_WRITE_BUFFER, 0, effectVariable.bufferOffset, static_cast<GLsizei>(sizeof(GLuint)));
  glBindBuffer(GL_COPY_READ_BUFFER, 0);
  glBindBuffer(GL_COPY_WRITE_BUFFER, 0);
}
 
void Cogs::ContextGL20::syncCounterFromEffect(const AtomicCounterMapGL20 mapping)
{
  const auto & effect = this->effects->effects[currentEffect];
  const auto & effectVariable = effect.atomicCounterVariables[mapping.effectAtomicCounterVariableIndex];
  const auto & effectBuffer = effect.atomicCounterBuffers[effectVariable.bufferIndex];
  auto effectBackingBuffer = effects->backingBuffers[effectBuffer.backingBuffer];
 
  glBindBuffer(GL_COPY_READ_BUFFER, effectBackingBuffer);
  glBindBuffer(GL_COPY_WRITE_BUFFER, mapping.backingBuffer);
  glCopyBufferSubData(GL_COPY_READ_BUFFER, GL_COPY_WRITE_BUFFER, effectVariable.bufferOffset, 0, static_cast<GLsizei>(sizeof(GLuint)));
  glBindBuffer(GL_COPY_READ_BUFFER, 0);
  glBindBuffer(GL_COPY_WRITE_BUFFER, 0);
}
 
 
void Cogs::ContextGL20::setBufferCounter(BufferHandle bufferHandle, uint32_t value)
{
  auto & buffer = buffers->buffers[bufferHandle];
  if (buffer.counterBufferId == GL_INVALID_INDEX) {
    return;
  }
 
  // Store in buffer's atomic counter backing store.
  GLuint v = value;
  glBindBuffer(GL_COPY_READ_BUFFER, buffer.counterBufferId);
  glBufferData(GL_COPY_READ_BUFFER, static_cast<GLsizeiptr>(sizeof(GLuint)), &v, GL_DYNAMIC_COPY);
  glBindBuffer(GL_COPY_READ_BUFFER, 0);
 
  // And update effect's backing store if the counter is in use.
  if (HandleIsValid(currentEffect)) {
    for (const auto & mapping : atomicCounterMappings) {
      if (mapping.backingBuffer == buffer.counterBufferId) {
        syncCounterToEffect(mapping);
      }
    }
  }
}
 
void Cogs::ContextGL20::setBufferCounter(BufferHandle bufferHandle, BufferHandle sourceBufferHandle)
{
  assert(HandleIsValid(sourceBufferHandle) && "Destination buffer handle must be valid.");
  const auto & sourceBuffer = this->buffers->buffers[sourceBufferHandle];
  assert(sizeof(GLuint) <= sourceBuffer.size);
 
  auto & buffer = buffers->buffers[bufferHandle];
  assert(buffer.counterBufferId != GL_INVALID_INDEX);
 
  copySubBuffer(GL_ARRAY_BUFFER, buffer.counterBufferId, 0,
    GL_ARRAY_BUFFER, sourceBuffer.bufferId, 0,
    sizeof(GLuint));
 
  // And update effect's backing store if the counter is in use.
  if (HandleIsValid(currentEffect)) {
    for (const auto & mapping : atomicCounterMappings) {
      if (mapping.backingBuffer == buffer.counterBufferId) {
        syncCounterToEffect(mapping);
      }
    }
  }
}
 
uint32_t Cogs::ContextGL20::getBufferCounter(BufferHandle bufferHandle)
{
  auto & buffer = buffers->buffers[bufferHandle];
 
  if (buffer.counterBufferId == GL_INVALID_INDEX) {
    return 0;
  }
 
  // Update buffer's backing store if the counter is used by the current effect.
  if (HandleIsValid(currentEffect)) {
    for (const auto & mapping : atomicCounterMappings) {
      if (mapping.backingBuffer == buffer.counterBufferId) {
        syncCounterFromEffect(mapping);
      }
    }
  }
 
  GLuint v;
  glBindBuffer(GL_COPY_WRITE_BUFFER, buffer.counterBufferId);
  glGetBufferSubData(GL_COPY_WRITE_BUFFER, static_cast<GLintptr>(0), static_cast<GLsizeiptr>(sizeof(GLuint)), &v);
  glBindBuffer(GL_COPY_WRITE_BUFFER, 0);
 
  return v;
}
 
 
void Cogs::ContextGL20::getBufferCounter(BufferHandle bufferHandle, BufferHandle destinationBufferHandle)
{
  assert(HandleIsValid(destinationBufferHandle) && "Destination buffer handle must be valid.");
  const auto & destinationBuffer = this->buffers->buffers[destinationBufferHandle];
  assert(sizeof(GLuint) <= destinationBuffer.size);
 
  auto & buffer = buffers->buffers[bufferHandle];
 
  if (buffer.counterBufferId == GL_INVALID_INDEX) {
    return;
  }
 
  // Update buffer's backing store if the counter is used by the current effect.
  if (HandleIsValid(currentEffect)) {
    for (const auto & mapping : atomicCounterMappings) {
      if (mapping.backingBuffer == buffer.counterBufferId) {
        syncCounterFromEffect(mapping);
      }
    }
  }
 
  copySubBuffer(GL_ARRAY_BUFFER, destinationBuffer.bufferId, 0,
    GL_ARRAY_BUFFER, buffer.counterBufferId, 0,
    sizeof(GLuint));
}
void Cogs::ContextGL20::copyTexture(TextureHandle dstHandle, unsigned dstSub, unsigned dstX, unsigned dstY, unsigned dstZ, TextureHandle srcHandle, unsigned srcSub)
{
#ifndef __APPLE__
  TextureGL20 & srcTexture = this->textures->textures[srcHandle];
  TextureGL20 & dstTexture = this->textures->textures[dstHandle];
 
  unsigned srcLevel = srcSub; // TODO srcSub%LevelCount
  unsigned srcLayer = 0; // TODO srcSub/LevelCount
  unsigned dstLevel = dstSub; // TODO dstSub%LevelCount
  unsigned dstLayer = 0; // TODO dstSub/LevelCount
 
  glCopyImageSubData(srcTexture.textureId,
                     srcTexture.type,
                     srcLevel,
                     0, 0, srcLayer,
                     dstTexture.textureId,
                     dstTexture.type,
                     dstLevel,
                     dstX, dstY, dstZ+dstLayer,
                     srcTexture.width, srcTexture.height, 1);
#else
  (void)dstHandle;
  (void)dstSub;
  (void)dstX;
  (void)dstY;
  (void)dstZ;
  (void)srcHandle;
  (void)srcSub;
  assert(false);
#endif
}
void Cogs::ContextGL20::clearResource(BufferHandle destinationHandle, uint32_t *Values)
{
  assert(HandleIsValid(destinationHandle) && "Destination buffer handle must be valid.");
#ifndef __APPLE__
  const auto & destinationBuffer = this->buffers->buffers[destinationHandle];
 
  GLenum internalformat = GL_R32UI;
  GLenum format = GL_RED_INTEGER;
  GLenum type = GL_UNSIGNED_INT;
 
  if (glClearNamedBufferData) {
    glClearNamedBufferData(destinationBuffer.bufferId, internalformat, format, type, Values);
  }
  else if(glClearBufferData){
    glBindBuffer(destinationBuffer.target, destinationBuffer.bufferId);
    glClearBufferData(destinationBuffer.target, internalformat, format, type, Values);
    glBindBuffer(destinationBuffer.target, 0);
  }
  else
#else
  (void)Values;
#endif
  {
    assert(false); // TODO
  }
}
void Cogs::ContextGL20::clearResource(BufferHandle destinationHandle, float *Values)
{
  assert(HandleIsValid(destinationHandle) && "Destination buffer handle must be valid.");
#ifndef __APPLE__
  const auto & destinationBuffer = this->buffers->buffers[destinationHandle];
 
  GLenum internalformat = GL_R32F;
  GLenum format = GL_RED;
  GLenum type = GL_FLOAT;
 
  if (glClearNamedBufferData) {
    glClearNamedBufferData(destinationBuffer.bufferId, internalformat, format, type, Values);
  }
  else if(glClearBufferData){
    glBindBuffer(destinationBuffer.target, destinationBuffer.bufferId);
    glClearBufferData(destinationBuffer.target, internalformat, format, type, Values);
    glBindBuffer(destinationBuffer.target, 0);
  }
  else
#else
  (void)Values;
#endif
  {
    assert(false); // TODO
  }
}
 
void Cogs::ContextGL20::preDraw()
{
  ContextCommon::updateConstantBuffers();
 
  if (!HandleIsValid(currentEffect)) return;
 
  auto & effect = effects->effects[currentEffect];
 
  for (auto & constantBuffer : effect.vertexShader.reflection.constantBuffers) {
    if (HandleIsValid(constantBuffer.buffer) && !constantBuffer.manual && constantBuffer.buffer != state.vsCBs[constantBuffer.slot]) {
      auto & buffer = buffers->buffers[constantBuffer.buffer];
      if (constantBuffer.index != GL_INVALID_INDEX) {
        glBindBufferBase(GL_UNIFORM_BUFFER, constantBuffer.index, buffer.bufferId);
        glUniformBlockBinding(currentProgramId, constantBuffer.index, constantBuffer.index);
      }
      state.vsCBs[constantBuffer.slot] = constantBuffer.buffer;
    }
  }
 
  for (auto & constantBuffer : effect.pixelShader.reflection.constantBuffers) {
    if (HandleIsValid(constantBuffer.buffer) && !constantBuffer.manual && constantBuffer.buffer != state.psCBs[constantBuffer.slot]) {
      auto & buffer = buffers->buffers[constantBuffer.buffer];
      if (constantBuffer.index != GL_INVALID_INDEX) {
        glBindBufferBase(GL_UNIFORM_BUFFER, constantBuffer.index, buffer.bufferId);
        glUniformBlockBinding(currentProgramId, constantBuffer.index, constantBuffer.index);
      }
      state.psCBs[constantBuffer.slot] = constantBuffer.buffer;
    }
  }
}
 
void Cogs::ContextGL20::postDraw()
{
  if (unorderedMemoryAcccess) {
#ifndef __APPLE__
    glMemoryBarrier(GL_ALL_BARRIER_BITS);
#else
    assert(false);
#endif
    unorderedMemoryAcccess = false;
  }
}
 
void Cogs::ContextGL20::pushCommandGroupAnnotation(const StringView & name)
{
#ifndef __APPLE__
  glPushDebugGroup(GL_DEBUG_SOURCE_APPLICATION, 1, static_cast<GLsizei>(name.size()), name.data());
#else
  (void)name;
#endif
}
void Cogs::ContextGL20::popCommandGroupAnnotation()
{
#ifndef __APPLE__
  glPopDebugGroup();
#endif
}
void Cogs::ContextGL20::setAnnotationMarker(const StringView & name)
{
#ifndef __APPLE__
  glDebugMessageInsert(GL_DEBUG_SOURCE_APPLICATION, GL_DEBUG_TYPE_OTHER, 1, GL_DEBUG_SEVERITY_HIGH, static_cast<GLsizei>(name.size()), name.data());
#else
  (void)name;
#endif
}