#ifndef MAIN_GAME
#define MAIN_GAME

#include "IOmanager.h"

#include "model.h"


class MainGame
{
public:
    static void DisplayWindow(void);
private:
    static Shader shadeProgram;

};
#endif



#include "MainGame.h"

Shader MainGame::shadeProgram;

void MainGame::DisplayWindow(void)
{
    IOmanager::initWindow();

    shadeProgram.compileShaders("Shaders/vertShader.txt", "Shaders/fragShader.txt");
    shadeProgram.linkShaders();

    SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);

    std::cout << glGetString(GL_VERSION);

    Batch::addModel(SMALL_CUBE,"C:/Users/Alan/Desktop/MSVS/graphics/Textures/RTS_Crate.png",glm::vec3(25.0f, 15.0f, 0.0f),0.0f,glm::vec3(1.0f, 0.0f, 0.0f));

    Batches::set_all_vao_state();

    while (GameEnums::currGS == GameEnums::PLAY){
        IOmanager::pollEvent();

        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
        glUseProgram(shadeProgram.programID);

        GLint textureLocation = glGetUniformLocation(Shader::programID, "myTexture");
        glUniform1i(textureLocation, 0);

        Batches::render_all();


        glUseProgram(0);
        SDL_GL_SwapWindow(IOmanager::_window);
    }
}


#ifndef IO_MANAGER
#define IO_MANAGER

#include <Windows.h>
#include <SDL/SDL.h>
#include <GL/glew.h>
#include "Camera.h"
#include "GameEnums.h"
#include <iostream>
#include <string>


class IOmanager
{
public:
    static void initWindow(void);
    static void pollEvent(void);
    static SDL_Window* _window;
    static bool getleftMouseisNotReleasedFlag(void){return leftMouseisNotReleasedFlag;}
private:
    static int scrW, scrH;
    static SDL_Event evt;
    static bool keyWisNotReleasedFlag;
    static bool keySisNotReleasedFlag;
    static bool keyAisNotReleasedFlag;
    static bool keyDisNotReleasedFlag;
    static bool leftMouseisNotReleasedFlag;

};

#endif



#include "IOmanager.h"

SDL_Window* IOmanager::_window;
int IOmanager::scrW;
int IOmanager::scrH;
SDL_Event IOmanager::evt;

bool IOmanager::keyWisNotReleasedFlag;
bool IOmanager::keySisNotReleasedFlag;
bool IOmanager::keyAisNotReleasedFlag;
bool IOmanager::keyDisNotReleasedFlag;
bool IOmanager::leftMouseisNotReleasedFlag;

void IOmanager::initWindow(void){
    SDL_Init(SDL_INIT_EVERYTHING);
    scrW = 1180;
    scrH = 924;
    _window = SDL_CreateWindow("Window", SDL_WINDOWPOS_CENTERED,SDL_WINDOWPOS_CENTERED,scrW,scrH, SDL_WINDOW_OPENGL);
    SDL_GLContext glContext = SDL_GL_CreateContext(_window);
    glewInit();

    glClearDepth(1.0);
    glClearColor(0.0f, 0.0f, 0.0f, 1.0f);

    glEnable(GL_DEPTH_TEST);
    glEnable(GL_CULL_FACE);
}
void IOmanager::pollEvent(void){
    GameEnums::currGS = GameEnums::PLAY;
    while (SDL_PollEvent(&evt)){
        switch (evt.type){
            case SDL_QUIT:
                GameEnums::currGS = GameEnums::EXIT;
                break;
            case SDL_MOUSEMOTION:
                Camera::mouseUpdate((glm::vec2(evt.motion.x, evt.motion.y)));
                break;
            case SDL_KEYDOWN:
                switch(evt.key.keysym.sym){
                case SDLK_w:
                    keyWisNotReleasedFlag = true;
                    break;
                case SDLK_s:
                    keySisNotReleasedFlag = true;
                    break;
                case SDLK_a:
                    keyAisNotReleasedFlag = true;
                    break;
                case SDLK_d:
                    keyDisNotReleasedFlag = true;
                    break;
            }
            break;
            case SDL_KEYUP:
                switch(evt.key.keysym.sym){
                case SDLK_w:
                    keyWisNotReleasedFlag = false;
                    break;
                case SDLK_s:
                    keySisNotReleasedFlag = false;
                    break;
                case SDLK_a:
                    keyAisNotReleasedFlag = false;
                    break;
                case SDLK_d:
                    keyDisNotReleasedFlag = false;
                    break;
            }
            break;
            case SDL_MOUSEBUTTONDOWN:
                switch(evt.button.button){
                case SDL_BUTTON_LEFT:
                    leftMouseisNotReleasedFlag = true;
                    break;
            }
            break;
            case SDL_MOUSEBUTTONUP:
                switch(evt.button.button){
                case SDL_BUTTON_LEFT:
                    leftMouseisNotReleasedFlag = false;
                    break;
            }
            break;
        }
    }
    if(keyWisNotReleasedFlag == true){
        Camera::moveForward();
    }
    if(keySisNotReleasedFlag == true){
        Camera::moveBackward();
    }
    if(keyAisNotReleasedFlag == true){
        Camera::moveLeft();
    }
    if(keyDisNotReleasedFlag == true){
        Camera::moveRight();
    }
    if(leftMouseisNotReleasedFlag == true){
        //std::cout << std::endl << "is NOT released" << std::endl;
    }
    if(leftMouseisNotReleasedFlag == false){
        //std::cout << std::endl << "is released" << std::endl;
    }
}


#ifndef MODEL_CLASS
#define MODEL_CLASS

#include "shapeData.h"
#include "resourceManager.h"
#include "Camera.h"
#include "Shader.h"
#include <algorithm>


class Batch{
public:
    Batch(SHAPE);
    static void addModel(SHAPE shape, std::string tex_path_key, glm::vec3 world_pos, GLfloat rot, glm::vec3 ax_of_rot);
    std::vector <glm::mat4> & get_instances_vec(void){return instances;}

    GLuint& get_vao(void){return vao;}

    Vertex* get_vert_Ptr(){return vert_Ptr;}
    GLushort get_vertsByteSize(){return vertsByteSize;}
    GLushort* get_ind_Ptr(){return ind_Ptr;}
    GLushort get_indsByteSize(){return indsByteSize;}
    Texture& get_texture(){return texture;}

    GLuint get_instances_byte_size(void);
private:
    Vertex* vert_Ptr;
    GLushort vertsByteSize;
    GLushort* ind_Ptr;
    GLushort indsByteSize;
    Texture texture;

    GLuint vao;

    std::vector <glm::mat4> instances;
};


class Batches{
public:
    static void render_all(void);
    Batches();//does nothing
    Batches(Texture texture, glm::vec3, GLfloat, glm::vec3);
    Batches(SHAPE shape, glm::vec3, GLfloat, glm::vec3);
    static GLuint& get_global_vbo(void){return global_vbo;}
    static GLuint& get_global_instance_vbo(void){return global_instance_vbo;}

    static std::vector <Batch*> get_batches_vec(void){return batches;}
    static GLuint get_batches_vec_vert_byte_size();
    static GLuint get_batches_vec_ind_byte_size();
    static GLuint get_total_num_instances_byte_size(void);


    static void set_all_vao_state(void);


private:
    static GLuint global_vbo;
    static GLuint global_instance_vbo;
    static std::vector <Batch*> batches;
};


#endif



#include "model.h"

std::vector <Batch*> Batches::batches;

GLuint Batches::global_vbo;
GLuint Batches::global_instance_vbo;


Batch::Batch(SHAPE shape){
    vert_Ptr = shapeData::getVerts(shape);
    vertsByteSize = shapeData::get_vertsByteSize();
    ind_Ptr = shapeData::getInds(shape);
    indsByteSize = shapeData::get_indsByteSize();

    texture = loadTexture::genTexture();//generates a texture consisting of a unique texture ID, with width and height of 0
}


void Batch::addModel(SHAPE shape, std::string tex_path_key, glm::vec3 world_pos, GLfloat rot, glm::vec3 ax_of_rot){
auto map_itr = resourceManager::getTexture_cache().find(tex_path_key);
    if(map_itr == resourceManager::getTexture_cache().end()){
        Batches(shape, world_pos, rot, ax_of_rot);  //adds another batch to the batches vector
        loadTexture::loadBufferToOpengl(tex_path_key, Batches::get_batches_vec().back()->get_texture());
    }
    else{
        Texture texture = map_itr->second;
        Batches(texture, world_pos, rot, ax_of_rot);    //add an instance of a model to an existing batch
    }
}

GLuint Batch::get_instances_byte_size(void){
    GLuint instances_byte_size = (instances.size() * sizeof(glm::mat4));
    return instances_byte_size;
}

