Restructuring

15 files changed, 0 insertions, 2042 deletions

diff --git a/src/body.cpp b/src/body.cpp
deleted file mode 100644
index 8d38e70a..00000000
--- a/src/body.cpp
+++ /dev/null
@@ -1,34 +0,0 @@
-/* ----------------------------------------------------------------------------
- * body.cpp
- *
- * Copyright (c) 2017 Yann Herklotz Grave <ymherklotz@gmail.com> -- MIT License
- * See file LICENSE for more details
- * ----------------------------------------------------------------------------
- */
-
-#include <YAGE/Physics/body.h>
-
-#include <utility>
-
-namespace yage
-{
-
-const double Body::GRAVITY = -9.81;
-
-double Body::xPosition() const
-{
-    return position_[0];
-}
-
-double Body::yPosition() const
-{
-    return position_[1];
-}
-
-Body::Body(Vector2d position, double mass, Vector2d velocity, bool gravity)
-    : position_(std::move(position)), mass_(mass),
-      velocity_(std::move(velocity)), gravity_(gravity)
-{
-}
-
-} // namespace yage
diff --git a/src/camera2d.cpp b/src/camera2d.cpp
deleted file mode 100644
index 292f998a..00000000
--- a/src/camera2d.cpp
+++ /dev/null
@@ -1,45 +0,0 @@
-/* ----------------------------------------------------------------------------
- * camera2d.cpp
- *
- * Copyright (c) 2017 Yann Herklotz Grave <ymherklotz@gmail.com> -- MIT License
- * See file LICENSE for more details
- * ----------------------------------------------------------------------------
- */
-
-#include <YAGE/camera2d.h>
-
-#include <GL/glew.h>
-
-namespace yage
-{
-
-Camera2D::Camera2D(int screen_width, int screen_height)
-    : position_(0.f, 0.f), camera_matrix_(1.f),
-      ortho_matrix_(
-          glm::ortho(0.f, (float)screen_width, 0.f, (float)screen_height))
-{
-}
-
-void Camera2D::update(GlslProgram &program)
-{
-    if (update_matrix_) {
-        glm::vec3 translate(-position_.x, -position_.y, 0.f);
-        glm::vec3 scale(scale_, scale_, 0.f);
-
-        camera_matrix_ = glm::translate(ortho_matrix_, translate);
-        camera_matrix_ = glm::scale(glm::mat4(1.f), scale) * camera_matrix_;
-
-        update_matrix_ = false;
-    }
-
-    GLint matrix_location = program.getUniformLocation("P");
-    glUniformMatrix4fv(matrix_location, 1, GL_FALSE, &(camera_matrix_[0][0]));
-}
-
-void Camera2D::move(const glm::vec2 &direction)
-{
-    position_ += direction;
-    update_matrix_ = true;
-}
-
-} // namespace yage
diff --git a/src/glslprogram.cpp b/src/glslprogram.cpp
deleted file mode 100644
index 11a3191e..00000000
--- a/src/glslprogram.cpp
+++ /dev/null
@@ -1,162 +0,0 @@
-/* ----------------------------------------------------------------------------
- * glslprogram.cpp
- *
- * Copyright (c) 2017 Yann Herklotz Grave <ymherklotz@gmail.com> -- MIT License
- * See file LICENSE for more details
- * ----------------------------------------------------------------------------
- */
-
-#include <YAGE/glslprogram.h>
-
-#include <fstream>
-#include <stdexcept>
-#include <vector>
-
-namespace yage
-{
-
-GlslProgram::~GlslProgram()
-{
-    // cleanup all the shaders and the program
-    if (fragment_shader_id_ != 0) {
-        glDeleteShader(fragment_shader_id_);
-    }
-
-    if (vertex_shader_id_ != 0) {
-        glDeleteShader(vertex_shader_id_);
-    }
-
-    if (program_id_ != 0) {
-        glDeleteProgram(program_id_);
-    }
-}
-
-void GlslProgram::compileShader(const GLuint &shader,
-                                const std::string &file_path)
-{
-    // get a string with the input from the shader file
-    std::ifstream file(file_path);
-    if (!file.is_open()) {
-        throw std::runtime_error("Failed to open '" + file_path + "'");
-    }
-
-    std::string content = "";
-    std::string line;
-
-    while (std::getline(file, line)) {
-        content += line + "\n";
-    }
-    file.close();
-
-    // cast source to a c string to get the address of it and input it for
-    // compilation
-    const auto *vertex_source = (const GLchar *)content.c_str();
-    glShaderSource(shader, 1, &vertex_source, nullptr);
-    glCompileShader(shader);
-
-    // check if compilation was successful
-    GLint is_compiled = 0;
-    glGetShaderiv(shader, GL_COMPILE_STATUS, (int *)&is_compiled);
-
-    // if it isn't compiled throw exception to clean up
-    if (is_compiled == GL_FALSE) {
-        GLint max_length = 0;
-        glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &max_length);
-
-        std::vector<GLchar> error_log(max_length);
-        glGetShaderInfoLog(shader, max_length, &max_length, &error_log[0]);
-        std::string error_log_str((const char *)&error_log[0]);
-
-        throw std::runtime_error("Couldn't compile " + file_path + " : " +
-                                 error_log_str);
-    }
-}
-
-void GlslProgram::compileShaders(const std::string &vertex_shader_path,
-                                 const std::string &fragment_shader_path)
-{
-    // create the program that will be run on GPU
-    program_id_ = glCreateProgram();
-
-    // create vertex shader
-    vertex_shader_id_ = glCreateShader(GL_VERTEX_SHADER);
-    if (vertex_shader_id_ == 0) {
-        throw std::runtime_error("Vertex shader failed to be created");
-    }
-
-    // create fragment shader
-    fragment_shader_id_ = glCreateShader(GL_FRAGMENT_SHADER);
-    if (fragment_shader_id_ == 0) {
-        throw std::runtime_error("Fragment shader failed to be created");
-    }
-
-    // compile the two shaders
-    compileShader(vertex_shader_id_, vertex_shader_path);
-    compileShader(fragment_shader_id_, fragment_shader_path);
-}
-
-void GlslProgram::linkShaders()
-{
-    // attach the shaders that we want
-    glAttachShader(program_id_, vertex_shader_id_);
-    glAttachShader(program_id_, fragment_shader_id_);
-
-    // link our program
-    glLinkProgram(program_id_);
-
-    GLint is_linked = 0;
-    glGetProgramiv(program_id_, GL_LINK_STATUS, (int *)&is_linked);
-    if (is_linked == GL_FALSE) {
-        GLint max_length = 0;
-        glGetProgramiv(program_id_, GL_INFO_LOG_LENGTH, &max_length);
-
-        std::vector<GLchar> error_log(max_length);
-        glGetProgramInfoLog(program_id_, max_length, &max_length,
-                            &error_log[0]);
-
-        std::string error_log_str((const char *)&error_log[0]);
-
-        throw std::runtime_error("Could not link program : " + error_log_str);
-    }
-
-    // detach shaders after successful link
-    glDetachShader(program_id_, fragment_shader_id_);
-    glDetachShader(program_id_, vertex_shader_id_);
-
-    // we can then delete the shaders once we have the program
-    glDeleteShader(fragment_shader_id_);
-    glDeleteShader(vertex_shader_id_);
-}
-
-void GlslProgram::addAttribute(const std::string &attribute_name)
-{
-    glBindAttribLocation(program_id_, attribute_index_++,
-                         attribute_name.c_str());
-}
-
-GLint GlslProgram::getUniformLocation(const std::string &uniform_name)
-{
-    GLint location = glGetUniformLocation(program_id_, uniform_name.c_str());
-    if ((GLuint)location == GL_INVALID_INDEX) {
-        throw std::runtime_error("'" + uniform_name + "' not found");
-    }
-    return location;
-}
-
-void GlslProgram::use()
-{
-    glUseProgram(program_id_);
-    for (int i = 0; i < attribute_index_; ++i) {
-        glEnableVertexAttribArray(i);
-    }
-}
-
-void GlslProgram::unuse()
-{
-    for (int i = 0; i < attribute_index_; ++i) {
-        glDisableVertexAttribArray(i);
-    }
-    glUseProgram(0);
-}
-
-} // namespace yage
diff --git a/src/imageloader.cpp b/src/imageloader.cpp
deleted file mode 100644
index 812110d8..00000000
--- a/src/imageloader.cpp
+++ /dev/null
@@ -1,60 +0,0 @@
-/* ----------------------------------------------------------------------------
- * imageloader.cpp
- *
- * Copyright (c) 2017 Yann Herklotz Grave <ymherklotz@gmail.com> -- MIT License
- * See file LICENSE for more details
- * ----------------------------------------------------------------------------
- */
-
-#include <YAGE/imageloader.h>
-#include <YAGE/iomanager.h>
-#include <YAGE/picopng.h>
-
-#include <stdexcept>
-
-namespace yage
-{
-
-Texture ImageLoader::loadPng(const std::string &file_path)
-{
-    Texture texture = {};
-
-    std::vector<unsigned char> in;
-    std::vector<unsigned char> out;
-    unsigned long width, height;
-
-    if (!IoManager::readFileToBuffer(file_path, in)) {
-        throw std::runtime_error("Failed to load '" + file_path +
-                                 "' to buffer");
-    }
-
-    int error_code = decodePNG(out, width, height, &in[0], in.size());
-    if (error_code != 0) {
-        throw std::runtime_error("Failed to load '" + file_path +
-                                 "' to png with error code" +
-                                 std::to_string(error_code));
-    }
-
-    glGenTextures(1, &texture.id);
-
-    glBindTexture(GL_TEXTURE_2D, texture.id);
-    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_RGBA,
-                 GL_UNSIGNED_BYTE, &out[0]);
-
-    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
-    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
-    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
-    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER,
-                    GL_LINEAR_MIPMAP_LINEAR);
-
-    glGenerateMipmap(GL_TEXTURE_2D);
-
-    glBindTexture(GL_TEXTURE_2D, 0);
-
-    texture.width = (int)width;
-    texture.height = (int)height;
-
-    return texture;
-}
-
-} // namespace yage
diff --git a/src/inputmanager.cpp b/src/inputmanager.cpp
deleted file mode 100644
index d429abd7..00000000
--- a/src/inputmanager.cpp
+++ /dev/null
@@ -1,33 +0,0 @@
-/* ----------------------------------------------------------------------------
- * inputmanager.cpp
- *
- * Copyright (c) 2017 Yann Herklotz Grave <ymherklotz@gmail.com> -- MIT License
- * See file LICENSE for more details
- * ----------------------------------------------------------------------------
- */
-
-#include <YAGE/inputmanager.h>
-
-namespace yage
-{
-
-void InputManager::keyPressed(unsigned key)
-{
-    key_map_[key] = true;
-}
-
-void InputManager::keyReleased(unsigned key)
-{
-    key_map_[key] = false;
-}
-
-bool InputManager::isKeyPressed(unsigned key) const
-{
-    auto key_index = key_map_.find(key);
-    if (key_index != key_map_.end()) {
-        return key_index->second;
-    }
-    return false;
-}
-
-} // namespace yage
diff --git a/src/iomanager.cpp b/src/iomanager.cpp
deleted file mode 100644
index 93ab41c9..00000000
--- a/src/iomanager.cpp
+++ /dev/null
@@ -1,42 +0,0 @@
-/* ----------------------------------------------------------------------------
- * iomanager.cpp
- *
- * Copyright (c) 2017 Yann Herklotz Grave <ymherklotz@gmail.com> -- MIT License
- * See file LICENSE for more details
- * ----------------------------------------------------------------------------
- */
-
-#include <YAGE/iomanager.h>
-
-#include <fstream>
-#include <stdexcept>
-
-namespace yage
-{
-
-bool IoManager::readFileToBuffer(const std::string &file_path,
-                                 std::vector<unsigned char> &buffer)
-{
-    std::ifstream file(file_path, std::ios::binary);
-    if (!file.is_open()) {
-        throw std::runtime_error("Could not open '" + file_path + "'");
-    }
-
-    // seek to the end
-    file.seekg(0, std::ios::end);
-
-    // get the file size
-    int file_size = file.tellg();
-    file.seekg(0, std::ios::beg);
-
-    // reduce file size by header bytes
-    file_size -= file.tellg();
-
-    buffer.resize(file_size);
-    file.read((char *)&buffer[0], file_size);
-    file.close();
-
-    return true;
-}
-
-} // namespace yage
diff --git a/src/particlebody.cpp b/src/particlebody.cpp
deleted file mode 100644
index bdb81eac..00000000
--- a/src/particlebody.cpp
+++ /dev/null
@@ -1,54 +0,0 @@
-/* ----------------------------------------------------------------------------
- * particlebody.cpp
- *
- * Copyright (c) 2017 Yann Herklotz Grave <ymherklotz@gmail.com> -- MIT License
- * See file LICENSE for more details
- * ----------------------------------------------------------------------------
- */
-
-#include <YAGE/Physics/particlebody.h>
-
-#include <cmath>
-#include <iostream>
-
-namespace yage
-{
-
-ParticleBody::ParticleBody(const Vector2d &position, double mass,
-                           const Vector2d &velocity, bool gravity)
-    : Body(position, mass, velocity, gravity)
-{
-}
-
-void ParticleBody::applyForce(const Vector2d &force)
-{
-    force_ += force;
-}
-
-void ParticleBody::update()
-{
-    // set the time_step for 60fps
-    double time_step = 1.0 / 60.0;
-
-    // set the last acceleration
-    Vector2d last_acceleration = acceleration_;
-
-    // update the position of the body
-    position_ += velocity_ * time_step +
-                 (0.5 * last_acceleration * std::pow(time_step, 2));
-
-    // update the acceleration
-    if (gravity_) {
-        acceleration_ =
-            Vector2d(force_.x() / mass_, (GRAVITY + force_.y()) / mass_);
-    } else {
-        acceleration_ = Vector2d(force_.x() / mass_, force_.y() / mass_);
-    }
-
-    Vector2d avg_acceleration = (acceleration_ + last_acceleration) / 2.0;
-
-    // update the velocity of the body
-    velocity_ += avg_acceleration * time_step;
-}
-
-} // namespace yage
diff --git a/src/picopng.cpp b/src/picopng.cpp
deleted file mode 100644
index dcc4b367..00000000
--- a/src/picopng.cpp
+++ /dev/null
@@ -1,1118 +0,0 @@
-#include <cstdlib>
-#include <vector>
-
-namespace yage
-{
-
-/*
-  decodePNG: The picoPNG function, decodes a PNG file buffer in memory, into a
-  raw pixel buffer.
-  out_image: output parameter, this will contain the raw pixels after decoding.
-  By default the output is 32-bit RGBA color.
-  The std::vector is automatically resized to the correct size.
-  image_width: output_parameter, this will contain the width of the image in
-  pixels.
-  image_height: output_parameter, this will contain the height of the image in
-  pixels.
-  in_png: pointer to the buffer of the PNG file in memory. To get it from a file
-  on
-  disk, load it and store it in a memory buffer yourself first.
-  in_size: size of the input PNG file in bytes.
-  convert_to_rgba32: optional parameter, true by default.
-  Set to true to get the output in RGBA 32-bit (8 bit per channel) color format
-  no matter what color type the original PNG image had. This gives predictable,
-  useable data from any random input PNG.
-  Set to false to do no color conversion at all. The result then has the same
-  data
-  type as the PNG image, which can range from 1 bit to 64 bits per pixel.
-  Information about the color type or palette colors are not provided. You need
-  to know this information yourself to be able to use the data so this only
-  works for trusted PNG files. Use LodePNG instead of picoPNG if you need this
-  information.
-  return: 0 if success, not 0 if some error occured.
-*/
-int decodePNG(std::vector<unsigned char> &out_image, unsigned long &image_width,
-              unsigned long &image_height, const unsigned char *in_png,
-              size_t in_size, bool convert_to_rgba32)
-{
-    // picoPNG version 20101224
-    // Copyright (c) 2005-2010 Lode Vandevenne
-    //
-    // This software is provided 'as-is', without any express or implied
-    // warranty. In no event will the authors be held liable for any damages
-    // arising from the use of this software.
-    //
-    // Permission is granted to anyone to use this software for any purpose,
-    // including commercial applications, and to alter it and redistribute it
-    // freely, subject to the following restrictions:
-    //
-    //     1. The origin of this software must not be misrepresented; you must
-    //     not
-    //     claim that you wrote the original software. If you use this software
-    //     in a product, an acknowledgment in the product documentation would be
-    //     appreciated but is not required.
-    //     2. Altered source versions must be plainly marked as such, and must
-    //     not be
-    //     misrepresented as being the original software.
-    //     3. This notice may not be removed or altered from any source
-    //     distribution.
-
-    // picoPNG is a PNG decoder in one C++ function of around 500 lines. Use
-    // picoPNG for
-    // programs that need only 1 .cpp file. Since it's a single function, it's
-    // very limited,
-    // it can convert a PNG to raw pixel data either converted to 32-bit RGBA
-    // color or
-    // with no color conversion at all. For anything more complex, another tiny
-    // library
-    // is available: LodePNG (lodepng.c(pp)), which is a single source and
-    // header file.
-    // Apologies for the compact code style, it's to make this tiny.
-
-    static const unsigned long LENBASE[29] = {
-        3,  4,  5,  6,  7,  8,  9,  10, 11,  13,  15,  17,  19,  23, 27,
-        31, 35, 43, 51, 59, 67, 83, 99, 115, 131, 163, 195, 227, 258};
-    static const unsigned long LENEXTRA[29] = {0, 0, 0, 0, 0, 0, 0, 0, 1, 1,
-                                               1, 1, 2, 2, 2, 2, 3, 3, 3, 3,
-                                               4, 4, 4, 4, 5, 5, 5, 5, 0};
-    static const unsigned long DISTBASE[30] = {
-        1,    2,    3,    4,    5,    7,    9,    13,    17,    25,
-        33,   49,   65,   97,   129,  193,  257,  385,   513,   769,
-        1025, 1537, 2049, 3073, 4097, 6145, 8193, 12289, 16385, 24577};
-    static const unsigned long DISTEXTRA[30] = {
-        0, 0, 0, 0, 1, 1, 2, 2,  3,  3,  4,  4,  5,  5,  6,
-        6, 7, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 13, 13};
-    static const unsigned long CLCL[19] = {
-        16, 17, 18, 0, 8,  7, 9,  6, 10, 5,
-        11, 4,  12, 3, 13, 2, 14, 1, 15}; // code length code lengths
-    struct Zlib // nested functions for zlib decompression
-    {
-        static unsigned long readBitFromStream(size_t &bitp,
-                                               const unsigned char *bits)
-        {
-            unsigned long result = (bits[bitp >> 3] >> (bitp & 0x7)) & 1;
-            bitp++;
-            return result;
-        }
-        static unsigned long readBitsFromStream(size_t &bitp,
-                                                const unsigned char *bits,
-                                                size_t nbits)
-        {
-            unsigned long result = 0;
-            for (size_t i = 0; i < nbits; i++) {
-                result += (readBitFromStream(bitp, bits)) << i;
-            }
-            return result;
-        }
-        struct HuffmanTree {
-            int makeFromLengths(const std::vector<unsigned long> &bitlen,
-                                unsigned long maxbitlen)
-            { // make tree given the lengths
-                unsigned long numcodes = (unsigned long)(bitlen.size()),
-                              treepos = 0, nodefilled = 0;
-                std::vector<unsigned long> tree1d(numcodes),
-                    blcount(maxbitlen + 1, 0), nextcode(maxbitlen + 1, 0);
-                for (unsigned long bits = 0; bits < numcodes; bits++) {
-                    blcount[bitlen[bits]]++; // count number of instances of
-                }
-                // each code length
-                for (unsigned long bits = 1; bits <= maxbitlen; bits++) {
-                    nextcode[bits] = (nextcode[bits - 1] + blcount[bits - 1])
-                                     << 1;
-                }
-                for (unsigned long n = 0; n < numcodes; n++) {
-                    if (bitlen[n] != 0) {
-                        tree1d[n] =
-                            nextcode[bitlen[n]]++; // generate all the codes
-                    }
-                }
-                tree2d.clear();
-                tree2d.resize(numcodes * 2, 32767); // 32767 here means the
-                                                    // tree2d isn't filled
-                                                    // there yet
-                for (unsigned long n = 0; n < numcodes; n++) { // the codes
-                    for (unsigned long i = 0; i < bitlen[n];
-                         i++) // the bits for this code
-                    {
-                        unsigned long bit =
-                            (tree1d[n] >> (bitlen[n] - i - 1)) & 1;
-                        if (treepos > numcodes - 2) {
-                            return 55;
-                        }
-                        if (tree2d[2 * treepos + bit] ==
-                            32767) // not yet filled in
-                        {
-                            if (i + 1 == bitlen[n]) {
-                                tree2d[2 * treepos + bit] = n;
-                                treepos = 0;
-                            } // last bit
-                            else {
-                                tree2d[2 * treepos + bit] =
-                                    ++nodefilled + numcodes;
-                                treepos = nodefilled;
-                            } // addresses are encoded as values > numcodes
-                        } else {
-                            treepos = tree2d[2 * treepos + bit] -
-                                      numcodes; // subtract numcodes from
-                        }
-                        // address to get address value
-                    }
-                }
-                return 0;
-            }
-            int decode(bool &decoded, unsigned long &result, size_t &treepos,
-                       unsigned long bit) const
-            { // Decodes a symbol from the tree
-                unsigned long numcodes = (unsigned long)tree2d.size() / 2;
-                if (treepos >= numcodes) {
-                    return 11; // error: you appeared outside the codetree
-                }
-                result = tree2d[2 * treepos + bit];
-                decoded = (result < numcodes);
-                treepos = decoded ? 0 : result - numcodes;
-                return 0;
-            }
-            std::vector<unsigned long> tree2d; // 2D representation of a
-                                               // huffman tree: The one
-                                               // dimension is "0" or "1", the
-                                               // other contains all nodes and
-                                               // leaves of the tree.
-        };
-        struct Inflator {
-            int error;
-            void inflate(std::vector<unsigned char> &out,
-                         const std::vector<unsigned char> &in, size_t inpos = 0)
-            {
-                size_t bp = 0, pos = 0; // bit pointer and byte pointer
-                error = 0;
-                unsigned long BFINAL = 0;
-                while (!BFINAL && !error) {
-                    if (bp >> 3 >= in.size()) {
-                        error = 52;
-                        return;
-                    } // error, bit pointer will jump past memory
-                    BFINAL = readBitFromStream(bp, &in[inpos]);
-                    unsigned long BTYPE = readBitFromStream(bp, &in[inpos]);
-                    BTYPE += 2 * readBitFromStream(bp, &in[inpos]);
-                    if (BTYPE == 3) {
-                        error = 20;
-                        return;
-                    } // error: invalid BTYPE
-                    else if (BTYPE == 0) {
-                        inflateNoCompression(out, &in[inpos], bp, pos,
-                                             in.size());
-                    } else {
-                        inflateHuffmanBlock(out, &in[inpos], bp, pos, in.size(),
-                                            BTYPE);
-                    }
-                }
-                if (!error) {
-                    out.resize(pos); // Only now we know the true size of out,
-                }
-                // resize it to that
-            }
-            void generateFixedTrees(HuffmanTree &tree,
-                                    HuffmanTree &treeD) // get the tree of a
-                                                        // deflated block with
-                                                        // fixed tree
-            {
-                std::vector<unsigned long> bitlen(288, 8), bitlenD(32, 5);
-                ;
-                for (size_t i = 144; i <= 255; i++) {
-                    bitlen[i] = 9;
-                }
-                for (size_t i = 256; i <= 279; i++) {
-                    bitlen[i] = 7;
-                }
-                tree.makeFromLengths(bitlen, 15);
-                treeD.makeFromLengths(bitlenD, 15);
-            }
-            HuffmanTree codetree, codetreeD,
-                codelengthcodetree; // the code tree for Huffman codes, dist
-                                    // codes, and code length codes
-            unsigned long huffmanDecodeSymbol(const unsigned char *in,
-                                              size_t &bp,
-                                              const HuffmanTree &codetree,
-                                              size_t inlength)
-            { // decode a single symbol from given list of
-                // bits with given code tree. return value
-                // is the symbol
-                bool decoded;
-                unsigned long ct;
-                for (size_t treepos = 0;;) {
-                    if ((bp & 0x07) == 0 && (bp >> 3) > inlength) {
-                        error = 10;
-                        return 0;
-                    } // error: end reached without endcode
-                    error = codetree.decode(decoded, ct, treepos,
-                                            readBitFromStream(bp, in));
-                    if (error) {
-                        return 0; // stop, an error happened
-                    }
-                    if (decoded) {
-                        return ct;
-                    }
-                }
-            }
-            void getTreeInflateDynamic(HuffmanTree &tree, HuffmanTree &treeD,
-                                       const unsigned char *in, size_t &bp,
-                                       size_t inlength)
-            { // get the tree of a deflated block with
-                // dynamic tree, the tree itself is also
-                // Huffman compressed with a known tree
-                std::vector<unsigned long> bitlen(288, 0), bitlenD(32, 0);
-                if (bp >> 3 >= inlength - 2) {
-                    error = 49;
-                    return;
-                } // the bit pointer is or will go past the memory
-                size_t HLIT = readBitsFromStream(bp, in, 5) +
-                              257; // number of literal/length codes + 257
-                size_t HDIST = readBitsFromStream(bp, in, 5) +
-                               1; // number of dist codes + 1
-                size_t HCLEN = readBitsFromStream(bp, in, 4) +
-                               4; // number of code length codes + 4
-                std::vector<unsigned long> codelengthcode(
-                    19); // lengths of tree to decode the lengths of the
-                         // dynamic tree
-                for (size_t i = 0; i < 19; i++) {
-                    codelengthcode[CLCL[i]] =
-                        (i < HCLEN) ? readBitsFromStream(bp, in, 3) : 0;
-                }
-                error = codelengthcodetree.makeFromLengths(codelengthcode, 7);
-                if (error) {
-                    return;
-                }
-                size_t i = 0, replength;
-                while (i < HLIT + HDIST) {
-                    unsigned long code = huffmanDecodeSymbol(
-                        in, bp, codelengthcodetree, inlength);
-                    if (error) {
-                        return;
-                    }
-                    if (code <= 15) {
-                        if (i < HLIT) {
-                            bitlen[i++] = code;
-                        } else {
-                            bitlenD[i++ - HLIT] = code;
-                        }
-                    }                    // a length code
-                    else if (code == 16) // repeat previous
-                    {
-                        if (bp >> 3 >= inlength) {
-                            error = 50;
-                            return;
-                        } // error, bit pointer jumps past memory
-                        replength = 3 + readBitsFromStream(bp, in, 2);
-                        unsigned long value; // set value to the previous code
-                        if ((i - 1) < HLIT) {
-                            value = bitlen[i - 1];
-                        } else {
-                            value = bitlenD[i - HLIT - 1];
-                        }
-                        for (size_t n = 0; n < replength;
-                             n++) // repeat this value in the next lengths
-                        {
-                            if (i >= HLIT + HDIST) {
-                                error = 13;
-                                return;
-                            } // error: i is larger than the amount of codes
-                            if (i < HLIT) {
-                                bitlen[i++] = value;
-                            } else {
-                                bitlenD[i++ - HLIT] = value;
-                            }
-                        }
-                    } else if (code == 17) // repeat "0" 3-10 times
-                    {
-                        if (bp >> 3 >= inlength) {
-                            error = 50;
-                            return;
-                        } // error, bit pointer jumps past memory
-                        replength = 3 + readBitsFromStream(bp, in, 3);
-                        for (size_t n = 0; n < replength;
-                             n++) // repeat this value in the next lengths
-                        {
-                            if (i >= HLIT + HDIST) {
-                                error = 14;
-                                return;
-                            } // error: i is larger than the amount of codes
-                            if (i < HLIT) {
-                                bitlen[i++] = 0;
-                            } else {
-                                bitlenD[i++ - HLIT] = 0;
-                            }
-                        }
-                    } else if (code == 18) // repeat "0" 11-138 times
-                    {
-                        if (bp >> 3 >= inlength) {
-                            error = 50;
-                            return;
-                        } // error, bit pointer jumps past memory
-                        replength = 11 + readBitsFromStream(bp, in, 7);
-                        for (size_t n = 0; n < replength;
-                             n++) // repeat this value in the next lengths
-                        {
-                            if (i >= HLIT + HDIST) {
-                                error = 15;
-                                return;
-                            } // error: i is larger than the amount of codes
-                            if (i < HLIT) {
-                                bitlen[i++] = 0;
-                            } else {
-                                bitlenD[i++ - HLIT] = 0;
-                            }
-                        }
-                    } else {
-                        error = 16;
-                        return;
-                    } // error: somehow an unexisting code appeared. This can
-                    // never happen.
-                }
-                if (bitlen[256] == 0) {
-                    error = 64;
-                    return;
-                } // the length of the end code 256 must be larger than 0
-                error = tree.makeFromLengths(bitlen, 15);
-                if (error) {
-                    return; // now we've finally got HLIT and HDIST, so
-                }
-                // generate the code trees, and the function is
-                // done
-                error = treeD.makeFromLengths(bitlenD, 15);
-                if (error) {
-                    return;
-                }
-            }
-            void inflateHuffmanBlock(std::vector<unsigned char> &out,
-                                     const unsigned char *in, size_t &bp,
-                                     size_t &pos, size_t inlength,
-                                     unsigned long btype)
-            {
-                if (btype == 1) {
-                    generateFixedTrees(codetree, codetreeD);
-                } else if (btype == 2) {
-                    getTreeInflateDynamic(codetree, codetreeD, in, bp,
-                                          inlength);
-                    if (error) {
-                        return;
-                    }
-                }
-                for (;;) {
-                    unsigned long code =
-                        huffmanDecodeSymbol(in, bp, codetree, inlength);
-                    if (error) {
-                        return;
-                    }
-                    if (code == 256) {
-                        return;             // end code
-                    } else if (code <= 255) // literal symbol
-                    {
-                        if (pos >= out.size()) {
-                            out.resize((pos + 1) * 2); // reserve more room
-                        }
-                        out[pos++] = (unsigned char)(code);
-                    } else if (code >= 257 && code <= 285) // length code
-                    {
-                        size_t length = LENBASE[code - 257],
-                               numextrabits = LENEXTRA[code - 257];
-                        if ((bp >> 3) >= inlength) {
-                            error = 51;
-                            return;
-                        } // error, bit pointer will jump past memory
-                        length += readBitsFromStream(bp, in, numextrabits);
-                        unsigned long codeD =
-                            huffmanDecodeSymbol(in, bp, codetreeD, inlength);
-                        if (error) {
-                            return;
-                        }
-                        if (codeD > 29) {
-                            error = 18;
-                            return;
-                        } // error: invalid dist code (30-31 are never used)
-                        unsigned long dist = DISTBASE[codeD],
-                                      numextrabitsD = DISTEXTRA[codeD];
-                        if ((bp >> 3) >= inlength) {
-                            error = 51;
-                            return;
-                        } // error, bit pointer will jump past memory
-                        dist += readBitsFromStream(bp, in, numextrabitsD);
-                        size_t start = pos, back = start - dist; // backwards
-                        if (pos + length >= out.size()) {
-                            out.resize((pos + length) * 2); // reserve more
-                        }
-                        // room
-                        for (size_t i = 0; i < length; i++) {
-                            out[pos++] = out[back++];
-                            if (back >= start) {
-                                back = start - dist;
-                            }
-                        }
-                    }
-                }
-            }
-            void inflateNoCompression(std::vector<unsigned char> &out,
-                                      const unsigned char *in, size_t &bp,
-                                      size_t &pos, size_t inlength)
-            {
-                while ((bp & 0x7) != 0) {
-                    bp++; // go to first boundary of byte
-                }
-                size_t p = bp / 8;
-                if (p >= inlength - 4) {
-                    error = 52;
-                    return;
-                } // error, bit pointer will jump past memory
-                unsigned long LEN = in[p] + 256 * in[p + 1],
-                              NLEN = in[p + 2] + 256 * in[p + 3];
-                p += 4;
-                if (LEN + NLEN != 65535) {
-                    error = 21;
-                    return;
-                } // error: NLEN is not one's complement of LEN
-                if (pos + LEN >= out.size()) {
-                    out.resize(pos + LEN);
-                }
-                if (p + LEN > inlength) {
-                    error = 23;
-                    return;
-                } // error: reading outside of in buffer
-                for (unsigned long n = 0; n < LEN; n++) {
-                    out[pos++] = in[p++]; // read LEN bytes of literal data
-                }
-                bp = p * 8;
-            }
-        };
-        int
-        decompress(std::vector<unsigned char> &out,
-                   const std::vector<unsigned char> &in) // returns error value
-        {
-            Inflator inflator;
-            if (in.size() < 2) {
-                return 53;
-            } // error, size of zlib data too small
-            if ((in[0] * 256 + in[1]) % 31 != 0) {
-                return 24;
-            } // error: 256 * in[0] + in[1] must be a multiple of 31, the
-            // FCHECK value is supposed to be made that way
-            unsigned long CM = in[0] & 15, CINFO = (in[0] >> 4) & 15,
-                          FDICT = (in[1] >> 5) & 1;
-            if (CM != 8 || CINFO > 7) {
-                return 25;
-            } // error: only compression method 8: inflate with sliding window
-            // of 32k is supported by the PNG spec
-            if (FDICT != 0) {
-                return 26;
-            } // error: the specification of PNG says about the zlib stream:
-            // "The additional flags shall not specify a preset dictionary."
-            inflator.inflate(out, in, 2);
-            return inflator
-                .error; // note: adler32 checksum was skipped and ignored
-        }
-    };
-    struct PNG // nested functions for PNG decoding
-    {
-        struct Info {
-            unsigned long width, height, colorType, bitDepth, compressionMethod,
-                filterMethod, interlaceMethod, key_r, key_g, key_b;
-            bool key_defined; // is a transparent color key given?
-            std::vector<unsigned char> palette;
-        } info;
-        int error;
-        void decode(std::vector<unsigned char> &out, const unsigned char *in,
-                    size_t size, bool convert_to_rgba32)
-        {
-            error = 0;
-            if (size == 0 || in == nullptr) {
-                error = 48;
-                return;
-            } // the given data is empty
-            readPngHeader(&in[0], size);
-            if (error) {
-                return;
-            }
-            size_t pos = 33; // first byte of the first chunk after the header
-            std::vector<unsigned char> idat; // the data from idat chunks
-            bool IEND = false, known_type = true;
-            info.key_defined = false;
-            while (!IEND) // loop through the chunks, ignoring unknown chunks
-                          // and stopping at IEND chunk. IDAT data is put at
-                          // the start of the in buffer
-            {
-                if (pos + 8 >= size) {
-                    error = 30;
-                    return;
-                } // error: size of the in buffer too small to contain next
-                // chunk
-                size_t chunkLength = read32bitInt(&in[pos]);
-                pos += 4;
-                if (chunkLength > 2147483647) {
-                    error = 63;
-                    return;
-                }
-                if (pos + chunkLength >= size) {
-                    error = 35;
-                    return;
-                } // error: size of the in buffer too small to contain next
-                // chunk
-                if (in[pos + 0] == 'I' && in[pos + 1] == 'D' &&
-                    in[pos + 2] == 'A' &&
-                    in[pos + 3] ==
-                        'T') // IDAT chunk, containing compressed image data
-                {
-                    idat.insert(idat.end(), &in[pos + 4],
-                                &in[pos + 4 + chunkLength]);
-                    pos += (4 + chunkLength);
-                } else if (in[pos + 0] == 'I' && in[pos + 1] == 'E' &&
-                           in[pos + 2] == 'N' && in[pos + 3] == 'D') {
-                    pos += 4;
-                    IEND = true;
-                } else if (in[pos + 0] == 'P' && in[pos + 1] == 'L' &&
-                           in[pos + 2] == 'T' &&
-                           in[pos + 3] == 'E') // palette chunk (PLTE)
-                {
-                    pos += 4; // go after the 4 letters
-                    info.palette.resize(4 * (chunkLength / 3));
-                    if (info.palette.size() > (4 * 256)) {
-                        error = 38;
-                        return;
-                    } // error: palette too big
-                    for (size_t i = 0; i < info.palette.size(); i += 4) {
-                        for (size_t j = 0; j < 3; j++) {
-                            info.palette[i + j] = in[pos++]; // RGB
-                        }
-                        info.palette[i + 3] = 255; // alpha
-                    }
-                } else if (in[pos + 0] == 't' && in[pos + 1] == 'R' &&
-                           in[pos + 2] == 'N' &&
-                           in[pos + 3] ==
-                               'S') // palette transparency chunk (tRNS)
-                {
-                    pos += 4; // go after the 4 letters
-                    if (info.colorType == 3) {
-                        if (4 * chunkLength > info.palette.size()) {
-                            error = 39;
-                            return;
-                        } // error: more alpha values given than there are
-                        // palette entries
-                        for (size_t i = 0; i < chunkLength; i++) {
-                            info.palette[4 * i + 3] = in[pos++];
-                        }
-                    } else if (info.colorType == 0) {
-                        if (chunkLength != 2) {
-                            error = 40;
-                            return;
-                        } // error: this chunk must be 2 bytes for greyscale
-                        // image
-                        info.key_defined = true;
-                        info.key_r = info.key_g = info.key_b =
-                            256 * in[pos] + in[pos + 1];
-                        pos += 2;
-                    } else if (info.colorType == 2) {
-                        if (chunkLength != 6) {
-                            error = 41;
-                            return;
-                        } // error: this chunk must be 6 bytes for RGB image
-                        info.key_defined = true;
-                        info.key_r = 256 * in[pos] + in[pos + 1];
-                        pos += 2;
-                        info.key_g = 256 * in[pos] + in[pos + 1];
-                        pos += 2;
-                        info.key_b = 256 * in[pos] + in[pos + 1];
-                        pos += 2;
-                    } else {
-                        error = 42;
-                        return;
-                    }  // error: tRNS chunk not allowed for other color models
-                } else // it's not an implemented chunk type, so ignore it:
-                       // skip over the data
-                {
-                    if (!(in[pos + 0] & 32)) {
-                        error = 69;
-                        return;
-                    } // error: unknown critical chunk (5th bit of first byte
-                    // of chunk type is 0)
-                    pos += (chunkLength + 4); // skip 4 letters and
-                                              // uninterpreted data of
-                                              // unimplemented chunk
-                    known_type = false;
-                }
-                pos += 4; // step over CRC (which is ignored)
-            }
-            unsigned long bpp = getBpp(info);
-            std::vector<unsigned char> scanlines(
-                ((info.width * (info.height * bpp + 7)) / 8) +
-                info.height); // now the out buffer will be filled
-            Zlib zlib;        // decompress with the Zlib decompressor
-            error = zlib.decompress(scanlines, idat);
-            if (error) {
-                return; // stop if the zlib decompressor returned an error
-            }
-            size_t bytewidth = (bpp + 7) / 8,
-                   outlength = (info.height * info.width * bpp + 7) / 8;
-            out.resize(outlength); // time to fill the out buffer
-            unsigned char *out_ =
-                outlength ? &out[0] : nullptr; // use a regular pointer to the
-                                               // std::vector for faster code if
-                                               // compiled without optimization
-            if (info.interlaceMethod == 0)     // no interlace, just filter
-            {
-                size_t linestart = 0,
-                       linelength = (info.width * bpp + 7) /
-                                    8; // length in bytes of a scanline,
-                                       // excluding the filtertype byte
-                if (bpp >= 8) {        // byte per byte
-                    for (unsigned long y = 0; y < info.height; y++) {
-                        unsigned long filterType = scanlines[linestart];
-                        const unsigned char *prevline =
-                            (y == 0) ? nullptr
-                                     : &out_[(y - 1) * info.width * bytewidth];
-                        unFilterScanline(&out_[linestart - y],
-                                         &scanlines[linestart + 1], prevline,
-                                         bytewidth, filterType, linelength);
-                        if (error) {
-                            return;
-                        }
-                        linestart +=
-                            (1 + linelength); // go to start of next scanline
-                    }
-                } else // less than 8 bits per pixel, so fill it up bit per bit
-                {
-                    std::vector<unsigned char> templine(
-                        (info.width * bpp + 7) >> 3); // only used if bpp < 8
-                    for (size_t y = 0, obp = 0; y < info.height; y++) {
-                        unsigned long filterType = scanlines[linestart];
-                        const unsigned char *prevline =
-                            (y == 0) ? nullptr
-                                     : &out_[(y - 1) * info.width * bytewidth];
-                        unFilterScanline(&templine[0],
-                                         &scanlines[linestart + 1], prevline,
-                                         bytewidth, filterType, linelength);
-                        if (error) {
-                            return;
-                        }
-                        for (size_t bp = 0; bp < info.width * bpp;) {
-                            setBitOfReversedStream(
-                                obp, out_,
-                                readBitFromReversedStream(bp, &templine[0]));
-                        }
-                        linestart +=
-                            (1 + linelength); // go to start of next scanline
-                    }
-                }
-            } else // interlaceMethod is 1 (Adam7)
-            {
-                size_t passw[7] = {(info.width + 7) / 8, (info.width + 3) / 8,
-                                   (info.width + 3) / 4, (info.width + 1) / 4,
-                                   (info.width + 1) / 2, (info.width + 0) / 2,
-                                   (info.width + 0) / 1};
-                size_t passh[7] = {(info.height + 7) / 8, (info.height + 7) / 8,
-                                   (info.height + 3) / 8, (info.height + 3) / 4,
-                                   (info.height + 1) / 4, (info.height + 1) / 2,
-                                   (info.height + 0) / 2};
-                size_t passstart[7] = {0};
-                size_t pattern[28] = {0, 4, 0, 2, 0, 1, 0, 0, 0, 4,
-                                      0, 2, 0, 1, 8, 8, 4, 4, 2, 2,
-                                      1, 8, 8, 8, 4, 4, 2, 2}; // values for the
-                                                               // adam7 passes
-                for (int i = 0; i < 6; i++) {
-                    passstart[i + 1] = passstart[i] +
-                                       passh[i] * ((passw[i] ? 1 : 0) +
-                                                   (passw[i] * bpp + 7) / 8);
-                }
-                std::vector<unsigned char> scanlineo((info.width * bpp + 7) /
-                                                     8),
-                    scanlinen((info.width * bpp + 7) /
-                              8); //"old" and "new" scanline
-                for (int i = 0; i < 7; i++) {
-                    adam7Pass(&out_[0], &scanlinen[0], &scanlineo[0],
-                              &scanlines[passstart[i]], info.width, pattern[i],
-                              pattern[i + 7], pattern[i + 14], pattern[i + 21],
-                              passw[i], passh[i], bpp);
-                }
-            }
-            if (convert_to_rgba32 && (info.colorType != 6 ||
-                                      info.bitDepth != 8)) // conversion needed
-            {
-                std::vector<unsigned char> data = out;
-                error = convert(out, &data[0], info, info.width, info.height);
-            }
-        }
-        void readPngHeader(const unsigned char *in,
-                           size_t inlength) // read the information from the
-                                            // header and store it in the Info
-        {
-            if (inlength < 29) {
-                error = 27;
-                return;
-            } // error: the data length is smaller than the length of the
-            // header
-            if (in[0] != 137 || in[1] != 80 || in[2] != 78 || in[3] != 71 ||
-                in[4] != 13 || in[5] != 10 || in[6] != 26 || in[7] != 10) {
-                error = 28;
-                return;
-            } // no PNG signature
-            if (in[12] != 'I' || in[13] != 'H' || in[14] != 'D' ||
-                in[15] != 'R') {
-                error = 29;
-                return;
-            } // error: it doesn't start with a IHDR chunk!
-            info.width = read32bitInt(&in[16]);
-            info.height = read32bitInt(&in[20]);
-            info.bitDepth = in[24];
-            info.colorType = in[25];
-            info.compressionMethod = in[26];
-            if (in[26] != 0) {
-                error = 32;
-                return;
-            } // error: only compression method 0 is allowed in the
-            // specification
-            info.filterMethod = in[27];
-            if (in[27] != 0) {
-                error = 33;
-                return;
-            } // error: only filter method 0 is allowed in the specification
-            info.interlaceMethod = in[28];
-            if (in[28] > 1) {
-                error = 34;
-                return;
-            } // error: only interlace methods 0 and 1 exist in the
-            // specification
-            error = checkColorValidity(info.colorType, info.bitDepth);
-        }
-        void unFilterScanline(unsigned char *recon,
-                              const unsigned char *scanline,
-                              const unsigned char *precon, size_t bytewidth,
-                              unsigned long filterType, size_t length)
-        {
-            switch (filterType) {
-            case 0:
-                for (size_t i = 0; i < length; i++) {
-                    recon[i] = scanline[i];
-                }
-                break;
-            case 1:
-                for (size_t i = 0; i < bytewidth; i++) {
-                    recon[i] = scanline[i];
-                }
-                for (size_t i = bytewidth; i < length; i++) {
-                    recon[i] = scanline[i] + recon[i - bytewidth];
-                }
-                break;
-            case 2:
-                if (precon) {
-                    for (size_t i = 0; i < length; i++) {
-                        recon[i] = scanline[i] + precon[i];
-                    }
-                } else {
-                    for (size_t i = 0; i < length; i++) {
-                        recon[i] = scanline[i];
-                    }
-                }
-                break;
-            case 3:
-                if (precon) {
-                    for (size_t i = 0; i < bytewidth; i++) {
-                        recon[i] = scanline[i] + precon[i] / 2;
-                    }
-                    for (size_t i = bytewidth; i < length; i++) {
-                        recon[i] = scanline[i] +
-                                   ((recon[i - bytewidth] + precon[i]) / 2);
-                    }
-                } else {
-                    for (size_t i = 0; i < bytewidth; i++) {
-                        recon[i] = scanline[i];
-                    }
-                    for (size_t i = bytewidth; i < length; i++) {
-                        recon[i] = scanline[i] + recon[i - bytewidth] / 2;
-                    }
-                }
-                break;
-            case 4:
-                if (precon) {
-                    for (size_t i = 0; i < bytewidth; i++) {
-                        recon[i] =
-                            scanline[i] + paethPredictor(0, precon[i], 0);
-                    }
-                    for (size_t i = bytewidth; i < length; i++) {
-                        recon[i] =
-                            scanline[i] + paethPredictor(recon[i - bytewidth],
-                                                         precon[i],
-                                                         precon[i - bytewidth]);
-                    }
-                } else {
-                    for (size_t i = 0; i < bytewidth; i++) {
-                        recon[i] = scanline[i];
-                    }
-                    for (size_t i = bytewidth; i < length; i++) {
-                        recon[i] = scanline[i] +
-                                   paethPredictor(recon[i - bytewidth], 0, 0);
-                    }
-                }
-                break;
-            default:
-                error = 36;
-                return; // error: unexisting filter type given
-            }
-        }
-        void adam7Pass(unsigned char *out, unsigned char *linen,
-                       unsigned char *lineo, const unsigned char *in,
-                       unsigned long w, size_t passleft, size_t passtop,
-                       size_t spacex, size_t spacey, size_t passw, size_t passh,
-                       unsigned long bpp)
-        { // filter and reposition the pixels
-            // into the output when the image
-            // is Adam7 interlaced. This
-            // function can only do it after
-            // the full image is already
-            // decoded. The out buffer must
-            // have the correct allocated
-            // memory size already.
-            if (passw == 0) {
-                return;
-            }
-            size_t bytewidth = (bpp + 7) / 8,
-                   linelength = 1 + ((bpp * passw + 7) / 8);
-            for (unsigned long y = 0; y < passh; y++) {
-                unsigned char filterType = in[y * linelength],
-                              *prevline = (y == 0) ? nullptr : lineo;
-                unFilterScanline(linen, &in[y * linelength + 1], prevline,
-                                 bytewidth, filterType, (w * bpp + 7) / 8);
-                if (error) {
-                    return;
-                }
-                if (bpp >= 8) {
-                    for (size_t i = 0; i < passw; i++) {
-                        for (size_t b = 0; b < bytewidth;
-                             b++) { // b = current byte of this pixel
-                            out[bytewidth * w * (passtop + spacey * y) +
-                                bytewidth * (passleft + spacex * i) + b] =
-                                linen[bytewidth * i + b];
-                        }
-                    }
-                } else {
-                    for (size_t i = 0; i < passw; i++) {
-                        size_t obp = bpp * w * (passtop + spacey * y) +
-                                     bpp * (passleft + spacex * i),
-                               bp = i * bpp;
-                        for (size_t b = 0; b < bpp; b++) {
-                            setBitOfReversedStream(
-                                obp, out,
-                                readBitFromReversedStream(bp, &linen[0]));
-                        }
-                    }
-                }
-                unsigned char *temp = linen;
-                linen = lineo;
-                lineo = temp; // swap the two buffer pointers "line old" and
-                              // "line new"
-            }
-        }
-        static unsigned long
-        readBitFromReversedStream(size_t &bitp, const unsigned char *bits)
-        {
-            unsigned long result = (bits[bitp >> 3] >> (7 - (bitp & 0x7))) & 1;
-            bitp++;
-            return result;
-        }
-        static unsigned long
-        readBitsFromReversedStream(size_t &bitp, const unsigned char *bits,
-                                   unsigned long nbits)
-        {
-            unsigned long result = 0;
-            for (size_t i = nbits - 1; i < nbits; i--) {
-                result += ((readBitFromReversedStream(bitp, bits)) << i);
-            }
-            return result;
-        }
-        void setBitOfReversedStream(size_t &bitp, unsigned char *bits,
-                                    unsigned long bit)
-        {
-            bits[bitp >> 3] |= (bit << (7 - (bitp & 0x7)));
-            bitp++;
-        }
-        unsigned long read32bitInt(const unsigned char *buffer)
-        {
-            return (buffer[0] << 24) | (buffer[1] << 16) | (buffer[2] << 8) |
-                   buffer[3];
-        }
-        int checkColorValidity(
-            unsigned long colorType,
-            unsigned long bd) // return type is a LodePNG error code
-        {
-            if ((colorType == 2 || colorType == 4 || colorType == 6)) {
-                if (!(bd == 8 || bd == 16)) {
-                    return 37;
-                } else {
-                    return 0;
-                }
-            } else if (colorType == 0) {
-                if (!(bd == 1 || bd == 2 || bd == 4 || bd == 8 || bd == 16)) {
-                    return 37;
-                } else {
-                    return 0;
-                }
-            } else if (colorType == 3) {
-                if (!(bd == 1 || bd == 2 || bd == 4 || bd == 8)) {
-                    return 37;
-                } else {
-                    return 0;
-                }
-            } else {
-                return 31; // unexisting color type
-            }
-        }
-        unsigned long getBpp(const Info &info)
-        {
-            if (info.colorType == 2) {
-                return (3 * info.bitDepth);
-            } else if (info.colorType >= 4) {
-                return (info.colorType - 2) * info.bitDepth;
-            } else {
-                return info.bitDepth;
-            }
-        }
-        int convert(std::vector<unsigned char> &out, const unsigned char *in,
-                    Info &infoIn, unsigned long w, unsigned long h)
-        { // converts from any color type to
-            // 32-bit. return value = LodePNG error
-            // code
-            size_t numpixels = w * h, bp = 0;
-            out.resize(numpixels * 4);
-            unsigned char *out_ =
-                out.empty()
-                    ? nullptr
-                    : &out[0]; // faster if compiled without optimization
-            if (infoIn.bitDepth == 8 && infoIn.colorType == 0) { // greyscale
-                for (size_t i = 0; i < numpixels; i++) {
-                    out_[4 * i + 0] = out_[4 * i + 1] = out_[4 * i + 2] = in[i];
-                    out_[4 * i + 3] =
-                        (infoIn.key_defined && in[i] == infoIn.key_r) ? 0 : 255;
-                }
-            } else if (infoIn.bitDepth == 8 && infoIn.colorType == 2) { // RGB
-                                                                        // color
-                for (size_t i = 0; i < numpixels; i++) {
-                    for (size_t c = 0; c < 3; c++) {
-                        out_[4 * i + c] = in[3 * i + c];
-                    }
-                    out_[4 * i + 3] = (infoIn.key_defined == 1 &&
-                                       in[3 * i + 0] == infoIn.key_r &&
-                                       in[3 * i + 1] == infoIn.key_g &&
-                                       in[3 * i + 2] == infoIn.key_b)
-                                          ? 0
-                                          : 255;
-                }
-            } else if (infoIn.bitDepth == 8 &&
-                       infoIn.colorType == 3) { // indexed color (palette)
-                for (size_t i = 0; i < numpixels; i++) {
-                    if (4U * in[i] >= infoIn.palette.size()) {
-                        return 46;
-                    }
-                    for (size_t c = 0; c < 4; c++) {
-                        out_[4 * i + c] =
-                            infoIn.palette[4 * in[i] + c]; // get rgb colors
-                    }
-                    // from the palette
-                }
-            } else if (infoIn.bitDepth == 8 &&
-                       infoIn.colorType == 4) { // greyscale with alpha
-                for (size_t i = 0; i < numpixels; i++) {
-                    out_[4 * i + 0] = out_[4 * i + 1] = out_[4 * i + 2] =
-                        in[2 * i + 0];
-                    out_[4 * i + 3] = in[2 * i + 1];
-                }
-            } else if (infoIn.bitDepth == 8 && infoIn.colorType == 6) {
-                for (size_t i = 0; i < numpixels; i++) {
-                    for (size_t c = 0; c < 4; c++) {
-                        out_[4 * i + c] = in[4 * i + c]; // RGB with alpha
-                    }
-                }
-            } else if (infoIn.bitDepth == 16 &&
-                       infoIn.colorType == 0) { // greyscale
-                for (size_t i = 0; i < numpixels; i++) {
-                    out_[4 * i + 0] = out_[4 * i + 1] = out_[4 * i + 2] =
-                        in[2 * i];
-                    out_[4 * i + 3] = (infoIn.key_defined &&
-                                       256U * in[i] + in[i + 1] == infoIn.key_r)
-                                          ? 0
-                                          : 255;
-                }
-            } else if (infoIn.bitDepth == 16 &&
-                       infoIn.colorType == 2) { // RGB color
-                for (size_t i = 0; i < numpixels; i++) {
-                    for (size_t c = 0; c < 3; c++) {
-                        out_[4 * i + c] = in[6 * i + 2 * c];
-                    }
-                    out_[4 * i + 3] =
-                        (infoIn.key_defined &&
-                         256U * in[6 * i + 0] + in[6 * i + 1] == infoIn.key_r &&
-                         256U * in[6 * i + 2] + in[6 * i + 3] == infoIn.key_g &&
-                         256U * in[6 * i + 4] + in[6 * i + 5] == infoIn.key_b)
-                            ? 0
-                            : 255;
-                }
-            } else if (infoIn.bitDepth == 16 &&
-                       infoIn.colorType == 4) { // greyscale with alpha
-                for (size_t i = 0; i < numpixels; i++) {
-                    out_[4 * i + 0] = out_[4 * i + 1] = out_[4 * i + 2] =
-                        in[4 * i]; // most significant byte
-                    out_[4 * i + 3] = in[4 * i + 2];
-                }
-            } else if (infoIn.bitDepth == 16 && infoIn.colorType == 6) {
-                for (size_t i = 0; i < numpixels; i++) {
-                    for (size_t c = 0; c < 4; c++) {
-                        out_[4 * i + c] = in[8 * i + 2 * c]; // RGB with alpha
-                    }
-                }
-            } else if (infoIn.bitDepth < 8 &&
-                       infoIn.colorType == 0) { // greyscale
-                for (size_t i = 0; i < numpixels; i++) {
-                    unsigned long value =
-                        (readBitsFromReversedStream(bp, in, infoIn.bitDepth) *
-                         255) /
-                        ((1 << infoIn.bitDepth) -
-                         1); // scale value from 0 to 255
-                    out_[4 * i + 0] = out_[4 * i + 1] = out_[4 * i + 2] =
-                        (unsigned char)(value);
-                    out_[4 * i + 3] =
-                        (infoIn.key_defined && value &&
-                         ((1U << infoIn.bitDepth) - 1U) == infoIn.key_r &&
-                         ((1U << infoIn.bitDepth) - 1U))
-                            ? 0
-                            : 255;
-                }
-            } else if (infoIn.bitDepth < 8 &&
-                       infoIn.colorType == 3) { // palette
-                for (size_t i = 0; i < numpixels; i++) {
-                    unsigned long value =
-                        readBitsFromReversedStream(bp, in, infoIn.bitDepth);
-                    if (4 * value >= infoIn.palette.size()) {
-                        return 47;
-                    }
-                    for (size_t c = 0; c < 4; c++) {
-                        out_[4 * i + c] =
-                            infoIn.palette[4 * value + c]; // get rgb colors
-                    }
-                    // from the palette
-                }
-            }
-            return 0;
-        }
-        unsigned char
-        paethPredictor(short a, short b,
-                       short c) // Paeth predicter, used by PNG filter type 4
-        {
-            short p = a + b - c, pa = p > a ? (p - a) : (a - p),
-                  pb = p > b ? (p - b) : (b - p),
-                  pc = p > c ? (p - c) : (c - p);
-            return (unsigned char)((pa <= pb && pa <= pc) ? a
-                                                          : pb <= pc ? b : c);
-        }
-    };
-    PNG decoder;
-    decoder.decode(out_image, in_png, in_size, convert_to_rgba32);
-    image_width = decoder.info.width;
-    image_height = decoder.info.height;
-    return decoder.error;
-}
-
-} // namespace yage
diff --git a/src/rectanglecollider.cpp b/src/rectanglecollider.cpp
deleted file mode 100644
index 64887278..00000000
--- a/src/rectanglecollider.cpp
+++ /dev/null
@@ -1,36 +0,0 @@
-/* ----------------------------------------------------------------------------
- * rectanglecollider.cpp
- *
- * Copyright (c) 2017 Yann Herklotz Grave <ymherklotz@gmail.com> -- MIT License
- * See file LICENSE for more details
- * ----------------------------------------------------------------------------
- */
-
-#include <YAGE/Physics/rectanglecollider.h>
-
-namespace yage
-{
-
-RectangleCollider::RectangleCollider(const glm::vec2 &position,
-                                     const glm::vec2 &size)
-    : Collider(position, size)
-{
-}
-
-bool RectangleCollider::collides(const Collider &collider) const
-{
-    for (int i = position_.x; i < position_.x + size_.x; ++i) {
-        for (int j = position_.y; j < position_.y + size_.y; ++j) {
-            return collider.inside(glm::vec2(i, j));
-        }
-    }
-    return false;
-}
-
-inline bool RectangleCollider::inside(const glm::vec2 &point) const
-{
-    return position_.x < point.x && position_.x + size_.x > point.x &&
-           position_.y < point.y && position_.y + size_.y > point.y;
-}
-
-} // namespace yage
diff --git a/src/resourcemanager.cpp b/src/resourcemanager.cpp
deleted file mode 100644
index 473ea37e..00000000
--- a/src/resourcemanager.cpp
+++ /dev/null
@@ -1,21 +0,0 @@
-/* ----------------------------------------------------------------------------
- * resourcemanager.cpp
- *
- * Copyright (c) 2017 Yann Herklotz Grave <ymherklotz@gmail.com> -- MIT License
- * See file LICENSE for more details
- * ----------------------------------------------------------------------------
- */
-
-#include <YAGE/resourcemanager.h>
-
-namespace yage
-{
-
-TextureCache ResourceManager::texture_cache_;
-
-Texture ResourceManager::getTexture(const std::string &texture_path)
-{
-    return texture_cache_.getTexture(texture_path);
-}
-
-} // namespace yage
diff --git a/src/rigidbody.cpp b/src/rigidbody.cpp
deleted file mode 100644
index dcab5f2f..00000000
--- a/src/rigidbody.cpp
+++ /dev/null
@@ -1,20 +0,0 @@
-/* ----------------------------------------------------------------------------
- * rigidbody.cpp
- *
- * Copyright (c) 2017 Yann Herklotz Grave <ymherklotz@gmail.com> -- MIT License
- * See file LICENSE for more details
- * ----------------------------------------------------------------------------
- */
-
-#include <YAGE/Physics/rigidbody.h>
-
-namespace yage
-{
-
-RigidBody::RigidBody(const Vector2d &position, double mass,
-                     const Vector2d &velocity, bool gravity)
-    : ParticleBody(position, mass, velocity, gravity)
-{
-}
-
-} // namespace yage
diff --git a/src/sprite.cpp b/src/sprite.cpp
deleted file mode 100644
index 68e08e5d..00000000
--- a/src/sprite.cpp
+++ /dev/null
@@ -1,97 +0,0 @@
-/* ----------------------------------------------------------------------------
- * sprite.cpp
- *
- * Copyright (c) 2017 Yann Herklotz Grave <ymherklotz@gmail.com> -- MIT License
- * See file LICENSE for more details
- * ----------------------------------------------------------------------------
- */
-
-#include <YAGE/sprite.h>
-#include <YAGE/resourcemanager.h>
-#include <YAGE/vertex.h>
-
-#include <cstddef>
-
-namespace yage
-{
-
-Sprite::Sprite() = default;
-
-Sprite::~Sprite()
-{
-    if (vbo_id_ != 0) {
-        glDeleteBuffers(1, &vbo_id_);
-    }
-}
-
-void Sprite::init(float x, float y, float width, float height,
-                  const std::string &texture_path)
-{
-    x_ = x;
-    y_ = y;
-    width_ = width;
-    height_ = height;
-    texture_ = ResourceManager::getTexture(texture_path);
-
-    if (vbo_id_ == 0) {
-        glGenBuffers(1, &vbo_id_);
-    }
-
-    Vertex vertex_data[6];
-
-    vertex_data[0].setPosition(x + width, y + height);
-    vertex_data[0].setUv(1.f, 1.f);
-
-    vertex_data[1].setPosition(x, y + height);
-    vertex_data[1].setUv(0.f, 1.f);
-
-    vertex_data[2].setPosition(x, y);
-    vertex_data[2].setUv(0.f, 0.f);
-
-    vertex_data[3].setPosition(x, y);
-    vertex_data[3].setUv(0.f, 0.f);
-
-    vertex_data[4].setPosition(x + width, y + height);
-    vertex_data[4].setUv(1.f, 1.f);
-
-    vertex_data[5].setPosition(x + width, y);
-    vertex_data[5].setUv(1.f, 0.f);
-
-    for (auto &i : vertex_data) {
-        i.setColor(255, 0, 255, 255);
-    }
-
-    vertex_data[1].setColor(0, 255, 255, 255);
-    vertex_data[4].setColor(255, 0, 0, 255);
-
-    glBindBuffer(GL_ARRAY_BUFFER, vbo_id_);
-    glBufferData(GL_ARRAY_BUFFER, sizeof(vertex_data), vertex_data,
-                 GL_STATIC_DRAW);
-    glBindBuffer(GL_ARRAY_BUFFER, 0);
-}
-
-void Sprite::draw()
-{
-    glBindTexture(GL_TEXTURE_2D, texture_.id);
-    glBindBuffer(GL_ARRAY_BUFFER, vbo_id_);
-
-    glEnableVertexAttribArray(0);
-    glEnableVertexAttribArray(1);
-    glEnableVertexAttribArray(2);
-
-    glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, sizeof(Vertex),
-                          (void *)offsetof(Vertex, position));
-    glVertexAttribPointer(1, 4, GL_UNSIGNED_BYTE, GL_TRUE, sizeof(Vertex),
-                          (void *)offsetof(Vertex, color));
-    glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, sizeof(Vertex),
-                          (void *)offsetof(Vertex, uv));
-    glDrawArrays(GL_TRIANGLES, 0, 6);
-
-    glDisableVertexAttribArray(2);
-    glDisableVertexAttribArray(1);
-    glDisableVertexAttribArray(0);
-
-    glBindBuffer(GL_ARRAY_BUFFER, 0);
-}
-
-} // namespace yage
diff --git a/src/spritebatch.cpp b/src/spritebatch.cpp
deleted file mode 100644
index ac98130b..00000000
--- a/src/spritebatch.cpp
+++ /dev/null
@@ -1,193 +0,0 @@
-/* ----------------------------------------------------------------------------
- * spritebatch.cpp
- *
- * Copyright (c) 2017 Yann Herklotz Grave <ymherklotz@gmail.com> -- MIT License
- * See file LICENSE for more details
- * ----------------------------------------------------------------------------
- */
-
-#include <YAGE/spritebatch.h>
-
-#include <algorithm>
-#include <stdexcept>
-
-namespace yage
-{
-
-const int SpriteBatch::NUM_VERTICES;
-
-Glyph::Glyph(GLuint texture, float depth, const Vertex &top_left,
-             const Vertex &top_right, const Vertex &bottom_right,
-             const Vertex &bottom_left)
-    : texture_(texture), depth_(depth), top_left_(top_left),
-      top_right_(top_right), bottom_right_(bottom_right),
-      bottom_left_(bottom_left)
-{
-}
-
-RenderBatch::RenderBatch(GLint offset, GLsizei num_vertices, GLuint texture)
-    : num_vertices_(num_vertices), offset_(offset), texture_(texture)
-{
-}
-
-SpriteBatch::SpriteBatch() = default;
-
-SpriteBatch::~SpriteBatch()
-{
-    if (vao_ != 0) {
-        glDeleteVertexArrays(1, &vao_);
-    }
-
-    if (vbo_ != 0) {
-        glDeleteVertexArrays(1, &vbo_);
-    }
-}
-
-void SpriteBatch::init()
-{
-    createVertexArray();
-}
-
-void SpriteBatch::begin()
-{
-    glyphs_.clear();
-    glyph_ptrs_.clear();
-    render_batches_.clear();
-}
-
-void SpriteBatch::end()
-{
-    sortGlyphs();
-    createRenderBatches();
-}
-
-void SpriteBatch::draw(const glm::vec4 &destination_rect,
-                       const glm::vec4 &uv_rect, GLuint texture,
-                       const Color &color, float depth)
-{
-    Vertex top_left, top_right, bottom_right, bottom_left;
-
-    top_left.color = color;
-    top_left.setPosition(destination_rect.x,
-                         destination_rect.y + destination_rect.w);
-    top_left.setUv(uv_rect.x, uv_rect.y + uv_rect.w);
-
-    top_right.color = color;
-    top_right.setPosition(destination_rect.x + destination_rect.z,
-                          destination_rect.y + destination_rect.w);
-    top_right.setUv(uv_rect.x + uv_rect.z, uv_rect.y + uv_rect.w);
-
-    bottom_right.color = color;
-    bottom_right.setPosition(destination_rect.x + destination_rect.z,
-                             destination_rect.y);
-    bottom_right.setUv(uv_rect.x + uv_rect.z, uv_rect.y);
-
-    bottom_left.color = color;
-    bottom_left.setPosition(destination_rect.x, destination_rect.y);
-    bottom_left.setUv(uv_rect.x, uv_rect.y);
-
-    // deal with fragmenting by creating vector of pointers
-    glyphs_.emplace_back(texture, depth, top_left, top_right, bottom_right,
-                         bottom_left);
-    glyph_ptrs_.push_back(&glyphs_.back());
-}
-
-void SpriteBatch::render()
-{
-    glBindVertexArray(vao_);
-    for (auto &&batch : render_batches_) {
-        glBindTexture(GL_TEXTURE_2D, batch.texture());
-        glDrawArrays(GL_TRIANGLES, batch.offset(), batch.num_vertices());
-    }
-    glBindVertexArray(0);
-}
-
-void SpriteBatch::createVertexArray()
-{
-    if (vao_ == 0) {
-        glGenVertexArrays(1, &vao_);
-        if (vao_ == 0) {
-            throw std::runtime_error("glGenVertexArrays failed");
-        }
-    }
-    // bind vertex array object
-    glBindVertexArray(vao_);
-
-    if (vbo_ == 0) {
-        glGenBuffers(1, &vbo_);
-        if (vbo_ == 0) {
-            throw std::runtime_error("glGenBuffers failed");
-        }
-    }
-    // bind vertex buffer object
-    glBindBuffer(GL_ARRAY_BUFFER, vbo_);
-
-    // enable vertex attribute arrays
-    glEnableVertexAttribArray(0);
-    glEnableVertexAttribArray(1);
-    glEnableVertexAttribArray(2);
-
-    // set the vertex attribute pointers
-    glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, sizeof(Vertex),
-                          (void *)offsetof(Vertex, position));
-    glVertexAttribPointer(1, 4, GL_UNSIGNED_BYTE, GL_TRUE, sizeof(Vertex),
-                          (void *)offsetof(Vertex, color));
-    glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, sizeof(Vertex),
-                          (void *)offsetof(Vertex, uv));
-    glDrawArrays(GL_TRIANGLES, 0, 6);
-
-    // unbind vertex array object
-    glBindVertexArray(0);
-}
-
-void SpriteBatch::createRenderBatches()
-{
-    std::vector<Vertex> vertices;
-    if (glyph_ptrs_.empty()) {
-        return;
-    }
-
-    render_batches_.reserve(glyph_ptrs_.size() * NUM_VERTICES);
-
-    for (int i = 0; i < (int)glyph_ptrs_.size(); ++i) {
-        if (i == 0 || (i > 0 && (glyph_ptrs_[i]->texture() !=
-                                 glyph_ptrs_[i - 1]->texture()))) {
-            render_batches_.emplace_back(i * NUM_VERTICES, NUM_VERTICES,
-                                         glyph_ptrs_[i]->texture());
-        } else {
-            render_batches_.back().num_vertices_ += NUM_VERTICES;
-        }
-
-        vertices.push_back(glyph_ptrs_[i]->bottom_left());
-        vertices.push_back(glyph_ptrs_[i]->top_left());
-        vertices.push_back(glyph_ptrs_[i]->top_right());
-        vertices.push_back(glyph_ptrs_[i]->bottom_left());
-        vertices.push_back(glyph_ptrs_[i]->bottom_right());
-        vertices.push_back(glyph_ptrs_[i]->top_right());
-
-        // bind vbo
-        glBindBuffer(GL_ARRAY_BUFFER, vbo_);
-        // orphan the buffer
-        glBufferData(GL_ARRAY_BUFFER, vertices.size() * sizeof(Vertex), nullptr,
-                     GL_DYNAMIC_DRAW);
-        // upload the data
-        glBufferSubData(GL_ARRAY_BUFFER, 0, vertices.size() * sizeof(Vertex),
-                        vertices.data());
-        // unbind buffer
-        glBindBuffer(GL_ARRAY_BUFFER, 0);
-    }
-}
-
-void SpriteBatch::sortGlyphs()
-{
-    // sort using introsort or quicksort
-    std::sort(glyph_ptrs_.begin(), glyph_ptrs_.end(),
-              [](Glyph *a, Glyph *b) -> bool {
-                  if (a->depth() == b->depth()) {
-                      return a->texture() < b->texture();
-                  }
-                  return a->depth() < b->depth();
-              });
-}
-
-} // namespace yage
diff --git a/src/texturecache.cpp b/src/texturecache.cpp
deleted file mode 100644
index fda5fcd9..00000000
--- a/src/texturecache.cpp
+++ /dev/null
@@ -1,30 +0,0 @@
-/* ----------------------------------------------------------------------------
- * texturecache.cpp
- *
- * Copyright (c) 2017 Yann Herklotz Grave <ymherklotz@gmail.com> -- MIT License
- * See file LICENSE for more details
- * ----------------------------------------------------------------------------
- */
-
-#include <YAGE/texturecache.h>
-#include <YAGE/imageloader.h>
-
-namespace yage
-{
-
-TextureCache::TextureCache() = default;
-
-Texture TextureCache::getTexture(const std::string &texture_path)
-{
-    auto itr = texture_map_.find(texture_path);
-
-    if (itr == texture_map_.end()) {
-        Texture new_texture = ImageLoader::loadPng(texture_path);
-        texture_map_.insert(make_pair(texture_path, new_texture));
-        return new_texture;
-    }
-
-    return itr->second;
-}
-
-} // namespace yage
diff --git a/src/window.cpp b/src/window.cpp
deleted file mode 100644
index 143b1d5d..00000000
--- a/src/window.cpp
+++ /dev/null
@@ -1,97 +0,0 @@
-/* ----------------------------------------------------------------------------
- * window.cpp
- *
- * Copyright (c) 2017 Yann Herklotz Grave <ymherklotz@gmail.com> -- MIT License
- * See file LICENSE for more details
- * ----------------------------------------------------------------------------
- */
-
-#include <YAGE/window.h>
-#include <GL/glew.h>
-
-#include <iostream>
-#include <stdexcept>
-
-namespace yage
-{
-
-Window::Window() = default;
-
-Window::~Window()
-{
-    SDL_DestroyWindow(window_);
-}
-
-void Window::create(const std::string &window_name, int width, int height,
-                    unsigned flags)
-{
-    Uint32 gl_window_states = 0;
-
-    // set the correct input flags
-    if (flags & WindowFlags::SHOWN) {
-        gl_window_states |= SDL_WINDOW_OPENGL;
-    }
-    if (flags & WindowFlags::HIDDEN) {
-        gl_window_states |= SDL_WINDOW_HIDDEN;
-    }
-    if (flags & WindowFlags::FULLSCREEN) {
-        gl_window_states |= SDL_WINDOW_FULLSCREEN;
-    }
-    if (flags & WindowFlags::BORDERLESS) {
-        gl_window_states |= SDL_WINDOW_BORDERLESS;
-    }
-
-    // SDL_GL options
-
-    // SDL_GL_SetAttribute (SDL_GL_CONTEXT_MAJOR_VERSION, 4);
-    // SDL_GL_SetAttribute (SDL_GL_CONTEXT_MINOR_VERSION, 5);
-    SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
-
-    // create the SDL window
-    window_ = SDL_CreateWindow(window_name.c_str(), SDL_WINDOWPOS_CENTERED,
-                               SDL_WINDOWPOS_CENTERED, width, height,
-                               gl_window_states);
-    if (window_ == nullptr) {
-        throw std::runtime_error("SDL_CreateWindow failed");
-    }
-
-    // initialize the GL context in the window
-    SDL_GLContext gl_context = SDL_GL_CreateContext(window_);
-    if (gl_context == nullptr) {
-        throw std::runtime_error("SDL_GL_CreateContext failed");
-    }
-
-    // initialize glew
-    GLenum error = glewInit();
-    if (error != GLEW_OK) {
-        throw std::runtime_error("glewInit failed");
-    }
-
-    // print out the current OpenGL version to debug
-    std::cout << "***  OpenGL version: " << glGetString(GL_VERSION)
-              << "  ***\n";
-
-    // set vsync on instead of custom fps limiting
-    SDL_GL_SetSwapInterval(1);
-    // set the clear color to black
-    glClearColor(0.f, 0.5f, 0.f, 1.f);
-    // set alpha blending
-    glEnable(GL_BLEND);
-    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
-}
-
-void Window::swapBuffer()
-{
-    // swap the window buffer
-    SDL_GL_SwapWindow(window_);
-}
-
-void Window::clearBuffer()
-{
-    // set the clear depth
-    glClearDepth(1.f);
-    // clears buffer with clear color
-    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
-}
-
-} // namespace yage