gl.cpp

// SPDX-License-Identifier: MIT
// Author:  Giovanni Santini
// Mail:    giovanni.santini@proton.me
// Github:  @San7o
 
#include <brenta/renderer/opengl/gl.hpp>
#include <brenta/logger.hpp>
#include <brenta/window.hpp>
 
#include <sstream>
 
using namespace brenta;
 
//
// Static variables
//
 
const std::string Gl::subsystem_name  = "gl";
Gl::Config        Gl::init_config     = {};
bool              Gl::initialized     = false;
const GLboolean   Gl::True            = GL_TRUE;
const GLboolean   Gl::False           = GL_FALSE;
  
// Forward declaration
void APIENTRY glDebugOutput([[maybe_unused]] GLenum source,
                            [[maybe_unused]] GLenum type,
                            [[maybe_unused]] GLuint id,
                            [[maybe_unused]] GLenum severity,
                            [[maybe_unused]] GLsizei length,
                            [[maybe_unused]] const GLchar *message,
                            [[maybe_unused]] const void *userParam);
 
//
// Subsystem interface
//
 
std::expected<void, Subsystem::Error> Gl::initialize()
{
  if (this->is_initialized()) return {};
  
  GLADloadproc loadproc = (GLADloadproc) Window::get_proc_address();
  if (!gladLoadGLLoader(loadproc))
  {
    ERROR("{}: failed to initialize GLAD", Gl::subsystem_name);
    return std::unexpected("Failed to initialize GLAD");
  }
 
  int width  = Window::get_width();
  int height = Window::get_height();
 
  glViewport(0, 0, width, height);
 
  if (Gl::init_config.enable_depth_test)
  {
    glEnable(GL_DEPTH_TEST);
    INFO("{}: enabled GL_DEPTH_TEST", Gl::subsystem_name);
  }
 
  if (Gl::init_config.enable_blending)
  {
    glEnable(GL_BLEND);
    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
    INFO("{}: enabled GL_BLEND (transparency)", Gl::subsystem_name);
  }
 
  if (Gl::init_config.enable_backface_culling)
  {
    glEnable(GL_CULL_FACE);
    INFO("{}: enabled GL_CULL_FACE", Gl::subsystem_name);
  }
 
  if (Gl::init_config.enable_multisample)
  {
    glEnable(GL_MULTISAMPLE);
    INFO("{}: enabled GL_MULTISAMPLE", Gl::subsystem_name);
  }
 
  int flags;
  glGetIntegerv(GL_CONTEXT_FLAGS, &flags);
  if (flags & GL_CONTEXT_FLAG_DEBUG_BIT)
  {
    // Enable all messages from all sources, of all types, of all severities.
    glEnable(GL_DEBUG_OUTPUT);
    glEnable(GL_DEBUG_OUTPUT_SYNCHRONOUS); 
    glDebugMessageCallback(glDebugOutput, nullptr);
    glDebugMessageControl(GL_DONT_CARE, GL_DONT_CARE, GL_DONT_CARE,
                          0, nullptr, GL_TRUE);
    INFO("{}: configured GL_DEBUG_OUTPUT", Gl::subsystem_name);
  }
  
  GLenum errcode = Gl::check_error();
  if (errcode != GL_NO_ERROR)
  {
    return std::unexpected("GL error");
  }
 
  Gl::initialized = true;
  INFO("{}: initialized", Gl::subsystem_name);
  return {};
}
 
std::expected<void, Subsystem::Error> Gl::terminate()
{
  if (!this->is_initialized()) return {};
 
  Gl::initialized = false;
  INFO("{}: terminated", Gl::subsystem_name);
  return {};
}
 
std::string Gl::name()
{
  return Gl::subsystem_name;
}
 
bool Gl::is_initialized()
{
  return Gl::initialized;
}
 
//
// Member functions
//
 
void Gl::set_poligon_mode(GLboolean enable)
{
  if (enable)
  {
    glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
    INFO("{}: enabled GL_POLYGON_MODE (wireframe)", Gl::subsystem_name);
  }
  else
  {
    glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
    INFO("{}: disabled GL_POLYGON_MODE (fill)", Gl::subsystem_name);
  }
  return;
}
 
Gl &Gl::instance()
{
  static Gl _gl;
  return _gl;
}
 
int Gl::get_num_channels(GLenum color_format)
{
  switch (color_format)
  {
  case GL_RED:
  case GL_RED_INTEGER:
  case GL_STENCIL_INDEX:
  case GL_DEPTH_COMPONENT:
    return 1;
 
  case GL_RG:
  case GL_RG_INTEGER:
  case GL_DEPTH_STENCIL: // Depth + Stencil combined
    return 2;
 
  case GL_RGB:
  case GL_BGR:
  case GL_RGB_INTEGER:
  case GL_BGR_INTEGER:
    return 3;
 
  case GL_RGBA:
  case GL_BGRA:
  case GL_RGBA_INTEGER:
  case GL_BGRA_INTEGER:
    return 4;
 
  default:
    return 0;
  }
}
 
int Gl::get_bytes_per_channel(GLenum type)
{
  switch (type)
  {
  case GL_UNSIGNED_BYTE:
  case GL_BYTE:
    return 1;
    
  case GL_UNSIGNED_SHORT:
  case GL_SHORT:
  case GL_HALF_FLOAT: // 16-bit floating point
    return 2;
 
  case GL_UNSIGNED_INT:
  case GL_INT:
  case GL_FLOAT:
    return 4;
 
  case GL_DOUBLE:
    return 8;
 
  case GL_UNSIGNED_INT_2_10_10_10_REV:
  case GL_UNSIGNED_INT_10F_11F_11F_REV:
  case GL_UNSIGNED_INT_24_8:
    return 4; // Total bytes for all channels combined
 
  default:
    return 0;
  }
}
 