Batches::Batches(Texture texture, glm::vec3 world_pos, GLfloat rot, glm::vec3 ax_of_rot){
    batches[texture.textureID - 1]->get_instances_vec().push_back(glm::rotate(glm::translate((Camera::get_projectMat()) * (Camera::getWtoVmat()), world_pos),rot,ax_of_rot));//fulltranformation
    batches[texture.textureID - 1]->get_instances_vec().push_back(glm::rotate(glm::translate(glm::mat4(), world_pos), rot,ax_of_rot));//modeltoworld only
}

Batches::Batches(SHAPE shape, glm::vec3 world_pos, GLfloat rot, glm::vec3 ax_of_rot){
    batches.emplace_back(new Batch(shape));
    batches[(batches.back()->get_texture().textureID) - 1]->get_instances_vec().push_back(glm::rotate(glm::translate((Camera::get_projectMat()) * (Camera::getWtoVmat()), world_pos),rot,ax_of_rot));//fulltranformation
    batches[(batches.back()->get_texture().textureID) - 1]->get_instances_vec().push_back(glm::rotate(glm::translate(glm::mat4(), world_pos), rot,ax_of_rot));//modeltoworld only
}

GLuint Batches::get_batches_vec_vert_byte_size(){
    GLuint total_batches_vec_vert_byte_size = 0;
    for (int i = 0; i < Batches::get_batches_vec().size(); i++){
        total_batches_vec_vert_byte_size += Batches::get_batches_vec()[i]->get_vertsByteSize();
    }
    return total_batches_vec_vert_byte_size;
    Batches::get_batches_vec();
}

GLuint Batches::get_batches_vec_ind_byte_size(){
    GLuint total_batches_vec_ind_byte_size = 0;
        for (int i = 0; i < Batches::get_batches_vec().size(); i++){
            total_batches_vec_ind_byte_size += Batches::get_batches_vec()[i]->get_indsByteSize();
        }
    return total_batches_vec_ind_byte_size;
}

GLuint Batches::get_total_num_instances_byte_size(void){
    GLuint total_num_instances = 0;
    for (int i = 0; i < Batches::get_batches_vec().size(); i++){
        total_num_instances += (Batches::get_batches_vec()[i]->get_instances_vec()).size();
    }
    GLuint total_num_instances_byte_size = (total_num_instances * sizeof(glm::mat4));
    return total_num_instances_byte_size;
}


void Batches::set_all_vao_state(void){

glGenBuffers(1, &Batches::get_global_vbo());
GLuint vert_byte_offset = 0;
GLuint elem_byte_offset = 0;

    for (int i = 0; i < Batches::get_batches_vec().size(); i++){
        glGenVertexArrays(1, &Batches::get_batches_vec()[i]->get_vao());
        glBindVertexArray(Batches::get_batches_vec()[i]->get_vao());
        glBindBuffer(GL_ARRAY_BUFFER, (Batches::get_global_vbo()));
        if (i == 0){
            glBufferData(GL_ARRAY_BUFFER, Batches::get_batches_vec_vert_byte_size(), nullptr, GL_DYNAMIC_DRAW);
        }
        glBufferSubData(GL_ARRAY_BUFFER, vert_byte_offset, Batches::get_batches_vec()[i]->get_vertsByteSize(), Batches::get_batches_vec()[i]->get_vert_Ptr());
        glEnableVertexAttribArray(0);
        glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, sizeof(GLfloat) * 11, (char*)((sizeof(GLfloat) * 0) + vert_byte_offset));
        glEnableVertexAttribArray(1);
        glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, sizeof(GLfloat) * 11, (char*)((sizeof(GLfloat) * 3) + vert_byte_offset));
        glEnableVertexAttribArray(2);
        glVertexAttribPointer(2, 3, GL_FLOAT, GL_FALSE, sizeof(GLfloat) * 11, (char*)((sizeof(GLfloat) * 6) + vert_byte_offset));
        glEnableVertexAttribArray(3);
        glVertexAttribPointer(3, 2, GL_FLOAT, GL_FALSE, sizeof(GLfloat) * 11, (char*)((sizeof(GLfloat) * 9) + vert_byte_offset));
        vert_byte_offset += Batches::get_batches_vec()[i]->get_vertsByteSize();
        glBindVertexArray(0);
    }
    for (int i = 0; i < Batches::get_batches_vec().size(); i++){
        glBindVertexArray(Batches::get_batches_vec()[i]->get_vao());
        glBindBuffer(GL_ELEMENT_ARRAY_BUFFER,Batches::get_global_vbo());
        if (i == 0){
            glBufferData(GL_ELEMENT_ARRAY_BUFFER, Batches::get_batches_vec_ind_byte_size(), nullptr, GL_DYNAMIC_DRAW);
        }
        glBufferSubData(GL_ELEMENT_ARRAY_BUFFER, elem_byte_offset, Batches::get_batches_vec()[i]->get_indsByteSize(), Batches::get_batches_vec()[i]->get_ind_Ptr());
        elem_byte_offset += Batches::get_batches_vec()[i]->get_indsByteSize();
        glBindVertexArray(0);
    }
    glGenBuffers(1, &Batches::get_global_instance_vbo());
    vert_byte_offset = 0;//we now bind gl_array_buffer to a different buffer object, so set vert_byte_offset to 0
    for (int i = 0; i < Batches::get_batches_vec().size(); i++){
        glBindVertexArray(Batches::get_batches_vec()[i]->get_vao());
        glBindBuffer(GL_ARRAY_BUFFER, Batches::get_global_instance_vbo());
        if (i == 0){
            glBufferData(GL_ARRAY_BUFFER, (Batches::get_total_num_instances_byte_size()),
                            nullptr, GL_DYNAMIC_DRAW);
        }

        glBufferSubData(GL_ARRAY_BUFFER, vert_byte_offset, Batches::get_batches_vec()[i]->get_instances_byte_size(),
        &(Batches::get_batches_vec()[i]->get_instances_vec()[0]));
        std::cout << std::endl;

        glEnableVertexAttribArray(4);
        glEnableVertexAttribArray(5);
        glEnableVertexAttribArray(6);
        glEnableVertexAttribArray(7);
        glEnableVertexAttribArray(8);
        glEnableVertexAttribArray(9);
        glEnableVertexAttribArray(10);
        glEnableVertexAttribArray(11);

        glVertexAttribPointer(4, 4, GL_FLOAT, GL_FALSE, (sizeof(glm::mat4) * 2), (char*)(sizeof(GLfloat) * 0));
        glVertexAttribPointer(5, 4, GL_FLOAT, GL_FALSE, (sizeof(glm::mat4) * 2), (char*)(sizeof(GLfloat) * 4));
        glVertexAttribPointer(6, 4, GL_FLOAT, GL_FALSE, (sizeof(glm::mat4) * 2), (char*)(sizeof(GLfloat) * 8));
        glVertexAttribPointer(7, 4, GL_FLOAT, GL_FALSE, (sizeof(glm::mat4) * 2), (char*)(sizeof(GLfloat) * 12));
        glVertexAttribPointer(8, 4, GL_FLOAT, GL_FALSE, (sizeof(glm::mat4) * 2), (char*)(sizeof(GLfloat) * 16));
        glVertexAttribPointer(9, 4, GL_FLOAT, GL_FALSE, (sizeof(glm::mat4) * 2), (char*)(sizeof(GLfloat) * 20));
        glVertexAttribPointer(10, 4, GL_FLOAT, GL_FALSE, (sizeof(glm::mat4) * 2), (char*)(sizeof(GLfloat) * 24));
        glVertexAttribPointer(11, 4, GL_FLOAT, GL_FALSE, (sizeof(glm::mat4) * 2), (char*)(sizeof(GLfloat) * 28));

        glVertexAttribDivisor(4,1);
        glVertexAttribDivisor(5,1);
        glVertexAttribDivisor(6,1);
        glVertexAttribDivisor(7,1);
        glVertexAttribDivisor(8,1);
        glVertexAttribDivisor(9,1);
        glVertexAttribDivisor(10,1);
        glVertexAttribDivisor(11,1);
    }
}

void Batches::render_all(void){
    GLint getLocforLightPos = glGetUniformLocation(Shader::programID, "lightPos");
    glm::vec3 lightPos(35.0f,14.5f,10.0f);
    glUniform3fv(getLocforLightPos, 1, &lightPos[0]);

    GLint getLocforAmbientLight = glGetUniformLocation(Shader::programID, "ambientLight");
    glm::vec4 ambientLight(0.2f,0.01f,0.03f, 1.0f);
    glUniform4fv(getLocforAmbientLight, 1, &ambientLight[0]);

    GLint getLocforEyePosition = glGetUniformLocation(Shader::programID, "eyePosition");
    glm::vec3 eyePosition = Camera::getEyePosition();
    glUniform3fv(getLocforEyePosition, 1, &eyePosition[0]);

    GLuint indices_byte_offset = 0;

    for (int i = 0; i < Batches::get_batches_vec().size(); i++){
        glBindVertexArray(Batches::get_batches_vec()[i]->get_vao());
        glActiveTexture(GL_TEXTURE0);
        glBindTexture(GL_TEXTURE_2D, Batches::get_batches_vec()[i]->get_texture().textureID);

        glDrawElementsInstanced(GL_TRIANGLES, (Batches::get_batches_vec()[i]->get_indsByteSize() / sizeof(GLushort)),
                                GL_UNSIGNED_SHORT, (void*)indices_byte_offset, (Batches::get_batches_vec()[i]->get_instances_vec().size())/2);
        indices_byte_offset += Batches::get_batches_vec()[i]->get_indsByteSize();
    }
}


