From 12fdcc237fe2a5456044f0025f2e383236e5f78a Mon Sep 17 00:00:00 2001 From: Dorian Wouters Date: Fri, 24 Feb 2017 21:15:22 -0500 Subject: [PATCH] Support for multiple OpenGL Loaders: epoxy, glbinding, glad, glew --- CMakeLists.txt | 48 +++++++++++-- include/.gitignore | 2 + src/.gitignore | 1 + src/Clouds.hpp | 8 +-- src/EscMenu.cpp | 4 +- src/GameWindow.cpp | 112 ++++++++++++++++------------- src/GameWindow.hpp | 8 ++- src/Player.hpp | 8 +-- src/Texture.cpp | 24 +++---- src/Texture.hpp | 12 ++-- src/content/Registry.cpp | 32 +++++---- src/platform/Fixes.glibc.hpp | 15 ++++ src/platform/Fixes.hpp | 12 ++++ src/platform/Fixes.windows.hpp | 12 ++++ src/render/CMakeLists.txt | 45 +++++++++++- src/render/gl/CMakeLists.txt | 2 + src/render/gl/FBO.cpp | 30 ++++---- src/render/gl/FBO.hpp | 2 +- src/render/gl/FeatureSupport.cpp | 16 +++-- src/render/gl/FeatureSupport.hpp | 4 +- src/render/gl/OpenGL.cpp | 40 +++++++++++ src/render/gl/OpenGL.glad.cpp | 51 +++++++++++++ src/render/gl/OpenGL.glbinding.cpp | 58 +++++++++++++++ src/render/gl/OpenGL.glew.cpp | 58 +++++++++++++++ src/render/gl/OpenGL.hpp | 95 ++++++++++++++++++++++++ src/render/gl/OpenGL.libepoxy.cpp | 57 +++++++++++++++ src/render/gl/Program.cpp | 10 ++- src/render/gl/Program.hpp | 2 +- src/render/gl/README.glad.md | 25 +++++++ src/render/gl/Shader.cpp | 3 +- src/render/gl/Shader.hpp | 9 ++- src/render/gl/Util.cpp | 4 ++ src/render/gl/Util.hpp | 6 +- src/render/gl/VAO.hpp | 2 +- src/render/gl/VBO.hpp | 2 +- src/ui/Font.hpp | 2 +- 36 files changed, 684 insertions(+), 137 deletions(-) create mode 100644 include/.gitignore create mode 100644 src/.gitignore create mode 100644 src/platform/Fixes.glibc.hpp create mode 100644 src/platform/Fixes.hpp create mode 100644 src/platform/Fixes.windows.hpp create mode 100644 src/render/gl/OpenGL.cpp create mode 100644 src/render/gl/OpenGL.glad.cpp create mode 100644 src/render/gl/OpenGL.glbinding.cpp create mode 100644 src/render/gl/OpenGL.glew.cpp create mode 100644 src/render/gl/OpenGL.hpp create mode 100644 src/render/gl/OpenGL.libepoxy.cpp create mode 100644 src/render/gl/README.glad.md diff --git a/CMakeLists.txt b/CMakeLists.txt index 778c5e9..957226d 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -92,16 +92,15 @@ endif() find_package(Optional REQUIRED) -pkg_search_module(EPOXY REQUIRED epoxy) pkg_search_module(GLFW REQUIRED glfw3) pkg_search_module(SQLITE3 REQUIRED sqlite3) pkg_search_module(LIBSODIUM REQUIRED libsodium) include_directories(BEFORE + "${CMAKE_CURRENT_SOURCE_DIR}/include" ${ETC_INCLUDE_DIRS} ${LUA_INCLUDE_DIR} ${LZFX_INCLUDE_DIRS} ${ENET_INCLUDE_DIRS} - ${EPOXY_INCLUDE_DIRS} ${GLFW_INCLUDE_DIRS} ${LIBSODIUM_INCLUDE_DIRS} ${SQLITE3_INCLUDE_DIRS} @@ -114,27 +113,64 @@ include_directories(BEFORE #file(GLOB_RECURSE FILELIST "*.h" "*.hpp" "*.cpp") #add_custom_target(files SOURCES ${FILELIST}) -# Add diggler executable target +### Allow subdirs to add params to the `diggler` target +# Sources set_property(GLOBAL PROPERTY DIGGLER_SOURCE_FILES "") -macro(diggler_add_sources) +function(diggler_add_sources) get_property(SRCS GLOBAL PROPERTY DIGGLER_SOURCE_FILES) list(APPEND SRCS ${ARGV}) set_property(GLOBAL PROPERTY DIGGLER_SOURCE_FILES "${SRCS}") -endmacro(diggler_add_sources) +endfunction(diggler_add_sources) + +# Definitions +set_property(GLOBAL PROPERTY DIGGLER_DEFINITIONS "") +function(diggler_add_definition) + get_property(DEFS GLOBAL PROPERTY DIGGLER_DEFINITIONS) + list(APPEND DEFS "${ARGV0}") + set_property(GLOBAL PROPERTY DIGGLER_DEFINITIONS "${DEFS}") +endfunction(diggler_add_definition) + +# Include directories +set_property(GLOBAL PROPERTY DIGGLER_INCLUDE_DIRECTORIES "") +function(diggler_include_directories) + get_property(INCDIRS GLOBAL PROPERTY DIGGLER_INCLUDE_DIRECTORIES) + list(APPEND INCDIRS ${ARGV}) + set_property(GLOBAL PROPERTY DIGGLER_INCLUDE_DIRECTORIES "${INCDIRS}") +endfunction(diggler_include_directories) + +# Link libraries +set_property(GLOBAL PROPERTY DIGGLER_LINK_LIBRARIES "") +function(diggler_link_libraries) + get_property(LIBS GLOBAL PROPERTY DIGGLER_LINK_LIBRARIES) + list(APPEND LIBS ${ARGV}) + set_property(GLOBAL PROPERTY DIGGLER_LINK_LIBRARIES "${LIBS}") +endfunction(diggler_link_libraries) set(DIGGLER_USED_ROOT_CMAKELISTS TRUE) add_subdirectory("${CMAKE_CURRENT_SOURCE_DIR}/src") +### Create target and apply parameters +# Include directories +get_property(INCDIRS GLOBAL PROPERTY DIGGLER_INCLUDE_DIRECTORIES) +include_directories(BEFORE ${INCDIRS}) + +# Sources get_property(SRCS GLOBAL PROPERTY DIGGLER_SOURCE_FILES) add_executable(diggler ${SRCS}) +# Definitions +get_property(DEFS GLOBAL PROPERTY DIGGLER_DEFINITIONS) +target_compile_definitions(diggler PUBLIC ${DEFS}) + +# Link libraries +get_property(LIBS GLOBAL PROPERTY DIGGLER_LINK_LIBRARIES) target_link_libraries(diggler + ${LIBS} ${ETC_LIBRARIES} ${LUA_LIBRARY} ${LZFX_LIBRARIES} ${ENET_LIBRARIES} - ${EPOXY_LIBRARIES} ${GLFW_LIBRARIES} ${LIBSODIUM_LIBRARIES} ${SQLITE3_LIBRARIES} diff --git a/include/.gitignore b/include/.gitignore new file mode 100644 index 0000000..2831253 --- /dev/null +++ b/include/.gitignore @@ -0,0 +1,2 @@ +KHR +glad diff --git a/src/.gitignore b/src/.gitignore new file mode 100644 index 0000000..15ea16d --- /dev/null +++ b/src/.gitignore @@ -0,0 +1 @@ +glad.c diff --git a/src/Clouds.hpp b/src/Clouds.hpp index 1ba2969..4c44674 100644 --- a/src/Clouds.hpp +++ b/src/Clouds.hpp @@ -1,7 +1,7 @@ -#ifndef CLOUDS_HPP -#define CLOUDS_HPP +#ifndef DIGGLER_CLOUDS_HPP +#define DIGGLER_CLOUDS_HPP -#include +#include "render/gl/OpenGL.hpp" #include #include "render/gl/VBO.hpp" @@ -37,4 +37,4 @@ public: } -#endif +#endif /* DIGGLER_CLOUDS_HPP */ diff --git a/src/EscMenu.cpp b/src/EscMenu.cpp index d3876db..5c297ea 100644 --- a/src/EscMenu.cpp +++ b/src/EscMenu.cpp @@ -1,7 +1,9 @@ #include "EscMenu.hpp" -#include + +#include "render/gl/OpenGL.hpp" #include #include + #include "Game.hpp" #include "ui/Text.hpp" #include "ui/Button.hpp" diff --git a/src/GameWindow.cpp b/src/GameWindow.cpp index b1438a8..9ab1326 100644 --- a/src/GameWindow.cpp +++ b/src/GameWindow.cpp @@ -27,54 +27,58 @@ static void APIENTRY glDebugCallback(GLenum source, GLenum type, GLuint id, GLenum severity, GLsizei length, const GLchar *message, const void *userParam) { const char *sourceStr = "???"; switch (source) { - case GL_DEBUG_SOURCE_API: - sourceStr = "API"; - break; - case GL_DEBUG_SOURCE_WINDOW_SYSTEM: - sourceStr = "WIN"; - break; - case GL_DEBUG_SOURCE_SHADER_COMPILER: - sourceStr = "SHC"; - break; - case GL_DEBUG_SOURCE_THIRD_PARTY: - sourceStr = "3PT"; - break; - case GL_DEBUG_SOURCE_APPLICATION: - sourceStr = "APP"; - break; - case GL_DEBUG_SOURCE_OTHER: - sourceStr = "OTH"; - break; + case GL_DEBUG_SOURCE_API: + sourceStr = "API"; + break; + case GL_DEBUG_SOURCE_WINDOW_SYSTEM: + sourceStr = "WIN"; + break; + case GL_DEBUG_SOURCE_SHADER_COMPILER: + sourceStr = "SHC"; + break; + case GL_DEBUG_SOURCE_THIRD_PARTY: + sourceStr = "3PT"; + break; + case GL_DEBUG_SOURCE_APPLICATION: + sourceStr = "APP"; + break; + case GL_DEBUG_SOURCE_OTHER: + sourceStr = "OTH"; + break; + default: + break; } const char *typeStr = "???"; switch (type) { - case GL_DEBUG_TYPE_ERROR: - typeStr = "ERR"; - break; - case GL_DEBUG_TYPE_DEPRECATED_BEHAVIOR: - typeStr = "DEP"; - break; - case GL_DEBUG_TYPE_UNDEFINED_BEHAVIOR: - typeStr = "UND"; - break; - case GL_DEBUG_TYPE_PORTABILITY: - typeStr = "PRT"; - break; - case GL_DEBUG_TYPE_PERFORMANCE: - typeStr = "PRF"; - break; - case GL_DEBUG_TYPE_MARKER: - typeStr = "MKR"; - break; - case GL_DEBUG_TYPE_PUSH_GROUP: - typeStr = "GP+"; - break; - case GL_DEBUG_TYPE_POP_GROUP: - typeStr = "GP-"; - break; - case GL_DEBUG_TYPE_OTHER: - typeStr = "OTH"; - break; + case GL_DEBUG_TYPE_ERROR: + typeStr = "ERR"; + break; + case GL_DEBUG_TYPE_DEPRECATED_BEHAVIOR: + typeStr = "DEP"; + break; + case GL_DEBUG_TYPE_UNDEFINED_BEHAVIOR: + typeStr = "UND"; + break; + case GL_DEBUG_TYPE_PORTABILITY: + typeStr = "PRT"; + break; + case GL_DEBUG_TYPE_PERFORMANCE: + typeStr = "PRF"; + break; + case GL_DEBUG_TYPE_MARKER: + typeStr = "MKR"; + break; + case GL_DEBUG_TYPE_PUSH_GROUP: + typeStr = "GP+"; + break; + case GL_DEBUG_TYPE_POP_GROUP: + typeStr = "GP-"; + break; + case GL_DEBUG_TYPE_OTHER: + typeStr = "OTH"; + break; + default: + break; } const char *severityStr = "??"; switch (severity) { @@ -90,6 +94,8 @@ static void APIENTRY glDebugCallback(GLenum source, GLenum type, GLuint id, case GL_DEBUG_SEVERITY_NOTIFICATION: severityStr = "NT"; break; + default: + break; } char line[3 + 1 + 3 + 1 + 2 + 2 + 1]; std::snprintf(line, sizeof(line)/sizeof(line[0]), "%3s %3s %2s] ", sourceStr, typeStr, severityStr); @@ -101,7 +107,7 @@ GameWindow::GameWindow(Game *G) : G(G) { if (InstanceCount++ == 0) { glfwSetErrorCallback(glfwErrorCallback); int glfwStatus = glfwInit(); - if (glfwStatus != GL_TRUE) { + if (glfwStatus != GLFW_TRUE) { std::ostringstream err; err << "GLFW init failed (" << glfwStatus << ')'; throw std::runtime_error(err.str()); @@ -122,7 +128,7 @@ GameWindow::GameWindow(Game *G) : G(G) { //glfwWindowHint(GLFW_STENCIL_BITS, 8); #ifdef DEBUG - glfwWindowHint(GLFW_OPENGL_DEBUG_CONTEXT, GL_TRUE); + glfwWindowHint(GLFW_OPENGL_DEBUG_CONTEXT, GLFW_TRUE); #endif m_window = glfwCreateWindow(m_w, m_h, "Diggler", nullptr, nullptr); @@ -131,6 +137,9 @@ GameWindow::GameWindow(Game *G) : G(G) { throw std::runtime_error("GLFW window creation failed"); } glfwMakeContextCurrent(m_window); + + Render::gl::OpenGL::init(); + #ifdef DEBUG glDebugMessageControl(GL_DONT_CARE, GL_DONT_CARE, GL_DONT_CARE, 0, nullptr, GL_TRUE); glDebugMessageCallback(glDebugCallback, nullptr); @@ -173,7 +182,14 @@ GameWindow::GameWindow(Game *G) : G(G) { #endif ; - getOutputStreamRaw() << "-- Epoxy GL" << (epoxy_is_desktop_gl() ? "" : "ES") << epoxy_gl_version() << std::endl; + auto glver = Render::gl::OpenGL::version(); + getOutputStreamRaw() << "-- " << + Render::gl::OpenGL::loaderName() << ' ' << + Render::gl::OpenGL::loaderVersion() << " -- GL" << + (glver.isGLES ? "ES" : "") << ' ' << + glver.major << '.' << glver.minor << + (glver.isCore ? " Core" : "") << + (glver.isForward ? " FC" : "") << ' ' << std::endl; if (InstanceCount == 1) { // If we're the first instance const uint8 *GL_version = glGetString(GL_VERSION); diff --git a/src/GameWindow.hpp b/src/GameWindow.hpp index 780f6b7..00176f1 100644 --- a/src/GameWindow.hpp +++ b/src/GameWindow.hpp @@ -1,10 +1,16 @@ #ifndef GAME_WINDOW_HPP #define GAME_WINDOW_HPP + #include + #include -#include + +#include "render/gl/OpenGL.hpp" +#define GLFW_INCLUDE_NONE #include + #include + #include "Platform.hpp" #include "ui/Manager.hpp" diff --git a/src/Player.hpp b/src/Player.hpp index a99c822..e66fa13 100644 --- a/src/Player.hpp +++ b/src/Player.hpp @@ -1,13 +1,13 @@ -#ifndef PLAYER_HPP -#define PLAYER_HPP +#ifndef DIGGLER_PLAYER_HPP +#define DIGGLER_PLAYER_HPP #include "Platform.hpp" #include #include #include +#include "render/gl/OpenGL.hpp" #include -#include #include "platform/PreprocUtils.hpp" #include "network/Network.hpp" @@ -75,4 +75,4 @@ public: } -#endif +#endif /* DIGGLER_PLAYER_HPP */ diff --git a/src/Texture.cpp b/src/Texture.cpp index 5fc6d3a..d6b61c4 100644 --- a/src/Texture.cpp +++ b/src/Texture.cpp @@ -40,9 +40,9 @@ Texture::Texture(const std::string &path, PixelFormat format) { case PixelFormat::RGBA: stbiFormat = STBI_rgb_alpha; break; - case PixelFormat::Monochrome8: +/* case PixelFormat::Monochrome8: stbiFormat = STBI_grey; - break; + break;*/ } int width, height, channels; unsigned char *ptr = nullptr; @@ -89,7 +89,7 @@ GLenum getFilterGlConstant(Texture::Filter filter) { case Texture::Filter::Nearest: return GL_NEAREST; } - return 0; + return GL_INVALID_ENUM; } void Texture::setFiltering(Filter min, Filter mag) { @@ -100,7 +100,7 @@ void Texture::setFiltering(Filter min, Filter mag) { PopBoundTex(); } -static GLint getWrapGlConstant(Texture::Wrapping wrap) { +static GLenum getWrapGlConstant(Texture::Wrapping wrap) { switch (wrap) { case Texture::Wrapping::ClampEdge: return GL_CLAMP_TO_EDGE; @@ -111,7 +111,7 @@ static GLint getWrapGlConstant(Texture::Wrapping wrap) { case Texture::Wrapping::MirroredRepeat: return GL_MIRRORED_REPEAT; } - return 0; + return GL_INVALID_ENUM; } void Texture::setWrapping(Wrapping s, Wrapping t) { @@ -130,9 +130,9 @@ void Texture::setPlaceholder() { case PixelFormat::RGBA: pxLength = 4; break; - case PixelFormat::Monochrome8: +/* case PixelFormat::Monochrome8: pxLength = 1; - break; + break;*/ } unsigned char *white = new unsigned char[m_w * m_h * pxLength]; memset(white, 255, m_w * m_h * pxLength); @@ -148,11 +148,11 @@ static GLenum getGlTexFormat(Texture::PixelFormat fmt) { case Texture::PixelFormat::RGBA: return GL_RGBA; break; - case Texture::PixelFormat::Monochrome8: +/* case Texture::PixelFormat::Monochrome8: return GL_R8; - break; + break;*/ } - return 0; + return GL_INVALID_ENUM; } void Texture::setTexture(uint w, uint h, const uint8_t *data, PixelFormat format) { @@ -223,9 +223,9 @@ uint Texture::requiredBufferSize() { case PixelFormat::RGBA: texelSize = 4; break; - case PixelFormat::Monochrome8: +/* case PixelFormat::Monochrome8: texelSize = 1; - break; + break; */ } return m_w * m_h * texelSize; } diff --git a/src/Texture.hpp b/src/Texture.hpp index b9a22ab..23497f3 100644 --- a/src/Texture.hpp +++ b/src/Texture.hpp @@ -1,15 +1,17 @@ -#ifndef TEXTURE_HPP -#define TEXTURE_HPP -#include +#ifndef DIGGLER_TEXTURE_HPP +#define DIGGLER_TEXTURE_HPP + #include +#include "render/gl/OpenGL.hpp" + namespace Diggler { class Texture { public: enum class PixelFormat { RGB, RGBA, - Monochrome8 + // Monochrome8 }; enum class Filter { Nearest, @@ -72,4 +74,4 @@ public: }; } -#endif +#endif /* DIGGLER_TEXTURE_HPP */ diff --git a/src/content/Registry.cpp b/src/content/Registry.cpp index e6b6eb7..d903df7 100644 --- a/src/content/Registry.cpp +++ b/src/content/Registry.cpp @@ -117,25 +117,29 @@ Registry::Registry() : br.commit(); } - m_texturePacker = new TexturePacker(64*8, 64*8); - m_texturePacker->freezeTexUpdate(true); + if (GlobalProperties::IsClient) { + m_texturePacker = new TexturePacker(64*8, 64*8); + m_texturePacker->freezeTexUpdate(true); - // Valve checkerboard! :) - unk1 = m_texturePacker->add(2, 2, 3, (uint8*)"\x00\x00\x00\xFF\x00\xFF\xFF\x00\xFF\x00\x00\x00"); - unk2 = m_texturePacker->add(2, 2, 3, (uint8*)"\x00\x00\x00\x00\x00\xFF\x00\x00\xFF\x00\x00\x00"); - unk3 = m_texturePacker->add(2, 2, 3, (uint8*)"\x00\x00\x00\x00\xFF\x00\x00\xFF\x00\x00\x00\x00"); - unk4 = m_texturePacker->add(2, 2, 3, (uint8*)"\x00\x00\x00\xFF\x00\x00\xFF\x00\x00\x00\x00\x00"); - unk5 = m_texturePacker->add(2, 2, 3, (uint8*)"\x00\x00\x00\x00\xFF\xFF\x00\xFF\xFF\x00\x00\x00"); - unk6 = m_texturePacker->add(2, 2, 3, (uint8*)"\x00\x00\x00\xFF\xFF\x00\xFF\xFF\x00\x00\x00\x00"); - unk7 = m_texturePacker->add(2, 2, 3, (uint8*)"\x00\x00\x00\xFF\xFF\xFF\xFF\xFF\xFF\x00\x00\x00"); - unk8 = m_texturePacker->add(2, 2, 3, (uint8*)"\x00\x00\x00\x00\x0F\x00\x00\x0F\x00\x00\x00\x00"); + // Valve checkerboard! :) + unk1 = m_texturePacker->add(2, 2, 3, (uint8*)"\x00\x00\x00\xFF\x00\xFF\xFF\x00\xFF\x00\x00\x00"); + unk2 = m_texturePacker->add(2, 2, 3, (uint8*)"\x00\x00\x00\x00\x00\xFF\x00\x00\xFF\x00\x00\x00"); + unk3 = m_texturePacker->add(2, 2, 3, (uint8*)"\x00\x00\x00\x00\xFF\x00\x00\xFF\x00\x00\x00\x00"); + unk4 = m_texturePacker->add(2, 2, 3, (uint8*)"\x00\x00\x00\xFF\x00\x00\xFF\x00\x00\x00\x00\x00"); + unk5 = m_texturePacker->add(2, 2, 3, (uint8*)"\x00\x00\x00\x00\xFF\xFF\x00\xFF\xFF\x00\x00\x00"); + unk6 = m_texturePacker->add(2, 2, 3, (uint8*)"\x00\x00\x00\xFF\xFF\x00\xFF\xFF\x00\x00\x00\x00"); + unk7 = m_texturePacker->add(2, 2, 3, (uint8*)"\x00\x00\x00\xFF\xFF\xFF\xFF\xFF\xFF\x00\x00\x00"); + unk8 = m_texturePacker->add(2, 2, 3, (uint8*)"\x00\x00\x00\x00\x0F\x00\x00\x0F\x00\x00\x00\x00"); - m_texturePacker->freezeTexUpdate(false); - m_atlas = m_texturePacker->getAtlas(); + m_texturePacker->freezeTexUpdate(false); + m_atlas = m_texturePacker->getAtlas(); + } } Registry::~Registry() { - delete m_texturePacker; + if (GlobalProperties::IsClient) { + delete m_texturePacker; + } } TexturePacker::Coord Registry::addTexture(const std::string &texName, diff --git a/src/platform/Fixes.glibc.hpp b/src/platform/Fixes.glibc.hpp new file mode 100644 index 0000000..2b059ee --- /dev/null +++ b/src/platform/Fixes.glibc.hpp @@ -0,0 +1,15 @@ +#ifndef DIGGLER_PLATFORM_FIXES_GLIBC +#define DIGGLER_PLATFORM_FIXES_GLIBC + +// Disable some names (major, minor, makedev) inappropriately reserved as macros +// by the morons glibc devs are. +// https://bugzilla.redhat.com/show_bug.cgi?id=130601 +#ifndef _SYS_SYSMACROS_H + #define _SYS_SYSMACROS_H 1 +#else + #undef major + #undef minor + #undef makedev +#endif + +#endif /* DIGGLER_PLATFORM_FIXES_GLIBC */ diff --git a/src/platform/Fixes.hpp b/src/platform/Fixes.hpp new file mode 100644 index 0000000..9ec4a65 --- /dev/null +++ b/src/platform/Fixes.hpp @@ -0,0 +1,12 @@ +#ifndef DIGGLER_PLATFORM_FIXES +#define DIGGLER_PLATFORM_FIXES + +#ifdef _GNU_SOURCE + #include "Fixes.glibc.hpp" +#endif + +#ifdef _WIN32 + #include "Fixes.windows.hpp" +#endif + +#endif /* DIGGLER_PLATFORM_FIXES */ diff --git a/src/platform/Fixes.windows.hpp b/src/platform/Fixes.windows.hpp new file mode 100644 index 0000000..e8194e0 --- /dev/null +++ b/src/platform/Fixes.windows.hpp @@ -0,0 +1,12 @@ +#ifndef DIGGLER_PLATFORM_FIXES_WINDOWS +#define DIGGLER_PLATFORM_FIXES_WINDOWS + +// Microsoft has a shitty habit of polluting the user namespace with frequently used names + +#define WIN32_LEAN_AND_MEAN 1 +#define NOMINMAX 1 +#include +#undef near +#undef far + +#endif /* DIGGLER_PLATFORM_FIXES_WINDOWS */ diff --git a/src/render/CMakeLists.txt b/src/render/CMakeLists.txt index 0516b27..fca2d4a 100644 --- a/src/render/CMakeLists.txt +++ b/src/render/CMakeLists.txt @@ -1,10 +1,51 @@ set(DIGGLER_ENABLE_GL_RENDERER TRUE CACHE BOOL "Enable OpenGL (ES) renderer") set(DIGGLER_ENABLE_VK_RENDERER TRUE CACHE BOOL "Enable Vulkan renderer") -if(DIGGLER_ENABLE_GL_RENDERER) +set(DIGGLER_GL_LOADER "libepoxy" CACHE STRING + "OpenGL loader to use. One of 'libepoxy', 'glad', 'glbinding', 'glew'") + +if (DIGGLER_ENABLE_GL_RENDERER) + if ("${DIGGLER_GL_LOADER}" STREQUAL "libepoxy") + pkg_search_module(EPOXY REQUIRED epoxy) + set(DIGGLER_GL_USE_LIBEPOXY TRUE) + set(DIGGLER_GL_LOADER_SUPPORTED TRUE) + diggler_add_definition("DIGGLER_GL_USE_LIBEPOXY") + diggler_include_directories(${EPOXY_INCLUDE_DIRS}) + diggler_link_libraries(${EPOXY_LIBRARIES}) + endif() + if ("${DIGGLER_GL_LOADER}" STREQUAL "glad") + set(DIGGLER_GL_USE_GLAD TRUE) + set(DIGGLER_GL_LOADER_SUPPORTED TRUE) + diggler_add_definition("DIGGLER_GL_USE_GLAD") + diggler_add_sources("${CMAKE_CURRENT_SOURCE_DIR}/../glad.c") + if ("${CMAKE_SYSTEM_NAME}" STREQUAL "Linux") + diggler_link_libraries(dl) + endif() + endif() + if ("${DIGGLER_GL_LOADER}" STREQUAL "glbinding") + find_package(glbinding REQUIRED) + set(DIGGLER_GL_USE_GLAD TRUE) + set(DIGGLER_GL_LOADER_SUPPORTED TRUE) + diggler_add_definition("DIGGLER_GL_USE_GLBINDING") + diggler_include_directories(${glbinding_INCLUDE_DIRS}) + diggler_link_libraries(glbinding) + endif() + if ("${DIGGLER_GL_LOADER}" STREQUAL "glew") + pkg_search_module(GLEW REQUIRED glew) + set(DIGGLER_GL_USE_GLEW TRUE) + set(DIGGLER_GL_LOADER_SUPPORTED TRUE) + diggler_add_definition("DIGGLER_GL_USE_GLEW") + diggler_include_directories(${GLEW_INCLUDE_DIRS}) + diggler_link_libraries(${GLEW_LIBRARIES}) + endif() + + if (NOT DIGGLER_GL_LOADER_SUPPORTED) + message(SEND_ERROR "OpenGL loader \"${DIGGLER_GL_LOADER}\" is unsupported") + endif() + add_subdirectory("gl") endif() -if(DIGGLER_ENABLE_VK_RENDERER) +if (DIGGLER_ENABLE_VK_RENDERER) add_subdirectory("vk") endif() diff --git a/src/render/gl/CMakeLists.txt b/src/render/gl/CMakeLists.txt index f1d4e2a..affb711 100644 --- a/src/render/gl/CMakeLists.txt +++ b/src/render/gl/CMakeLists.txt @@ -3,6 +3,8 @@ diggler_add_sources( ${CSD}/FBO.cpp ${CSD}/FeatureSupport.cpp ${CSD}/FontRenderer.cpp + ${CSD}/OpenGL.cpp + ${CSD}/OpenGL.${DIGGLER_GL_LOADER}.cpp ${CSD}/ParticlesRenderer.cpp ${CSD}/Program.cpp ${CSD}/ProgramManager.cpp diff --git a/src/render/gl/FBO.cpp b/src/render/gl/FBO.cpp index 213e5af..3ae79c1 100644 --- a/src/render/gl/FBO.cpp +++ b/src/render/gl/FBO.cpp @@ -3,18 +3,6 @@ #include "FeatureSupport.hpp" #include "Util.hpp" -#ifdef IN_IDE_PARSER - void glCheck(); -#else - #define glCheck() { GLenum glErr = glGetError(); \ - if (glErr) { \ - getDebugStream() << getErrorString(glErr) << std::endl; \ - } glErr = glCheckFramebufferStatus(GL_FRAMEBUFFER); if (glErr != GL_FRAMEBUFFER_COMPLETE) { \ - getDebugStream() << getErrorString(glErr) << std::endl; \ - } \ - } -#endif - namespace Diggler { namespace Render { namespace gl { @@ -34,8 +22,13 @@ FBO::FBO(int w, int h, Texture::PixelFormat format, bool stencil) : m_hasStencil glGenRenderbuffers(1, &rboId); glBindRenderbuffer(GL_RENDERBUFFER, rboId); if (stencil) { - glRenderbufferStorage(GL_RENDERBUFFER, FeatureSupport::FBO_ARB ? GL_DEPTH24_STENCIL8 : - GL_DEPTH24_STENCIL8_OES, w, h); +#ifdef GL_DEPTH24_STENCIL8_OES + const GLenum depth24stencil8 = FeatureSupport::FBO_ARB ? GL_DEPTH24_STENCIL8 : + GL_DEPTH24_STENCIL8_OES; +#else + constexpr GLenum depth24stencil8 = GL_DEPTH24_STENCIL8; +#endif + glRenderbufferStorage(GL_RENDERBUFFER, depth24stencil8, w, h); } else { glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_COMPONENT24, w, h); } @@ -53,7 +46,14 @@ FBO::FBO(int w, int h, Texture::PixelFormat format, bool stencil) : m_hasStencil glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, rboId); } - glCheck(); + GLenum glErr = glGetError(); + if (glErr != GL_NO_ERROR) { + getDebugStream() << getErrorString(glErr) << std::endl; + } + glErr = glCheckFramebufferStatus(GL_FRAMEBUFFER); + if (glErr != GL_FRAMEBUFFER_COMPLETE) { + getDebugStream() << getErrorString(glErr) << std::endl; + } } void FBO::resize(int w, int h) { diff --git a/src/render/gl/FBO.hpp b/src/render/gl/FBO.hpp index 2900de4..404524f 100644 --- a/src/render/gl/FBO.hpp +++ b/src/render/gl/FBO.hpp @@ -5,7 +5,7 @@ #include -#include +#include "OpenGL.hpp" #include "../../Texture.hpp" diff --git a/src/render/gl/FeatureSupport.cpp b/src/render/gl/FeatureSupport.cpp index b1d0a9b..045389c 100644 --- a/src/render/gl/FeatureSupport.cpp +++ b/src/render/gl/FeatureSupport.cpp @@ -2,6 +2,8 @@ #include +#include "OpenGL.hpp" + namespace Diggler { namespace Render { namespace gl { @@ -18,14 +20,14 @@ bool F::buffer_storage; void F::probe() { - VAO = epoxy_has_gl_extension("GL_ARB_vertex_array_object") or - epoxy_has_gl_extension("GL_OES_vertex_array_object"); - DSA_ARB = epoxy_has_gl_extension("GL_ARB_direct_state_access"); - DSA_EXT = epoxy_has_gl_extension("GL_EXT_direct_state_access"); + VAO = OpenGL::hasExtension("GL_ARB_vertex_array_object") or + OpenGL::hasExtension("GL_OES_vertex_array_object"); + DSA_ARB = OpenGL::hasExtension("GL_ARB_direct_state_access"); + DSA_EXT = OpenGL::hasExtension("GL_EXT_direct_state_access"); DSA = DSA_ARB or DSA_EXT; - shader_image_load_store = epoxy_has_gl_extension("GL_ARB_shader_image_load_store"); - FBO_ARB = epoxy_has_gl_extension("GL_ARB_framebuffer_object"); - buffer_storage = epoxy_has_gl_extension("GL_ARB_buffer_storage"); + shader_image_load_store = OpenGL::hasExtension("GL_ARB_shader_image_load_store"); + FBO_ARB = OpenGL::hasExtension("GL_ARB_framebuffer_object"); + buffer_storage = OpenGL::hasExtension("GL_ARB_buffer_storage"); } #define feature(x) if(x){oss<<#x< +#include "../../platform/Types.hpp" namespace Diggler { namespace Render { diff --git a/src/render/gl/OpenGL.cpp b/src/render/gl/OpenGL.cpp new file mode 100644 index 0000000..16571c3 --- /dev/null +++ b/src/render/gl/OpenGL.cpp @@ -0,0 +1,40 @@ +#include "OpenGL.hpp" + +#include + +namespace Diggler { +namespace Render { +namespace gl { + +static std::set extensionsSet; + +void OpenGL::probeExtensions() { + if (version() >= 30) { +#ifdef GL_NUM_EXTENSIONS + GLint numExt; + glGetIntegerv(GL_NUM_EXTENSIONS, &numExt); + for (GLint i = 0; i < numExt; ++i) { + extensionsSet.insert(reinterpret_cast(glGetStringi(GL_EXTENSIONS, GLuint(i)))); + } +#endif + } else { + std::stringstream ss; + ss.str(reinterpret_cast(glGetString(GL_EXTENSIONS))); + std::string item; + while (std::getline(ss, item, ' ')) { + extensionsSet.insert(item); + } + } +} + +const std::set& OpenGL::extensions() { + return extensionsSet; +} + +bool OpenGL::hasExtension(const std::string &ext) { + return extensionsSet.find(ext) != extensionsSet.end(); +} + +} +} +} diff --git a/src/render/gl/OpenGL.glad.cpp b/src/render/gl/OpenGL.glad.cpp new file mode 100644 index 0000000..32a81db --- /dev/null +++ b/src/render/gl/OpenGL.glad.cpp @@ -0,0 +1,51 @@ +#include "OpenGL.hpp" + +#include + +namespace Diggler { +namespace Render { +namespace gl { + +void OpenGL::init() { + if (!gladLoadGL()) { + throw std::runtime_error("GLAD initialization failed"); + } + probeExtensions(); +} + +std::set OpenGL::loaderSupportedGLVersions() { + return {}; +} + +OpenGL::Version OpenGL::version() { + const int major = GLVersion.major, minor = GLVersion.minor; + bool isForward = false; +#ifdef GL_CONTEXT_FLAGS + if (major >= 3) { + GLuint contextFlags; + glGetIntegerv(GL_CONTEXT_FLAGS, reinterpret_cast(&contextFlags)); + isForward = bool(contextFlags & GLuint(GL_CONTEXT_FLAG_FORWARD_COMPATIBLE_BIT)); + } +#endif + bool isCore = false; +#ifdef GL_CONTEXT_PROFILE_MASK + if (major >= 3 and (major >= 4 or minor >= 2)) { + GLuint profileFlags = 0; + glGetIntegerv(GL_CONTEXT_PROFILE_MASK, reinterpret_cast(&profileFlags)); + isCore = bool(profileFlags & GLuint(GL_CONTEXT_CORE_PROFILE_BIT)); + } +#endif + return { major, minor, false, isCore, isForward }; +} + +const char* OpenGL::loaderName() { + return "GLAD"; +} + +const char* OpenGL::loaderVersion() { + return "rolling"; +} + +} +} +} diff --git a/src/render/gl/OpenGL.glbinding.cpp b/src/render/gl/OpenGL.glbinding.cpp new file mode 100644 index 0000000..afb900a --- /dev/null +++ b/src/render/gl/OpenGL.glbinding.cpp @@ -0,0 +1,58 @@ +#include "OpenGL.hpp" + +#include +#include +#include +#include +#include + +namespace Diggler { +namespace Render { +namespace gl { + +void OpenGL::init() { + glbinding::Binding::initialize(false); + probeExtensions(); +} + +std::set OpenGL::loaderSupportedGLVersions() { + std::set versions; + for (const auto& version : glbinding::Meta::versions()) { + versions.emplace(version.majorVersion(), version.minorVersion(), false, false, false); + if (version.majorVersion() >= 3) { + versions.emplace(version.majorVersion(), version.minorVersion(), false, false, true); + versions.emplace(version.majorVersion(), version.minorVersion(), false, true, false); + versions.emplace(version.majorVersion(), version.minorVersion(), false, true, true); + } + } + return versions; +} + +OpenGL::Version OpenGL::version() { + auto ver = glbinding::ContextInfo::version(); + const int major = ver.majorVersion(), minor = ver.minorVersion(); + GLuint contextFlags = 0; + if (major >= 3) { + glGetIntegerv(GL_CONTEXT_FLAGS, reinterpret_cast(&contextFlags)); + } + GLuint profileFlags = 0; + if (major >= 3 and (major >= 4 or minor >= 2)) { + glGetIntegerv(GL_CONTEXT_PROFILE_MASK, reinterpret_cast(&profileFlags)); + } + return { major, minor, false, + bool(profileFlags & GLuint(GL_CONTEXT_CORE_PROFILE_BIT)), + bool(contextFlags & GLuint(GL_CONTEXT_FLAG_FORWARD_COMPATIBLE_BIT)) + }; +} + +const char* OpenGL::loaderName() { + return "glbinding"; +} + +const char* OpenGL::loaderVersion() { + return GLBINDING_VERSION; +} + +} +} +} diff --git a/src/render/gl/OpenGL.glew.cpp b/src/render/gl/OpenGL.glew.cpp new file mode 100644 index 0000000..555917d --- /dev/null +++ b/src/render/gl/OpenGL.glew.cpp @@ -0,0 +1,58 @@ +#include "OpenGL.hpp" + +#include + +namespace Diggler { +namespace Render { +namespace gl { + +void OpenGL::init() { + GLenum err = glewInit(); + if (err != GLEW_OK) { + throw std::runtime_error(std::string("GLEW initialization failed") + + reinterpret_cast(glewGetErrorString(err))); + } + probeExtensions(); +} + +std::set OpenGL::loaderSupportedGLVersions() { + std::set versions; + for (int ver : { 20, 21, 30, 31, 32, 33, 40, 41, 42, 43, 44, 45 }) { + versions.emplace(ver / 10, ver % 10, false, false, false); + if (ver >= 30) { + versions.emplace(ver / 10, ver % 10, false, false, true); + versions.emplace(ver / 10, ver % 10, false, true, false); + versions.emplace(ver / 10, ver % 10, false, true, true); + } + } + return versions; +} + +OpenGL::Version OpenGL::version() { + auto ver = glGetString(GL_VERSION); + const int major = ver[0] - '0', minor = ver[2] - '0'; + GLuint contextFlags = 0; + if (major >= 3) { + glGetIntegerv(GL_CONTEXT_FLAGS, reinterpret_cast(&contextFlags)); + } + GLuint profileFlags = 0; + if (major >= 3 and (major >= 4 or minor >= 2)) { + glGetIntegerv(GL_CONTEXT_PROFILE_MASK, reinterpret_cast(&profileFlags)); + } + return { major, minor, false, + bool(profileFlags & GLuint(GL_CONTEXT_CORE_PROFILE_BIT)), + bool(contextFlags & GLuint(GL_CONTEXT_FLAG_FORWARD_COMPATIBLE_BIT)) + }; +} + +const char* OpenGL::loaderName() { + return "GLEW"; +} + +const char* OpenGL::loaderVersion() { + return reinterpret_cast(glewGetString(GLEW_VERSION)); +} + +} +} +} diff --git a/src/render/gl/OpenGL.hpp b/src/render/gl/OpenGL.hpp new file mode 100644 index 0000000..2c16771 --- /dev/null +++ b/src/render/gl/OpenGL.hpp @@ -0,0 +1,95 @@ +#ifndef DIGGLER_RENDER_GL_OPENGL_HPP +#define DIGGLER_RENDER_GL_OPENGL_HPP + +#include "../../platform/Fixes.hpp" + +#include +#include + +#if defined(DIGGLER_GL_USE_LIBEPOXY) + #include +#elif defined(DIGGLER_GL_USE_GLAD) + #include +#elif defined(DIGGLER_GL_USE_GLBINDING) + #include + using namespace gl; +#elif defined(DIGGLER_GL_USE_GLEW) + #define GLEW_NO_GLU + #include +#else + #error "No OpenGL loader selected" +#endif + +namespace Diggler { +namespace Render { +namespace gl { + +class OpenGL { +private: + static void probeExtensions(); + +public: + struct Version { + int major, minor; + bool isGLES, isCore, isForward; + + Version(int major, int minor, bool isGLES, bool isCore, bool isForward) : + major(major), + minor(minor), + isGLES(isGLES), + isCore(isCore), + isForward(isForward) {} + + operator int() const { return major * 10 + minor; } + bool operator<(const Version &v) const { + return major < v.major && minor < v.minor && + (isGLES ^ v.isGLES) && (isCore ^ v.isCore) && (isForward ^ v.isForward); + } + }; + + /** + * @return The OpenGL Loader name + */ + static const char* loaderName(); + + /** + * @return The OpenGL Loader version + */ + static const char* loaderVersion(); + + /** + * Get the list of OpenGL versions whose initialization is supported by the Loader. + * An empty set means supported versions are unknown. + * @note Presence of a given version in this liss only shows Loader support, not driver support + * @return The OpenGL versions the Loader supports + */ + static std::set loaderSupportedGLVersions(); + + + /** + * Initializes OpenGL entrypoints + */ + static void init(); + + /** + * @return The currently loaded OpenGL version + */ + static Version version(); + + /** + * @return The currently available OpenGL extensions + */ + static const std::set& extensions(); + + /** + * Checks for availability of an OpenGL extension + * @return `true` if the extension is available, `false` otherwise + */ + static bool hasExtension(const std::string&); +}; + +} +} +} + +#endif /* DIGGLER_RENDER_GL_OPENGL_HPP */ diff --git a/src/render/gl/OpenGL.libepoxy.cpp b/src/render/gl/OpenGL.libepoxy.cpp new file mode 100644 index 0000000..f71dc9b --- /dev/null +++ b/src/render/gl/OpenGL.libepoxy.cpp @@ -0,0 +1,57 @@ +#include "OpenGL.hpp" + +#include + +namespace Diggler { +namespace Render { +namespace gl { + +void OpenGL::init() { + // libepoxy initializes lazily + probeExtensions(); +} + +std::set OpenGL::loaderSupportedGLVersions() { + std::set versions; + for (int ver : { 20, 21, 30, 31, 32, 33, 40, 41, 42, 43, 44, 45 }) { + versions.emplace(ver / 10, ver % 10, false, false, false); + if (ver >= 30) { + versions.emplace(ver / 10, ver % 10, false, false, true); + versions.emplace(ver / 10, ver % 10, false, true, false); + versions.emplace(ver / 10, ver % 10, false, true, true); + } + } + for (int ver : { 20, 30, 31, 32 }) { + versions.emplace(ver / 10, ver % 10, true, false, false); + } + return versions; +} + +OpenGL::Version OpenGL::version() { + auto ver = epoxy_gl_version(); + const int major = ver / 10, minor = ver % 10; + GLuint contextFlags = 0; + if (major >= 3) { + glGetIntegerv(GL_CONTEXT_FLAGS, reinterpret_cast(&contextFlags)); + } + GLuint profileFlags = 0; + if (major >= 3 and (major >= 4 or minor >= 2)) { + glGetIntegerv(GL_CONTEXT_PROFILE_MASK, reinterpret_cast(&profileFlags)); + } + return { major, minor, !epoxy_is_desktop_gl(), + bool(profileFlags & GL_CONTEXT_CORE_PROFILE_BIT), + bool(contextFlags & GL_CONTEXT_FLAG_FORWARD_COMPATIBLE_BIT) + }; +} + +const char* OpenGL::loaderName() { + return "libepoxy"; +} + +const char* OpenGL::loaderVersion() { + return "rolling"; +} + +} +} +} diff --git a/src/render/gl/Program.cpp b/src/render/gl/Program.cpp index 8467711..083c028 100644 --- a/src/render/gl/Program.cpp +++ b/src/render/gl/Program.cpp @@ -8,7 +8,11 @@ namespace Diggler { namespace Render { namespace gl { -Program::Program(Shader* vsh, Shader* fsh) : vsh(vsh), fsh(fsh), id(0) { +Program::Program(Shader* vsh, Shader* fsh) : + vsh(vsh), + fsh(fsh), + id(0), + linked(GL_FALSE) { } @@ -34,7 +38,9 @@ bool Program::link() { glAttachShader(id, vsh->getId()); glAttachShader(id, fsh->getId()); glLinkProgram(id); - glGetProgramiv(id, GL_LINK_STATUS, &linked); + GLint linkStatus; + glGetProgramiv(id, GL_LINK_STATUS, &linkStatus); + linked = GLboolean(linkStatus); if (!linked) { getErrorStream() << id << ':' << getError() << std::endl; return false; diff --git a/src/render/gl/Program.hpp b/src/render/gl/Program.hpp index ea12fb7..79c86ad 100644 --- a/src/render/gl/Program.hpp +++ b/src/render/gl/Program.hpp @@ -11,7 +11,7 @@ class Program { private: Shader *vsh, *fsh; GLuint id; - GLint linked = GL_FALSE; + GLboolean linked; bool mustDestroy = false; std::string fshPath, vshPath; diff --git a/src/render/gl/README.glad.md b/src/render/gl/README.glad.md new file mode 100644 index 0000000..55770ca --- /dev/null +++ b/src/render/gl/README.glad.md @@ -0,0 +1,25 @@ +# Using GLAD in Diggler + +GLAD is a small, generated OpenGL loader targeting a single GL version with an optional set of supported extensions. + +It is hosted on GitHub at https://github.com/Dav1dde/glad . It can be either installed, or [used from a web service](http://glad.dav1d.de/). + +## Diggler requirements + +Diggler mandates a minimum support of OpenGL (ES) 2.0. + +On desktop OpenGL, loader support of these extensions is required: + +* GL_ARB_buffer_storage +* GL_ARB_direct_state_access +* GL_ARB_framebuffer_object +* GL_ARB_shader_image_load_store +* GL_ARB_vertex_array_object +* GL_EXT_direct_state_access +* GL_KHR_debug + +``` +--profile="compatibility" --api="gl=2.0" --generator="c" --spec="gl" --extensions="GL_ARB_buffer_storage,GL_ARB_direct_state_access,GL_ARB_framebuffer_object,GL_ARB_shader_image_load_store,GL_ARB_vertex_array_object,GL_EXT_direct_state_access,GL_KHR_debug" +``` + +As said, you can [generate the loader online](http://glad.dav1d.de/#profile=compatibility&language=c&specification=gl&loader=on&api=gl%3D2.0&extensions=GL_ARB_buffer_storage&extensions=GL_ARB_direct_state_access&extensions=GL_ARB_framebuffer_object&extensions=GL_ARB_shader_image_load_store&extensions=GL_ARB_vertex_array_object&extensions=GL_EXT_direct_state_access&extensions=GL_KHR_debug). diff --git a/src/render/gl/Shader.cpp b/src/render/gl/Shader.cpp index 59fd5ba..cace2d2 100644 --- a/src/render/gl/Shader.cpp +++ b/src/render/gl/Shader.cpp @@ -51,8 +51,9 @@ bool Shader::compileFromString(const std::string &source, const std::string &pat const char *src = srcStr.c_str(); glShaderSource(id, 1, &src, nullptr); glCompileShader(id); + GLint compiled; glGetShaderiv(id, GL_COMPILE_STATUS, &compiled); - if (!compiled) { + if (!GLboolean(compiled)) { getErrorStream() << "Compile error in " << path << "\n" << getError() << std::endl; return false; } diff --git a/src/render/gl/Shader.hpp b/src/render/gl/Shader.hpp index ae8966a..a9c425b 100644 --- a/src/render/gl/Shader.hpp +++ b/src/render/gl/Shader.hpp @@ -4,7 +4,7 @@ #include #include -#include +#include "OpenGL.hpp" namespace Diggler { namespace Render { @@ -13,13 +13,12 @@ namespace gl { class Shader { private: GLuint id; - GLint compiled = GL_FALSE; const std::vector *m_preludeLines; public: - enum class Type : GLenum { - FRAGMENT = GL_FRAGMENT_SHADER, - VERTEX = GL_VERTEX_SHADER + enum class Type : unsigned int { + FRAGMENT = static_cast(GL_FRAGMENT_SHADER), + VERTEX = static_cast(GL_VERTEX_SHADER) } type; Shader(Type type); Shader(Type type, const std::string& path); diff --git a/src/render/gl/Util.cpp b/src/render/gl/Util.cpp index acf7ffb..4deccc8 100644 --- a/src/render/gl/Util.cpp +++ b/src/render/gl/Util.cpp @@ -22,8 +22,10 @@ const char* getErrorString(GLenum code) { return "GL_OUT_OF_MEMORY"; case GL_INVALID_FRAMEBUFFER_OPERATION: return "GL_INVALID_FRAMEBUFFER_OPERATION"; +#ifdef GL_TABLE_TOO_LARGE case GL_TABLE_TOO_LARGE: return "GL_TABLE_TOO_LARGE"; +#endif case GL_FRAMEBUFFER_COMPLETE: return "GL_FRAMEBUFFER_COMPLETE"; case GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT: @@ -36,6 +38,8 @@ const char* getErrorString(GLenum code) { return "GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT"; case GL_FRAMEBUFFER_UNSUPPORTED: return "GL_FRAMEBUFFER_UNSUPPORTED"; + default: + break; } return ""; } diff --git a/src/render/gl/Util.hpp b/src/render/gl/Util.hpp index f374383..37f066f 100644 --- a/src/render/gl/Util.hpp +++ b/src/render/gl/Util.hpp @@ -3,7 +3,7 @@ #include "../../Platform.hpp" -#include +#include "OpenGL.hpp" namespace Diggler { namespace Render { @@ -43,8 +43,10 @@ constexpr GLenum getBinding(GLenum bufferT) { return GL_RENDERBUFFER_BINDING; case GL_VERTEX_ARRAY: return GL_VERTEX_ARRAY_BINDING; + default: + break; } - return 0; + return GL_INVALID_ENUM; } template diff --git a/src/render/gl/VAO.hpp b/src/render/gl/VAO.hpp index fa8b5d5..4038dba 100644 --- a/src/render/gl/VAO.hpp +++ b/src/render/gl/VAO.hpp @@ -5,7 +5,7 @@ #include -#include +#include "OpenGL.hpp" #include "FeatureSupport.hpp" #include "Util.hpp" diff --git a/src/render/gl/VBO.hpp b/src/render/gl/VBO.hpp index 6be6993..6211eed 100644 --- a/src/render/gl/VBO.hpp +++ b/src/render/gl/VBO.hpp @@ -3,7 +3,7 @@ #include -#include +#include "OpenGL.hpp" #include "../../platform/PreprocUtils.hpp" #include "FeatureSupport.hpp" diff --git a/src/ui/Font.hpp b/src/ui/Font.hpp index 7393254..4476d6e 100644 --- a/src/ui/Font.hpp +++ b/src/ui/Font.hpp @@ -3,7 +3,7 @@ #include "../Platform.hpp" -#include +#include "../render/gl/OpenGL.hpp" #include #include "../render/FontRendererFwd.hpp"