void Gl::set_viewport(int x, int y, int width, int height)
{
  glViewport(x, y, width, height);
  return;
}
 
void Gl::set_color(const Color &color)
{
  glClearColor(color.r, color.g, color.b, color.a);
  return;
}
 
void Gl::draw_arrays(GLenum mode, int first, int count)
{
  glDrawArrays(mode, first, count);
  return;
}
 
void Gl::draw_elements(GLenum mode, int count, GLenum type, const void *indices)
{
  glDrawElements(mode, count, type, indices);
  return;
}
 
void Gl::clear()
{
  glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
  return;
}
 
GLenum Gl::_check_error(const char *file, int line)
{
  GLenum errorCode;
  while ((errorCode = glGetError()) != GL_NO_ERROR)
  {
    std::string error = "";
    switch (errorCode)
    {
    case GL_INVALID_ENUM: error = "invalid enum"; break;
    case GL_INVALID_VALUE: error = "invalid value"; break;
    case GL_INVALID_OPERATION: error = "invalid operation"; break;
    case GL_STACK_OVERFLOW: error = "stack overflow"; break;
    case GL_STACK_UNDERFLOW: error = "stack underflow"; break;
    case GL_OUT_OF_MEMORY: error = "out of memory"; break;
    case GL_INVALID_FRAMEBUFFER_OPERATION:
      error = "invalid framebuffer operation"; break;
    default: error = "unknown error";  break;
    }
 
    error += " | " + std::string(file) + " (" + std::to_string(line) + ")";
    ERROR("{}: {}", Gl::subsystem_name, error);
  }
  return errorCode;
}
 
//
// Utilities
//
 
void APIENTRY glDebugOutput([[maybe_unused]] GLenum source,
                            [[maybe_unused]] GLenum type,
                            [[maybe_unused]] GLuint id,
                            [[maybe_unused]] GLenum severity,
                            [[maybe_unused]] GLsizei length,
                            [[maybe_unused]] const GLchar *message,
                            [[maybe_unused]] const void *userParam)
{
  // ignore non-significant error/warning codes
  if(id == 131169 || id == 131185 || id == 131218 || id == 131204) return; 
 
  std::stringstream out;
  out << "Debug message (" << id << "): " <<  message << std::endl;
 
  switch (source)
  {
  case GL_DEBUG_SOURCE_API:
    out << "Source: API"; break;
  case GL_DEBUG_SOURCE_WINDOW_SYSTEM:
    out << "Source: Window System"; break;
  case GL_DEBUG_SOURCE_SHADER_COMPILER:
    out << "Source: Shader Compiler"; break;
  case GL_DEBUG_SOURCE_THIRD_PARTY:
    out << "Source: Third Party"; break;
  case GL_DEBUG_SOURCE_APPLICATION:
    out << "Source: Application"; break;
  case GL_DEBUG_SOURCE_OTHER:
    out << "Source: Other"; break;
  } out << std::endl;
 
  switch (type)
  {
  case GL_DEBUG_TYPE_ERROR:
    out << "Type: Error"; break;
  case GL_DEBUG_TYPE_DEPRECATED_BEHAVIOR:
    out << "Type: Deprecated Behaviour"; break;
  case GL_DEBUG_TYPE_UNDEFINED_BEHAVIOR:
    out << "Type: Undefined Behaviour"; break; 
  case GL_DEBUG_TYPE_PORTABILITY:
    out << "Type: Portability"; break;
  case GL_DEBUG_TYPE_PERFORMANCE:
    out << "Type: Performance"; break;
  case GL_DEBUG_TYPE_MARKER:
    out << "Type: Marker"; break;
  case GL_DEBUG_TYPE_PUSH_GROUP:
    out << "Type: Push Group"; break;
  case GL_DEBUG_TYPE_POP_GROUP:
    out << "Type: Pop Group"; break;
  case GL_DEBUG_TYPE_OTHER:
    out << "Type: Other"; break;
  } out << std::endl;
    
  switch (severity)
  {
  case GL_DEBUG_SEVERITY_HIGH:
    out << "Severity: high"; break;
  case GL_DEBUG_SEVERITY_MEDIUM:
    out << "Severity: medium"; break;
  case GL_DEBUG_SEVERITY_LOW:
    out << "Severity: low"; break;
  case GL_DEBUG_SEVERITY_NOTIFICATION:
    out << "Severity: notification"; break;
  } out << std::endl;
  out << std::endl;
 
  ERROR("{}: {}", Gl::subsystem_name, out.str());
}
 
//
// Builder
//
 
Gl::Builder &Gl::Builder::blending()
{
  this->conf.enable_blending = true;
  return *this;
}
 
Gl::Builder &Gl::Builder::backface_culling()
{
  this->conf.enable_backface_culling = true;
  return *this;
}
 
Gl::Builder &Gl::Builder::multisample()
{
  this->conf.enable_multisample = true;
  return *this;
}
 
Gl::Builder &Gl::Builder::depth_test()
{
  this->conf.enable_depth_test = true;
  return *this;
}
 
brenta::Subsystem &Gl::Builder::build()
{
  Gl::init_config = this->conf;
  return Gl::instance();
}