GraphicsDeviceGL20.cpp

#include "GraphicsDeviceGL20.h"
 
#include "Foundation/Logging/Logger.h"
#include "Foundation/Platform/Unicode.h"
 
// In an ideal world this would be above the platform includes so as not to hide any
// missing dependencies.  However... glxext uses Bool which is "defined" in xlib.h by
// muppets (included via glx.h in GraphicsDeviceGL20.h), which causes additional
// conflicts in other places in our code, so WindowData.h (which also needs to include
// xlib.h) undefines Bool.
#include "Foundation/Platform/WindowData.h"
 
#include <algorithm>
 
namespace {
  Cogs::Logging::Log logger = Cogs::Logging::getLogger("GraphicsDeviceGL20");
}
 
Cogs::GraphicsDeviceGL20::GraphicsDeviceGL20(RenderingAllocatorInfo*) : defaultSwapChain(this, true) {
}
 
Cogs::GraphicsDeviceGL20::~GraphicsDeviceGL20() {
  releaseResources();
  defaultSwapChain.destroy();
}
 
bool Cogs::GraphicsDeviceGL20::initialize() {
  assert(!initialized && "Initialize invoked multiple times.");
 
  if (settings.windowData->windowHandle == (WindowData::nativeHandleType)nullptr) {
    LOG_ERROR(logger, "No window handle");
    return false;
  }
  bool enableDiagnostics = isDebug() || ((settings.flags & GraphicsDeviceFlags::EnableDiagnostics) == GraphicsDeviceFlags::EnableDiagnostics);
 
#if defined( __APPLE__ )
  glShareContext = GLContext(settings.windowData->defaultContext);
  glShareContext.makeCurrent();
#else
#ifdef __linux__
  GLContext::NativeDisplay display = settings.windowData->display;
#else
  GLContext::NativeDisplay display = nullptr;
#endif
  if (!glShareContext.create(display, nullptr, nullptr, &settings, GLContext::Platform::GL, enableDiagnostics)) {
    LOG_ERROR(logger, "Failed to create share context.");
    return false;
  }
#endif
 
  defaultSwapChain.initialize(settings.windowData, enableDiagnostics);
 
  bool useClipControl = (settings.flags & GraphicsDeviceFlags::UseOpenGLClipControl) != 0;
#ifdef __APPLE__
  useClipControl = false;
#else
  if(!glClipControl) useClipControl = false;
#endif
 
  capabilities.initialize(useClipControl);
  context.initialize(&capabilities, &buffers, &textures, &effects, &renderTargets, &syncObjects);
  effects.initialize(this, &capabilities, &buffers);
  renderTargets.initialize(&textures);
  textures.initialize(this);
 
  glEnable(GL_PROGRAM_POINT_SIZE);
 
  if (settings.colorFormat == TextureFormat::R8G8B8A8_UNORM_SRGB) {
    glEnable(GL_FRAMEBUFFER_SRGB);
  }
 
#ifndef __APPLE__
  if(useClipControl){
    LOG_DEBUG(logger, "glClipControl(GL_LOWER_LEFT, GL_ZERO_TO_ONE)");
    glClipControl(GL_LOWER_LEFT, GL_ZERO_TO_ONE);
  }
#endif
 
  initialized = true;
  return true;
}
 
bool Cogs::GraphicsDeviceGL20::setSettings(const GraphicsDeviceSettings& newSettings) {
  IGraphicsDevice::setSettings(newSettings);
 
  if (settings.ioHandler) {
    effects.setIOHandler(settings.ioHandler);
  }
 
  return true;
}
 
Cogs::ISwapChain* Cogs::GraphicsDeviceGL20::createSwapChain(struct WindowData* windowData) {
  SwapChainGL20* swapChain = new SwapChainGL20(this, false);
 
  bool enableDiagnostics = isDebug() || ((settings.flags & GraphicsDeviceFlags::EnableDiagnostics) == GraphicsDeviceFlags::EnableDiagnostics);
  if (swapChain->initialize(windowData, enableDiagnostics)) {
    swapChains.push_back(swapChain);
    return swapChain;
  }
  delete swapChain;
  return nullptr;
}
 
void Cogs::GraphicsDeviceGL20::deleteSwapChain(ISwapChain* swapChain) {
  auto e = swapChains.end();
  auto i = std::find(swapChains.begin(), e, swapChain);
 
  if (i != e) {
    swapChains.erase(i);
    delete swapChain;
  }
}
 