#ifndef CAMERA
#define CAMERA
#include <glm/glm.hpp>
#include <glm/gtc/matrix_transform.hpp>

class Camera
{
public:
    static void mouseUpdate(glm::vec2 &newScreenPos);
    static void moveForward();
    static void moveBackward();
    static void moveLeft();
    static void moveRight();
    static const glm::mat4 getWtoVmat() {return glm::lookAt(position, position + viewDir, UP);}
    static const glm::mat4 get_projectMat() {return (glm::perspective(95.0f, 1.28f, 0.1f, 90.0f));}
    static glm::vec3 getEyePosition() {return position;}
    static glm::vec3 getViewDir() {return viewDir;}
private:
    static glm::vec3 position;
    static glm::vec3 viewDir;
    static glm::vec3 UP;
    static glm::vec3 rotationAroundX;
    static glm::vec2 oldScreenPos;
};

#endif


#include "Camera.h"

glm::vec3 Camera::position = glm::vec3(12.0f, 15.0f, 36.0f);
glm::vec3 Camera::viewDir = glm::vec3(0.0f, -0.5f, -1.0f);
glm::vec3 Camera::UP = glm::vec3(0.0f, 1.0f, 0.0f);
glm::vec3 Camera::rotationAroundX = glm::vec3(1.0f, 0.0f, 0.0f);
glm::vec2 Camera::oldScreenPos = glm::vec2(0.0f, 0.0f);

void Camera::mouseUpdate(glm::vec2 &newScreenPos){
    glm::vec2 mouseDelta = newScreenPos - oldScreenPos;
    if (abs (mouseDelta.x) > 120.0f)
        mouseDelta.x = 0.0f;
    if (abs (mouseDelta.y) > 120.0f)
        mouseDelta.y = 0.0f;
    viewDir = glm::mat3 (glm::rotate(glm::mat4(),-mouseDelta.x * 0.20f, UP)) * viewDir; // sets x motion
    viewDir = glm::mat3 (glm::rotate(glm::mat4(),-mouseDelta.y * 0.22f, rotationAroundX)) * viewDir; //sets y motion
    rotationAroundX = glm::mat3 (glm::rotate(glm::mat4(),-mouseDelta.x * 0.20f, UP)) * rotationAroundX;// updates rotationAroundX vector
    // to be perp to UP and viewDir
    oldScreenPos = newScreenPos;
}

void Camera::moveForward(){
        position += (0.2f * viewDir);
}
void Camera::moveBackward(){
        position += (-0.2f * viewDir);
}
void Camera::moveLeft(){
        position += (-0.2f * rotationAroundX);
}
void Camera::moveRight(){
        position += (0.2f * rotationAroundX);
}

//shapeData.h
#ifndef SHAPE_DATA
#define SHAPE_DATA

#define GLEW_STATIC
#include <GL/glew.h>
#include "Vertex.h"


enum SHAPE {CUBE, SMALL_CUBE, FLOOR_TILE, TINY_CUBE};
struct shapeData{
    static Vertex* Verts;
    static GLushort* Indices;
    static Vertex*  getVerts(SHAPE);
    static GLushort* getInds(SHAPE);
    static GLushort VertsByteSize;
    static GLushort IndicesByteSize;
    static GLushort get_vertsByteSize(void);
    static GLushort get_indsByteSize(void);
};

#endif


#include "shapeData.h"

Vertex* shapeData::Verts;
GLushort* shapeData::Indices;
GLushort shapeData::VertsByteSize;
GLushort shapeData::IndicesByteSize;

