// Timestep Example Source Code
// Copyright (c) Glenn Fiedler 2004
// http://www.gaffer.org/articles

bool openDisplay(int width, int height);
void updateDisplay();
void closeDisplay();
void onQuit();
float time();

#include "Apple.h"
#include "Windows.h"

bool quit = false;

void onQuit()
{
    quit = true;
}

struct State
{
    float x;
    float v;
};

struct Derivative
{
    float dx;
    float dv;
};

State interpolate(const State &previous, const State &current, float alpha)
{
    State state;
    state.x = current.x*alpha + previous.x*(1-alpha);
    state.v = current.v*alpha + previous.v*(1-alpha);
    return state;
}

float acceleration(const State &state, float t)
{
    const float k = 10;
    const float b = 1;
    return - k*state.x - b*state.v;
}

Derivative evaluate(const State &initial, float t)
{
    Derivative output;
    output.dx = initial.v;
    output.dv = acceleration(initial, t);
    return output;
}

Derivative evaluate(const State &initial, float t, float dt, const Derivative &d)
{
    State state;
    state.x = initial.x + d.dx*dt;
    state.v = initial.v + d.dv*dt;
    Derivative output;
    output.dx = state.v;
    output.dv = acceleration(state, t+dt);
    return output;
}

void integrate(State &state, float t, float dt)
{
    Derivative a = evaluate(state, t);
    Derivative b = evaluate(state, t, dt*0.5f, a);
    Derivative c = evaluate(state, t, dt*0.5f, b);
    Derivative d = evaluate(state, t, dt, c);

    const float dxdt = 1.0f/6.0f * (a.dx + 2.0f*(b.dx + c.dx) + d.dx);
    const float dvdt = 1.0f/6.0f * (a.dv + 2.0f*(b.dv + c.dv) + d.dv);

    state.x = state.x + dxdt*dt;
    state.v = state.v + dvdt*dt;
}

int main()
{
    const int width = 640;
    const int height = 480;

    if (!openDisplay("Timestep", width, height))
        return 1;

    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    gluPerspective(45.0, 4.0/3.0, 1, 1000);

    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();
    gluLookAt(0,0,150, 0,0,0, 0,1,0);

    glHint(GL_POINT_SMOOTH_HINT, GL_NICEST);
    glEnable(GL_POINT_SMOOTH);
    glPointSize(4);

    glClearColor(0.3f, 0.3f, 0.3f, 1);

    State current;
    current.x = 100;
    current.v = 0;

    State previous = current;

    float t = 0.0f;
    float dt = 0.1f;

    float currentTime = 0.0f;
    float accumulator = 0.0f;

    while (!quit)
    {
        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

        const float newTime = time();
        float deltaTime = newTime - currentTime;
        currentTime = newTime;

        if (deltaTime>0.25f)
            deltaTime = 0.25f;

        accumulator += deltaTime;

        while (accumulator>=dt)
        {
            accumulator -= dt;
            previous = current;
            integrate(current, t, dt);
            t += dt;
        }

        State state = interpolate(previous, current, accumulator/dt);

        glBegin(GL_POINTS);
        glColor3f(1,1,1);
        glVertex3f(state.x, 0, 0);
        glEnd();

        updateDisplay();
    }

    closeDisplay();

    return 0;
}