SwapChainGL20.cpp

#include "SwapChainGL20.h"
 
#include "CommonGL20.h"
#include "FormatsGL20.h"
#include "GraphicsDeviceGL20.h"
 
#include "Foundation/Logging/Logger.h"
#include "Foundation/Platform/WindowData.h"
 
namespace {
 
  Cogs::Logging::Log    logger = Cogs::Logging::getLogger("SwapChainGL20");
}
 
Cogs::SwapChainGL20::SwapChainGL20(GraphicsDeviceGL20* device, bool isPrimary)
  : graphicsDevice(device),
    isPrimary(isPrimary) {
}
 
Cogs::SwapChainGL20::~SwapChainGL20() {
}
 
bool Cogs::SwapChainGL20::initialize(WindowData* winData, bool debugLogging)
{
  windowData = winData;
 
  GraphicsDeviceSettings settings = graphicsDevice->getSettings();
  if (!isPrimary) {
    // Secondary swapchains doen't need MSAA back buffer since we use a texture for drawing.
    // Present blit does resolve.
    settings.numSamples = 1;
  }
 
#if defined(__APPLE__)
  (void)debugLogging;
 
  if (isPrimary) {
    glContext = graphicsDevice->getShareContext();
  }
  else if (windowData && windowData->defaultContext) {
    glContext = GLContext(windowData->defaultContext);
  }
  else {
    LOG_ERROR(logger, "No share or window context .");
    return false;
  }
#else
  if (!glContext.create(nullptr, winData, &graphicsDevice->getShareContext(), &settings, GLContext::Platform::GL, debugLogging)) {
    LOG_ERROR(logger, "Can't retrieve window's device context.");
    return false;
  }
#endif
  glContext.makeCurrent();
  if (!isPrimary) {
    // If we are a secondary framebuffer, we create an FBO in our context that we will bind to the
    // texture in the primary framebuffer that holds our image. Framebuffer objects aren't shared.
    glGenFramebuffers(1, &framebuffer);
 
    // And back to the primary context
    graphicsDevice->getDefaultSwapChain()->glContext.makeCurrent();
  }
 
  return true;
}
 
void Cogs::SwapChainGL20::destroy()
{
  glContext.destroy();
}
 
 
void Cogs::SwapChainGL20::beginFrame() {
  if (isPrimary) {
    glContext.makeCurrent();
    glBindFramebuffer(GL_FRAMEBUFFER, 0);
    glDrawBuffer(GL_BACK);
  }
  else {
    if (needsResize) {
      recreateOffscreenBuffers();
      needsResize = false;
    }
    ReleaseWait(); // This can be optimized by moving it to where the render target is first used.
  }
}
 
void Cogs::SwapChainGL20::endFrame(uint32_t syncInterval, PresentFlags presentFlags) {
 
  if (!isPrimary) {
    // Switch to secondary context and blit contents from primary context
    GLsync acquire = 0;
    if (framebuffer){
      acquire = glFenceSync(GL_SYNC_GPU_COMMANDS_COMPLETE, 0);
    }
    glContext.makeCurrent();
    if (framebuffer) {
      glWaitSync(acquire, 0, GL_TIMEOUT_IGNORED);
      glDeleteSync(acquire);
      glDisable(GL_SCISSOR_TEST);
      glViewport(0, 0, width, height);
      glBindFramebuffer(GL_READ_FRAMEBUFFER, framebuffer);
      glBindFramebuffer(GL_DRAW_FRAMEBUFFER, 0);
      glDrawBuffer(GL_BACK);
      glBlitFramebuffer(0, 0, width, height, 0, 0, width, height, GL_COLOR_BUFFER_BIT, GL_NEAREST);
      glBindFramebuffer(GL_READ_FRAMEBUFFER, 0);
      ReleaseFence();
    }
  }
 
  // Swap this context regardless of it being primary or secondary
  glContext.swapBuffers(syncInterval, presentFlags);
 
  if (!isPrimary) {
    // If secondary, swap back to primary context
    graphicsDevice->getDefaultSwapChain()->glContext.makeCurrent();
  }
}
 
void Cogs::SwapChainGL20::ReleaseFence()
{
  if(release) glDeleteSync(release);
  release = glFenceSync(GL_SYNC_GPU_COMMANDS_COMPLETE, 0);
}
 