Vertex* shapeData::getVerts(SHAPE shape) {
    switch(shape){
    case CUBE:
        {
            Vertex cubeDat[] = {
                        glm::vec3(-5.0f, -5.0f, -5.0f),
                        glm::vec3(+0.5f, +0.5f, +0.5f),
                        glm::vec3(0.0f, -1.0f, 0.0f),
                        glm::vec2(0.0, 0.0),

                        glm::vec3(-5.0f, -5.0f, 5.0f),
                        glm::vec3(+0.5f, +0.5f, +0.5f),
                        glm::vec3(0.0f, -1.0f, 0.0f),
                        glm::vec2(0.0, 1.0),

                        glm::vec3(+5.0f, -5.0f, 5.0f),
                        glm::vec3(+0.5f, +0.5f, +0.5f),
                        glm::vec3(0.0f, -1.0f, 0.0f),
                        glm::vec2(1.0, 1.0),

                        glm::vec3(+5.0f, -5.0f, -5.0f),
                        glm::vec3(+0.5f, +0.5f, +0.5f),
                        glm::vec3(0.0f, -1.0f, 0.0f),
                        glm::vec2(1.0, 0.0),//good great 6 lower

                        glm::vec3(-5.0f, 5.0f, -5.0f),
                        glm::vec3(+0.5f, +0.5f, +0.5f),
                        glm::vec3(0.0f, 1.0f, 0.0f),
                        glm::vec2(0.0, 1.0),

                        glm::vec3(-5.0f, 5.0f, 5.0f),
                        glm::vec3(+0.5f, +0.5f, +0.5f),
                        glm::vec3(0.0f, 1.0f, 0.0f),
                        glm::vec2(0.0, 0.0),

                        glm::vec3(+5.0f, 5.0f, 5.0f),
                        glm::vec3(+0.5f, +0.5f, +0.5f),
                        glm::vec3(0.0f, 1.0f, 0.0f),
                        glm::vec2(1.0, 0.0),

                        glm::vec3(+5.0f, 5.0f, -5.0f),
                        glm::vec3(+0.5f, +0.5f, +0.5f),
                        glm::vec3(0.0f, 1.0f, 0.0f),
                        glm::vec2(1.0, 1.0),////////good great 1 upper

                        glm::vec3(-5.0f, -5.0f, -5.0f),
                        glm::vec3(+0.5f, +0.5f, +0.5f),
                        glm::vec3(-1.0f, 0.0f, 0.0f),
                        glm::vec2(0.0, 0.0),

                        glm::vec3(-5.0f, -5.0f, 5.0f),
                        glm::vec3(+0.5f, +0.5f, +0.5f),
                        glm::vec3(-1.0f, 0.0f, 0.0f),
                        glm::vec2(1.0, 0.0),

                        glm::vec3(-5.0f, +5.0f, 5.0f),
                        glm::vec3(+0.5f, +0.5f, +0.5f),
                        glm::vec3(-1.0f, 0.0f, 0.0f),
                        glm::vec2(1.0, 1.0),

                        glm::vec3(-5.0f, +5.0f, -5.0f),
                        glm::vec3(+0.5f, +0.5f, +0.5f),
                        glm::vec3(-1.0f, 0.0f, 0.0f),//good great 3 left
                        glm::vec2(0.0, 1.0),

                        glm::vec3(5.0f, -5.0f, -5.0f), ////
                        glm::vec3(+0.5f, +0.5f, +0.5f),
                        glm::vec3(1.0f, 0.0f, 0.0f),
                        glm::vec2(1.0, 0.0),

                        glm::vec3(5.0f, -5.0f, 5.0f),
                        glm::vec3(+0.5f, +0.5f, +0.5f),
                        glm::vec3(1.0f, 0.0f, 0.0f),
                        glm::vec2(0.0, 0.0),

                        glm::vec3(+5.0f, +5.0f, 5.0f),
                        glm::vec3(+0.5f, +0.5f, +0.5f),
                        glm::vec3(1.0f, 0.0f, 0.0f),
                        glm::vec2(0.0, 1.0),

                        glm::vec3(+5.0f, +5.0f, -5.0f),
                        glm::vec3(+0.5f, +0.5f, +0.5f),
                        glm::vec3(1.0f, 0.0f, 0.0f),//good great 5 right
                        glm::vec2(1.0, 1.0),
                        /////
                        glm::vec3(-5.0f, -5.0f, -5.0f),
                        glm::vec3(+0.5f, +0.5f, +0.5f),
                        glm::vec3(0.0f, 0.0f, -1.0f),
                        glm::vec2(1.0, 0.0),

                        glm::vec3(-5.0f, +5.0f, -5.0f),
                        glm::vec3(+0.5f, +0.5f, +0.5f),
                        glm::vec3(0.0f, 0.0f, -1.0f),
                        glm::vec2(1.0, 1.0),

                        glm::vec3(+5.0f, +5.0f, -5.0f),
                        glm::vec3(+0.5f, +0.5f, +0.5f),
                        glm::vec3(0.0f, 0.0f, -1.0f),
                        glm::vec2(0.0, 1.0),

                        glm::vec3(+5.0f, -5.0f, -5.0f),
                        glm::vec3(+0.5f, +0.5f, +0.5f),
                        glm::vec3(0.0f, 0.0f, -1.0f),//good great 4 back
                        glm::vec2(0.0, 0.0),

                        glm::vec3(-5.0f, -5.0f, 5.0f),
                        glm::vec3(+0.5f, +0.5f, +0.5f),
                        glm::vec3(0.0f, 0.0f, 1.0f),
                        glm::vec2(0.0, 0.0),

                        glm::vec3(-5.0f, +5.0f, 5.0f),
                        glm::vec3(+0.5f, +0.5f, +0.5f),
                        glm::vec3(0.0f, 0.0f, 1.0f),
                        glm::vec2(0.0, 1.0),

                        glm::vec3(+5.0f, +5.0f, 5.0f),
                        glm::vec3(+0.5f, +0.5f, +0.5f),
                        glm::vec3(0.0f, 0.0f, 1.0f),
                        glm::vec2(1.0, 1.0),

                        glm::vec3(+5.0f, -5.0f, 5.0f),
                        glm::vec3(+0.5f, +0.5f, +0.5f),
                        glm::vec3(0.0f, 0.0f, 1.0f),//good great 2 front
                        glm::vec2(1.0, 0.0)

                    };
            VertsByteSize = sizeof(cubeDat);
            Verts = new Vertex[sizeof(cubeDat)/sizeof(*cubeDat)];
            memcpy(Verts, cubeDat, (sizeof(cubeDat)/sizeof(*cubeDat)) * sizeof(Vertex));
        }
        break;
    case SMALL_CUBE:
        {
            Vertex cubeDat[] = {
                    glm::vec3(-2.5f, -2.5f, -2.5f),
                    glm::vec3(+0.5f, +0.5f, +0.5f),
                    glm::vec3(0.0f, -1.0f, 0.0f),
                    glm::vec2(0.0, 0.0),

                    glm::vec3(-2.5f, -2.5f, 2.5f),
                    glm::vec3(+0.5f, +0.5f, +0.5f),
                    glm::vec3(0.0f, -1.0f, 0.0f),
                    glm::vec2(0.0, 1.0),

                    glm::vec3(+2.5f, -2.5f, 2.5f),
                    glm::vec3(+0.5f, +0.5f, +0.5f),
                    glm::vec3(0.0f, -1.0f, 0.0f),
                    glm::vec2(1.0, 1.0),

                    glm::vec3(+2.5f, -2.5f, -2.5f),
                    glm::vec3(+0.5f, +0.5f, +0.5f),
                    glm::vec3(0.0f, -1.0f, 0.0f),
                    glm::vec2(1.0, 0.0),//good great 6 lower

                    glm::vec3(-2.5f, 2.5f, -2.5f),
                    glm::vec3(+0.5f, +0.5f, +0.5f),
                    glm::vec3(0.0f, 1.0f, 0.0f),
                    glm::vec2(0.0, 1.0),

                    glm::vec3(-2.5f, 2.5f, 2.5f),
                    glm::vec3(+0.5f, +0.5f, +0.5f),
                    glm::vec3(0.0f, 1.0f, 0.0f),
                    glm::vec2(0.0, 0.0),

                    glm::vec3(+2.5f, 2.5f, 2.5f),
                    glm::vec3(+0.5f, +0.5f, +0.5f),
                    glm::vec3(0.0f, 1.0f, 0.0f),
                    glm::vec2(1.0, 0.0),

                    glm::vec3(+2.5f, 2.5f, -2.5f),
                    glm::vec3(+0.5f, +0.5f, +0.5f),
                    glm::vec3(0.0f, 1.0f, 0.0f),
                    glm::vec2(1.0, 1.0),////////good great 1 upper

                    glm::vec3(-2.5f, -2.5f, -2.5f),
                    glm::vec3(+0.5f, +0.5f, +0.5f),
                    glm::vec3(-1.0f, 0.0f, 0.0f),
                    glm::vec2(0.0, 0.0),

                    glm::vec3(-2.5f, -2.5f, 2.5f),
                    glm::vec3(+0.5f, +0.5f, +0.5f),
                    glm::vec3(-1.0f, 0.0f, 0.0f),
                    glm::vec2(1.0, 0.0),

                    glm::vec3(-2.5f, +2.5f, 2.5f),
                    glm::vec3(+0.5f, +0.5f, +0.5f),
                    glm::vec3(-1.0f, 0.0f, 0.0f),
                    glm::vec2(1.0, 1.0),

                    glm::vec3(-2.5f, +2.5f, -2.5f),
                    glm::vec3(+0.5f, +0.5f, +0.5f),
                    glm::vec3(-1.0f, 0.0f, 0.0f),//good great 3 left
                    glm::vec2(0.0, 1.0),

                    glm::vec3(2.5f, -2.5f, -2.5f),
                    glm::vec3(+0.5f, +0.5f, +0.5f),
                    glm::vec3(1.0f, 0.0f, 0.0f),
                    glm::vec2(1.0, 0.0),

                    glm::vec3(2.5f, -2.5f, 2.5f),
                    glm::vec3(+0.5f, +0.5f, +0.5f),
                    glm::vec3(1.0f, 0.0f, 0.0f),
                    glm::vec2(0.0, 0.0),

                    glm::vec3(+2.5f, +2.5f, 2.5f),
                    glm::vec3(+0.5f, +0.5f, +0.5f),
                    glm::vec3(1.0f, 0.0f, 0.0f),
                    glm::vec2(0.0, 1.0),

                    glm::vec3(+2.5f, +2.5f, -2.5f),
                    glm::vec3(+0.5f, +0.5f, +0.5f),
                    glm::vec3(1.0f, 0.0f, 0.0f),//good great 5 right
                    glm::vec2(1.0, 1.0),
                    /////
                    glm::vec3(-2.5f, -2.5f, -2.5f),
                    glm::vec3(+0.5f, +0.5f, +0.5f),
                    glm::vec3(0.0f, 0.0f, -1.0f),
                    glm::vec2(1.0, 0.0),

                    glm::vec3(-2.5f, +2.5f, -2.5f),
                    glm::vec3(+0.5f, +0.5f, +0.5f),
                    glm::vec3(0.0f, 0.0f, -1.0f),
                    glm::vec2(1.0, 1.0),

                    glm::vec3(+2.5f, +2.5f, -2.5f),
                    glm::vec3(+0.5f, +0.5f, +0.5f),
                    glm::vec3(0.0f, 0.0f, -1.0f),
                    glm::vec2(0.0, 1.0),

                    glm::vec3(+2.5f, -2.5f, -2.5f),
                    glm::vec3(+0.5f, +0.5f, +0.5f),
                    glm::vec3(0.0f, 0.0f, -1.0f),//good great 4 back
                    glm::vec2(0.0, 0.0),

                    glm::vec3(-2.5f, -2.5f, 2.5f),
                    glm::vec3(+0.5f, +0.5f, +0.5f),
                    glm::vec3(0.0f, 0.0f, 1.0f),
                    glm::vec2(0.0, 0.0),

                    glm::vec3(-2.5f, +2.5f, 2.5f),
                    glm::vec3(+0.5f, +0.5f, +0.5f),
                    glm::vec3(0.0f, 0.0f, 1.0f),
                    glm::vec2(0.0, 1.0),

                    glm::vec3(+2.5f, +2.5f, 2.5f),
                    glm::vec3(+0.5f, +0.5f, +0.5f),
                    glm::vec3(0.0f, 0.0f, 1.0f),
                    glm::vec2(1.0, 1.0),

                    glm::vec3(+2.5f, -2.5f, 2.5f),
                    glm::vec3(+0.5f, +0.5f, +0.5f),
                    glm::vec3(0.0f, 0.0f, 1.0f),//good great 2 front
                    glm::vec2(1.0, 0.0)
                };
            VertsByteSize = sizeof(cubeDat);
            Verts = new Vertex[sizeof(cubeDat)/sizeof(*cubeDat)];
            memcpy(Verts, cubeDat, (sizeof(cubeDat)/sizeof(*cubeDat)) * sizeof(Vertex));
    }
    break;
    case FLOOR_TILE:
        {
            Vertex cubeDat[] = {
                    glm::vec3(-5.0f, 5.0f, -5.0f),
                    glm::vec3(+0.5f, +0.5f, +0.5f),
                    glm::vec3(0.0f, 1.0f, 0.0f),
                    glm::vec2(0.0, 1.0),

                    glm::vec3(-5.0f, 5.0f, 5.0f),
                    glm::vec3(+0.5f, +0.5f, +0.5f),
                    glm::vec3(0.0f, 1.0f, 0.0f),
                    glm::vec2(0.0, 0.0),

                    glm::vec3(+5.0f, 5.0f, 5.0f),
                    glm::vec3(+0.5f, +0.5f, +0.5f),
                    glm::vec3(0.0f, 1.0f, 0.0f),
                    glm::vec2(1.0, 0.0),

                    glm::vec3(+5.0f, 5.0f, -5.0f),
                    glm::vec3(+0.5f, +0.5f, +0.5f),
                    glm::vec3(0.0f, 1.0f, 0.0f),
                    glm::vec2(1.0, 1.0),////////good great 1 upper
                };
            VertsByteSize = sizeof(cubeDat);
            Verts = new Vertex[sizeof(cubeDat)/sizeof(*cubeDat)];
            memcpy(Verts, cubeDat, (sizeof(cubeDat)/sizeof(*cubeDat)) * sizeof(Vertex));
    }
    break;
    case TINY_CUBE:
        {
            Vertex cubeDat[] = {
                    glm::vec3(-0.5f, -0.5f, -0.5f),
                    glm::vec3(+0.5f, +0.5f, +0.5f),
                    glm::vec3(0.0f, -1.0f, 0.0f),
                    glm::vec2(0.0, 0.0),

                    glm::vec3(-0.5f, -0.5f, 0.5f),
                    glm::vec3(+0.5f, +0.5f, +0.5f),
                    glm::vec3(0.0f, -1.0f, 0.0f),
                    glm::vec2(0.0, 1.0),

                    glm::vec3(+0.5f, -0.5f, 0.5f),
                    glm::vec3(+0.5f, +0.5f, +0.5f),
                    glm::vec3(0.0f, -1.0f, 0.0f),
                    glm::vec2(1.0, 1.0),

                    glm::vec3(+0.5f, -0.5f, -0.5f),
                    glm::vec3(+0.5f, +0.5f, +0.5f),
                    glm::vec3(0.0f, -1.0f, 0.0f),
                    glm::vec2(1.0, 0.0),//good great 6 lower

                    glm::vec3(-0.5f, 0.5f, -0.5f),
                    glm::vec3(+0.5f, +0.5f, +0.5f),
                    glm::vec3(0.0f, 1.0f, 0.0f),
                    glm::vec2(0.0, 1.0),

                    glm::vec3(-0.5f, 0.5f, 0.5f),
                    glm::vec3(+0.5f, +0.5f, +0.5f),
                    glm::vec3(0.0f, 1.0f, 0.0f),
                    glm::vec2(0.0, 0.0),

                    glm::vec3(+0.5f, 0.5f, 0.5f),
                    glm::vec3(+0.5f, +0.5f, +0.5f),
                    glm::vec3(0.0f, 1.0f, 0.0f),
                    glm::vec2(1.0, 0.0),

                    glm::vec3(+0.5f, 0.5f, -0.5f),
                    glm::vec3(+0.5f, +0.5f, +0.5f),
                    glm::vec3(0.0f, 1.0f, 0.0f),
                    glm::vec2(1.0, 1.0),////////good great 1 upper

                    glm::vec3(-0.5f, -0.5f, -0.5f),
                    glm::vec3(+0.5f, +0.5f, +0.5f),
                    glm::vec3(-1.0f, 0.0f, 0.0f),
                    glm::vec2(0.0, 0.0),

                    glm::vec3(-0.5f, -0.5f, 0.5f),
                    glm::vec3(+0.5f, +0.5f, +0.5f),
                    glm::vec3(-1.0f, 0.0f, 0.0f),
                    glm::vec2(1.0, 0.0),

                    glm::vec3(-0.5f, +0.5f, 0.5f),
                    glm::vec3(+0.5f, +0.5f, +0.5f),
                    glm::vec3(-1.0f, 0.0f, 0.0f),
                    glm::vec2(1.0, 1.0),

                    glm::vec3(-0.5f, +0.5f, -0.5f),
                    glm::vec3(+0.5f, +0.5f, +0.5f),
                    glm::vec3(-1.0f, 0.0f, 0.0f),//good great 3 left
                    glm::vec2(0.0, 1.0),

                    glm::vec3(0.5f, -0.5f, -0.5f),
                    glm::vec3(+0.5f, +0.5f, +0.5f),
                    glm::vec3(1.0f, 0.0f, 0.0f),
                    glm::vec2(1.0, 0.0),

                    glm::vec3(0.5f, -0.5f, 0.5f),
                    glm::vec3(+0.5f, +0.5f, +0.5f),
                    glm::vec3(1.0f, 0.0f, 0.0f),
                    glm::vec2(0.0, 0.0),

                    glm::vec3(+0.5f, +0.5f, 0.5f),
                    glm::vec3(+0.5f, +0.5f, +0.5f),
                    glm::vec3(1.0f, 0.0f, 0.0f),
                    glm::vec2(0.0, 1.0),

                    glm::vec3(+0.5f, +0.5f, -0.5f),
                    glm::vec3(+0.5f, +0.5f, +0.5f),
                    glm::vec3(1.0f, 0.0f, 0.0f),//good great 5 right
                    glm::vec2(1.0, 1.0),
                    /////
                    glm::vec3(-0.5f, -0.5f, -0.5f),
                    glm::vec3(+0.5f, +0.5f, +0.5f),
                    glm::vec3(0.0f, 0.0f, -1.0f),
                    glm::vec2(1.0, 0.0),

                    glm::vec3(-0.5f, +0.5f, -0.5f),
                    glm::vec3(+0.5f, +0.5f, +0.5f),
                    glm::vec3(0.0f, 0.0f, -1.0f),
                    glm::vec2(1.0, 1.0),

                    glm::vec3(+0.5f, +0.5f, -0.5f),
                    glm::vec3(+0.5f, +0.5f, +0.5f),
                    glm::vec3(0.0f, 0.0f, -1.0f),
                    glm::vec2(0.0, 1.0),

                    glm::vec3(+0.5f, -0.5f, -0.5f),
                    glm::vec3(+0.5f, +0.5f, +0.5f),
                    glm::vec3(0.0f, 0.0f, -1.0f),//good great 4 back
                    glm::vec2(0.0, 0.0),

                    glm::vec3(-0.5f, -0.5f, 0.5f),
                    glm::vec3(+0.5f, +0.5f, +0.5f),
                    glm::vec3(0.0f, 0.0f, 1.0f),
                    glm::vec2(0.0, 0.0),

                    glm::vec3(-0.5f, +0.5f, 0.5f),
                    glm::vec3(+0.5f, +0.5f, +0.5f),
                    glm::vec3(0.0f, 0.0f, 1.0f),
                    glm::vec2(0.0, 1.0),

                    glm::vec3(+0.5f, +0.5f, 0.5f),
                    glm::vec3(+0.5f, +0.5f, +0.5f),
                    glm::vec3(0.0f, 0.0f, 1.0f),
                    glm::vec2(1.0, 1.0),

                    glm::vec3(+0.5f, -0.5f, 0.5f),
                    glm::vec3(+0.5f, +0.5f, +0.5f),
                    glm::vec3(0.0f, 0.0f, 1.0f),//good great 2 front
                    glm::vec2(1.0, 0.0)
                };
            VertsByteSize = sizeof(cubeDat);
            Verts = new Vertex[sizeof(cubeDat)/sizeof(*cubeDat)];
            memcpy(Verts, cubeDat, (sizeof(cubeDat)/sizeof(*cubeDat)) * sizeof(Vertex));
    }
    break;
    }
    return Verts;
}

