ohai.zig

const std = @import("std");

const console = @import("console.zig");
const gl = @import("gfx.zig").gl;
const timing = @import("timing.zig");
const ui = @import("ui.zig");

// Rect demo
//
const rect_demo = struct {
    const vert_src =
        \\attribute vec4 a_position;
        \\attribute vec4 a_color;
        \\varying vec4 v_position;
        \\varying vec4 v_color;
        \\void main() {
        \\  v_color = a_color;
        \\  gl_Position = a_position;
        \\  v_position = gl_Position;
        \\}
    ;

    const frag_src =
        \\precision mediump float;
        \\varying vec4 v_position;
        \\varying vec4 v_color;
        \\void main() {
        \\  gl_FragColor = vec4(v_color.xyz, 1.0);
        \\}
    ;

    var prog: c_uint = undefined;
    var pos_attrib: c_int = undefined;
    var col_attrib: c_int = undefined;

    var pos_buf: c_uint = undefined;
    var col_buf: c_uint = undefined;
    var ind_buf: c_uint = undefined;

    var size: f32 = 2;

    fn init() void {
        const vert = gl.setupShader(gl.VERTEX_SHADER, vert_src);
        defer gl.deleteShader(vert);
        const frag = gl.setupShader(gl.FRAGMENT_SHADER, frag_src);
        defer gl.deleteShader(frag);
        prog = gl.setupProgram(vert, frag);
        pos_attrib = gl.getAttribLocation(prog, "a_position");
        col_attrib = gl.getAttribLocation(prog, "a_color");

        pos_buf = gl.createBuffer();
        col_buf = gl.createBuffer();
        ind_buf = gl.createBuffer();

        gl.bindBuffer(gl.ARRAY_BUFFER, col_buf);
        gl.bufferData(gl.ARRAY_BUFFER, &[_]f32{
            0, 1, 0.5,
            0, 0, 0.5,
            1, 1, 0.5,
            1, 0, 0.5,
        }, gl.STATIC_DRAW);

        gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, ind_buf);
        gl.bufferData(gl.ELEMENT_ARRAY_BUFFER, &[_]c_ushort{
            0, 1, 2,
            2, 1, 3,
        }, gl.STATIC_DRAW);
    }

    fn deinit() void {
        gl.deleteBuffer(ind_buf);
        gl.deleteBuffer(col_buf);
        gl.deleteBuffer(pos_buf);
        gl.deleteProgram(prog);
    }

    fn draw() void {
        gl.useProgram(prog);

        gl.bindBuffer(gl.ARRAY_BUFFER, pos_buf);
        gl.enableVertexAttribArray(pos_attrib);
        gl.vertexAttribPointer(pos_attrib, 2, gl.FLOAT, false, 0, 0);
        gl.bufferData(gl.ARRAY_BUFFER, &[_]f32{
            -0.1 * size, 0.1 * size,
            -0.1 * size, -0.1 * size,
            0.1 * size,  0.1 * size,
            0.1 * size,  -0.1 * size,
        }, gl.DYNAMIC_DRAW);

        gl.bindBuffer(gl.ARRAY_BUFFER, col_buf);
        gl.enableVertexAttribArray(col_attrib);
        gl.vertexAttribPointer(col_attrib, 3, gl.FLOAT, false, 0, 0);

        gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, ind_buf);

        gl.drawElements(gl.TRIANGLES, 6, gl.UNSIGNED_SHORT, 0);
    }

    fn ui() void {
        ui.elemOpen("div", .{ .class = "section" });
        {
            ui.elemOpen("button", .{ .class = "plus" });
            if (ui.event("click")) {
                size += 1;
            }
            ui.elemClose("button");

            var tmp: [64]u8 = undefined;
            ui.elemOpen("input", .{
                .type = "number",
                .step = "any",
                .value = std.fmt.bufPrint(&tmp, "{d:.2}", .{size}) catch unreachable,
            });
            if (ui.event("change")) {
                size = std.fmt.parseFloat(f32, ui.value(&tmp)) catch size;
                ui.setValue(std.fmt.bufPrint(&tmp, "{d:.2}", .{size}) catch unreachable);
            }
            ui.elemClose("input");

            ui.elemOpen("button", .{ .class = "minus" });
            if (ui.event("click")) {
                size -= 1;
            }
            ui.elemClose("button");
        }
        ui.elemClose("div");
    }
};

// Text input demo
//
const text_input_demo = struct {
    var text_buf: [16]u8 = undefined;
    var text: []u8 = text_buf[0..0];

    fn ui() void {
        ui.elemOpen("div", .{ .class = "section" });
        {
            ui.elemOpen("input", .{
                .value = text,
                .placeholder = "type here!",
            });
            if (ui.event("input")) {
                text = ui.value(&text_buf);
                ui.setValue(text);
            }
            ui.elemClose("input");
        }
        ui.elemClose("div");
        ui.elemOpen("div", .{ .class = "section" });
        {
            var tmp: [text_buf.len + 32]u8 = undefined;
            ui.text(std.fmt.bufPrint(&tmp, "text: {}", .{text}) catch "");
        }
        ui.elemClose("div");
    }
};

// Top level
//
pub const panic = console.panic; // Install panic handler

export fn init() void {
    console.log("hello from zig!\n");

    rect_demo.init();
}

export fn deinit() void {
    rect_demo.deinit();
}

export fn frame() void {
    timing.frame();

    gl.setupViewport();

    gl.clearColor(0.2, 0.1, 0.1 + 0.3 * @sin(@floatCast(f32, timing.t)), 1);
    gl.clear(gl.COLOR_BUFFER_BIT);

    rect_demo.draw();
}

export fn uiSide() void {
    ui.elemOpen("div", .{ .class = "section" });
    ui.text("hello from zig! :O");
    ui.elemClose("div");

    rect_demo.ui();

    text_input_demo.ui();
}

export fn uiBottom() void {
    ui.elemOpen("div", .{ .class = "status" });
    var tmp: [16]u8 = undefined;
    ui.text(std.fmt.bufPrint(&tmp, "fps: {}", .{@floatToInt(i32, @round(timing.fps))}) catch "");
    ui.elemClose("div");
}