void Cogs::SwapChainGL20::ReleaseWait()
{
  if(release){
    glWaitSync(release, 0, GL_TIMEOUT_IGNORED);
    glDeleteSync(release);
    release = 0;
  }
}
 
void Cogs::SwapChainGL20::setSize(int newWidth, int newHeight, bool forceIt) {
  if ((width != newWidth) || (height != newHeight) || forceIt) {
    width = newWidth;
    height = newHeight;
    needsResize = true;
  }
}
 
void Cogs::SwapChainGL20::setFullscreen(bool /*enabled*/) {
}
 
int Cogs::SwapChainGL20::getSamples() const {
  return graphicsDevice->getSettings().numSamples;
}
 
bool Cogs::SwapChainGL20::recreateOffscreenBuffers() {
  assert(!isPrimary);
 
  // Create texture and rendertarget in primary context
  const GraphicsDeviceSettings& settings = graphicsDevice->getSettings();
  RenderTargetsGL20* renderTargets = graphicsDevice->getRenderTargets();
  TexturesGL20* textures = graphicsDevice->getTextures();
  TextureDescription            desc;
 
  desc.width = width;
  desc.height = height;
  desc.format = settings.colorFormat;
  desc.samples = settings.numSamples;
  desc.target = Cogs::ResourceDimensions::Texture2DMS;
  desc.flags = Cogs::TextureFlags::RenderTarget;
 
  if (Cogs::HandleIsValid(depthStencil)) {
    renderTargets->releaseDepthStencilTarget(depthStencil);
    depthStencil = DepthStencilHandle();
  }
  if (Cogs::HandleIsValid(renderTarget)) {
    renderTargets->releaseRenderTarget(renderTarget);
    renderTarget = RenderTargetHandle();
  }
  if (Cogs::HandleIsValid(textureHandle)) {
    textures->releaseTexture(textureHandle);
    textureHandle = TextureHandle();
  }
 
  textureHandle = textures->loadTexture(desc, nullptr);
  if (!Cogs::HandleIsValid(this->textureHandle)) {
    LOG_ERROR(logger, "Unable to create offscreen texture.");
    return false;
  }
 
  RenderTargetViewDescription rt_desc = {};
  rt_desc.texture = textureHandle;
  rt_desc.numLayers = 1;
  renderTarget = renderTargets->createRenderTarget(&rt_desc, 1);
  if (!Cogs::HandleIsValid(renderTarget)) {
    LOG_ERROR(logger, "Error creating render target.");
    return false;
  }
 
  depthStencil = renderTargets->createDepthStencilTarget(renderTarget);
  if (!Cogs::HandleIsValid(depthStencil)) {
    LOG_ERROR(logger, "Error creating depth stencil.");
    return false;
  }
 
  // Switch to secondary context to set up FBO that we will use for rendering
  GLsync acquire = glFenceSync(GL_SYNC_GPU_COMMANDS_COMPLETE, 0);
  glContext.makeCurrent();
  glWaitSync(acquire, 0, GL_TIMEOUT_IGNORED);
  glDeleteSync(acquire);
 
  const TextureGL20& texture = graphicsDevice->getTextures()->textures[textureHandle];
  glBindFramebuffer(GL_FRAMEBUFFER, framebuffer);
  glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, texture.type, texture.textureId, 0);
  GLenum status = glCheckFramebufferStatus(GL_FRAMEBUFFER);
  switch (status) {
  case GL_FRAMEBUFFER_COMPLETE:
    break;
  case GL_FRAMEBUFFER_UNDEFINED: [[fallthrough]];
  case GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT: [[fallthrough]];
  case GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT: [[fallthrough]];
  case GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER: [[fallthrough]];
  case GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER: [[fallthrough]];
  case GL_FRAMEBUFFER_UNSUPPORTED: [[fallthrough]];
  case GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE: [[fallthrough]];
  case GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS: [[fallthrough]];
  default:
    LOG_ERROR(logger, "Failed to create swapchain FBO, glCheckFramebufferStatus()=0x%x", status);
    glDeleteFramebuffers(1, &framebuffer);
    framebuffer = 0;
    break;
  }
 
  // We are secondary, so swap back to primary context
  ReleaseFence();
  graphicsDevice->getDefaultSwapChain()->glContext.makeCurrent();
  return true;
}