GLushort* shapeData:: getInds(SHAPE shape) {
    switch(shape){
    case CUBE:
        {
            GLushort indices[] = {2,1,0, 0,3,2, 4,5,6, 6,7,4, 8,9,10, 10,11,8, 13,12,15, 15,14,13, 19,16,17, 17,18,19, 20,23,22, 22,21,20};

            IndicesByteSize = sizeof(indices);

            Indices = new GLushort [sizeof(indices)/sizeof(*indices)];
            memcpy(Indices, indices, (sizeof(indices)/sizeof(*indices)) * sizeof(GLushort));
        }
    break;
    case SMALL_CUBE: //I know I dont actually need this shape since I already have CUBE, just added it for variety
        {
            GLushort indices[] = {2,1,0, 0,3,2, 4,5,6, 6,7,4, 8,9,10, 10,11,8, 13,12,15, 15,14,13, 19,16,17, 17,18,19, 20,23,22, 22,21,20};

            IndicesByteSize = sizeof(indices);

            Indices = new GLushort [sizeof(indices)/sizeof(*indices)];
            memcpy(Indices, indices, (sizeof(indices)/sizeof(*indices)) * sizeof(GLushort));
        }
    break;
    case FLOOR_TILE:
        {
            GLushort indices[] = {0,1,2, 2,3,0};
            IndicesByteSize = sizeof(indices);

            Indices = new GLushort [sizeof(indices)/sizeof(*indices)];
            memcpy(Indices, indices, (sizeof(indices)/sizeof(*indices)) * sizeof(GLushort));
        }
    break;
    }

    return Indices;
}


