Correcting indentation and removed vector2d.cpp

11 files changed, 814 insertions, 834 deletions

diff --git a/src/camera2d.cpp b/src/camera2d.cpp
index 041870ed..81e8d971 100644
--- a/src/camera2d.cpp
+++ b/src/camera2d.cpp
@@ -6,9 +6,9 @@ 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))
+	position_(0.f, 0.f),
+	camera_matrix_(1.f),
+	ortho_matrix_(glm::ortho(0.f, (float)screen_width, 0.f, (float)screen_height))
 {}
 
 Camera2D::~Camera2D()
@@ -16,25 +16,25 @@ Camera2D::~Camera2D()
 
 void Camera2D::update(GlslProgram &program)
 {
-    if(matrix_needs_update_)
-    {
-	glm::vec3 translate(-position_.x, -position_.y, 0.f);
-	glm::vec3 scale(scale_, scale_, 0.f);
+	if(matrix_needs_update_)
+	{
+		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_;
+		camera_matrix_=glm::translate(ortho_matrix_, translate);
+		camera_matrix_=glm::scale(glm::mat4(1.f), scale)*camera_matrix_;
 
-	matrix_needs_update_=false;
-    }
+		matrix_needs_update_=false;
+	}
 
-    GLint matrix_location = program.getUniformLocation("P");
-    glUniformMatrix4fv(matrix_location, 1, GL_FALSE, &(camera_matrix_[0][0]));    
+	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;
-    matrix_needs_update_=true;
+	position_+=direction;
+	matrix_needs_update_=true;
 }
 
 } // yage
diff --git a/src/glslprogram.cpp b/src/glslprogram.cpp
index 26ba1a8f..f9795a34 100644
--- a/src/glslprogram.cpp
+++ b/src/glslprogram.cpp
@@ -12,132 +12,132 @@ GlslProgram::GlslProgram()
 
 GlslProgram::~GlslProgram()
 {
-    // cleanup all the shaders and the program
-    if(fragment_shader_id_ != 0)
-	glDeleteShader(fragment_shader_id_);
+	// 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(vertex_shader_id_ != 0)
+		glDeleteShader(vertex_shader_id_);
     
-    if(program_id_ != 0)
-	glDeleteProgram(program_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 GLchar *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);
+	// 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 GLchar *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]);
+		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);
-    }
+		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);    
+	// 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_);
+	// attach the shaders that we want
+	glAttachShader(program_id_, vertex_shader_id_);
+	glAttachShader(program_id_, fragment_shader_id_);
 
-    // link our program
-    glLinkProgram(program_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);
+	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::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]);
+		std::string error_log_str((const char *)&error_log[0]);
 
-	throw std::runtime_error("Could not link program : "+error_log_str);
-    }
+		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_);
+	// 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_);    
+	// 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());
+	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;
+	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);
+	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);
+	for(int i = 0; i < attribute_index_; ++i)
+		glDisableVertexAttribArray(i);
+	glUseProgram(0);
 }
     
 } // yage
diff --git a/src/imageloader.cpp b/src/imageloader.cpp
index 359d0af5..cca71844 100644
--- a/src/imageloader.cpp
+++ b/src/imageloader.cpp
@@ -9,37 +9,37 @@ namespace yage
 
 Texture ImageLoader::loadPng(const std::string &file_path)
 {
-    Texture texture = {};
+	Texture texture = {};
 
-    std::vector<unsigned char> in;
-    std::vector<unsigned char> out;
-    unsigned long width, height;
+	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");
+	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));
+	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);
+	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]);
+	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);
+	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);
+	glGenerateMipmap(GL_TEXTURE_2D);
 
-    glBindTexture(GL_TEXTURE_2D, 0);
+	glBindTexture(GL_TEXTURE_2D, 0);
 
-    texture.width = (int)width;
-    texture.height = (int)height;
+	texture.width = (int)width;
+	texture.height = (int)height;
 
-    return texture;
+	return texture;
 }
     
 } // yage
diff --git a/src/inputmanager.cpp b/src/inputmanager.cpp
index 0bcb35f8..402cc420 100644
--- a/src/inputmanager.cpp
+++ b/src/inputmanager.cpp
@@ -5,20 +5,20 @@ namespace yage
 
 void InputManager::keyPressed(unsigned key)
 {
-    key_map_[key]=true;
+	key_map_[key]=true;
 }
 
 void InputManager::keyReleased(unsigned key)
 {
-    key_map_[key]=false;
+	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;
+	auto key_index=key_map_.find(key);
+	if(key_index!=key_map_.end())
+		return key_index->second;
+	return false;
 }
 
 }
