gosu 1.4.6 → 2.0.0.pre7

data/src/Image.cpp

@@ -1,53 +1,54 @@
 #include <Gosu/Bitmap.hpp>
+#include <Gosu/Buffer.hpp>
+#include <Gosu/Drawable.hpp>
 #include <Gosu/Graphics.hpp>
-#include <Gosu/IO.hpp>
 #include <Gosu/Image.hpp>
-#include <Gosu/ImageData.hpp>
 #include <Gosu/Math.hpp>
-#include "EmptyImageData.hpp"
+#include "EmptyDrawable.hpp"
 #include <stdexcept>
 
 Gosu::Image::Image()
-: m_data{EmptyImageData::instance_ptr()}
 {
+    static const auto default_data_ptr = std::make_shared<EmptyDrawable>(0, 0);
+    m_drawable = default_data_ptr;
 }
 
 Gosu::Image::Image(const std::string& filename, unsigned image_flags)
-: Image(load_image_file(filename), image_flags)
+    : Image(load_image_file(filename), image_flags)
 {
 }
 
-Gosu::Image::Image(const std::string& filename, int src_x, int src_y, int src_width, int src_height,
-                   unsigned image_flags)
-: Image(load_image_file(filename), src_x, src_y, src_width, src_height, image_flags)
+Gosu::Image::Image(const std::string& filename, const Rect& source_rect, unsigned image_flags)
+    : Image(load_image_file(filename), source_rect, image_flags)
 {
 }
 
 Gosu::Image::Image(const Bitmap& source, unsigned image_flags)
-: Image(source, 0, 0, source.width(), source.height(), image_flags)
+    : Image(source, Rect::covering(source), image_flags)
 {
 }
 
-Gosu::Image::Image(const Bitmap& source, int src_x, int src_y, int src_width, int src_height,
-                   unsigned image_flags)
-: m_data{Graphics::create_image(source, src_x, src_y, src_width, src_height, image_flags)}
+Gosu::Image::Image(const Bitmap& source, const Rect& source_rect, unsigned image_flags)
+    : m_drawable(create_drawable(source, source_rect, image_flags))
 {
 }
 