GLushort shapeData::get_vertsByteSize(void){
    return VertsByteSize;
}
GLushort shapeData::get_indsByteSize(void){
    return IndicesByteSize;
}


#ifndef TEXTURE
#define TEXTURE

#include "Texture.h"
#include <string>
#include <fstream>
#include <vector>
#include <iostream>

class loadTexture
{
public:
    static void loadBufferToOpengl(std::string filePath, Texture &);
    static Texture genTexture(void);
private:
    static void fileToBuffer(std::string,std::vector <unsigned char>&);
    static int decodePNGbuffer(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 = true);
};

#endif


#include "loadTexture.h"


void loadTexture::fileToBuffer(std::string path, std::vector <unsigned char> &buffer)
{

    std::ifstream textureFile(path, std::ios::binary);
    if(textureFile.fail())
        perror(path.c_str());

    textureFile.seekg(0, std::ios::end);
    int fileSize = textureFile.tellg();
    textureFile.seekg(0, std::ios::beg);

    fileSize -= textureFile.tellg();

    buffer.resize(fileSize);
    textureFile.read((char *)&(buffer[0]),fileSize);
}

/*
decodePNG: The picoPNG function, decodes a PNG file buffer in memory, into a raw pixel buffer.
out_image: output parameter, this will contain the raw pixels after decoding.
  By default the output is 32-bit RGBA color.
  The std::vector is automatically resized to the correct size.
image_width: output_parameter, this will contain the width of the image in pixels.
image_height: output_parameter, this will contain the height of the image in pixels.
in_png: pointer to the buffer of the PNG file in memory. To get it from a file on
  disk, load it and store it in a memory buffer yourself first.
in_size: size of the input PNG file in bytes.
convert_to_rgba32: optional parameter, true by default.
  Set to true to get the output in RGBA 32-bit (8 bit per channel) color format
  no matter what color type the original PNG image had. This gives predictable,
  useable data from any random input PNG.
  Set to false to do no color conversion at all. The result then has the same data
  type as the PNG image, which can range from 1 bit to 64 bits per pixel.
  Information about the color type or palette colors are not provided. You need
  to know this information yourself to be able to use the data so this only
  works for trusted PNG files. Use LodePNG instead of picoPNG if you need this information.
return: 0 if success, not 0 if some error occured.
*/
int loadTexture::decodePNGbuffer(std::vector<unsigned char>& out_image, unsigned long& image_width, unsigned long& image_height, const unsigned char* in_png, size_t in_size, bool convert_to_rgba32)
{
  // picoPNG version 20101224
  // Copyright (c) 2005-2010 Lode Vandevenne
  //
  // This software is provided 'as-is', without any express or implied
  // warranty. In no event will the authors be held liable for any damages
  // arising from the use of this software.
  //
  // Permission is granted to anyone to use this software for any purpose,
  // including commercial applications, and to alter it and redistribute it
  // freely, subject to the following restrictions:
  //
  //     1. The origin of this software must not be misrepresented; you must not
  //     claim that you wrote the original software. If you use this software
  //     in a product, an acknowledgment in the product documentation would be
  //     appreciated but is not required.
  //     2. Altered source versions must be plainly marked as such, and must not be
  //     misrepresented as being the original software.
  //     3. This notice may not be removed or altered from any source distribution.

  // picoPNG is a PNG decoder in one C++ function of around 500 lines. Use picoPNG for
  // programs that need only 1 .cpp file. Since it's a single function, it's very limited,
  // it can convert a PNG to raw pixel data either converted to 32-bit RGBA color or
  // with no color conversion at all. For anything more complex, another tiny library
  // is available: LodePNG (lodepng.c(pp)), which is a single source and header file.
  // Apologies for the compact code style, it's to make this tiny.

  static const unsigned long LENBASE[29] =  {3,4,5,6,7,8,9,10,11,13,15,17,19,23,27,31,35,43,51,59,67,83,99,115,131,163,195,227,258};
  static const unsigned long LENEXTRA[29] = {0,0,0,0,0,0,0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4,  4,  5,  5,  5,  5,  0};
  static const unsigned long DISTBASE[30] =  {1,2,3,4,5,7,9,13,17,25,33,49,65,97,129,193,257,385,513,769,1025,1537,2049,3073,4097,6145,8193,12289,16385,24577};
  static const unsigned long DISTEXTRA[30] = {0,0,0,0,1,1,2, 2, 3, 3, 4, 4, 5, 5,  6,  6,  7,  7,  8,  8,   9,   9,  10,  10,  11,  11,  12,   12,   13,   13};
  static const unsigned long CLCL[19] = {16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15}; //code length code lengths
  struct Zlib //nested functions for zlib decompression
  {
    static unsigned long readBitFromStream(size_t& bitp, const unsigned char* bits) { unsigned long result = (bits[bitp >> 3] >> (bitp & 0x7)) & 1; bitp++; return result;}
    static unsigned long readBitsFromStream(size_t& bitp, const unsigned char* bits, size_t nbits)
    {
      unsigned long result = 0;
      for(size_t i = 0; i < nbits; i++) result += (readBitFromStream(bitp, bits)) << i;
      return result;
    }
    struct HuffmanTree
    {
      int makeFromLengths(const std::vector<unsigned long>& bitlen, unsigned long maxbitlen)
      { //make tree given the lengths
        unsigned long numcodes = (unsigned long)(bitlen.size()), treepos = 0, nodefilled = 0;
        std::vector<unsigned long> tree1d(numcodes), blcount(maxbitlen + 1, 0), nextcode(maxbitlen + 1, 0);
        for(unsigned long bits = 0; bits < numcodes; bits++) blcount[bitlen[bits]]++; //count number of instances of each code length
        for(unsigned long bits = 1; bits <= maxbitlen; bits++) nextcode[bits] = (nextcode[bits - 1] + blcount[bits - 1]) << 1;
        for(unsigned long n = 0; n < numcodes; n++) if(bitlen[n] != 0) tree1d[n] = nextcode[bitlen[n]]++; //generate all the codes
        tree2d.clear(); tree2d.resize(numcodes * 2, 32767); //32767 here means the tree2d isn't filled there yet
        for(unsigned long n = 0; n < numcodes; n++) //the codes
        for(unsigned long i = 0; i < bitlen[n]; i++) //the bits for this code
        {
          unsigned long bit = (tree1d[n] >> (bitlen[n] - i - 1)) & 1;
          if(treepos > numcodes - 2) return 55;
          if(tree2d[2 * treepos + bit] == 32767) //not yet filled in
          {
            if(i + 1 == bitlen[n]) { tree2d[2 * treepos + bit] = n; treepos = 0; } //last bit
            else { tree2d[2 * treepos + bit] = ++nodefilled + numcodes; treepos = nodefilled; } //addresses are encoded as values > numcodes
          }
          else treepos = tree2d[2 * treepos + bit] - numcodes; //subtract numcodes from address to get address value
        }
        return 0;
      }
      int decode(bool& decoded, unsigned long& result, size_t& treepos, unsigned long bit) const
      { //Decodes a symbol from the tree
        unsigned long numcodes = (unsigned long)tree2d.size() / 2;
        if(treepos >= numcodes) return 11; //error: you appeared outside the codetree
        result = tree2d[2 * treepos + bit];
        decoded = (result < numcodes);
        treepos = decoded ? 0 : result - numcodes;
        return 0;
      }
      std::vector<unsigned long> tree2d; //2D representation of a huffman tree: The one dimension is "0" or "1", the other contains all nodes and leaves of the tree.
    };
    struct Inflator
    {
      int error;
      void inflate(std::vector<unsigned char>& out, const std::vector<unsigned char>& in, size_t inpos = 0)
      {
        size_t bp = 0, pos = 0; //bit pointer and byte pointer
        error = 0;
        unsigned long BFINAL = 0;
        while(!BFINAL && !error)
        {
          if(bp >> 3 >= in.size()) { error = 52; return; } //error, bit pointer will jump past memory
          BFINAL = readBitFromStream(bp, &in[inpos]);
          unsigned long BTYPE = readBitFromStream(bp, &in[inpos]); BTYPE += 2 * readBitFromStream(bp, &in[inpos]);
          if(BTYPE == 3) { error = 20; return; } //error: invalid BTYPE
          else if(BTYPE == 0) inflateNoCompression(out, &in[inpos], bp, pos, in.size());
          else inflateHuffmanBlock(out, &in[inpos], bp, pos, in.size(), BTYPE);
        }
        if(!error) out.resize(pos); //Only now we know the true size of out, resize it to that
      }
      void generateFixedTrees(HuffmanTree& tree, HuffmanTree& treeD) //get the tree of a deflated block with fixed tree
      {
        std::vector<unsigned long> bitlen(288, 8), bitlenD(32, 5);;
        for(size_t i = 144; i <= 255; i++) bitlen[i] = 9;
        for(size_t i = 256; i <= 279; i++) bitlen[i] = 7;
        tree.makeFromLengths(bitlen, 15);
        treeD.makeFromLengths(bitlenD, 15);
      }
      HuffmanTree codetree, codetreeD, codelengthcodetree; //the code tree for Huffman codes, dist codes, and code length codes
      unsigned long huffmanDecodeSymbol(const unsigned char* in, size_t& bp, const HuffmanTree& codetree, size_t inlength)
      { //decode a single symbol from given list of bits with given code tree. return value is the symbol
        bool decoded; unsigned long ct;
        for(size_t treepos = 0;;)
        {
          if((bp & 0x07) == 0 && (bp >> 3) > inlength) { error = 10; return 0; } //error: end reached without endcode
          error = codetree.decode(decoded, ct, treepos, readBitFromStream(bp, in)); if(error) return 0; //stop, an error happened
          if(decoded) return ct;
        }
      }
      void getTreeInflateDynamic(HuffmanTree& tree, HuffmanTree& treeD, const unsigned char* in, size_t& bp, size_t inlength)
      { //get the tree of a deflated block with dynamic tree, the tree itself is also Huffman compressed with a known tree
        std::vector<unsigned long> bitlen(288, 0), bitlenD(32, 0);
        if(bp >> 3 >= inlength - 2) { error = 49; return; } //the bit pointer is or will go past the memory
        size_t HLIT =  readBitsFromStream(bp, in, 5) + 257; //number of literal/length codes + 257
        size_t HDIST = readBitsFromStream(bp, in, 5) + 1; //number of dist codes + 1
        size_t HCLEN = readBitsFromStream(bp, in, 4) + 4; //number of code length codes + 4
        std::vector<unsigned long> codelengthcode(19); //lengths of tree to decode the lengths of the dynamic tree
        for(size_t i = 0; i < 19; i++) codelengthcode[CLCL[i]] = (i < HCLEN) ? readBitsFromStream(bp, in, 3) : 0;
        error = codelengthcodetree.makeFromLengths(codelengthcode, 7); if(error) return;
        size_t i = 0, replength;
        while(i < HLIT + HDIST)
        {
          unsigned long code = huffmanDecodeSymbol(in, bp, codelengthcodetree, inlength); if(error) return;
          if(code <= 15)  { if(i < HLIT) bitlen[i++] = code; else bitlenD[i++ - HLIT] = code; } //a length code
          else if(code == 16) //repeat previous
          {
            if(bp >> 3 >= inlength) { error = 50; return; } //error, bit pointer jumps past memory
            replength = 3 + readBitsFromStream(bp, in, 2);
            unsigned long value; //set value to the previous code
            if((i - 1) < HLIT) value = bitlen[i - 1];
            else value = bitlenD[i - HLIT - 1];
            for(size_t n = 0; n < replength; n++) //repeat this value in the next lengths
            {
              if(i >= HLIT + HDIST) { error = 13; return; } //error: i is larger than the amount of codes
              if(i < HLIT) bitlen[i++] = value; else bitlenD[i++ - HLIT] = value;
            }
          }
          else if(code == 17) //repeat "0" 3-10 times
          {
            if(bp >> 3 >= inlength) { error = 50; return; } //error, bit pointer jumps past memory
            replength = 3 + readBitsFromStream(bp, in, 3);
            for(size_t n = 0; n < replength; n++) //repeat this value in the next lengths
            {
              if(i >= HLIT + HDIST) { error = 14; return; } //error: i is larger than the amount of codes
              if(i < HLIT) bitlen[i++] = 0; else bitlenD[i++ - HLIT] = 0;
            }
          }
          else if(code == 18) //repeat "0" 11-138 times
          {
            if(bp >> 3 >= inlength) { error = 50; return; } //error, bit pointer jumps past memory
            replength = 11 + readBitsFromStream(bp, in, 7);
            for(size_t n = 0; n < replength; n++) //repeat this value in the next lengths
            {
              if(i >= HLIT + HDIST) { error = 15; return; } //error: i is larger than the amount of codes
              if(i < HLIT) bitlen[i++] = 0; else bitlenD[i++ - HLIT] = 0;
            }
          }
          else { error = 16; return; } //error: somehow an unexisting code appeared. This can never happen.
        }
        if(bitlen[256] == 0) { error = 64; return; } //the length of the end code 256 must be larger than 0
        error = tree.makeFromLengths(bitlen, 15); if(error) return; //now we've finally got HLIT and HDIST, so generate the code trees, and the function is done
        error = treeD.makeFromLengths(bitlenD, 15); if(error) return;
      }
      void inflateHuffmanBlock(std::vector<unsigned char>& out, const unsigned char* in, size_t& bp, size_t& pos, size_t inlength, unsigned long btype)
      {
        if(btype == 1) { generateFixedTrees(codetree, codetreeD); }
        else if(btype == 2) { getTreeInflateDynamic(codetree, codetreeD, in, bp, inlength); if(error) return; }
        for(;;)
        {
          unsigned long code = huffmanDecodeSymbol(in, bp, codetree, inlength); if(error) return;
          if(code == 256) return; //end code
          else if(code <= 255) //literal symbol
          {
            if(pos >= out.size()) out.resize((pos + 1) * 2); //reserve more room
            out[pos++] = (unsigned char)(code);
          }
          else if(code >= 257 && code <= 285) //length code
          {
            size_t length = LENBASE[code - 257], numextrabits = LENEXTRA[code - 257];
            if((bp >> 3) >= inlength) { error = 51; return; } //error, bit pointer will jump past memory
            length += readBitsFromStream(bp, in, numextrabits);
            unsigned long codeD = huffmanDecodeSymbol(in, bp, codetreeD, inlength); if(error) return;
            if(codeD > 29) { error = 18; return; } //error: invalid dist code (30-31 are never used)
            unsigned long dist = DISTBASE[codeD], numextrabitsD = DISTEXTRA[codeD];
            if((bp >> 3) >= inlength) { error = 51; return; } //error, bit pointer will jump past memory
            dist += readBitsFromStream(bp, in, numextrabitsD);
            size_t start = pos, back = start - dist; //backwards
            if(pos + length >= out.size()) out.resize((pos + length) * 2); //reserve more room
            for(size_t i = 0; i < length; i++) { out[pos++] = out[back++]; if(back >= start) back = start - dist; }
          }
        }
      }
      void inflateNoCompression(std::vector<unsigned char>& out, const unsigned char* in, size_t& bp, size_t& pos, size_t inlength)
      {
        while((bp & 0x7) != 0) bp++; //go to first boundary of byte
        size_t p = bp / 8;
        if(p >= inlength - 4) { error = 52; return; } //error, bit pointer will jump past memory
        unsigned long LEN = in[p] + 256 * in[p + 1], NLEN = in[p + 2] + 256 * in[p + 3]; p += 4;
        if(LEN + NLEN != 65535) { error = 21; return; } //error: NLEN is not one's complement of LEN
        if(pos + LEN >= out.size()) out.resize(pos + LEN);
        if(p + LEN > inlength) { error = 23; return; } //error: reading outside of in buffer
        for(unsigned long n = 0; n < LEN; n++) out[pos++] = in[p++]; //read LEN bytes of literal data
        bp = p * 8;
      }
    };
    int decompress(std::vector<unsigned char>& out, const std::vector<unsigned char>& in) //returns error value
    {
      Inflator inflator;
      if(in.size() < 2) { return 53; } //error, size of zlib data too small
      if((in[0] * 256 + in[1]) % 31 != 0) { return 24; } //error: 256 * in[0] + in[1] must be a multiple of 31, the FCHECK value is supposed to be made that way
      unsigned long CM = in[0] & 15, CINFO = (in[0] >> 4) & 15, FDICT = (in[1] >> 5) & 1;
      if(CM != 8 || CINFO > 7) { return 25; } //error: only compression method 8: inflate with sliding window of 32k is supported by the PNG spec
      if(FDICT != 0) { return 26; } //error: the specification of PNG says about the zlib stream: "The additional flags shall not specify a preset dictionary."
      inflator.inflate(out, in, 2);
      return inflator.error; //note: adler32 checksum was skipped and ignored
    }
  };
  struct PNG //nested functions for PNG decoding
  {
    struct Info
    {
      unsigned long width, height, colorType, bitDepth, compressionMethod, filterMethod, interlaceMethod, key_r, key_g, key_b;
      bool key_defined; //is a transparent color key given?
      std::vector<unsigned char> palette;
    } info;
    int error;
    void decode(std::vector<unsigned char>& out, const unsigned char* in, size_t size, bool convert_to_rgba32)
    {
      error = 0;
      if(size == 0 || in == 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);
      }
    }
    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;
      }
      else if(infoIn.bitDepth == 8 && infoIn.colorType == 2) //RGB color
      for(size_t i = 0; i < numpixels; i++)
      {
        for(size_t c = 0; c < 3; c++) out_[4 * i + c] = in[3 * i + c];
        out_[4 * i + 3] = (infoIn.key_defined == 1 && in[3 * i + 0] == infoIn.key_r && in[3 * i + 1] == infoIn.key_g && in[3 * i + 2] == infoIn.key_b) ? 0 : 255;
      }
      else if(infoIn.bitDepth == 8 && infoIn.colorType == 3) //indexed color (palette)
      for(size_t i = 0; i < numpixels; i++)
      {
        if(4U * in[i] >= infoIn.palette.size()) return 46;
        for(size_t c = 0; c < 4; c++) out_[4 * i + c] = infoIn.palette[4 * in[i] + c]; //get rgb colors from the palette
      }
      else if(infoIn.bitDepth == 8 && infoIn.colorType == 4) //greyscale with alpha
      for(size_t i = 0; i < numpixels; i++)
      {
        out_[4 * i + 0] = out_[4 * i + 1] = out_[4 * i + 2] = in[2 * i + 0];
        out_[4 * i + 3] = in[2 * i + 1];
      }
      else if(infoIn.bitDepth == 8 && infoIn.colorType == 6) for(size_t i = 0; i < numpixels; i++) for(size_t c = 0; c < 4; c++) out_[4 * i + c] = in[4 * i + c]; //RGB with alpha
      else if(infoIn.bitDepth == 16 && infoIn.colorType == 0) //greyscale
      for(size_t i = 0; i < numpixels; i++)
      {
        out_[4 * i + 0] = out_[4 * i + 1] = out_[4 * i + 2] = in[2 * i];
        out_[4 * i + 3] = (infoIn.key_defined && 256U * in[i] + in[i + 1] == infoIn.key_r) ? 0 : 255;
      }
      else if(infoIn.bitDepth == 16 && infoIn.colorType == 2) //RGB color
      for(size_t i = 0; i < numpixels; i++)
      {
        for(size_t c = 0; c < 3; c++) out_[4 * i + c] = in[6 * i + 2 * c];
        out_[4 * i + 3] = (infoIn.key_defined && 256U*in[6*i+0]+in[6*i+1] == infoIn.key_r && 256U*in[6*i+2]+in[6*i+3] == infoIn.key_g && 256U*in[6*i+4]+in[6*i+5] == infoIn.key_b) ? 0 : 255;
      }
      else if(infoIn.bitDepth == 16 && infoIn.colorType == 4) //greyscale with alpha
      for(size_t i = 0; i < numpixels; i++)
      {
        out_[4 * i + 0] = out_[4 * i + 1] = out_[4 * i + 2] = in[4 * i]; //most significant byte
        out_[4 * i + 3] = in[4 * i + 2];
      }
      else if(infoIn.bitDepth == 16 && infoIn.colorType == 6) for(size_t i = 0; i < numpixels; i++) for(size_t c = 0; c < 4; c++) out_[4 * i + c] = in[8 * i + 2 * c]; //RGB with alpha
      else if(infoIn.bitDepth < 8 && infoIn.colorType == 0) //greyscale
      for(size_t i = 0; i < numpixels; i++)
      {
        unsigned long value = (readBitsFromReversedStream(bp, in, infoIn.bitDepth) * 255) / ((1 << infoIn.bitDepth) - 1); //scale value from 0 to 255
        out_[4 * i + 0] = out_[4 * i + 1] = out_[4 * i + 2] = (unsigned char)(value);
        out_[4 * i + 3] = (infoIn.key_defined && value && ((1U << infoIn.bitDepth) - 1U) == infoIn.key_r && ((1U << infoIn.bitDepth) - 1U)) ? 0 : 255;
      }
      else if(infoIn.bitDepth < 8 && infoIn.colorType == 3) //palette
      for(size_t i = 0; i < numpixels; i++)
      {
        unsigned long value = readBitsFromReversedStream(bp, in, infoIn.bitDepth);
        if(4 * value >= infoIn.palette.size()) return 47;
        for(size_t c = 0; c < 4; c++) out_[4 * i + c] = infoIn.palette[4 * value + c]; //get rgb colors from the palette
      }
      return 0;
    }
    unsigned char paethPredictor(short a, short b, short c) //Paeth predicter, used by PNG filter type 4
    {
      short p = a + b - c, pa = p > a ? (p - a) : (a - p), pb = p > b ? (p - b) : (b - p), pc = p > c ? (p - c) : (c - p);
      return (unsigned char)((pa <= pb && pa <= pc) ? a : pb <= pc ? b : c);
    }
  };
  PNG decoder; decoder.decode(out_image, in_png, in_size, convert_to_rgba32);
  image_width = decoder.info.width; image_height = decoder.info.height;
  return decoder.error;
}




