#include <globject.hpp>
#include <algorithm>
#include <array>
#include <cerrno>
#include <cstdio>
#include <cstring>
#include <fstream>
#include <iostream>
#include <iterator>
#include <sstream>
#include <string>
#include <unordered_set>
// NOLINTNEXTLINE
#define STR_EXCEPTION GLObject::Exception
#include <str.hpp>
/// Special member functions
GLObject::GLObject(
GLGenObjects gl_gen_objects,
GLDeleteObjects gl_delete_objects,
GLenum object_type,
// cppcheck-suppress passedByValue
std::string object_label
)
:
gl_delete_objects_{gl_delete_objects},
object_type_ {object_type},
object_label_ {std::move(object_label)},
object_ {0}
{
try
{
if (gl_gen_objects)
gl_gen_objects(1, &object_);
else
object_ = object_pseudo_;
check_error_(glGetError());
GLOBJECT_DEBUG_IF(1)
{
debug_label_();
debug_objects_push_back_(this);
debug_callback()("Create " + debug_name());
}
}
catch (...)
{
if (gl_delete_objects_)
gl_delete_objects_(1, &object_);
fail_action_("create");
}
}
GLObject::GLObject(GLObject && other) noexcept
:
gl_delete_objects_{other.gl_delete_objects_},
object_type_ {other.object_type_},
object_label_ {std::move(other.object_label_)},
object_ {other.object_}
{
other.object_ = 0;
GLOBJECT_DEBUG_IF(1)
{
debug_objects_erase_(&other);
debug_objects_push_back_(this);
debug_callback()("Move " + debug_name());
}
}
GLObject::~GLObject()
{
if (gl_delete_objects_)
gl_delete_objects_(1, &object_);
GLOBJECT_DEBUG_IF(1)
{
debug_objects_erase_(this);
debug_callback()("Destroy " + debug_name());
}
}
/// Core
bool GLObject::supported(
Version version_min,
std::string const & extension
)
{
auto static version = Version{0, 0};
auto static extensions = std::unordered_set<std::string>{};
if (extension.size() && extension.rfind("GL_", 0) == extension.npos)
STR_THROW("Failed to parse extension \"" << extension << "\".");
if (version == Version{0, 0})
{
auto const * version_str = (char const *)glGetString(GL_VERSION);
if (!version_str)
return false;
// NOLINTNEXTLINE
if (2 != std::sscanf(version_str, "%d.%d", &version[0], &version[1]))
STR_THROW("Failed to parse version \"" << version_str << "\".");
if (version[0] >= 3)
{
auto extension_count = get_integer(GL_NUM_EXTENSIONS);
for (auto i = 0; i < extension_count; ++i)
extensions.insert(
(char const *)glGetStringi(GL_EXTENSIONS, (GLuint)i)
);
}
else
{
auto istream = std::istringstream(
(char const *)glGetString(GL_EXTENSIONS)
);
std::copy(
std::istream_iterator<std::string>(istream),
std::istream_iterator<std::string>(),
std::inserter(extensions, extensions.end())
);
}
}
if
(
(version_min != Version{0, 0}) &&
(
(version[0] > version_min[0]) ||
(
version[0] == version_min[0] &&
version[1] >= version_min[1]
)
)
)
return true;
if
(
extension.size() &&
extensions.find(extension) != extensions.end()
)
return true;
return false;
}
GLint GLObject::get_integer(GLenum name)
try
{
auto value = GLint{};
glGetIntegerv(name, &value);
GLOBJECT_DEBUG_IF(1)
check_error_(glGetError());
return value;
}
catch (...)
{
STR_THROW_NESTED("Failed to get integer " << str_enum_(name) << ":");
}
/// Path
GLObject::Path GLObject::path_prefix_(
Path const & path,
Path const & prefix
)
{
if (prefix.empty() || path[0] == '/')
return path;
return STR(prefix << "/" << path);
}
/// TGA
GLObject::TGA::TGA(Size size, Data data)
try
:
header_{size},
data_{std::move(data)}
{
check_data_();
}
catch (...)
{
STR_THROW_NESTED("Failed to create TGA " << str_size_(size) << ":");
}
GLObject::TGA GLObject::TGA::read(Path const & path)
try
{
auto tga = TGA({}, {});
auto istream = std::ifstream(path, std::ios::binary);
istream.read(
(char *) tga.header_.data(),
(std::streamsize)tga.header_.size()
);
tga.check_header_();
tga.data_.resize((std::size_t)(4 * tga.size()[0] * tga.size()[1]));
istream.read(
(char *) tga.data_.data(),
(std::streamsize)tga.data_.size()
);
istream.close();
if (!istream)
// NOLINTNEXTLINE
STR_THROW(std::strerror(errno));
return tga;
}
catch (...)
{
STR_THROW_NESTED("Failed to read TGA " << str_path_(path) << ":");
}
void GLObject::TGA::write(Path const & path) const
try
{
check_data_();
auto ostream = std::ofstream(path, std::ios::binary);
ostream.write((char *)header_.data(), (std::streamsize)header_.size());
ostream.write((char *)data_ .data(), (std::streamsize)data_ .size());
ostream.close();
if (!ostream)
// NOLINTNEXTLINE
STR_THROW(std::strerror(errno));
}
catch (...)
{
STR_THROW_NESTED("Failed to write TGA " << str_path_(path) << ":");
}
GLObject::TGA::Data const & GLObject::TGA::data()
{
return data_;
}
GLObject::TGA::Size GLObject::TGA::size() const
{
return {
(GLsizei)(header_[12]) << 0 | // NOLINT
(GLsizei)(header_[13]) << 8, // NOLINT
(GLsizei)(header_[14]) << 0 | // NOLINT
(GLsizei)(header_[15]) << 8, // NOLINT
};
}
GLObject::TGA::Header::Header(Size size)
:
std::array<GLubyte, 18>{ // NOLINT
0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, // NOLINT
(GLubyte)(size[0] >> 0), // NOLINT
(GLubyte)(size[0] >> 8), // NOLINT
(GLubyte)(size[1] >> 0), // NOLINT
(GLubyte)(size[1] >> 8), // NOLINT
32, 8, // NOLINT
}
{
}
std::string GLObject::TGA::str_size_(Size size)
{
return STR("{" << STR_JOIN(", ", it, it, size) << "}");
}
void GLObject::TGA::check_header_() const
{
auto header = Header(size());
if (header_ != header)
STR_THROW(
"Expected TGA header" << " " <<
"[" << STR_JOIN(", ", byte, byte, header) << "]" << ", " <<
"got" << " " <<
"[" << STR_JOIN(", ", byte, byte, header_) << "]" << "."
);
}
void GLObject::TGA::check_data_() const
{
auto data_size = (std::size_t)(4 * size()[0] * size()[1]);
if (data_size != data_.size())
STR_THROW(
"Expected TGA data size " << data_size << ", " <<
"got " << data_.size() << "."
);
}
/// Debug
GLOBJECT_THREAD(GLObject::debug_, {1})
GLOBJECT_THREAD(GLObject::debug_objects_, {})
GLOBJECT_THREAD(GLObject::debug_callback_, {[](std::string const & debug)
{
std::cerr << debug << std::endl;
}})
std::string GLObject::debug_name() const
{
return STR_JOIN(" ", it, it, {
object_type_ == 0 ? "<GLObject>" :
str_object_type_(object_type_),
object_label_,
object_ == 0 ? "<INVALID>" :
object_ == object_pseudo_ ? "<PSEUDO>" :
STR(object_),
});
}
void GLObject::debug_label_() const
{
if
(
object_type_ &&
object_label_.size() &&
object_
)
{
if (supported({4, 3}, "GL_KHR_debug"))
{
auto static object_label_length_max = get_integer(
GL_MAX_LABEL_LENGTH
);
auto object_label_length = std::min(
(GLsizei)object_label_length_max,
(GLsizei)object_label_.length()
);
glObjectLabel(
object_type_,
object_,
object_label_length,
object_label_.c_str()
);
}
}
}
std::string static debug_objects_data_(
std::string (GLObject::*debug_data)() const
)
{
auto const & objects = GLObject::debug_objects();
auto header = STR("GLObjects: " << objects.size());
auto data = STR_JOIN(
"\n",
object,
" " << (object->*debug_data)(),
objects
);
return STR_JOIN("\n", it, it, {header, data});
}
std::string GLObject::debug_objects_name()
{
return debug_objects_data_(&GLObject::debug_name);
}
std::string GLObject::debug_objects_info()
{
return debug_objects_data_(&GLObject::debug_info);
}
std::string GLObject::debug_info() const
{
return debug_name();
}
void GLObject::debug_objects_push_back_(GLObject * debug_object)
{
debug_objects_.push_back(debug_object);
}
void GLObject::debug_objects_erase_(GLObject * debug_object)
{
debug_objects_.erase(
std::remove(
debug_objects_.begin(),
debug_objects_.end(),
debug_object
),
debug_objects_.end()
);
}
/// Check
void GLObject::check_path_(std::string const & path)
{
if (!path.size())
STR_THROW(
"Expected " << "non-empty path" << ", " <<
"got " << "\"" << path << "\"" << "."
);
}
void GLObject::check_error_(GLenum error)
{
if (error != GL_NO_ERROR)
STR_THROW(
"Expected " << "no error" << ", " <<
"got " << str_error_(error) << "."
);
}
void GLObject::check_supported_(
Version version_min,
std::string const & extension
)
{
if (!supported(version_min, extension))
STR_THROW(
"Expected GL version " <<
STR_JOIN(".", it, it, version_min) <<
(extension.size() ? STR(" or extension " << extension) : "") << " "
"got " << glGetString(GL_VERSION) << "."
);
}
void GLObject::check_format_(
GLenum format,
GLenum format_expected
)
{
if (format != format_expected)
STR_THROW(
"Expected format " << str_format_(format_expected) << ", " <<
"got " << str_format_(format) << "."
);
}
void GLObject::check_type_(
GLenum type,
GLenum type_expected
)
{
if (type != type_expected)
STR_THROW(
"Expected type " << str_type_(type_expected) << ", " <<
"got " << str_type_(type) << "."
);
}
void GLObject::check_internal_format_(GLenum internal_format)
{
switch (internal_format)
{
case GL_RED:
case GL_RGB:
case GL_RGBA:
case GL_DEPTH_COMPONENT:
case GL_STENCIL_INDEX:
case GL_R3_G3_B2:
check_supported_({1, 0});
return;
case GL_RGB4:
case GL_RGB5:
case GL_RGB8:
case GL_RGB10:
case GL_RGB12:
case GL_RGB16:
case GL_RGBA2:
case GL_RGBA4:
case GL_RGBA8:
case GL_RGBA12:
case GL_RGBA16:
case GL_RGB5_A1:
case GL_RGB10_A2:
check_supported_({1, 1}, "GL_EXT_texture");
return;
case GL_COMPRESSED_RGB:
case GL_COMPRESSED_RGBA:
check_supported_({1, 3}, "GL_ARB_texture_compression");
return;
case GL_DEPTH_COMPONENT16:
case GL_DEPTH_COMPONENT24:
case GL_DEPTH_COMPONENT32:
check_supported_({1, 4}, "GL_ARB_depth_texture");
return;
case GL_SRGB:
case GL_SRGB8:
case GL_SRGB_ALPHA:
case GL_SRGB8_ALPHA8:
case GL_COMPRESSED_SRGB:
case GL_COMPRESSED_SRGB_ALPHA:
check_supported_({2, 1}, "GL_EXT_texture_sRGB");
return;
case GL_SR8_EXT:
check_supported_({}, "GL_EXT_texture_sRGB_R8");
return;
case GL_SRG8_EXT:
check_supported_({}, "GL_EXT_texture_sRGB_RG8");
return;
case GL_COMPRESSED_RGB_S3TC_DXT1_EXT:
case GL_COMPRESSED_RGBA_S3TC_DXT1_EXT:
case GL_COMPRESSED_RGBA_S3TC_DXT3_EXT:
case GL_COMPRESSED_RGBA_S3TC_DXT5_EXT:
check_supported_({}, "GL_EXT_texture_compression_s3tc");
return;
case GL_COMPRESSED_SRGB_S3TC_DXT1_EXT:
case GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT:
case GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT:
case GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT:
check_supported_({}, "GL_EXT_texture_sRGB");
check_supported_({}, "GL_EXT_texture_compression_s3tc");
return;
case GL_COMPRESSED_RED:
case GL_COMPRESSED_RG:
check_supported_({3, 0});
return;
case GL_COMPRESSED_RED_RGTC1:
case GL_COMPRESSED_SIGNED_RED_RGTC1:
case GL_COMPRESSED_RG_RGTC2:
case GL_COMPRESSED_SIGNED_RG_RGTC2:
check_supported_({3, 0}, "GL_ARB_texture_compression_rgtc");
return;
case GL_RGB16F:
case GL_RGB32F:
case GL_RGBA16F:
case GL_RGBA32F:
check_supported_({3, 0}, "GL_ARB_texture_float");
return;
case GL_RGB8I:
case GL_RGB16I:
case GL_RGB32I:
case GL_RGB8UI:
case GL_RGB16UI:
case GL_RGB32UI:
case GL_RGBA8I:
case GL_RGBA16I:
case GL_RGBA32I:
case GL_RGBA8UI:
case GL_RGBA16UI:
case GL_RGBA32UI:
check_supported_({3, 0}, "GL_EXT_texture_integer");
return;
case GL_R16F:
case GL_R32F:
case GL_RG16F:
case GL_RG32F:
case GL_R8:
case GL_R8I:
case GL_R8UI:
case GL_R16:
case GL_R16I:
case GL_R16UI:
case GL_R32I:
case GL_R32UI:
case GL_RG:
case GL_RG8:
case GL_RG8I:
case GL_RG8UI:
case GL_RG16:
case GL_RG16I:
case GL_RG16UI:
case GL_RG32I:
case GL_RG32UI:
check_supported_({3, 0}, "GL_ARB_texture_rg");
return;
case GL_R11F_G11F_B10F:
check_supported_({3, 0}, "GL_EXT_packed_float");
return;
case GL_RGB9_E5:
check_supported_({3, 0}, "GL_EXT_texture_shared_exponent");
return;
case GL_DEPTH_STENCIL:
case GL_DEPTH24_STENCIL8:
check_supported_({3, 0}, "GL_EXT_packed_depth_stencil");
return;
case GL_DEPTH32F_STENCIL8:
case GL_DEPTH_COMPONENT32F:
check_supported_({3, 0}, "GL_ARB_depth_buffer_float");
return;
case GL_STENCIL_INDEX8:
check_supported_({3, 0}, "GL_ARB_texture_stencil8");
return;
case GL_STENCIL_INDEX1:
case GL_STENCIL_INDEX4:
case GL_STENCIL_INDEX16:
check_supported_({3, 0}, "GL_ARB_framebuffer_object");
return;
case GL_R8_SNORM:
case GL_R16_SNORM:
case GL_RG8_SNORM:
case GL_RG16_SNORM:
case GL_RGB8_SNORM:
case GL_RGB16_SNORM:
case GL_RGBA8_SNORM:
case GL_RGBA16_SNORM:
check_supported_({3, 1}, "GL_EXT_texture_snorm");
return;
case GL_RGB10_A2UI:
check_supported_({3, 3}, "GL_ARB_texture_rgb10_a2ui");
return;
case GL_RGB565:
check_supported_({4, 1}, "GL_ARB_ES2_compatibility");
return;
case GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT:
case GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT:
case GL_COMPRESSED_RGBA_BPTC_UNORM:
case GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM:
check_supported_({4, 2}, "GL_ARB_texture_compression_bptc");
return;
case GL_COMPRESSED_R11_EAC:
case GL_COMPRESSED_RG11_EAC:
case GL_COMPRESSED_SIGNED_R11_EAC:
case GL_COMPRESSED_SIGNED_RG11_EAC:
case GL_COMPRESSED_RGB8_ETC2:
case GL_COMPRESSED_SRGB8_ETC2:
case GL_COMPRESSED_RGBA8_ETC2_EAC:
case GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC:
case GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2:
case GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2:
check_supported_({4, 2}, "GL_ARB_ES3_compatibility");
return;
case GL_COMPRESSED_RGBA_ASTC_4x4_KHR:
case GL_COMPRESSED_RGBA_ASTC_5x4_KHR:
case GL_COMPRESSED_RGBA_ASTC_5x5_KHR:
case GL_COMPRESSED_RGBA_ASTC_6x5_KHR:
case GL_COMPRESSED_RGBA_ASTC_6x6_KHR:
case GL_COMPRESSED_RGBA_ASTC_8x5_KHR:
case GL_COMPRESSED_RGBA_ASTC_8x6_KHR:
case GL_COMPRESSED_RGBA_ASTC_8x8_KHR:
case GL_COMPRESSED_RGBA_ASTC_10x5_KHR:
case GL_COMPRESSED_RGBA_ASTC_10x6_KHR:
case GL_COMPRESSED_RGBA_ASTC_10x8_KHR:
case GL_COMPRESSED_RGBA_ASTC_10x10_KHR:
case GL_COMPRESSED_RGBA_ASTC_12x10_KHR:
case GL_COMPRESSED_RGBA_ASTC_12x12_KHR:
case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR:
case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR:
case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR:
case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR:
case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR:
case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR:
case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR:
case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR:
case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR:
case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR:
case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR:
case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR:
case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR:
case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR:
check_supported_({4, 2}, "GL_KHR_texture_compression_astc_ldr");
return;
default:
STR_THROW(
"Expected " << "supported internal format" << ", "
"got " << str_internal_format_(internal_format) << "."
);
}
}
/// Fail
void GLObject::fail_action_(std::string const & action) const
{
STR_THROW_NESTED("Failed to " << action << " " << debug_name() << ":");
}
/// String
std::string GLObject::str_path_(Path const & path)
{
return STR("\"" << path << "\"");
}
std::string GLObject::str_paths_(Paths const & paths)
{
return STR_JOIN(", ", path, str_path_(path), paths);
}
std::string GLObject::str_enum_(GLenum name)
{
return STR(std::hex << std::showbase << name);
}
std::string GLObject::str_error_(GLenum error)
{
switch (error)
{
STR_CASE(GL_NO_ERROR)
STR_CASE(GL_INVALID_ENUM)
STR_CASE(GL_INVALID_VALUE)
STR_CASE(GL_INVALID_OPERATION)
STR_CASE(GL_INVALID_FRAMEBUFFER_OPERATION)
STR_CASE(GL_OUT_OF_MEMORY)
STR_CASE(GL_STACK_UNDERFLOW)
STR_CASE(GL_STACK_OVERFLOW)
default:
return str_enum_(error);
}
}
std::string GLObject::str_object_type_(GLenum object_type)
{
switch (object_type)
{
STR_CASE(GL_BUFFER)
STR_CASE(GL_SHADER)
STR_CASE(GL_PROGRAM)
STR_CASE(GL_VERTEX_ARRAY)
STR_CASE(GL_QUERY)
STR_CASE(GL_PROGRAM_PIPELINE)
STR_CASE(GL_TRANSFORM_FEEDBACK)
STR_CASE(GL_SAMPLER)
STR_CASE(GL_TEXTURE)
STR_CASE(GL_RENDERBUFFER)
STR_CASE(GL_FRAMEBUFFER)
default:
return str_enum_(object_type);
}
}
std::string GLObject::str_format_(GLenum format)
{
switch (format)
{
STR_CASE(GL_RED)
STR_CASE(GL_R)
STR_CASE(GL_RG)
STR_CASE(GL_RGB)
STR_CASE(GL_RGBA)
STR_CASE(GL_BGR)
STR_CASE(GL_BGRA)
STR_CASE(GL_DEPTH_COMPONENT)
STR_CASE(GL_STENCIL_INDEX)
default:
return str_enum_(format);
}
}
std::string GLObject::str_type_(GLenum type)
{
switch (type)
{
STR_CASE(GL_FLOAT)
STR_CASE(GL_BYTE)
STR_CASE(GL_SHORT)
STR_CASE(GL_INT)
STR_CASE(GL_UNSIGNED_BYTE)
STR_CASE(GL_UNSIGNED_SHORT)
STR_CASE(GL_UNSIGNED_INT)
STR_CASE(GL_UNSIGNED_BYTE_3_3_2)
STR_CASE(GL_UNSIGNED_BYTE_2_3_3_REV)
STR_CASE(GL_UNSIGNED_SHORT_5_6_5)
STR_CASE(GL_UNSIGNED_SHORT_5_6_5_REV)
STR_CASE(GL_UNSIGNED_SHORT_4_4_4_4)
STR_CASE(GL_UNSIGNED_SHORT_4_4_4_4_REV)
STR_CASE(GL_UNSIGNED_SHORT_5_5_5_1)
STR_CASE(GL_UNSIGNED_SHORT_1_5_5_5_REV)
STR_CASE(GL_UNSIGNED_INT_8_8_8_8)
STR_CASE(GL_UNSIGNED_INT_8_8_8_8_REV)
STR_CASE(GL_UNSIGNED_INT_10_10_10_2)
STR_CASE(GL_UNSIGNED_INT_2_10_10_10_REV)
default:
return str_enum_(type);
}
}
std::string GLObject::str_internal_format_(GLenum internal_format)
{
switch (internal_format)
{
STR_CASE(GL_RED)
STR_CASE(GL_RGB)
STR_CASE(GL_RGBA)
STR_CASE(GL_DEPTH_COMPONENT)
STR_CASE(GL_STENCIL_INDEX)
STR_CASE(GL_R3_G3_B2)
STR_CASE(GL_RGB4)
STR_CASE(GL_RGB5)
STR_CASE(GL_RGB8)
STR_CASE(GL_RGB10)
STR_CASE(GL_RGB12)
STR_CASE(GL_RGB16)
STR_CASE(GL_RGBA2)
STR_CASE(GL_RGBA4)
STR_CASE(GL_RGBA8)
STR_CASE(GL_RGBA12)
STR_CASE(GL_RGBA16)
STR_CASE(GL_RGB5_A1)
STR_CASE(GL_RGB10_A2)
STR_CASE(GL_COMPRESSED_RGB)
STR_CASE(GL_COMPRESSED_RGBA)
STR_CASE(GL_DEPTH_COMPONENT16)
STR_CASE(GL_DEPTH_COMPONENT24)
STR_CASE(GL_DEPTH_COMPONENT32)
STR_CASE(GL_SRGB)
STR_CASE(GL_SRGB8)
STR_CASE(GL_SRGB_ALPHA)
STR_CASE(GL_SRGB8_ALPHA8)
STR_CASE(GL_COMPRESSED_SRGB)
STR_CASE(GL_COMPRESSED_SRGB_ALPHA)
STR_CASE(GL_SR8_EXT)
STR_CASE(GL_SRG8_EXT)
STR_CASE(GL_COMPRESSED_RGB_S3TC_DXT1_EXT)
STR_CASE(GL_COMPRESSED_RGBA_S3TC_DXT1_EXT)
STR_CASE(GL_COMPRESSED_RGBA_S3TC_DXT3_EXT)
STR_CASE(GL_COMPRESSED_RGBA_S3TC_DXT5_EXT)
STR_CASE(GL_COMPRESSED_SRGB_S3TC_DXT1_EXT)
STR_CASE(GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT)
STR_CASE(GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT)
STR_CASE(GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT)
STR_CASE(GL_COMPRESSED_RED)
STR_CASE(GL_COMPRESSED_RG)
STR_CASE(GL_COMPRESSED_RED_RGTC1)
STR_CASE(GL_COMPRESSED_SIGNED_RED_RGTC1)
STR_CASE(GL_COMPRESSED_RG_RGTC2)
STR_CASE(GL_COMPRESSED_SIGNED_RG_RGTC2)
STR_CASE(GL_RGB16F)
STR_CASE(GL_RGB32F)
STR_CASE(GL_RGBA16F)
STR_CASE(GL_RGBA32F)
STR_CASE(GL_RGB8I)
STR_CASE(GL_RGB16I)
STR_CASE(GL_RGB32I)
STR_CASE(GL_RGB8UI)
STR_CASE(GL_RGB16UI)
STR_CASE(GL_RGB32UI)
STR_CASE(GL_RGBA8I)
STR_CASE(GL_RGBA16I)
STR_CASE(GL_RGBA32I)
STR_CASE(GL_RGBA8UI)
STR_CASE(GL_RGBA16UI)
STR_CASE(GL_RGBA32UI)
STR_CASE(GL_R16F)
STR_CASE(GL_R32F)
STR_CASE(GL_RG16F)
STR_CASE(GL_RG32F)
STR_CASE(GL_R8)
STR_CASE(GL_R8I)
STR_CASE(GL_R8UI)
STR_CASE(GL_R16)
STR_CASE(GL_R16I)
STR_CASE(GL_R16UI)
STR_CASE(GL_R32I)
STR_CASE(GL_R32UI)
STR_CASE(GL_RG)
STR_CASE(GL_RG8)
STR_CASE(GL_RG8I)
STR_CASE(GL_RG8UI)
STR_CASE(GL_RG16)
STR_CASE(GL_RG16I)
STR_CASE(GL_RG16UI)
STR_CASE(GL_RG32I)
STR_CASE(GL_RG32UI)
STR_CASE(GL_R11F_G11F_B10F)
STR_CASE(GL_RGB9_E5)
STR_CASE(GL_DEPTH_STENCIL)
STR_CASE(GL_DEPTH24_STENCIL8)
STR_CASE(GL_DEPTH32F_STENCIL8)
STR_CASE(GL_DEPTH_COMPONENT32F)
STR_CASE(GL_STENCIL_INDEX8)
STR_CASE(GL_STENCIL_INDEX1)
STR_CASE(GL_STENCIL_INDEX4)
STR_CASE(GL_STENCIL_INDEX16)
STR_CASE(GL_R8_SNORM)
STR_CASE(GL_R16_SNORM)
STR_CASE(GL_RG8_SNORM)
STR_CASE(GL_RG16_SNORM)
STR_CASE(GL_RGB8_SNORM)
STR_CASE(GL_RGB16_SNORM)
STR_CASE(GL_RGBA8_SNORM)
STR_CASE(GL_RGBA16_SNORM)
STR_CASE(GL_RGB10_A2UI)
STR_CASE(GL_RGB565)
STR_CASE(GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT)
STR_CASE(GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT)
STR_CASE(GL_COMPRESSED_RGBA_BPTC_UNORM)
STR_CASE(GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM)
STR_CASE(GL_COMPRESSED_R11_EAC)
STR_CASE(GL_COMPRESSED_RG11_EAC)
STR_CASE(GL_COMPRESSED_SIGNED_R11_EAC)
STR_CASE(GL_COMPRESSED_SIGNED_RG11_EAC)
STR_CASE(GL_COMPRESSED_RGB8_ETC2)
STR_CASE(GL_COMPRESSED_SRGB8_ETC2)
STR_CASE(GL_COMPRESSED_RGBA8_ETC2_EAC)
STR_CASE(GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC)
STR_CASE(GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2)
STR_CASE(GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2)
STR_CASE(GL_COMPRESSED_RGBA_ASTC_4x4_KHR)
STR_CASE(GL_COMPRESSED_RGBA_ASTC_5x4_KHR)
STR_CASE(GL_COMPRESSED_RGBA_ASTC_5x5_KHR)
STR_CASE(GL_COMPRESSED_RGBA_ASTC_6x5_KHR)
STR_CASE(GL_COMPRESSED_RGBA_ASTC_6x6_KHR)
STR_CASE(GL_COMPRESSED_RGBA_ASTC_8x5_KHR)
STR_CASE(GL_COMPRESSED_RGBA_ASTC_8x6_KHR)
STR_CASE(GL_COMPRESSED_RGBA_ASTC_8x8_KHR)
STR_CASE(GL_COMPRESSED_RGBA_ASTC_10x5_KHR)
STR_CASE(GL_COMPRESSED_RGBA_ASTC_10x6_KHR)
STR_CASE(GL_COMPRESSED_RGBA_ASTC_10x8_KHR)
STR_CASE(GL_COMPRESSED_RGBA_ASTC_10x10_KHR)
STR_CASE(GL_COMPRESSED_RGBA_ASTC_12x10_KHR)
STR_CASE(GL_COMPRESSED_RGBA_ASTC_12x12_KHR)
STR_CASE(GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR)
STR_CASE(GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR)
STR_CASE(GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR)
STR_CASE(GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR)
STR_CASE(GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR)
STR_CASE(GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR)
STR_CASE(GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR)
STR_CASE(GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR)
STR_CASE(GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR)
STR_CASE(GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR)
STR_CASE(GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR)
STR_CASE(GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR)
STR_CASE(GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR)
STR_CASE(GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR)
default:
return str_enum_(internal_format);
}
}
git.rcrnstn.net