/*
Compile with :
g++ vbo_stride_fail.cpp -g -lglfw -lGL -lGLEW -lGLU -o vbo_fail

*/


#include <GL/glew.h>
#include <GL/glfw.h>
#include <GL/gl.h>
#include <cassert>
#include <iostream>

struct Vector3 {
    Vector3(float _x, float _y, float _z) : x(_x), y(_y), z(_z) {}
	union {
		struct { float x, y, z; };
		struct { float xyz[3]; };
	};
};

struct Color {
    Color(unsigned char _r, unsigned char _g, unsigned char _b) : 
        r(_r), g(_g), b(_b) {}

    union {
        struct { unsigned char r,g,b; };
        struct { unsigned char rgb[3];};
    };
};


#define VERTEX_COUNT 3
struct Vector3 pos[VERTEX_COUNT] = {
    Vector3(-1, -1, 0),
    Vector3(-1, 1, 0),
    Vector3(1, 1, 0)

};

struct Color col[VERTEX_COUNT] = {
    Color(255, 0,0),
    Color(0, 255, 0),
    Color(0, 0, 255)
};


int copyVec3(const Vector3& data, unsigned char* out) {
	float* fout = (float*) out;
	*fout++ = data.x;
	*fout++ = data.y;
	*fout++ = data.z;
	
	return sizeof(data);
}

int copyColor(const Color& data, unsigned char* fout) {
	*fout++ = data.r;
	*fout++ = data.g;
	*fout++ = data.b;
	
	return sizeof(data);
}


int fillVboBuffer(unsigned char** buffer, unsigned int** indices, int& outSizePerEntry) {
    outSizePerEntry = 0;
    outSizePerEntry += sizeof(Vector3); // position
    outSizePerEntry += 3 * sizeof(char); // color

    (*buffer) = new unsigned char[outSizePerEntry * VERTEX_COUNT];
    (*indices) = new unsigned int[outSizePerEntry];

    int index = 0;

    for(int i=0; i<VERTEX_COUNT; ++i) {
        index += copyVec3(pos[i], &(*buffer)[index]);
        index += copyColor(col[i] , &(*buffer)[index]);

        (*indices)[i] = i;
    }

    assert(index == VERTEX_COUNT * outSizePerEntry);

    return VERTEX_COUNT;
}

#define BUFFER_OFFSET(_offset) ((char *)NULL + (_offset))
#define CHECK_GL_ERROR {GLenum err = glGetError(); if (err != GL_NO_ERROR) { std::cout << "Error : " << gluErrorString(err) << std::endl; assert(false); }}

int main() {
    glfwInit();

    glfwOpenWindow(320, 200, 8, 8, 8, 8, 8, 1, GLFW_WINDOW);

    glewInit();

    GLuint vbos[2];
    unsigned char* tmp;
    unsigned int* indices;

    // create 2 VBOs
    glGenBuffers(2, vbos);

    glBindBuffer(GL_ARRAY_BUFFER, vbos[0]);
    int sizePerEntry = 0;
    int entryCount = fillVboBuffer(&tmp, &indices, sizePerEntry);
    glBufferData(GL_ARRAY_BUFFER, entryCount * sizePerEntry, tmp, GL_STATIC_DRAW);
	glBindBuffer(GL_ARRAY_BUFFER, 0);
	
	glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, vbos[1]);
	glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(unsigned int) * entryCount, indices, GL_STATIC_DRAW);
	glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);

    // setup camera
	glMatrixMode(GL_PROJECTION);
	glLoadIdentity();
	gluPerspective(70, 320.0/200.0, 0.1, 200);
	glMatrixMode(GL_MODELVIEW);
	glLoadIdentity();
	gluLookAt(
			0, 0, 3,
			0, 0, 0,
			0, 1, 0);
    glClearColor(1,1,1,1);
    
    glDisable(GL_LIGHTING);
	glDisable(GL_BLEND);
	glDisable(GL_TEXTURE_2D);
	glDisable(GL_DITHER);
	glDisable(GL_CULL_FACE);
    glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);  

    while(true) {
        CHECK_GL_ERROR
        glClear( GL_DEPTH_BUFFER_BIT | GL_COLOR_BUFFER_BIT );

#if 0
        // render : immediate mode
        glBegin(GL_TRIANGLES);
        for(int i=0; i<entryCount; ++i) {
            glColor3ubv(col[i].rgb);
            glVertex3fv(pos[i].xyz);
        }
        glEnd();
#else
        // render : vbo mode
        glBindBuffer(GL_ARRAY_BUFFER, vbos[0]);

        glVertexPointer( 3, GL_FLOAT, sizePerEntry, BUFFER_OFFSET(0));
        glColorPointer( 3, GL_UNSIGNED_BYTE, sizePerEntry, BUFFER_OFFSET(sizeof(Vector3)) );

        glEnableClientState( GL_VERTEX_ARRAY );
        glEnableClientState( GL_COLOR_ARRAY );

        glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, vbos[1]);

        glDrawElements(GL_TRIANGLES, entryCount, GL_UNSIGNED_INT, 0);

        glDisableClientState( GL_VERTEX_ARRAY );
        glDisableClientState( GL_COLOR_ARRAY );
#endif
        glfwSwapBuffers();

        if (glfwGetKey( GLFW_KEY_ESC ) || !glfwGetWindowParam( GLFW_OPENED )) break;
    }

    return 0;
}