// Copyright (c) 2009, Thomas Trummer
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are met:
//     * Redistributions of source code must retain the above copyright
//       notice, this list of conditions and the following disclaimer.
//     * Redistributions in binary form must reproduce the above copyright
//       notice, this list of conditions and the following disclaimer in the
//       documentation and/or other materials provided with the distribution.
//     * Neither the name of the <organization> nor the
//       names of its contributors may be used to endorse or promote products
//       derived from this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY Thomas Trummer ''AS IS'' AND ANY
// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
// DISCLAIMED. IN NO EVENT SHALL <copyright holder> BE LIABLE FOR ANY
// DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
// (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
// LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
// ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.


#include <SDL.h>
#include <SDL_opengl.h>

#include <iostream>
#include <sstream>
#include <fstream>
#include <stdexcept>
#include <string>
#include <vector>
#include <algorithm>
#include <cstdio>
#include <ctime>


struct Mesh
{
    std::vector <float>            vertices;
    std::vector <unsigned>     faces;
}
dragonMesh;


void init(const int windowWidth, const int windowHeight, const std::string& windowTitle)
{
    std::stringstream ss;


    if (SDL_Init(SDL_INIT_VIDEO) != 0)
    {
        ss << "Unable to initialize SDL: " << SDL_GetError() << '\n';

        throw std::runtime_error(ss.str());
    }


    SDL_GL_SetAttribute(SDL_GL_RED_SIZE, 8);
    SDL_GL_SetAttribute(SDL_GL_GREEN_SIZE, 8);
    SDL_GL_SetAttribute(SDL_GL_BLUE_SIZE, 8);
    SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 24);
    SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);


    SDL_WM_SetCaption(windowTitle.c_str(), 0);


    if ((SDL_SetVideoMode(windowWidth, windowHeight, 0, SDL_OPENGL)) == NULL)
    {
        ss << "Couldn't set GL mode: " << SDL_GetError() << '\n';

        throw std::runtime_error(ss.str());
    }


    std::cout << "GL_VENDOR     : " << glGetString(GL_VENDOR)     << std::endl;
    std::cout << "GL_RENDERER : " << glGetString(GL_RENDERER) << std::endl;
    std::cout << "GL_VERSION    : " << glGetString(GL_VERSION)    << std::endl;

    std::cout << std::endl;


    // Setup the window and view port
    glViewport(0, 0, windowWidth, windowHeight);

    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();

    gluPerspective(45.0f, GLfloat(windowWidth) / GLfloat(windowHeight), 0.1f, 1000.0f);

    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();


    // Enable back face culling
    glEnable(GL_CULL_FACE);

    // Enable smooth shading
    glShadeModel(GL_SMOOTH);

    // Enable the depth buffer
    glEnable(GL_DEPTH_TEST);

    // Setup depth buffer
    glClearDepth(1.0f);

    // Set the depth buffer function
    glDepthFunc(GL_LEQUAL);

    // Enable vertex and and normal arrays
    glEnableClientState(GL_VERTEX_ARRAY);
    glEnableClientState(GL_NORMAL_ARRAY);

    // Set correct perspective correction
    glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
}


void initScene()
{
    glEnable(GL_COLOR_MATERIAL);

    glColorMaterial(GL_FRONT, GL_AMBIENT_AND_DIFFUSE);
    glMateriali(GL_FRONT, GL_SHININESS, 96);

    float specReflection[] = { 0.8f, 0.8f, 0.8f, 1.0f };
    glMaterialfv(GL_FRONT, GL_SPECULAR, specReflection);


    glEnable(GL_LIGHT0);

    // Define the light components and position
    GLfloat ambient[] = {    0.2f, 0.2f, 0.2f, 1.0f };
    GLfloat diffuse[] = {    0.8f, 0.8f, 0.8f, 1.0f };
    GLfloat specular[] = {    0.5f, 0.5f, 0.5f, 1.0f };
    GLfloat position[] = { 10.0f, 10.0f, 0.0f, 0.0f };

    // Define the light components and position
    glLightfv(GL_LIGHT0, GL_AMBIENT, ambient);
    glLightfv(GL_LIGHT0, GL_DIFFUSE, diffuse);
    glLightfv(GL_LIGHT0, GL_SPECULAR, specular);
    glLightfv(GL_LIGHT0, GL_POSITION, position);

    // Define the camera
    gluLookAt(0, 0.12, 0.24, 0, 0.12, 0, 0, 1, 0);
}


