RenderTargetsGL20.cpp

#include "RenderTargetsGL20.h"
#include "TexturesGL20.h"
#include "GraphicsDeviceGL20.h"
 
#include "Foundation/Logging/Logger.h"
 
namespace
{
  static Cogs::Logging::Log logger = Cogs::Logging::getLogger("RenderTargetsGL20");
 
  bool checkFrameBuffer()
  {
    GLenum status = glCheckFramebufferStatus(GL_FRAMEBUFFER);
 
    if (status == GL_FRAMEBUFFER_UNDEFINED) { return false; }
    else if (status == GL_FRAMEBUFFER_UNSUPPORTED) { 
      LOG_ERROR(logger, "FBO contains unsupported image formats.");
      return false;
    } else if (status == GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT) {
      LOG_ERROR(logger, "FBO incomplete, missing any image attachments.");
      return false;
    } else if (status == GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT) {
      LOG_ERROR(logger, "FBO incomplete, missing complete attachments.");
      return false;
    } else if (status == GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER) {
      LOG_ERROR(logger, "FBO incomplete, draw buffer.");
      return false;
    } else if (status == GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER) {
      LOG_ERROR(logger, "FBO incomplete, read buffer.");
      return false;
    } else if (status == GL_FRAMEBUFFER_UNSUPPORTED) {
      LOG_ERROR(logger, "FBO incomplete, unsupported combination of internal formats.");
      return false;
    } else if (status == GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE) {
      LOG_ERROR(logger, "FBO incomplete, multisample.");
      return false;
    } else if (status == GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS) {
      LOG_ERROR(logger, "FBO incomplete, layers.");
      return false;
    }
    assert(status == GL_FRAMEBUFFER_COMPLETE);
 
    return true;
  }
}
 
Cogs::RenderTargetsGL20::~RenderTargetsGL20()
{
  if (this->renderTargets.size()) {
    LOG_WARNING(logger, "Render targets resources not empty. %zu resources left.", this->renderTargets.size());
  }
  if (this->depthStencils.size()) {
    LOG_WARNING(logger, "Depth stencil target resources not empty. %zu resources left.", this->depthStencils.size());
  }
}
 
Cogs::RenderTargetHandle Cogs::RenderTargetsGL20::createRenderTarget(const Cogs::RenderTargetViewDescription * renderTargetViews, const size_t numViews)
{
  RenderTargetGL20 renderTarget = {};
 
  glGenFramebuffers(1, &renderTarget.frameBuffer);
  glBindFramebuffer(GL_FRAMEBUFFER, renderTarget.frameBuffer);
 
  renderTarget.numTextures = numViews;
 
  for (size_t i = 0; i < numViews; ++i) {
    TextureGL20 & texture = this->textures->textures[renderTargetViews[i].texture];
    GLenum target = texture.type;
    renderTarget.textures[i] = renderTargetViews[i].texture;
 
    if(target == GL_TEXTURE_CUBE_MAP){
      GLint face = renderTargetViews[i].layerIndex%6;
      GLint layer = renderTargetViews[i].layerIndex/6;
      assert(layer == 0);
      glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0 + static_cast<GLint>(i),
                             GL_TEXTURE_CUBE_MAP_POSITIVE_X+face,
                             texture.textureId, renderTargetViews[i].layerIndex);
    } else if(target == GL_TEXTURE_CUBE_MAP_ARRAY || target == GL_TEXTURE_2D_ARRAY) {
      glFramebufferTextureLayer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0 + static_cast<GLint>(i),
                                texture.textureId,
                                renderTargetViews[i].levelIndex, renderTargetViews[i].layerIndex);
    } else {
      glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0 + static_cast<GLint>(i),
                             target, texture.textureId, renderTargetViews[i].levelIndex);
    }
  }
 
  if (numViews && !checkFrameBuffer()) {
    return RenderTargetHandle::InvalidHandle;
  }
 
  glBindFramebuffer(GL_FRAMEBUFFER, 0);
 
  return this->renderTargets.addResource(renderTarget);
}
 
void Cogs::RenderTargetsGL20::releaseRenderTarget(RenderTargetHandle renderTargetHandle)
{
  auto & renderTarget = this->renderTargets[renderTargetHandle];
 
  glDeleteFramebuffers(1, &renderTarget.frameBuffer);
 
  this->renderTargets.removeResource(renderTargetHandle);
}
 
