GraphicsDeviceGLES30.cpp

#include "GraphicsDeviceGLES30.h"
 
#include "FormatsGLES30.h"
 
#include "Foundation/Platform/WindowData.h"
 
#include "../Base/Utilities.h"
 
namespace {
  Cogs::Logging::Log logger = Cogs::Logging::getLogger("GraphicsDeviceGLES30");
}
 
Cogs::GraphicsDeviceGLES30::GraphicsDeviceGLES30(RenderingAllocatorInfo*)
{
}
 
Cogs::GraphicsDeviceGLES30::~GraphicsDeviceGLES30()
{
  if (glContext.makeCurrent()) {
    releaseResources();
    glContext.destroy();
  }
}
 
bool Cogs::GraphicsDeviceGLES30::initialize()
{
  if (reinterpret_cast<void*>(settings.windowData->windowHandle) == nullptr) {
    LOG_ERROR(logger, "No window handle");
    return false;
  }
  bool enableDiagnostics = isDebug() || ((settings.flags & GraphicsDeviceFlags::EnableDiagnostics) == GraphicsDeviceFlags::EnableDiagnostics);
 
#ifdef __linux__
  GLContext::NativeDisplay display = settings.windowData->display;
#else
  GLContext::NativeDisplay display = (GLContext::NativeDisplay)nullptr;
#endif
  if (!glContext.create(display, settings.windowData, nullptr, &settings, GLContext::Platform::ES3, enableDiagnostics)) {
    return false;
  }
  glContext.makeCurrent();
 
  bool useClipControl = (settings.flags & GraphicsDeviceFlags::UseOpenGLClipControl) != 0;
#ifdef __EMSCRIPTEN__
  if(!has_glClipControl()) useClipControl = false;
#elif defined(__APPLE__)
  useClipControl = false;
#else
  if(!glClipControl) useClipControl = false;
#endif
 
  capabilities.initialize(glContext.platform == GLContext::Platform::GL, useClipControl);
  buffers.initialize(&capabilities, &context, &effects);
  textures.initialize(&context, &capabilities);
  context.initialize(&buffers, &textures, &effects, &renderTargets, &capabilities, &syncObjects);
  renderTargets.initialize(&capabilities, &textures);
  effects.initialize(&context);
 
  if (settings.ioHandler) effects.setIOHandler(settings.ioHandler);
 
#ifndef __APPLE__
  if(useClipControl){
    LOG_DEBUG(logger, "glClipControl(GL_LOWER_LEFT, GL_ZERO_TO_ONE)");
    glClipControl(GL_LOWER_LEFT, GL_ZERO_TO_ONE);
  }
#endif
 
  return true;
}
 
void Cogs::GraphicsDeviceGLES30::setSize(int width, int height)
{
  if (width == this->width && height == this->height) return;
 
  this->width = width;
  this->height = height;
 
  LOG_TRACE(logger, "Resize(%d, %d)", width, height);
 
  CHECKED(glViewport(0, 0, width, height));
}
 
void Cogs::GraphicsDeviceGLES30::beginFrame()
{
  glContext.makeCurrent();
  glEnable(GL_DEPTH_TEST);
 
  context.frameStatisticsBeginFrame();
  context.setDefaults();
}
 
void Cogs::GraphicsDeviceGLES30::endFrame(uint32_t syncInterval, PresentFlags presentFlags)
{
  context.clearCachedState();
  glContext.swapBuffers(syncInterval, presentFlags);
}
 
void Cogs::GraphicsDeviceGLES30::releaseResources()
{
  effects.releaseResources();
  renderTargets.releaseResources();
  textures.releaseResources();
  buffers.releaseResources();
}
 
Cogs::ResourceStatistics Cogs::GraphicsDeviceGLES30::getResourceStatistics()
{
  ResourceStatistics stats{};
 
  stats.bufferMemoryConsumption = buffers.bufferMemoryConsumption;
  stats.textureMemoryConsumption = textures.textureMemoryConsumption;
  stats.bufferCount = static_cast<uint32_t>(buffers.buffers.size());
  stats.vertexArrayObjectCount = static_cast<uint32_t>(buffers.vertexArrayObjects.size());
  stats.inputLayoutCount = static_cast<uint32_t>(buffers.inputLayouts.size());
  stats.textureCount = static_cast<uint32_t>(textures.textures.size());
  stats.samplerStateCount = 0;// static_cast<uint32_t>(textures.samplerStates.size());
  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 = 0;// static_cast<uint32_t>(renderTargets.framebuffers.size());
 
  return stats;
}