//R. RAFFIN, IUT Aix-Marseille, dépt. Informatique - Arles
//TP simple, affichages de quelques points
//compilation par : g++ -Wall TP1points.cpp -lGL -lGLU -lglut -lGLEW -o TP1points

#include <cstdio>
#include <cstdlib>
#include <cmath>

#include <vector>

#include <GL/glew.h>
#include <GL/freeglut.h>
#include <iostream>

using namespace std;

struct Vertex {
        float x;
        float y;
        float z;
};

class Primitive {
    public:
        Primitive() : m_init(false) { glGenBuffers(1, &m_vbo); }
        virtual ~Primitive() {
            glDeleteBuffers(1, &m_vbo);
        }

        void render() {
            if(!m_init) return;
            //rendu de la primitive
            glBindBuffer(GL_ARRAY_BUFFER, m_vbo);
                glEnableClientState(GL_VERTEX_ARRAY);
                    glVertexPointer(3, GL_FLOAT, 0, 0);
                    glDrawArrays(GL_LINE_LOOP, 0, m_vertices_count);
                glDisableClientState(GL_VERTEX_ARRAY);
            glBindBuffer(GL_ARRAY_BUFFER, 0);
        }

        inline std::uint8_t vertices_count() const {
            return m_vertices_count;
        }

    protected:
        virtual void genShape() = 0;
        void upload() {
            //envois des vertices sur la carte graphique
            glBindBuffer(GL_ARRAY_BUFFER, m_vbo);
            std::cout << "error: " << glGetError() << std::endl;
            glBufferData(GL_ARRAY_BUFFER, m_vertices.size() * sizeof(float), &(m_vertices.front()), GL_STATIC_DRAW);
            glBindBuffer(GL_ARRAY_BUFFER, 0);

            m_init = true;
        }

        std::vector<Vertex> m_vertices;
        std::uint8_t        m_vertices_count;
        GLuint              m_vbo;
        bool                m_init;
};

class CirclePrimitive : public Primitive {
    public:
        CirclePrimitive(float radius, std::uint8_t border_precision) : m_radius(radius) {
            m_vertices_count = border_precision;
            m_vertices.reserve(m_vertices_count);

            genShape();
            upload();
        }

        inline float radius() const {
            return m_radius;
        }

    private:
        virtual void genShape() {
            static const float deg2rad = M_PI / 180.f;

            //generation des points du cercle
            for(unsigned int i = 0;i < 360; ++i) {
                Vertex vertex;

                const float rad = float(i) * deg2rad;
                vertex.x = std::cos(rad) * m_radius;
                vertex.y = std::sin(rad) * m_radius;
                vertex.z = 0;

                m_vertices.push_back(vertex);
            }
        }

        float m_radius;
};

static void RenderScene();
static void InitializeGlutCallbacks();
CirclePrimitive *circle = NULL;

int main(int argc, char** argv)
{
    glutInit(&argc, argv);
    glutInitDisplayMode(GLUT_DOUBLE|GLUT_RGBA);
    glutInitWindowSize(500, 500);
    glutInitWindowPosition(100, 100);
    glutCreateWindow("TP1 : quelques points");

    InitializeGlutCallbacks();

    //toujours après l'initialisation de glut
    GLenum res = glewInit();

    if (res != GLEW_OK) {
        cerr << "Error: " << glewGetErrorString(res) << endl;
        return (EXIT_FAILURE);
    }

    //cout << "Using GLEW Version: " << glewGetString(GLEW_VERSION);

    circle = new CirclePrimitive(0.5f, 100);
    glClearColor(0.0f, 0.0f, 0.0f, 0.0f);

    glutMainLoop();

    return (EXIT_SUCCESS);
}


static void RenderScene()
{
    glClear(GL_COLOR_BUFFER_BIT);

    if(circle)
        circle->render();

    glutSwapBuffers();
}


static void InitializeGlutCallbacks()
{
    glutDisplayFunc(RenderScene);
}

static void CreateVertexBuffer()
{


    //glGenBuffers(1, &leVBO); //génération d'une référence de buffer object
    //glBindBuffer(GL_ARRAY_BUFFER, leVBO); //liaison du buffer avec un type tableau de données
    //glBufferData(GL_ARRAY_BUFFER, sizeof(float)*27, vertices, GL_STATIC_DRAW); //création et initialisation du container de données (3 sommets -> 9 float)

}