CapabilitiesGLES30.cpp

#include "CapabilitiesGLES30.h"
 
#include <sstream>
#include <iterator>
#include <algorithm>
#include <cctype>
#include <regex>
 
#include "CommonGLES30.h"
#include "FormatsGLES30.h"
 
#include "Foundation/Logging/Logger.h"
 
#ifdef __EMSCRIPTEN__
#include <emscripten.h>
#endif
 
namespace
{
  static Cogs::Logging::Log logger = Cogs::Logging::getLogger("CapabilitiesGLES30");
 
  void toUpper(std::string & string)
  {
    std::transform(string.begin(), string.end(), string.begin(), [](const char & c) { return (char)::toupper(c); });
  }
}
 
void Cogs::CapabilitiesGLES30::initialize(bool isFullGL, bool useClipControl)
{
  isFullGL_ = isFullGL;
 
  std::string vendor((const char *)glGetString(GL_VENDOR));
  std::string renderer((const char *)glGetString(GL_RENDERER));
 
  if (logStrings) {
    LOG_DEBUG(logger, "GL_VERSION: %s", glGetString(GL_VERSION));
    LOG_DEBUG(logger, "GL_VENDOR: %s", vendor.c_str());
    LOG_DEBUG(logger, "GL_RENDERER: %s", renderer.c_str());
    LOG_DEBUG(logger, "GL_SHADING_LANGUAGE_VERSION: %s", glGetString(GL_SHADING_LANGUAGE_VERSION));
 
  }
 
  const auto extensionsString = std::string((const char *)glGetString(GL_EXTENSIONS));
  {
    std::istringstream sstream(extensionsString);
    extensions = std::unordered_set<std::string>(std::istream_iterator<std::string>(sstream), std::istream_iterator<std::string>());
  }
 
  if (logExtensions) {
    std::istringstream sstream(extensionsString);
    std::string ext;
    while(sstream >> ext){
      LOG_DEBUG(logger, "Extension: %s", ext.c_str());
    }
  }
 
  ::toUpper(vendor);
  ::toUpper(renderer);
 
  if (vendor.find("NVIDIA") != vendor.npos) {
    this->vendor = Vendors::nVidia;
 
    if (renderer.find("QUADRO FX") != std::string::npos) series = Series::QuadroFX;
    else if (renderer.find("QUADRO") != std::string::npos) series = Series::Quadro;
    else if (renderer.find("GEFORCE") != std::string::npos) series = Series::geForce;
 
    auto modelString = renderer.substr(0, renderer.find_first_of('/'));
 
    if (modelString.size()) {
      std::regex numbers("\\d.*");
      std::smatch results;
 
      if (std::regex_search(modelString, results, numbers)) {
        model = std::stoi(results[0].str());
      }
    }
  } else if (vendor.find("AMD") != vendor.npos || vendor.find("ATI") != vendor.npos) {
    this->vendor = Vendors::AMD;
 
    if (renderer.find("FIREGL") != std::string::npos) series = Series::FireGL;
  } else if (vendor.find("INTEL") != vendor.npos) {
    this->vendor = Vendors::Intel;
  } else {
    this->vendor = Vendors::Unknown;
  }
 
  glGetIntegerv(GL_MAX_TEXTURE_IMAGE_UNITS, &deviceCapabilities.MaxTextureSlots);
  glGetIntegerv(GL_MAX_VERTEX_ATTRIBS, &deviceCapabilities.MaxVertexInputElements);
 
  if (isSupported("GL_EXT_texture_filter_anisotropic")) {
    glGetFloatv(GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT, &deviceCapabilities.MaxAnisotropy);
    LOG_DEBUG(logger, "GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT: %f", deviceCapabilities.MaxAnisotropy);
  }
 
  GLint samples = 0;
  glGetIntegerv(GL_MAX_SAMPLES, &samples);
  deviceCapabilities.MaxSamples = std::max(1, samples);
 
  GLint maxTextureSize = 0;
  glGetIntegerv(GL_MAX_TEXTURE_SIZE, &maxTextureSize);
  deviceCapabilities.MaxTexture2DSize = std::max(1, maxTextureSize);
 
  GLint max3DTextureSize = 0;
  glGetIntegerv(GL_MAX_3D_TEXTURE_SIZE, &max3DTextureSize);
  deviceCapabilities.MaxTexture3DSize = std::max(1, max3DTextureSize);
 
  GLint maxCubeTextureSize = 0;
  glGetIntegerv(GL_MAX_CUBE_MAP_TEXTURE_SIZE, &maxCubeTextureSize);
  deviceCapabilities.MaxTextureCubeSize = std::max(1, maxCubeTextureSize);
 
  GLint maxArrayTextureLayers = 0;
  glGetIntegerv(GL_MAX_ARRAY_TEXTURE_LAYERS, &maxArrayTextureLayers);
  deviceCapabilities.MaxTextureArrayLayers = std::max(1, maxArrayTextureLayers);
 
  LOG_DEBUG(logger, "Texture limits: 2D=%u 3D=%u Cube=%u Array=%u",
            deviceCapabilities.MaxTexture2DSize,
            deviceCapabilities.MaxTexture3DSize,
            deviceCapabilities.MaxTextureCubeSize,
            deviceCapabilities.MaxTextureArrayLayers);
 
  GLint uniformBufferOffsetAlignment = 0;
  glGetIntegerv(GL_UNIFORM_BUFFER_OFFSET_ALIGNMENT, &uniformBufferOffsetAlignment);
  if (uniformBufferOffsetAlignment) {
    deviceCapabilities.ConstantBufferOffsetAlignment = uniformBufferOffsetAlignment;
  }
  deviceCapabilities.ConstantBufferRange = true;
 
  if (isSupported("GL_OCULUS_multiview")) {
    deviceCapabilities.MultiSampleMultiView = true;
    deviceCapabilities.MultiView = true;
  }
  else if (isSupported("GL_OVR_multiview_multisampled_render_to_texture")) {
    deviceCapabilities.MultiSampleMultiView = true;
    deviceCapabilities.MultiView = true;
  }
  else if (isSupported("GL_OVR_multiview2")) {
    deviceCapabilities.MultiView = true;
  }
  else if (isSupported("GL_OVR_multiview")) {
    deviceCapabilities.MultiView = true;
  }
 
#ifdef __EMSCRIPTEN__
  if (!deviceCapabilities.MultiView) {
    int x = EM_ASM_INT({
      for (const item of Object.values(Module.GL.contexts)) {
        if (item && item.hasOwnProperty('GLctx')) {
          const ext = item.GLctx.getExtension("OVR_multiview2");
          return ext !== null ? 1 : 0;
        }
      }
    });
    if (x) {
      LOG_DEBUG(logger, "Browser supports OVR_multiview2 even though emscripten doesn't, enabling regardless");
      deviceCapabilities.MultiView = true;
    }
  }
 
  if (!deviceCapabilities.MultiSampleMultiView) {
    int x = EM_ASM_INT({
      for (const item of Object.values(Module.GL.contexts)) {
        if (item && item.hasOwnProperty('GLctx')) {
          const ext = item.GLctx.getExtension("OCULUS_multiview");
          return ext !== null ? 1 : 0;
        }
      }
    });
    if (x) {
      LOG_DEBUG(logger, "Browser supports OCULUS_multiview even though emscripten doesn't, enabling regardless");
      deviceCapabilities.MultiSampleMultiView = true;
      deviceCapabilities.MultiView = true;
    }
  }
#endif
 
  // Check color encoding of default framebuffer.
  deviceCapabilities.DefaultColorTargetHasLinearEncoding = false;
  {
    GLint param = GL_INVALID_ENUM;
    glBindFramebuffer(GL_FRAMEBUFFER, 0);
    glGetFramebufferAttachmentParameteriv(GL_FRAMEBUFFER, GL_BACK, GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING, &param);
    switch (param) {
    case GL_LINEAR:
      LOG_DEBUG(logger, "Default render target has LINEAR encoding");
      deviceCapabilities.DefaultColorTargetHasLinearEncoding = true;
      break;
    case GL_SRGB:
      LOG_DEBUG(logger, "Default render target has SRGB encoding");
      break;
    default:
      LOG_ERROR(logger, "glGetFramebufferAttachmentParameter returned unrecognized enum: #%04x", param);
      break;
    }
  }
 
  if (deviceCapabilities.MultiView) {
    GLint maxViews = 0;
    glGetIntegerv(GL_MAX_VIEWS_OVR, &maxViews);
    deviceCapabilities.MaxMultiViews = std::max(0, maxViews);
    LOG_DEBUG(logger, "MultiView rendering available, maxViews=%d, maxSamples=%d",
              maxViews,
              deviceCapabilities.MultiSampleMultiView ? deviceCapabilities.MaxSamples : 1);
  }
 
//  "framebufferTextureMultisampleMultiviewOVR"
 
#ifdef EMSCRIPTEN
  // ES 2.0 supports buffer sharing, WebGL explicitly does not (WebGL 1.0, section 6.1).
  deviceCapabilities.VertexAndIndexDataInSharedBuffers = false;
#endif
 
  deviceCapabilities.SyncObjects = true;
  deviceCapabilities.UnsignedIntIndexes = true;
  deviceCapabilities.FloatTextures = true;
  deviceCapabilities.FragDepth = true;
  deviceCapabilities.SupportsHlsl = false;
  deviceCapabilities.StartInstance = false;
  deviceCapabilities.IndependentSamplerState = false;
  deviceCapabilities.SupportsMultipleThreads = false;
  deviceCapabilities.TextureCubeArrays = false;
  deviceCapabilities.VertexArrayObjects = true;
  deviceCapabilities.OriginOnTop = false;
  deviceCapabilities.DepthNegativeOneToOne = !useClipControl;
 
  if (isSupported("GL_EXT_depth_clamp")) {
    // Disabled until we have control over its use in Cogs.Core: It will break
    // reflection passes if it is enabled during it as that technique relies
    // on using the near-plane clip to remove anything above the reflection
    // plane.
    // deviceCapabilities.NoDepthClip = true;
  }
  if (isSupported("GL_EXT_texture_compression_s3tc") ||
    isSupported("GL_WEBGL_compressed_texture_s3tc")) {
    deviceCapabilities.TextureCompressionS3TC = true;
  }
  if (isSupported("GL_ARB_texture_compression_rgtc") || 
    isSupported("GL_EXT_texture_compression_rgtc")) {
    deviceCapabilities.TextureCompressionRGTC = true;
  }
  if (isSupported("GL_ARB_texture_compression_bptc") || 
    isSupported("GL_EXT_texture_compression_bptc")) {
    deviceCapabilities.TextureCompressionBPTC = true;
  }
  if (isSupported("WEBGL_compressed_texture_etc") ||
    isSupported("GL_OES_compressed_ETC1_RGB8_texture")) {
    deviceCapabilities.TextureCompressionETC = true;
  }
  if (isSupported("WEBGL_compressed_texture_pvrtc") ||
    isSupported("GL_IMG_texture_compression_pvrtc")) {
    deviceCapabilities.TextureCompressionPVRTC = true;
  }
  if (isSupported("WEBGL_compressed_texture_astc") || 
    isSupported("GL_OES_texture_compression_astc") || (
    isSupported("GL_KHR_texture_compression_astc_hdr") &&
    isSupported("GL_KHR_texture_compression_astc_ldr"))) {
    deviceCapabilities.TextureCompressionASTC = true;
  }
 
  OpenGLES30::enableExtensionFormats(this);
}
 
bool Cogs::CapabilitiesGLES30::isSupported(const StringView & extension) const
{
  return extensions.find(std::string(extension)) != extensions.end();
}