Cogs::DepthStencilHandle Cogs::RenderTargetsGL20::createDepthStencilTarget(const RenderTargetHandle handle)
{
  RenderTargetGL20 & renderTarget = this->renderTargets[handle];
  TextureGL20 & texture = this->textures->textures[renderTarget.textures[0]];
 
  GLuint depthRenderBuffer;
  glGenRenderbuffers(1, &depthRenderBuffer);
  glBindRenderbuffer(GL_RENDERBUFFER, depthRenderBuffer);
 
  GLenum format = GL_DEPTH_COMPONENT32F;
  if (texture.numSamples == 1) {
    glRenderbufferStorage(GL_RENDERBUFFER, format, texture.width, texture.height);
  } else {
    glRenderbufferStorageMultisample(GL_RENDERBUFFER, texture.numSamples, format, texture.width, texture.height);
  }
 
  glBindRenderbuffer(GL_RENDERBUFFER, 0);
 
  glBindFramebuffer(GL_FRAMEBUFFER, renderTarget.frameBuffer);
  glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, depthRenderBuffer);
 
  if (!checkFrameBuffer()){
    return DepthStencilHandle::InvalidHandle;
  }
 
  glBindFramebuffer(GL_FRAMEBUFFER, 0);
 
  DepthStencilTargetGL20 depthStencilTarget = { TextureHandle::NoHandle, handle, true, depthRenderBuffer };
 
  return this->depthStencils.addResource(depthStencilTarget);
}
 
Cogs::DepthStencilHandle Cogs::RenderTargetsGL20::createDepthStencilTarget(const RenderTargetHandle handle, const TextureHandle textureHandle)
{
  RenderTargetHandle renderTargetHandle = handle;
  if(!HandleIsValid(renderTargetHandle)){
    renderTargetHandle = createRenderTarget(nullptr, 0);
  }
  RenderTargetGL20 & renderTarget = this->renderTargets[renderTargetHandle];
  TextureGL20 & texture = this->textures->textures[textureHandle];
  GLenum target = texture.type;
 
  GLuint frameBuffer = renderTarget.frameBuffer;
 
  glBindFramebuffer(GL_FRAMEBUFFER, frameBuffer);
  glFramebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, target, texture.textureId, 0);
 
  if (!checkFrameBuffer()){
    return DepthStencilHandle::InvalidHandle;
  }
 
  glBindFramebuffer(GL_FRAMEBUFFER, 0);
 
  DepthStencilTargetGL20 depthTarget = { textureHandle, renderTargetHandle, false, frameBuffer };
 
  return this->depthStencils.addResource(depthTarget);
}
 
Cogs::DepthStencilHandle Cogs::RenderTargetsGL20::createDepthStencilTarget(const Cogs::RenderTargetHandle handle, const Cogs::DepthStencilViewDescription & depthStencilView)
{
  RenderTargetHandle renderTargetHandle = handle;
  if(!HandleIsValid(renderTargetHandle)){
    renderTargetHandle = createRenderTarget(nullptr, 0);
  }
  RenderTargetGL20 & renderTarget = this->renderTargets[renderTargetHandle];
  TextureGL20 & texture = this->textures->textures[depthStencilView.texture];
  GLenum target = texture.type;
  GLuint frameBuffer = renderTarget.frameBuffer;
 
  glBindFramebuffer(GL_FRAMEBUFFER, frameBuffer);
 
  if(target == GL_TEXTURE_CUBE_MAP){
    GLint face = depthStencilView.layerIndex%6;
    GLint layer = depthStencilView.layerIndex/6;
    assert(layer == 0);
    glFramebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT,
                           GL_TEXTURE_CUBE_MAP_POSITIVE_X+face,
                           texture.textureId, depthStencilView.levelIndex);
  }
  else if(target == GL_TEXTURE_CUBE_MAP_ARRAY || target == GL_TEXTURE_2D_ARRAY){
    glFramebufferTextureLayer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, texture.textureId,
                              depthStencilView.levelIndex, depthStencilView.layerIndex);
  }
  else if(depthStencilView.layerIndex == 0){
    glFramebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT,
                           target, texture.textureId, depthStencilView.levelIndex);
  }
 
  if (!checkFrameBuffer()){
    return DepthStencilHandle::InvalidHandle;
  }
 
  glBindFramebuffer(GL_FRAMEBUFFER, 0);
 
  DepthStencilTargetGL20 depthTarget = { depthStencilView.texture, renderTargetHandle, false, frameBuffer };
 
  return this->depthStencils.addResource(depthTarget);
}
 
void Cogs::RenderTargetsGL20::releaseDepthStencilTarget(DepthStencilHandle depthStencilHandle)
{
  auto & depthStencil = this->depthStencils[depthStencilHandle];
 
  if (depthStencil.renderBuffer) {
    glDeleteRenderbuffers(1, &depthStencil.depthBuffer);
  }
 
  this->depthStencils.removeResource(depthStencilHandle);
}
 
