new file mode 100644

@@ -0,0 +1,196 @@

+#include <gltexture.hpp>

+

+#include <algorithm>

+#include <ostream>

+#include <utility>

+

+#include <globject.hpp>

+

+// NOLINTNEXTLINE

+#define STR_EXCEPTION GLObject<>::Exception

+#include <str.hpp>

+

+

+/// Special member functions

+

+

+GLTexture::GLTexture(

+    // NOLINTNEXTLINE

+    std::string object_label,

+    GLenum      target,

+    GLenum      binding,

+    GLenum      internal_format,

+    GLenum      wrap,

+    GLenum      min_filter,

+    GLenum      mag_filter

+)

+:

+    GLObject(STR_JOIN(" ", it, it, {

+        str_target_(target),

+        str_internal_format_(internal_format),

+        std::move(object_label)

+    })),

+    target_    {target},

+    binding_   {binding},

+    min_filter_{min_filter},

+    unit_      {0}

+{

+    // check_internal_format_(internal_format);

+    unit(true);

+    if (wrap)

+    {

+        glTexParameteri(target_, GL_TEXTURE_WRAP_S, (GLint)wrap);

+        glTexParameteri(target_, GL_TEXTURE_WRAP_T, (GLint)wrap);

+        glTexParameteri(target_, GL_TEXTURE_WRAP_R, (GLint)wrap);

+    }

+    if (min_filter)

+        glTexParameteri(target_, GL_TEXTURE_MIN_FILTER, (GLint)min_filter);

+    if (mag_filter)

+        glTexParameteri(target_, GL_TEXTURE_MAG_FILTER, (GLint)mag_filter);

+    if (min_filter_mipmap_())

+        if (!supported({3, 0}, "GL_ARB_framebuffer_object"))

+            glTexParameteri(target_, GL_GENERATE_MIPMAP, GL_TRUE);

+    if (target_ == GL_TEXTURE_2D)

+        // NOLINTNEXTLINE

+        if (supported({4, 6}, "GL_ARB_texture_filter_anisotropic"))

+            // TODO(rcrnstn): Remove the `_EXT` suffix when the headers are

+            // updated.

+            glTexParameterf(target_, GL_TEXTURE_MAX_ANISOTROPY_EXT, anisotropy_);

+}

+

+

+/// Core

+

+

+GLOBJECT_THREAD(GLTexture::anisotropy_, {1.0F})

+

+

+GLint GLTexture::unit(bool force_active) const

+try

+{

+    auto static const unit_count = (GLuint)integer(

+        GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS

+    );

+    auto static units       = std::vector<GLuint>(unit_count);

+    auto static textures    = std::vector<GLuint>(unit_count);

+    auto static targets     = std::vector<GLenum>(unit_count);

+    auto static unit_next   = GLuint{1};

+    auto static unit_active = GLuint{0};

+

+    if (!unit_ || textures[unit_] != object())

+    {

+        if (unit_next < unit_count)

+            units.back() = unit_ = unit_next++;

+        else

+            unit_ = units.back();

+        std::rotate(units.begin(), units.end() - 1, units.end());

+    }

+

+    if (force_active || unit_active != unit_)

+    {

+        glActiveTexture(GL_TEXTURE0 + unit_);

+        unit_active = unit_;

+    }

+

+    if (textures[unit_] != object())

+    {

+        GLOBJECT_DEBUG_IF(1)

+            check_unit_active_();

+        GLOBJECT_DEBUG_IF(1)

+        {

+            glBindTexture(targets[unit_], 0);

+            targets[unit_] = target_;

+        }

+        glBindTexture(target_, object());

+        textures[unit_] = object();

+    }

+    GLOBJECT_DEBUG_IF(1)

+        check_unit_texture_();

+

+    return (GLint)unit_;

+}

+catch (...)

+{

+    fail_action_("allocate texture unit for");

+}

+

+

+bool GLTexture::min_filter_mipmap_() const

+{

+    switch (min_filter_)

+    {

+        case GL_NEAREST_MIPMAP_NEAREST:

+        case GL_NEAREST_MIPMAP_LINEAR:

+        case GL_LINEAR_MIPMAP_NEAREST:

+        case GL_LINEAR_MIPMAP_LINEAR:

+            return true;

+        default:

+            return false;

+    }

+}

+

+

+/// Path

+

+

+GLOBJECT_THREAD(GLTexture::prefix_, {"assets/textures"})

+

+

+/// Check

+

+

+void GLTexture::check_unit_active_() const

+{

+    auto unit_active = (GLuint)integer(GL_ACTIVE_TEXTURE) - GL_TEXTURE0;

+    if (unit_active != unit_)

+        STR_THROW(

+            "Expected active unit " << unit_        << ", " <<

+            "got "                  << unit_active  << "."

+        );

+}

+

+

+void GLTexture::check_unit_texture_() const

+{

+    auto unit_texture = (GLuint)integer(binding_);

+    if (unit_texture != object())

+        STR_THROW(

+            "Expected unit "  << unit_        << " "   <<

+            "to be bound to " << debug_name() << ", "  <<

+            "got "            << unit_texture << "."

+        );

+}

+

+

+void GLTexture::check_data_size_(std::size_t data_size) const

+{

+    if (data_size != data_size_())

+        STR_THROW(

+            "Expected data size " << data_size_() << ", " <<

+            "got "                << data_size    << "."

+        );

+}

+

+

+/// String

+

+

+std::string GLTexture::str_target_(GLenum target)

+{

+    switch (target)

+    {

+        STR_CASE(GL_TEXTURE_1D)

+        STR_CASE(GL_TEXTURE_2D)

+        STR_CASE(GL_TEXTURE_3D)

+        STR_CASE(GL_TEXTURE_1D_ARRAY)

+        STR_CASE(GL_TEXTURE_2D_ARRAY)

+        STR_CASE(GL_TEXTURE_RECTANGLE)

+        STR_CASE(GL_TEXTURE_CUBE_MAP)

+        STR_CASE(GL_TEXTURE_CUBE_MAP_ARRAY)

+        STR_CASE(GL_TEXTURE_BUFFER)

+        STR_CASE(GL_TEXTURE_2D_MULTISAMPLE)

+        STR_CASE(GL_TEXTURE_2D_MULTISAMPLE_ARRAY)

+        default:

+            return str_enum_(target);

+    }

+}