Common.h

#ifndef LEARNOPENGL_COMMON_H
#define LEARNOPENGL_COMMON_H

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

#include <SDL2/SDL_opengl.h>

#include "vector"

class common {
public:

    template<typename V>
    static bool are_equal(int size, V v1[], V v2[]) {
        for (int i = 0; i < size; i++) {
            //std::cout << v1[i] << " " << v2[i] << "\n";
            if (v1[i] != v2[i]) return false;
        }
        return true;
    }

    template<typename V>
    static void push_iterable(const int length, V start[], std::vector<V>* vector) {
        for (int s = 0; s < length; s++) {
            vector->push_back(start[s]);
        }
    }

    template<typename V, typename E>
    static void GenOptimizedArrays(const int vertex_size, std::vector<V>* vertex_source,
                                   std::vector<V>* vertex_out, std::vector<E>* ebo_out, bool cleanup = false) {

        bool vertex_is_unique = true;

        push_iterable(vertex_size, &((*vertex_source)[0]), vertex_out);
        ebo_out->push_back(0);
        int unique_vertices = 1;

        for (int source_vertex = 1; source_vertex < vertex_source->size() / vertex_size; source_vertex++) {
            for (int element_vertex = 0; element_vertex < ebo_out->size(); element_vertex++) {
                if (element_vertex != source_vertex && are_equal(vertex_size, &((*vertex_source)[source_vertex * vertex_size]),
                              &((*vertex_source)[element_vertex * vertex_size]))) {
                    ebo_out->push_back(element_vertex);
                    vertex_is_unique = false;
                    break;
                }
            }
            if (vertex_is_unique) {
                push_iterable(vertex_size, &((*vertex_source)[source_vertex * vertex_size]), vertex_out);
                ebo_out->push_back(unique_vertices);
                unique_vertices += 1;
            } else { vertex_is_unique = true; }
        }

        if (cleanup) { delete vertex_source;}
    }
};


#endif //LEARNOPENGL_COMMON_H