Cogs::RenderTargetLayout Cogs::RenderTargetsGL20::getLayout(const RenderTargetHandle renderTargetHandle, const DepthStencilHandle depthStencilHandle)
{
  RenderTargetLayout layout;
 
  if (HandleIsValid(renderTargetHandle)) {
    const RenderTargetGL20 & renderTarget = this->renderTargets[renderTargetHandle];
    layout.numColorTargets = static_cast<uint8_t>(renderTarget.numTextures);
 
    for (size_t i = 0; i < renderTarget.numTextures; ++i) {
      const TextureGL20 & texture = this->textures->textures[renderTarget.textures[i]];
      layout.colorFormats[i] = texture.format;
      layout.samples = static_cast<uint8_t>(texture.numSamples);
    }
  } else {
    const GraphicsDeviceSettings & settings = graphicsDevice->getSettings();
    layout.numColorTargets = 1;
    layout.colorFormats[0] = settings.colorFormat;
    layout.samples = static_cast<uint8_t>(settings.numSamples);
  }
 
  if (HandleIsValid(depthStencilHandle)) {
    const DepthStencilTargetGL20 & depthStencil = this->depthStencils[depthStencilHandle];
    layout.depthStencilFormat = HandleIsValid(depthStencil.texture)
      ? this->textures->textures[depthStencil.texture].format
      : TextureFormat::D32_FLOAT; // Renderbuffer-only depth targets are always created as GL_DEPTH_COMPONENT32F.
  } else if (!HandleIsValid(renderTargetHandle)) {
    layout.depthStencilFormat = graphicsDevice->getSettings().depthFormat;
  }
 
  return layout;
}
 
Cogs::DepthStencilStateHandle Cogs::RenderTargetsGL20::loadDepthStencilState(const DepthStencilState & depthStencilState)
{
  return this->depthStencilStates.addResource(depthStencilState);
}
 
void Cogs::RenderTargetsGL20::releaseDepthStencilState(DepthStencilStateHandle handle)
{
  this->depthStencilStates.removeResource(handle);
}
 
Cogs::RasterizerStateHandle Cogs::RenderTargetsGL20::loadRasterizerState(const RasterizerState & rasterizerState)
{
  return this->rasterizerStates.addResource(rasterizerState);
}
 
void Cogs::RenderTargetsGL20::releaseRasterizerState(RasterizerStateHandle handle)
{
  this->rasterizerStates.removeResource(handle);
}
 
Cogs::BlendStateHandle Cogs::RenderTargetsGL20::loadBlendState(const BlendState & blendState)
{
  return loadBlendState(blendState, blendState);
}
 
Cogs::BlendStateHandle Cogs::RenderTargetsGL20::loadBlendState(const BlendState& blendStateColor, const BlendState& blendStateAlpha)
{
  BlendStateGL20 blendState{};
  blendState.color = blendStateColor;
  blendState.alpha = blendStateAlpha;
  return this->blendStates.addResource(std::move(blendState));
}
 
 
void Cogs::RenderTargetsGL20::releaseBlendState(BlendStateHandle handle)
{
  this->blendStates.removeResource(handle);
}
 
void Cogs::RenderTargetsGL20::releaseResources()
{
  std::vector<RenderTargetHandle> rtHandles;
  for (auto & rt : renderTargets) {
    rtHandles.push_back(renderTargets.getHandle(rt));
  }
 
  for (auto & handle : rtHandles) {
    releaseRenderTarget(handle);
  }
 
  std::vector<DepthStencilHandle> dsHandles;
  for (auto & ds : depthStencils) {
    dsHandles.push_back(depthStencils.getHandle(ds));
  }
 
  for (auto & handle : dsHandles) {
    releaseDepthStencilTarget(handle);
  }
 
  this->blendStates.clear();
  this->rasterizerStates.clear();
  this->depthStencilStates.clear();
}
 
void Cogs::RenderTargetsGL20::annotate(RenderTargetHandle handle, const StringView& name)
{
  if(name.empty() || !HandleIsValid(handle)) return;
 
#ifndef __APPLE__
  auto & renderTarget = this->renderTargets[handle];
  glObjectLabel(GL_FRAMEBUFFER, renderTarget.frameBuffer, static_cast<GLsizei>(name.size()), name.data());
#else
    (void)name;
#endif
}
 
void Cogs::RenderTargetsGL20::annotate(DepthStencilHandle handle, const StringView& name)
{
  if(name.empty() || !HandleIsValid(handle)) return;
 
  auto & depthStencil = this->depthStencils[handle];
  if(depthStencil.renderBuffer){
#ifndef __APPLE__
    glObjectLabel(GL_RENDERBUFFER, depthStencil.depthBuffer, static_cast<GLsizei>(name.size()), name.data());
#else
    (void)name;
#endif
  }
}