glfw.nt

module glfw;

macro import std.macro.assert;
macro import std.macro.cimport;

import c_header("GL/gl.h");
import c_header("GL/glext.h", "-include GL/gl.h -DGL_GLEXT_PROTOTYPES");
import c_header("GLFW/glfw3.h");
import c_header("SOIL.h");
import std.math;
import std.math.matrix;
import std.math.vector;
import std.string : toStringz;

pragma(lib, "soil2");
pragma(lib, "GL");
pragma(lib, "glfw");

struct Vertex {
    vec3f pos;
    vec3f color;
    vec2f texCoord;
}

Vertex[] vertices() {
    mut Vertex[] ret;
    float h(int x, int y) {
        if (x >= 4 && x <= 6 && y >= 4 && y <= 6) return 0.3f;
        return 0;
    }
    for (mut int y = 0; y < 10; y += 1) {
        for (mut int x = 0; x < 10; x += 1) {
            auto base = vec3f(x - 5, y - 5, 0);
            auto a = base + vec3f(0, 0, h(x+0, y+0));
            auto b = base + vec3f(0, 1, h(x+0, y+1));
            auto c = base + vec3f(1, 1, h(x+1, y+1));
            auto d = base + vec3f(1, 0, h(x+1, y+0));
            auto n = (c - a).cross(d - b);
            auto l = vec3f(0.4f, 1, 0.2f).normal;
            auto angle = max(0.6f, angle(n, vec3f(0, 0, 0) - l));
            // vec3f col = vec3f(0.6, 0.5, 0.4);
            vec3f col = vec3f(1, 1, 1) * angle;
            ret ~= Vertex(a, col, vec2f(0, 0));
            ret ~= Vertex(b, col, vec2f(0, 1));
            ret ~= Vertex(c, col, vec2f(1, 1));
            ret ~= Vertex(d, col, vec2f(1, 0));
        }
    }
    return ret;
}

string vertexShader() {
    return "#version 330
uniform mat4 MVP;
attribute vec3 vPos;
attribute vec3 vColor;
attribute vec2 vTexPos;
out vec2 texCoord;
flat out vec3 color;
void main()
{
    gl_Position = MVP * vec4(vPos, 1.0);
    color = vColor;
    texCoord = vTexPos;
};";
}

string fragmentShader() {
    return "#version 330
in vec2 texCoord;
flat in vec3 color;
uniform sampler2D tex;
void main()
{
    gl_FragColor = texture2D(tex, texCoord) * vec4(color, 1);
}";
}

class Shader {
    (:vertex | :fragment) kind;

    string source;

    this(this.kind, this.source) { }

    GLuint compile() {
        auto shaderId = glCreateShader(
            kind.case((:vertex): GL_VERTEX_SHADER, (:fragment): GL_FRAGMENT_SHADER));
        mut char* shaderPtr = source.toStringz;
        glShaderSource(shaderId, 1, &shaderPtr, null);
        glCompileShader(shaderId);
        free(shaderPtr);

        mut int isCompiled;
        glGetShaderiv(shaderId, GL_COMPILE_STATUS, &isCompiled);
        if (!isCompiled) {
            mut int maxLength = 0;
            glGetShaderiv(shaderId, GL_INFO_LOG_LENGTH, &maxLength);

            auto errorLog = new string(maxLength);
            glGetShaderInfoLog(shaderId, maxLength, &maxLength, errorLog.ptr);

            print(errorLog);
            assert(false);
        }
        return shaderId;
    }
}

void key_callback(GLFWwindow* window, int key, int scancode, int action, int mods)
{
    auto window = __leak(cast(Window) glfwGetWindowUserPointer(window));

    window.key(key, scancode, action, mods);
}

class Window
{
    GLFWwindow* handle;
    mut bool mut[] keyPressed_;

    mut float lastFrameTime;
    mut float delay;