void Cogs::GraphicsDeviceGL20::setSize(int newWidth, int newHeight) {
  defaultSwapChain.setSize(newWidth, newHeight);
}
 
bool Cogs::GraphicsDeviceGL20::getSize(int& w, int& h) const {
  w = defaultSwapChain.getWidth();
  h = defaultSwapChain.getHeight();
  return true;
}
 
void Cogs::GraphicsDeviceGL20::beginFrame() {
  defaultSwapChain.beginFrame();
  
  for (ISwapChain* swapChain : swapChains) {
    swapChain->beginFrame();
  }
 
  // On frame start for the current device. This ensures that if
  // e.g. the GL driver provides different
  //::threadContext = &glContext;
 
  context.setDefaults();
}
 
void Cogs::GraphicsDeviceGL20::endFrame(uint32_t syncInterval, uint32_t presentFlags) {
  for (ISwapChain* swapChain : swapChains) {
    swapChain->endFrame(0, presentFlags);
  }
  defaultSwapChain.endFrame(syncInterval, presentFlags);
}
 
 
void Cogs::GraphicsDeviceGL20::waitForCommandSync() {
  // Avoid using fence sync on FireGL series cards, since they seem to return without waiting.
  if (capabilities.getSeries() != Series::FireGL) {
    GLsync sync = glFenceSync(GL_SYNC_GPU_COMMANDS_COMPLETE, 0);
 
    glClientWaitSync(sync, GL_SYNC_FLUSH_COMMANDS_BIT, GL_TIMEOUT_IGNORED);
    glDeleteSync(sync);
  }
  else {
    glFinish();
  }
}
 
void Cogs::GraphicsDeviceGL20::releaseResources() {
  // Ensure the primary context is selected...
  defaultSwapChain.beginFrame();
 
  context.releaseResources();
  effects.releaseResources();
  renderTargets.releaseResources();
  textures.releaseResources();
 
  //TODO: Fix pinned effect/buffer relationships, reintroduce.
  //buffers.releaseResources();
 
  context.defaultSamplerStateHandle = SamplerStateHandle::NoHandle;
}
 
Cogs::ResourceStatistics Cogs::GraphicsDeviceGL20::getResourceStatistics() {
  ResourceStatistics stats{};
 
  stats.bufferMemoryConsumption = buffers.bufferMemoryConsumption;
  stats.textureMemoryConsumption = 0;
  stats.bufferCount = static_cast<uint32_t>(buffers.buffers.size());
  stats.inputLayoutCount = static_cast<uint32_t>(buffers.inputLayouts.size());
  stats.textureCount = static_cast<uint32_t>(textures.textures.size());
  stats.samplerStateCount = ~0u;
  stats.effectCount = static_cast<uint32_t>(effects.effects.size());
  stats.blendStateCount = static_cast<uint32_t>(renderTargets.blendStates.size());
  stats.rasterizerStateCount = static_cast<uint32_t>(renderTargets.rasterizerStates.size());
  stats.depthStencilStateCount = static_cast<uint32_t>(renderTargets.depthStencilStates.size());
  stats.rendertargetsCount = static_cast<uint32_t>(renderTargets.renderTargets.size());
  stats.framebufferCount = ~0u;
 
  return stats;
}
 
namespace Cogs {
  struct SharedGraphicsContext
  {
    GLContext context;
  };
}
 
Cogs::SharedGraphicsContext* Cogs::GraphicsDeviceGL20::createSharedContext()
{
  bool enableDiagnostics = isDebug() || ((settings.flags & GraphicsDeviceFlags::EnableDiagnostics) == GraphicsDeviceFlags::EnableDiagnostics);
  SharedGraphicsContext* sharedContext = new SharedGraphicsContext();
  if (sharedContext->context.create(nullptr, nullptr, &glShareContext, &settings, GLContext::Platform::GL, enableDiagnostics)) {
    return sharedContext;
  }
  sharedContext->context.destroy();
  delete sharedContext;
  return nullptr;
}
 
void Cogs::GraphicsDeviceGL20::activateSharedContext(SharedGraphicsContext* sharedContext)
{
  if (sharedContext) {
    sharedContext->context.makeCurrent();
  }
}
 
void Cogs::GraphicsDeviceGL20::releaseSharedContext(SharedGraphicsContext* sharedContext)
{
  if (sharedContext) {
    sharedContext->context.destroy();
    delete sharedContext;
  }
}