/*
//an example using the PNG loading function:

#include <iostream>
#include <fstream>

void loadFile(std::vector<unsigned char>& buffer, const std::string& filename) //designed for loading files from hard disk in an std::vector
{
  std::ifstream file(filename.c_str(), std::ios::in|std::ios::binary|std::ios::ate);

  //get filesize
  std::streamsize size = 0;
  if(file.seekg(0, std::ios::end).good()) size = file.tellg();
  if(file.seekg(0, std::ios::beg).good()) size -= file.tellg();

  //read contents of the file into the vector
  if(size > 0)
  {
    buffer.resize((size_t)size);
    file.read((char*)(&buffer[0]), size);
  }
  else buffer.clear();
}

int main(int argc, char *argv[])
{
  const char* filename = argc > 1 ? argv[1] : "test.png";

  //load and decode
  std::vector<unsigned char> buffer, image;
  loadFile(buffer, filename);
  unsigned long w, h;
  int error = decodePNG(image, w, h, buffer.empty() ? 0 : &buffer[0], (unsigned long)buffer.size());

  //if there's an error, display it
  if(error != 0) std::cout << "error: " << error << std::endl;

  //the pixels are now in the vector "image", use it as texture, draw it, ...

  if(image.size() > 4) std::cout << "width: " << w << " height: " << h << " first pixel: " << std::hex << int(image[0]) << int(image[1]) << int(image[2]) << int(image[3]) << std::endl;
}
*/
/*
  //this is test code, it displays the pixels of a 1 bit PNG. To use it, set the flag convert_to_rgba32 to false and load a 1-bit PNG image with a small size (so that its ASCII representation can fit in a console window)
  for(int y = 0; y < h; y++)
  {
    for(int x = 0; x < w; x++)
    {
      int i = y * h + x;
      std::cout << (((image[i/8] >> (7-i%8)) & 1) ? '.' : '#');
    }
    std::cout << std::endl;
  }
*/