    this() {
        if (!glfwInit) return;

        glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 2);
        glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 0);

        this.handle = glfwCreateWindow(640, 480, "Simple example".toStringz, null, null);
        if (!this.handle) {
            glfwTerminate;
            return;
        }
        glfwSetWindowUserPointer(this.handle, this);
        glfwSetKeyCallback(this.handle, &key_callback);

        glfwMakeContextCurrent(this.handle);
        glfwSwapInterval(1);
    }

    void key(int key, int scancode, int action, int mods) {
        while (key >= keyPressed_.length) keyPressed_ ~= false;
        if (action == GLFW_PRESS) keyPressed_[key] = true;
        else if (action == GLFW_RELEASE) keyPressed_[key] = false;
    }

    bool keyPressed(int key) {
        if (key >= keyPressed_.length) return false;
        return keyPressed_[key];
    }

    bool shouldClose() {
        return !!glfwWindowShouldClose(this.handle);
    }

    (int width, int height) getFramebufferSize() {
        mut int width, height;
        glfwGetFramebufferSize(this.handle, &width, &height);
        return (width, height);
    }

    void swap() {
        glfwSwapBuffers(this.handle);
        auto time = cast(float) glfwGetTime;
        this.delay = time - this.lastFrameTime;
        this.lastFrameTime = time;
    }

    void poll() {
        glfwPollEvents;
    }

    void destroy() {
        glfwDestroyWindow(this.handle);
        glfwTerminate;
    }
}

class Program {
    Shader vertexShader, fragmentShader;

    GLuint handle;

    this(this.vertexShader, this.fragmentShader) {
        this.handle = glCreateProgram;
        handle.glAttachShader(this.vertexShader.compile);
        handle.glAttachShader(this.fragmentShader.compile);
        handle.glLinkProgram;
    }

    GLuint uniformLocation(string name) {
        auto ptr = name.toStringz;
        auto res = glGetUniformLocation(handle, ptr);
        free(ptr);
        return res;
    }

    GLuint attribLocation(string name) {
        auto ptr = name.toStringz;
        auto res = glGetAttribLocation(handle, ptr);
        free(ptr);
        return res;
    }
}

void main() {
    auto window = new Window;

    glEnable(GL_DEPTH_TEST);

    mut GLuint vertex_buffer;
    glGenBuffers(1, &vertex_buffer);
    glBindBuffer(GL_ARRAY_BUFFER, vertex_buffer);

    auto vertex_shader = new Shader(:vertex, vertexShader);
    auto fragment_shader = new Shader(:fragment, fragmentShader);
    auto program = new Program(vertex_shader, fragment_shader);

    auto mvp_location = program.uniformLocation("MVP");
    auto vpos_location = program.attribLocation("vPos");
    auto vcolor_location = program.attribLocation("vColor");
    auto vtexpos_location = program.attribLocation("vTexPos");

    auto tex = SOIL_load_OGL_texture("some_grass_or_we.png".toStringz,
        SOIL_LOAD_AUTO, SOIL_CREATE_NEW_ID,
        SOIL_FLAG_MIPMAPS | SOIL_FLAG_INVERT_Y | SOIL_FLAG_COMPRESS_TO_DXT);
    assert(tex != 0);

    glEnableVertexAttribArray(vpos_location);
    glVertexAttribPointer(vpos_location, 3, GL_FLOAT, cast(char) false,
                          sizeof(Vertex), null);
    glEnableVertexAttribArray(vcolor_location);
    glVertexAttribPointer(vcolor_location, 3, GL_FLOAT, cast(char) false,
                          sizeof(Vertex), cast(void*) sizeof(vec3f));
    glEnableVertexAttribArray(vtexpos_location);
    glVertexAttribPointer(vtexpos_location, 2, GL_FLOAT, cast(char) false,
                          sizeof(Vertex), cast(void*) sizeof((vec3f, vec3f)));

    mut float rotate = 0;
    mut vec3f base = vec3f(0, 0, 0);
    while (!window.shouldClose) {
        (int width, int height) size = window.getFramebufferSize;
        auto ratio = size.width * 1.0f / size.height;

        auto vertices = vertices;
        glBufferData(GL_ARRAY_BUFFER, sizeof(vertices[0]) * vertices.length, cast(void*) vertices.ptr, GL_STATIC_DRAW);

        glViewport(0, 0, size.width, size.height);
        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

        auto m = mat4x4.identity.rotateX(1).rotateZ(rotate);
        auto p = mat4x4.ortho(-ratio * 5, ratio * 5, -5, 5, 1, -1);
        mut auto mvp = p.mul(m);

        glUseProgram(program.handle);
        glUniformMatrix4fv(mvp_location, 1, cast(char) false, cast(GLfloat*) &mvp);

        glBindTexture(GL_TEXTURE_2D, tex);
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
        glDrawArrays(GL_QUADS, 0, cast(int) vertices.length * 4);

        window.swap;
        window.poll;
        if (window.keyPressed(GLFW_KEY_Q)) rotate += 1.4f * window.delay;
        if (window.keyPressed(GLFW_KEY_E)) rotate -= 1.4f * window.delay;
    }

    // TODO destructor
    window.destroy;
}