-Gosu::Image::Image(std::unique_ptr<ImageData>&& data)
-: m_data{data.release()}
+Gosu::Image::Image(std::unique_ptr<Drawable> data)
+    : m_drawable(std::move(data))
 {
-    if (!m_data) throw std::invalid_argument("Gosu::Image cannot be initialized with nullptr");
+    if (!m_drawable) {
+        throw std::invalid_argument("Gosu::Image cannot be initialized with nullptr");
+    }
 }
 
 unsigned Gosu::Image::width() const
 {
-    return m_data->width();
+    return m_drawable->width();
 }
 
 unsigned Gosu::Image::height() const
 {
-    return m_data->height();
+    return m_drawable->height();
 }
 
 void Gosu::Image::draw(double x, double y, ZPos z, double scale_x, double scale_y, Color c,
@@ -56,7 +57,7 @@ void Gosu::Image::draw(double x, double y, ZPos z, double scale_x, double scale_
     double x2 = x + width() * scale_x;
     double y2 = y + height() * scale_y;
 
-    m_data->draw(x, y, c, x2, y, c, x, y2, c, x2, y2, c, z, mode);
+    m_drawable->draw(x, y, c, x2, y, c, x, y2, c, x2, y2, c, z, mode);
 }
 
 void Gosu::Image::draw_mod(double x, double y, ZPos z, double scale_x, double scale_y, Color c1,
@@ -65,7 +66,7 @@ void Gosu::Image::draw_mod(double x, double y, ZPos z, double scale_x, double sc
     double x2 = x + width() * scale_x;
     double y2 = y + height() * scale_y;
 
-    m_data->draw(x, y, c1, x2, y, c2, x, y2, c3, x2, y2, c4, z, mode);
+    m_drawable->draw(x, y, c1, x2, y, c2, x, y2, c3, x2, y2, c4, z, mode);
 }
 
 void Gosu::Image::draw_rot(double x, double y, ZPos z, double angle, double center_x,
@@ -87,44 +88,49 @@ void Gosu::Image::draw_rot(double x, double y, ZPos z, double angle, double cent
     double dist_to_bottom_x = -offs_x * size_y * (1 - center_y);
     double dist_to_bottom_y = -offs_y * size_y * (1 - center_y);
 
-    m_data->draw(x + dist_to_left_x + dist_to_top_x, y + dist_to_left_y + dist_to_top_y, c,
-                 x + dist_to_right_x + dist_to_top_x, y + dist_to_right_y + dist_to_top_y, c,
-                 x + dist_to_left_x + dist_to_bottom_x, y + dist_to_left_y + dist_to_bottom_y, c,
-                 x + dist_to_right_x + dist_to_bottom_x, y + dist_to_right_y + dist_to_bottom_y, c,
-                 z, mode);
+    m_drawable->draw( //
+        x + dist_to_left_x + dist_to_top_x, y + dist_to_left_y + dist_to_top_y, c,
+        x + dist_to_right_x + dist_to_top_x, y + dist_to_right_y + dist_to_top_y, c,
+        x + dist_to_left_x + dist_to_bottom_x, y + dist_to_left_y + dist_to_bottom_y, c,
+        x + dist_to_right_x + dist_to_bottom_x, y + dist_to_right_y + dist_to_bottom_y, c, //
+        z, mode);
 }
 
-Gosu::ImageData& Gosu::Image::data() const
+Gosu::Drawable& Gosu::Image::drawable() const
 {
-    return *m_data;
+    return *m_drawable;
 }
 
-std::vector<Gosu::Image> Gosu::load_tiles(const Bitmap& bmp, //
+std::vector<Gosu::Image> Gosu::load_tiles(const Bitmap& bitmap, //
                                           int tile_width, int tile_height, unsigned flags)
 {
+    if (tile_width == 0 || tile_height == 0) {
+        throw std::invalid_argument("Gosu::load_tiles does not support empty tiles");
+    }
+
     int tiles_x, tiles_y;
     std::vector<Image> images;
 
     if (tile_width > 0) {
-        tiles_x = bmp.width() / tile_width;
+        tiles_x = bitmap.width() / tile_width;
     }
     else {
         tiles_x = -tile_width;
-        tile_width = bmp.width() / tiles_x;
+        tile_width = bitmap.width() / tiles_x;
     }
 
     if (tile_height > 0) {
-        tiles_y = bmp.height() / tile_height;
+        tiles_y = bitmap.height() / tile_height;
     }
     else {
         tiles_y = -tile_height;
-        tile_height = bmp.height() / tiles_y;
+        tile_height = bitmap.height() / tiles_y;
     }
 
     for (int y = 0; y < tiles_y; ++y) {
         for (int x = 0; x < tiles_x; ++x) {
-            images.emplace_back(bmp, x * tile_width, y * tile_height, tile_width, tile_height,
-                                flags);
+            images.emplace_back(
+                bitmap, Rect { x * tile_width, y * tile_height, tile_width, tile_height }, flags);
         }
     }
 
@@ -134,6 +140,6 @@ std::vector<Gosu::Image> Gosu::load_tiles(const Bitmap& bmp, //
 std::vector<Gosu::Image> Gosu::load_tiles(const std::string& filename, //
                                           int tile_width, int tile_height, unsigned flags)
 {
-    Bitmap bmp = load_image_file(filename);
-    return load_tiles(bmp, tile_width, tile_height, flags);
+    const Bitmap bitmap = load_image_file(filename);
+    return load_tiles(bitmap, tile_width, tile_height, flags);
 }

data/src/Input.cpp

@@ -8,21 +8,20 @@
 #include <SDL.h>
 #include <utf8proc.h>
 
-#include <cwctype>
 #include <cstdlib>
 #include <algorithm>
 #include <array>
-#include <mutex>
 #include <stdexcept>
 using namespace std;
 
 static void require_sdl_video()
 {
-    static std::once_flag initialized;
-
-    std::call_once(initialized, [] {
-        SDL_InitSubSystem(SDL_INIT_VIDEO);
-    });
+    // Don't bother shutting down the SDL video subsystem because OpenGLContext.cpp keeps it alive
+    // forever as well, and it is hard to know when to free things in a Ruby C extension.
+    static const int initialized = SDL_Init(SDL_INIT_VIDEO);
+    if (initialized < 0) {
+        throw std::runtime_error(SDL_GetError());
+    }
 }
 
 static const unsigned NUM_BUTTONS_PER_GAMEPAD =
@@ -602,7 +601,7 @@ bool Gosu::Input::down(Gosu::Button btn)
 
 double Gosu::Input::axis(Gosu::Button btn)
 {
-    unsigned axis_id = btn - GP_LEFT_STICK_X_AXIS;
+    unsigned axis_id = btn - static_cast<unsigned>(GP_LEFT_STICK_X_AXIS);
 
     if (axis_id >= axis_states.size()) {
         throw std::out_of_range("Invalid axis ID: " + std::to_string(btn));

data/src/Macro.cpp

@@ -132,7 +132,7 @@ struct Gosu::Macro::Impl : private Gosu::Noncopyable
         for (const auto& vertex_array : vertex_arrays) {
             glPushMatrix();
             vertex_array.render_state.apply();
-            glMultMatrixd(&transform[0]);
+            glMultMatrixd(transform.matrix.data());
             glInterleavedArrays(GL_T2F_C4UB_V3F, 0, &vertex_array.vertices[0]);
             glDrawArrays(GL_QUADS, 0, (GLsizei) vertex_array.vertices.size());
             glPopMatrix();
@@ -169,7 +169,7 @@ void Gosu::Macro::draw(double x1, double y1, Color c1, double x2, double y2, Col
 
     normalize_coordinates(x1, y1, x2, y2, x3, y3, c3, x4, y4, c4);
 
-    Gosu::Graphics::gl(z, [=] { pimpl->draw_vertex_arrays(x1, y1, x2, y2, x3, y3, x4, y4); });
+    Gosu::gl(z, [=, this] { pimpl->draw_vertex_arrays(x1, y1, x2, y2, x3, y3, x4, y4); });
 }
 
 const Gosu::GLTexInfo* Gosu::Macro::gl_tex_info() const
@@ -184,15 +184,15 @@ Gosu::Bitmap Gosu::Macro::to_bitmap() const
              pimpl->width, pimpl->height, Color::WHITE, 0, BM_DEFAULT);
     };
 
-    return Gosu::Graphics::render(pimpl->width, pimpl->height, render_this).data().to_bitmap();
+    return Gosu::render(pimpl->width, pimpl->height, render_this).drawable().to_bitmap();
 }
 
-std::unique_ptr<Gosu::ImageData> Gosu::Macro::subimage(int x, int y, int width, int height) const
+std::unique_ptr<Gosu::Drawable> Gosu::Macro::subimage(const Rect&) const
 {
-    return std::unique_ptr<ImageData>{};
+    return nullptr;
 }
 
-void Gosu::Macro::insert(const Bitmap& bitmap, int x, int y)
+void Gosu::Macro::insert(const Bitmap&, int, int)
 {
     throw std::logic_error{"Gosu::Macro cannot be updated with a Gosu::Bitmap yet"};
 }

data/src/Macro.hpp

@@ -1,11 +1,11 @@
 #pragma once
 
 #include <Gosu/Fwd.hpp>
-#include <Gosu/ImageData.hpp>
+#include <Gosu/Drawable.hpp>
 #include "GraphicsImpl.hpp"
 #include <memory>
 
-class Gosu::Macro : public Gosu::ImageData
+class Gosu::Macro : public Gosu::Drawable
 {
     struct Impl;
     std::shared_ptr<Impl> pimpl;
@@ -24,7 +24,7 @@ public:
 
     Gosu::Bitmap to_bitmap() const override;
 
-    std::unique_ptr<ImageData> subimage(int x, int y, int width, int height) const override;
+    std::unique_ptr<Drawable> subimage(const Rect&) const override;
 
-    void insert(const Bitmap& bitmap, int x, int y) override;
+    void insert(const Bitmap&, int x, int y) override;
 };

data/src/MarkupParser.cpp

@@ -157,29 +157,29 @@ void Gosu::MarkupParser::add_current_substring()
 void Gosu::MarkupParser::add_composed_substring(u32string&& substring)
 {
     FormattedString fstr;
-    fstr.text = substring;
+    fstr.text = std::move(substring);
     fstr.flags = flags();
     fstr.color = c.back();
 
     if (!substrings.empty() && substrings.back().can_be_merged_with(fstr)) {
-        substrings.back().text.append(move(fstr.text));
+        substrings.back().text.append(fstr.text);
     }
     else {
-        substrings.emplace_back(move(fstr));
+        substrings.emplace_back(std::move(fstr));
     }
 }
 
 void Gosu::MarkupParser::flush_to_consumer()
 {
     if (!substrings.empty()) {
-        consumer(move(substrings));
+        consumer(std::move(substrings));
         substrings.clear();
     }
 }
 
 Gosu::MarkupParser::MarkupParser(unsigned base_flags, bool split_words,
                                  function<void (vector<FormattedString>)> consumer)
-: consumer(move(consumer))
+: consumer(std::move(consumer))
 {
     word_state = (split_words ? ADDING_WORD : IGNORE_WORDS);
 

data/src/Math.cpp

@@ -1,38 +1,55 @@
 #include <Gosu/Math.hpp>
-#include <cstdlib>
-using namespace std;
+#include <cmath>
+#include <limits> // for std::numeric_limits::quiet_NaN
+#include <random>
 
 double Gosu::random(double min, double max)
 {
-    double rnd = rand();
-    return rnd / (static_cast<double>(RAND_MAX) + 1) * (max - min) + min;
+    if (std::isnan(min) || std::isnan(max)) {
+        return std::numeric_limits<double>::quiet_NaN();
+    }
+
+    if (min == max) {
+        return min;
+    }
+
+    thread_local std::mt19937_64 generator(std::random_device {}());
+    std::uniform_real_distribution<double> distribution(min, max);
+    const double result = distribution(generator);
+    // Make sure that we do not return "max" even when uniform_real_distribution is buggy.
+    // See "Notes": https://en.cppreference.com/w/cpp/numeric/random/uniform_real_distribution
+    return result == max ? min : result;
 }
 
 double Gosu::offset_x(double angle, double radius)
 {
-    return +sin(angle / 180 * M_PI) * radius;
+    return +std::sin(angle / 180 * std::numbers::pi) * radius;
 }
 
 double Gosu::offset_y(double angle, double radius)
 {
-    return -cos(angle / 180 * M_PI) * radius;
+    return -std::cos(angle / 180 * std::numbers::pi) * radius;
 }
 
-double Gosu::angle(double from_x, double from_y, double to_x, double to_y, double def)
+double Gosu::angle(double from_x, double from_y, double to_x, double to_y, double fallback)
 {
     double dist_x = to_x - from_x;
     double dist_y = to_y - from_y;
 
+    // Special-case the four cardinal directions values so that we don't run into subtle rounding
+    // errors for these obvious values.
     if (dist_x == 0) {
-        // Special-case these values so that for a result of 0°/360° we  never 
-        // run into subtle precision errors by converting from radian to angles.
-        if (dist_y < 0) return 0;
-        if (dist_y > 0) return 180;
-        // dist_y == 0
-        return 0;
+        if (dist_y == 0) {
+            return fallback;
+        }
+
+        return dist_y < 0 ? 0 : 180;
+    }
+    else if (dist_y == 0) {
+        return dist_x < 0 ? 270 : 90;
     }
 
-    return normalize_angle(radians_to_gosu(atan2(dist_y, dist_x)));
+    return normalize_angle(radians_to_angle(std::atan2(dist_y, dist_x)));
 }
 
 double Gosu::angle_diff(double from, double to)
@@ -51,19 +68,15 @@ int Gosu::wrap(int value, int min, int max)
     return result < 0 ? result + max : result + min;
 }
 
-float Gosu::wrap(float value, float min, float max)
-{
-    float result = fmodf(value - min, max - min);
-    return result < 0 ? result + max : result + min;
-}
-
 double Gosu::wrap(double value, double min, double max)
 {
-    double result = fmod(value - min, max - min);
+    double result = std::fmod(value - min, max - min);
     return result < 0 ? result + max : result + min;
 }
 
 double Gosu::distance(double x1, double y1, double x2, double y2)
 {
-    return sqrt(distance_sqr(x1, y1, x2, y2));
+    double dist_x = (x2 - x1);
+    double dist_y = (y2 - y1);
+    return std::sqrt(dist_x * dist_x + dist_y * dist_y);
 }

data/src/OffScreenTarget.cpp

@@ -1,99 +1,103 @@
 #include "OffScreenTarget.hpp"
-#include "Texture.hpp"
 #include <Gosu/Image.hpp>
 #include <Gosu/Platform.hpp>
+#include "OpenGLContext.hpp"
+#include "Texture.hpp"
 #ifndef GOSU_IS_IPHONE
-#include <SDL.h>
+#include <SDL.h> // for SDL_GL_GetProcAddress
 #endif
-using namespace std;
 
 #ifdef GOSU_IS_OPENGLES
-    #define GOSU_LOAD_GL_EXT(fn, type) \
-        static auto fn = fn ## OES;
-
-    #define GOSU_GL_CONST(name) \
-        name ## _OES
-
-    #define GOSU_GL_DEPTH_COMPONENT \
-        GL_DEPTH_COMPONENT16_OES
+#define GOSU_LOAD_GL_EXT(fn, type) static auto fn = fn##OES
+#define GOSU_GL_CONST(name) name##_OES
+#define GOSU_GL_DEPTH_COMPONENT GL_DEPTH_COMPONENT16_OES
 #else
-    #define GOSU_LOAD_GL_EXT(fn, type) \
-        static auto fn = (type) SDL_GL_GetProcAddress(#fn); \
-        if (!fn) throw runtime_error("Unable to load " #fn);
-
-    #define GOSU_GL_CONST(name) \
-        name
-
-    #define GOSU_GL_DEPTH_COMPONENT \
-        GL_DEPTH_COMPONENT
+#define GOSU_LOAD_GL_EXT(fn, type)                                                                 \
+    static auto fn = reinterpret_cast<type>(SDL_GL_GetProcAddress(#fn));                           \
+    if ((fn) == nullptr) {                                                                         \
+        throw std::runtime_error("Unable to load " #fn);                                           \
+    }
+#define GOSU_GL_CONST(name) name
+#define GOSU_GL_DEPTH_COMPONENT GL_DEPTH_COMPONENT
 #endif
 
 Gosu::OffScreenTarget::OffScreenTarget(int width, int height, unsigned image_flags)
+    : r_renderbuffer(static_cast<GLuint>(-1)),
+      m_framebuffer(static_cast<GLuint>(-1))
 {
 #ifndef GOSU_IS_IPHONE
+    // GCOV_EXCL_START
     if (!SDL_GL_ExtensionSupported("GL_EXT_framebuffer_object")) {
-        throw runtime_error("Missing GL_EXT_framebuffer_object extension");
+        throw std::runtime_error("Missing GL_EXT_framebuffer_object extension");
     }
+    // GCOV_EXCL_end
 #endif
-    
+
     // Create a new texture that will be our rendering target.
-    texture = make_shared<Texture>(width, height, image_flags & IF_RETRO);
-    // Mark the full texture as blocked for our TexChunk.
-    texture->block(0, 0, width, height);
-    
+    m_texture = std::make_shared<Texture>(width, height, image_flags & IF_RETRO);
+
     // Besides the texture, also create a renderbuffer for depth information.
-    // Gosu doesn't use this, but custom OpenGL code could might.
+    // Gosu doesn't use this, but custom OpenGL code might.
     GOSU_LOAD_GL_EXT(glGenRenderbuffers, PFNGLGENRENDERBUFFERSPROC);
-    glGenRenderbuffers(1, &renderbuffer);
-    
+    glGenRenderbuffers(1, &r_renderbuffer);
+
     GOSU_LOAD_GL_EXT(glBindRenderbuffer, PFNGLBINDRENDERBUFFERPROC);
-    glBindRenderbuffer(GOSU_GL_CONST(GL_RENDERBUFFER), renderbuffer);
-    
+    glBindRenderbuffer(GOSU_GL_CONST(GL_RENDERBUFFER), r_renderbuffer);
+
     GOSU_LOAD_GL_EXT(glRenderbufferStorage, PFNGLRENDERBUFFERSTORAGEPROC);
     glRenderbufferStorage(GOSU_GL_CONST(GL_RENDERBUFFER), GOSU_GL_DEPTH_COMPONENT, width, height);
     glBindRenderbuffer(GOSU_GL_CONST(GL_RENDERBUFFER), 0);
-    
+
     // Now tie everything together.
     GOSU_LOAD_GL_EXT(glGenFramebuffers, PFNGLGENFRAMEBUFFERSPROC);
-    glGenFramebuffers(1, &framebuffer);
-    
+    glGenFramebuffers(1, &m_framebuffer);
+
     GOSU_LOAD_GL_EXT(glBindFramebuffer, PFNGLBINDFRAMEBUFFERPROC);
-    glBindFramebuffer(GOSU_GL_CONST(GL_FRAMEBUFFER), framebuffer);
-    
+    glBindFramebuffer(GOSU_GL_CONST(GL_FRAMEBUFFER), m_framebuffer);
+
     GOSU_LOAD_GL_EXT(glFramebufferTexture2D, PFNGLFRAMEBUFFERTEXTURE2DPROC);
     glFramebufferTexture2D(GOSU_GL_CONST(GL_FRAMEBUFFER), GOSU_GL_CONST(GL_COLOR_ATTACHMENT0),
-                           GL_TEXTURE_2D, texture->tex_name(), 0);
-    
+                           GL_TEXTURE_2D, m_texture->tex_name(), 0);
+
     GOSU_LOAD_GL_EXT(glFramebufferRenderbuffer, PFNGLFRAMEBUFFERRENDERBUFFERPROC);
     glFramebufferRenderbuffer(GOSU_GL_CONST(GL_FRAMEBUFFER), GOSU_GL_CONST(GL_DEPTH_ATTACHMENT),
-                              GOSU_GL_CONST(GL_RENDERBUFFER), renderbuffer);
+                              GOSU_GL_CONST(GL_RENDERBUFFER), r_renderbuffer);
 }
 
 Gosu::OffScreenTarget::~OffScreenTarget()
 {
     try {
         GOSU_LOAD_GL_EXT(glDeleteRenderbuffers, PFNGLDELETERENDERBUFFERSPROC);
-        glDeleteRenderbuffers(1, &renderbuffer);
-        
+        glDeleteRenderbuffers(1, &r_renderbuffer);
+
         GOSU_LOAD_GL_EXT(glDeleteFramebuffers, PFNGLDELETEFRAMEBUFFERSPROC);
-        glDeleteFramebuffers(1, &framebuffer);
+        glDeleteFramebuffers(1, &m_framebuffer);
+        // GCOV_EXCL_START
     } catch (...) {
         // If we can't load these functions, just accept the resource leak.
     }
+    // GCOV_EXCL_END
 }
 
 Gosu::Image Gosu::OffScreenTarget::render(const std::function<void ()>& f)
 {
     GOSU_LOAD_GL_EXT(glBindFramebuffer, PFNGLBINDFRAMEBUFFERPROC);
-    glBindFramebuffer(GOSU_GL_CONST(GL_FRAMEBUFFER), framebuffer);
-    
+    glBindFramebuffer(GOSU_GL_CONST(GL_FRAMEBUFFER), m_framebuffer);
+
     GOSU_LOAD_GL_EXT(glCheckFramebufferStatus, PFNGLCHECKFRAMEBUFFERSTATUSPROC);
     GLenum status = glCheckFramebufferStatus(GOSU_GL_CONST(GL_FRAMEBUFFER));
-    if (status != GOSU_GL_CONST(GL_FRAMEBUFFER_COMPLETE)) throw runtime_error("Incomplete framebuffer");
-    
-    f();
+    if (status != GOSU_GL_CONST(GL_FRAMEBUFFER_COMPLETE)) {
+        throw std::runtime_error("Incomplete framebuffer");
+    }
+
+    try {
+        f();
+
+    } catch (...) {
+        glBindFramebuffer(GOSU_GL_CONST(GL_FRAMEBUFFER), 0);
+        throw;
+    }
     glBindFramebuffer(GOSU_GL_CONST(GL_FRAMEBUFFER), 0);
 
-    unique_ptr<ImageData> tex_chunk(new TexChunk(texture, 0, 0, texture->width(), texture->height(), 0));
-    return Image(move(tex_chunk));
+    return Image(std::make_unique<TexChunk>(m_texture, Rect::covering(*m_texture), nullptr));
 }

data/src/OffScreenTarget.hpp

@@ -1,23 +1,25 @@
 #pragma once
 
-#include "GraphicsImpl.hpp"
+#include <Gosu/Utility.hpp>
+#include <cstdint>
+#include <functional>
+#include <memory>
 
 namespace Gosu
 {
-    class OffScreenTarget
+    class Image;
+    class Texture;
+
+    class OffScreenTarget : private Noncopyable
     {
-        std::shared_ptr<Texture> texture;
-        GLuint renderbuffer;
-        GLuint framebuffer;
-        
-        OffScreenTarget(const OffScreenTarget& other) = delete;
-        OffScreenTarget& operator=(const OffScreenTarget& other) = delete;
-        OffScreenTarget(OffScreenTarget&& other) = delete;
-        OffScreenTarget& operator=(OffScreenTarget&& other) = delete;
-        
+        std::shared_ptr<Texture> m_texture;
+        std::uint32_t r_renderbuffer;
+        std::uint32_t m_framebuffer;
+
     public:
         OffScreenTarget(int width, int height, unsigned image_flags);
         ~OffScreenTarget();
+
         Gosu::Image render(const std::function<void ()>& f);
     };
 }