void loadTexture::loadBufferToOpengl(std::string filePath, Texture &texture){
    std::vector<unsigned char> in_buffer; //undecoded PNG file data
    std::vector<unsigned char> out_buffer; //raw pixel data

    fileToBuffer(filePath,in_buffer);

    unsigned long width, height;
    int checkError;
    checkError = decodePNGbuffer(out_buffer, width, height, &in_buffer[0],in_buffer.size());

    glActiveTexture(GL_TEXTURE0);
    glBindTexture(GL_TEXTURE_2D, texture.textureID);

    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, &out_buffer[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_NEAREST);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST_MIPMAP_LINEAR);
    glGenerateMipmap(GL_TEXTURE_2D);
    texture.width = width;
    texture.height = height;
}

Texture loadTexture::genTexture(void){//texture ID is needed, width and height can be 0 for now
    Texture texture;
    glGenTextures(1, &texture.textureID);
    texture.width = 0;
    texture.height = 0;
    return texture;
}


#ifndef TEXTURE_STRUCT
#define TEXTURE_STRUCT

#include <GL/glew.h>
struct Texture{
    GLuint textureID;
    int width;
    int height;
};
#endif

#ifndef VERTEX_STRUCT
#define VERTEX_STRUCT

#include <glm/glm.hpp>

struct Vertex {
    glm::vec3 position;
    glm::vec3 color;
    glm::vec3 normal;
    glm::vec2 UV;
};


#endif


#ifndef TEXTURE_CACHE
#define TEXTURE_CACHE
#include <string>
#include <map>
#include "loadTexture.h"



class resourceManager
{
public:
    static std::map <std::string, Texture>& getTexture_cache(void){return texture_cache;}
private:
    static std::map <std::string, Texture> texture_cache;

};

#endif

#include "resourceManager.h"


std::map <std::string, Texture> resourceManager::texture_cache;


#ifndef GAME_ENUMS
#define GAME_ENUMS
class GameEnums
{
public:
    static enum GameState {PLAY, EXIT} currGS;
};

#endif

#include "GameEnums.h"

GameEnums::GameState GameEnums::currGS = PLAY;