diff --git a/src/iomanager.cpp b/src/iomanager.cpp
index b5e5518f..697273dc 100644
--- a/src/iomanager.cpp
+++ b/src/iomanager.cpp
@@ -8,25 +8,25 @@ 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+"'");
+	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);
+	// 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);
+	// 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();
+	// reduce file size by header bytes
+	file_size -= file.tellg();
 
-    buffer.resize(file_size);
-    file.read((char *)&buffer[0], file_size);
-    file.close();
+	buffer.resize(file_size);
+	file.read((char *)&buffer[0], file_size);
+	file.close();
 
-    return true;
+	return true;
 }
     
 } // yage
diff --git a/src/picopng.cpp b/src/picopng.cpp
index 7c86e179..b2dd70fe 100644
--- a/src/picopng.cpp
+++ b/src/picopng.cpp
@@ -27,513 +27,513 @@ namespace yage
 */
 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 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.
+	// 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)
+	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
 	{
-	    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)
+		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)
 		{
-		    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);
+			unsigned long result = 0;
+			for(size_t i = 0; i < nbits; i++) result += (readBitFromStream(bitp, bits)) << i;
+			return result;
 		}
-		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;;)
+		struct HuffmanTree
 		{
-		    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)
+			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
 		{
-		    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
+			int error;
+			void inflate(std::vector<unsigned char>& out, const std::vector<unsigned char>& in, size_t inpos = 0)
 			{
-			    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;
+				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
 			}
-		    }
-		    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
+			void generateFixedTrees(HuffmanTree& tree, HuffmanTree& treeD) //get the tree of a deflated block with fixed tree
 			{
-			    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;
+				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;
+				}
 			}
-		    }
-		    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
+			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(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;
+				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; }
+					}
+				}
 			}
-		    }
-		    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(;;)
+			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
 		{
-		    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; }
-		    }
+			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
 		}
-	    }
-	    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
+	struct PNG //nested functions for PNG decoding
 	{
-	    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 == 0) { 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)
+		struct Info
 		{
-		    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)
+			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)
 		{
-		    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 = 1; 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 = 1;
-			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] : 0; //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) ? 0 : &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) ? 0 : &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) ? 0 : 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() ? 0 : &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;
+			error = 0;
+			if(size == 0 || in == 0) { 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 = 1; 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 = 1;
+						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] : 0; //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) ? 0 : &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) ? 0 : &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);
+			}
 		}
-	    else if(infoIn.bitDepth == 8 && infoIn.colorType == 2) //RGB color
-		for(size_t i = 0; i < numpixels; i++)
+		void readPngHeader(const unsigned char* in, size_t inlength) //read the information from the header and store it in the Info
 		{
-		    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;
+			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);
 		}
-	    else if(infoIn.bitDepth == 8 && infoIn.colorType == 3) //indexed color (palette)
-		for(size_t i = 0; i < numpixels; i++)
+		void unFilterScanline(unsigned char* recon, const unsigned char* scanline, const unsigned char* precon, size_t bytewidth, unsigned long filterType, size_t length)
 		{
-		    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
+			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
+			}
 		}
-	    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];
+		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) ? 0 : 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"
+			}
 		}
-	    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++)
+		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)
 		{
-		    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;
+			unsigned long result = 0;
+			for(size_t i = nbits - 1; i < nbits; i--) result += ((readBitFromReversedStream(bitp, bits)) << i);
+			return result;
 		}
-	    else if(infoIn.bitDepth == 16 && infoIn.colorType == 2) //RGB color
-		for(size_t i = 0; i < numpixels; i++)
+		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
 		{
-		    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;
+			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
 		}
-	    else if(infoIn.bitDepth == 16 && infoIn.colorType == 4) //greyscale with alpha
-		for(size_t i = 0; i < numpixels; i++)
+		unsigned long getBpp(const Info& info)
 		{
-		    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];
+			if(info.colorType == 2) return (3 * info.bitDepth);
+			else if(info.colorType >= 4) return (info.colorType - 2) * info.bitDepth;
+			else return info.bitDepth;
 		}
-	    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;
+		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() ? 0 : &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;
 		}
-	    else if(infoIn.bitDepth < 8 && infoIn.colorType == 3) //palette
-		for(size_t i = 0; i < numpixels; i++)
+		unsigned char paethPredictor(short a, short b, short c) //Paeth predicter, used by PNG filter type 4
 		{
-		    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
+			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);
 		}
-	    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;
+	};
+	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;
 }
     
 } // yage
diff --git a/src/sprite.cpp b/src/sprite.cpp
index 010b43a7..cd8f328d 100644
--- a/src/sprite.cpp
+++ b/src/sprite.cpp
@@ -12,71 +12,71 @@ Sprite::Sprite()
 
 Sprite::~Sprite()
 {
-    if(vbo_id_ != 0)
-	glDeleteBuffers(1, &vbo_id_);
+	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);
+	x_ = x;
+	y_ = y;
+	width_ = width;
+	height_ = height;
+	texture_ = ResourceManager::getTexture(texture_path);
 