void done()
{
    SDL_Quit();
}


void drawModelVA(const Mesh& mesh)
{
    int maxIndices;

    glGetIntegerv(GL_MAX_ELEMENTS_INDICES, &maxIndices);


    glVertexPointer(3, GL_FLOAT, 24, &mesh.vertices[0]);
    glNormalPointer(GL_FLOAT, 24, &mesh.vertices[3]);


    for (size_t n = 0; n < mesh.faces.size() / 3; n += maxIndices)
    {
        const int count = std::min(maxIndices, int(mesh.faces.size() / 3 - n));

        glDrawElements(GL_TRIANGLES, count * 3, GL_UNSIGNED_INT, &dragonMesh.faces[n * 3]);
    }
}


bool paintGL()
{
    glClear(GL_DEPTH_BUFFER_BIT);


    glMatrixMode(GL_PROJECTION);
    glPushMatrix();
    glLoadIdentity();

    glOrtho(0.0, 1.0, 0.0, 1.0, -1, 1);

    glMatrixMode(GL_MODELVIEW);
    glPushMatrix();
    glLoadIdentity();


    glDisable(GL_DEPTH_TEST);
    glDisable(GL_LIGHTING);

    // Draw the background gradient
    glBegin(GL_QUADS);
    {
        glColor3ub(0x3B, 0x3B, 0x75);
        glVertex2f(0.0f, 0.0f);
        glVertex2f(1.0f, 0.0f);

        glColor3ub(0x00, 0x00, 0x00);
        glVertex2f(1.0f, 1.0f);
        glVertex2f(0.0f, 1.0f);
    }
    glEnd();


    // Restore the 3D projection
    glMatrixMode(GL_PROJECTION);
    glPopMatrix();

    glMatrixMode(GL_MODELVIEW);
    glPopMatrix();


    glEnable(GL_DEPTH_TEST);
    glEnable(GL_LIGHTING);


    // Set the color of the model
    glColor3ub(0x90, 0x80, 0x90);

    // Draw the model using vertex arrays
    drawModelVA(dragonMesh);

    // Draw the current frame
    SDL_GL_SwapBuffers();



    static int steps = 0;

    // Rotate for 2 degrees
    glRotatef(2.0f, 0, 1, 0);

    // Return true if a full rotation was done
    return (steps++ == 180) ? (steps = 0, true) : false;
}


void runEventLoop()
{
    static std::clock_t startTime = std::clock();

    while (true)
    {
        SDL_Event event;

        if (SDL_PollEvent(&event))
        {
            if (event.type == SDL_QUIT)
                break;
        }
        else
        {
            // Render the next frame and test if a full turn was completed
            if (paintGL())
            {
                // Get the time it took to render a full turn
                double time = double(std::clock() - startTime) / CLOCKS_PER_SEC;

                // Print the current frames per second
                std::printf("%.1lf seconds for 180 frames = %.1lf FPS\n", time, 180 / time);

                // Restart the timer
                startTime = std::clock();
            }
        }
    }
}


void loadMesh(const std::string& fileName, Mesh& mesh)
{
    std::ifstream in(fileName.c_str(), std::ios::binary);


    if (!in.is_open())
    {
        std::stringstream ss;

        ss << "Unable to open file: " << fileName << '\n';

        throw std::runtime_error(ss.str());

    }


    mesh.vertices.resize(100139 * 6);
    in.read(reinterpret_cast<char*>(&mesh.vertices[0]), 100139 * 6 * 4);


    mesh.faces.resize(200198 * 3);
    for (unsigned i = 0; i < 200198; i++)
    {
        in.seekg(1, std::ios::cur);

        in.read(reinterpret_cast<char*>(&mesh.faces[i * 3]), 3 * 4);
    }
}


int main()
{
    try
    {
        loadMesh("dragon.mesh", dragonMesh);

        init(640, 480, "glxdragon");

        initScene();

        runEventLoop();
    }
    catch(std::runtime_error & e)
    {
        std::cerr << e.what();
    }

    done();
}