CapabilitiesGL20.cpp

#include "CapabilitiesGL20.h"
#include "CommonGL20.h"
 
#include "Foundation/Logging/Logger.h"
 
#include <algorithm>
#include <cctype>
#include <regex>
 
namespace 
{
  static Cogs::Logging::Log logger = Cogs::Logging::getLogger("CapabilitiesGL20");
 
  void toUpper(std::string & string)
  {
    std::transform(string.begin(), string.end(), string.begin(), [](const char & c) { return (char)::toupper(c); });
  }
}
 
Cogs::CapabilitiesGL20::CapabilitiesGL20() :
  logStrings(true),
  logExtensions(false),
  vendor(Vendors::Unknown),
  series(Series::Unknown),
  model(UnknownModel)
{
}
 
void Cogs::CapabilitiesGL20::initialize(bool useClipControl)
{
  const char* vendorString = reinterpret_cast<const char*>(glGetString(GL_VENDOR));
  const char* rendererString = reinterpret_cast<const char*>(glGetString(GL_RENDERER));
  std::string vendor(vendorString ? vendorString : "");
  std::string renderer(rendererString ? rendererString : "");
  
  if (logStrings) {
    LOG_DEBUG(logger, "Version: %s", glGetString(GL_VERSION));
    LOG_DEBUG(logger, "Vendor: %s", vendor.c_str());
    LOG_DEBUG(logger, "Renderer: %s", renderer.c_str());
    
    if (logExtensions) {
      GLint numExtensions;
      glGetIntegerv(GL_NUM_EXTENSIONS, &numExtensions);
 
      for (GLint i = 0; i < numExtensions; i++) {
        LOG_DEBUG(logger, "%s", (const char *)glGetStringi(GL_EXTENSIONS, i));
      }
    }
  }
 
  toUpper(vendor);
  toUpper(renderer);
 
  GLint num_extensions = 0;
  glGetIntegerv(GL_NUM_EXTENSIONS, &num_extensions);
  for(GLint i=0; i<num_extensions; i++){
    const char *ext = (const char*)glGetStringi(GL_EXTENSIONS, i);
    extensions.insert(std::string(ext));
  }
 
  ARB_base_instance = isSupported("GL_ARB_base_instance");
  ARB_instanced_arrays = isSupported("GL_ARB_instanced_arrays");
  ARB_sampler_objects = isSupported("GL_ARB_sampler_objects");
  ARB_shader_image_load_store = isSupported("GL_ARB_shader_image_load_store");
  ARB_pixel_buffer_object = isSupported("GL_ARB_pixel_buffer_object");
  ARB_texture_storage = isSupported("GL_ARB_texture_storage");
  ARB_texture_storage_multisample = isSupported("GL_ARB_texture_storage_multisample");
  ARB_compute_shader = isSupported("GL_ARB_compute_shader");
  KHR_debug = isSupported("GL_KHR_debug");
  ARB_debug_output = isSupported("GL_ARB_debug_output");
  EXT_texture_filter_anisotropic = isSupported("GL_EXT_texture_filter_anisotropic");
 
  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 if (vendor.find("APPLE") != vendor.npos) {
    this->vendor = Vendors::Apple;
  }
  else {
    this->vendor = Vendors::Unknown;
  }
 
  glGetIntegerv(GL_MAX_TEXTURE_IMAGE_UNITS, &deviceCapabilities.MaxTextureSlots);
  glGetIntegerv(GL_MAJOR_VERSION, &deviceCapabilities.featureLevelMajor);
  glGetIntegerv(GL_MINOR_VERSION, &deviceCapabilities.featureLevelMinor);
 
  GLint uniformBufferOffsetAlignment = 0;
  glGetIntegerv(GL_UNIFORM_BUFFER_OFFSET_ALIGNMENT, &uniformBufferOffsetAlignment);
  if (uniformBufferOffsetAlignment) {
    deviceCapabilities.ConstantBufferOffsetAlignment = uniformBufferOffsetAlignment;
  }
 
  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);
 
  deviceCapabilities.SyncObjects = true;
#ifdef COGS_ENABLE_GLSLANG
  deviceCapabilities.SupportsHlsl = true;
#endif
  deviceCapabilities.GeometryShaders = true;
  deviceCapabilities.TessellationShaders = true;
  deviceCapabilities.ComputeShaders = true;
  deviceCapabilities.SupportsMultipleThreads = false;
  deviceCapabilities.OriginOnTop = false;
  deviceCapabilities.DepthNegativeOneToOne = !useClipControl;
 
  if (isSupported("GL_EXT_texture_compression_s3tc")) {
    deviceCapabilities.TextureCompressionS3TC = true;
  }
  if (isSupported("GL_EXT_texture_compression_rgtc")) {
    deviceCapabilities.TextureCompressionRGTC = true;
  }
  if (isSupported("GL_ARB_texture_compression_bptc")) {
    deviceCapabilities.TextureCompressionBPTC = true;
  }
  if (isSupported("GL_KHR_texture_compression_astc_hdr")) {
    deviceCapabilities.TextureCompressionASTC = true;
  }
 
}
 
bool Cogs::CapabilitiesGL20::isSupported(const StringView & extension) const
{
  return extensions.find(std::string(extension)) != extensions.end();
}