-    if(vbo_id_ == 0)
-	glGenBuffers(1, &vbo_id_);
+	if(vbo_id_ == 0)
+		glGenBuffers(1, &vbo_id_);
 
-    Vertex vertex_data[6];
+	Vertex vertex_data[6];
 
-    vertex_data[0].setPosition(x+width, y+height);
-    vertex_data[0].setUv(1.f, 1.f);
+	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[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[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[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[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);
+	vertex_data[5].setPosition(x+width, y);
+	vertex_data[5].setUv(1.f, 0.f);
 
-    for(int i = 0; i < 6; ++i)
-	vertex_data[i].setColor(255, 0, 255, 255);
+	for(int i = 0; i < 6; ++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);
+	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);
+	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_);
+	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);
+	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);
+	glDisableVertexAttribArray(2);
+	glDisableVertexAttribArray(1);
+	glDisableVertexAttribArray(0);
     
-    glBindBuffer(GL_ARRAY_BUFFER, 0);    
+	glBindBuffer(GL_ARRAY_BUFFER, 0);    
 }
     
 } // yage
diff --git a/src/spritebatch.cpp b/src/spritebatch.cpp
index d09b663b..a530a0ac 100644
--- a/src/spritebatch.cpp
+++ b/src/spritebatch.cpp
@@ -9,18 +9,18 @@ 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)
+	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)
+	num_vertices_(num_vertices),
+	offset_(offset),    
+	texture_(texture)
 {}
 
 SpriteBatch::SpriteBatch()
@@ -28,143 +28,143 @@ SpriteBatch::SpriteBatch()
 
 SpriteBatch::~SpriteBatch()
 {
-    if(vao_!=0)
-	glDeleteVertexArrays(1, &vao_);
+	if(vao_!=0)
+		glDeleteVertexArrays(1, &vao_);
 
-    if(vbo_!=0)
-	glDeleteVertexArrays(1, &vbo_);
+	if(vbo_!=0)
+		glDeleteVertexArrays(1, &vbo_);
 }
 
 void SpriteBatch::init()
 {
-    createVertexArray();
+	createVertexArray();
 }
 
 void SpriteBatch::begin()
 {
-    glyphs_.clear();
-    glyph_ptrs_.clear();
-    render_batches_.clear();
+	glyphs_.clear();
+	glyph_ptrs_.clear();
+	render_batches_.clear();
 }
 
 void SpriteBatch::end()
 {
-    sortGlyphs();
-    createRenderBatches();
+	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;
+	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_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);
+	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_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);
+	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());
+	// 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);
+	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_);
+	{
+		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);
+	{
+		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;
+	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);
-    }
+	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();
-	});
+	// 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();
+		});
 }
 
 } // yage
diff --git a/src/texturecache.cpp b/src/texturecache.cpp
index 9bebc72c..ca47217e 100644
--- a/src/texturecache.cpp
+++ b/src/texturecache.cpp
@@ -12,16 +12,16 @@ TextureCache::~TextureCache()
 
 Texture TextureCache::getTexture(const std::string &texture_path)
 {
-    auto itr = texture_map_.find(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;
-    }
+	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;
+	return itr->second;
 }
     
 } // yage
diff --git a/src/vector2d.cpp b/src/vector2d.cpp
deleted file mode 100644
index 9955f12f..00000000
--- a/src/vector2d.cpp
+++ /dev/null
@@ -1,20 +0,0 @@
-#include "vector2d.hpp"
-
-namespace yage
-{
-
-Vector2D::Vector2D(long double x, long double y) :
-	Vector({ x, y })
-{}
-
-long double Vector2D::getX() const
-{
-	return (*this)[0];
-}
-
-long double Vector2D::getY() const
-{
-	return (*this)[1];
-}
-
-} // yage
diff --git a/src/window.cpp b/src/window.cpp
index dc2a743a..37c3b16d 100644
--- a/src/window.cpp
+++ b/src/window.cpp
@@ -13,69 +13,69 @@ Window::Window()
 
 Window::~Window()
 {
-    SDL_DestroyWindow(window_);
+	SDL_DestroyWindow(window_);
 }
 
 void Window::create(const std::string &window_name, int width, int height, unsigned flags)
 {
-    Uint32 gl_window_states=0;
+	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;
+	// 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 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);
+	// 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");
+	// 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 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");
+	// 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";
+	// 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);
+	// 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_);
+	// 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);
+	// set the clear depth
+	glClearDepth(1.f);
+	// clears buffer with clear color
+	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
 }
     
 } // yage