path: root/src/misc.zig

// Miscellaneous functions
// Copyright (C) 2021  Nguyễn Gia Phong
//
// This file is part of Black Shades.
//
// Black Shades is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published
// by the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// Black Shades is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with Black Shades.  If not, see <https://www.gnu.org/licenses/>.

usingnamespace @cImport({
    @cInclude("AL/al.h");
    @cInclude("GL/gl.h");
    @cInclude("GL/glu.h");
    @cInclude("lodepng.h");
});

const Dir = std.fs.Dir;
const al = @import("zeal");
const allocPrint = std.fmt.allocPrint;
const allocator = std.heap.c_allocator;
const count = std.mem.count;
const cwd = std.fs.cwd;
const data_dir = @import("build_options").data_dir ++ [_]u8{ sep };
const eql = std.mem.eql;
const free = std.c.free;
const join = std.fs.path.joinZ;
const maxInt = std.math.maxInt;
const parseFloat = std.fmt.parseFloat;
const parseInt = std.fmt.parseInt;
const sep = std.fs.path.sep;
const span = std.mem.span;
const std = @import("std");
const tokenize = std.mem.tokenize;

// Don't judge me, take care of me!
const max_size = maxInt(usize);

/// Read given file to heap, allocated by C allocator.
fn readFile(dir: Dir, comptime fmt: []const u8, args: anytype) ![]const u8 {
    const filename = try allocPrint(allocator, fmt, args);
    defer allocator.free(filename);
    return dir.readFileAlloc(allocator, filename, max_size);
}

const Frame = extern struct {
    joints: [20]extern struct {
        x: f32,
        y: f32,
        z: f32,
    },
    speed: f32,
};

export fn loadAnimation(name: [*:0]const u8) extern struct {
    ptr: [*]Frame,
    len: usize,
} {
    var dir = cwd().openDir(data_dir ++ "animations", .{}) catch unreachable;
    defer dir.close();
    const anim_file = readFile(dir, "{s}{c}index.tsv", .{
        name, sep, // $animation/index.tsv
    }) catch unreachable;
    defer allocator.free(anim_file);
    const length = count(u8, anim_file, "\t") - 1;
    const frames = allocator.alloc(Frame, length) catch unreachable;

    var anim = tokenize(anim_file, "\n");
    _ = anim.next().?; // ignore field names
    var i = @as(usize, 0);
    while (i < length) : (i += 1) {
        var values = tokenize(anim.next().?, "\t");
        const frame_file = readFile(dir, "{s}{c}frames{c}{s}.tsv", .{
            name, sep, sep, values.next().?, // $animation/frames/$frame.tsv
        }) catch unreachable;
        defer allocator.free(frame_file);

        var frame = tokenize(frame_file, "\n");
        _ = frame.next().?; // ignore field names
        var j = @as(usize, 0);
        while (frame.next()) |position| {
            var coordinates = tokenize(position, "\t");
            frames[i].joints[j].x = parseFloat(f32, coordinates.next().?)
                catch unreachable;
            frames[i].joints[j].y = parseFloat(f32, coordinates.next().?)
                catch unreachable;
            frames[i].joints[j].z = parseFloat(f32, coordinates.next().?)
                catch unreachable;
            j += 1;
        }
        frames[i].speed = parseFloat(f32, values.next().?) catch unreachable;
    }
    return .{ .ptr = frames.ptr, .len = frames.len };
}

/// Parse boolean values.
pub fn parseBool(s: []const u8) !bool {
    if (eql(u8, s, "false"))
        return false;
    if (eql(u8, s, "true"))
        return true;
    return error.InvalidCharacter;
}

const Joint = extern struct {
    label: i8,
    x: f32,
    y: f32,
    z: f32,
    length: f32,
    model: u8,
    visible: bool,
    lower: bool,
    parent: i8,

    pub fn load(self: *Joint, row: []const u8) !void {
        var values = tokenize(row, "\t");
        self.label = try parseInt(i8, values.next().?, 10);
        self.x = try parseFloat(f32, values.next().?);
        self.y = try parseFloat(f32, values.next().?);
        self.z = try parseFloat(f32, values.next().?);
        self.length = try parseFloat(f32, values.next().?);
        self.model = try parseInt(u8, values.next().?, 10);
        self.visible = try parseBool(values.next().?);
        self.lower = try parseBool(values.next().?);
        self.parent = try parseInt(i8, values.next().?, 10);
    }
};

/// Load joints in character's skeleton.
export fn loadJoints(joints: [*]Joint) void {
    var tsv = tokenize(@embedFile("joints.tsv"), "\n");
    _ = tsv.next().?; // ignore field names
    var i = @as(u8, 0);
    while (tsv.next()) |row| {
        joints[i].load(row) catch unreachable;
        i += 1;
    }
}

const Muscle = extern struct {
    length: f32,
    initlen: f32,
    minlen: f32,
    maxlen: f32,
    flag: bool,
    visible: bool,
    parent1: i8,
    parent2: i8,

    pub fn load(self: *Muscle, row: []const u8) !void {
        var values = tokenize(row, "\t");
        self.length = try parseFloat(f32, values.next().?);
        self.initlen = try parseFloat(f32, values.next().?);
        self.minlen = try parseFloat(f32, values.next().?);
        self.maxlen = try parseFloat(f32, values.next().?);
        self.flag = try parseBool(values.next().?);
        self.visible = try parseBool(values.next().?);
        self.parent1 = try parseInt(i8, values.next().?, 10);
        self.parent2 = try parseInt(i8, values.next().?, 10);
    }
};

/// Load muscles in character's skeleton.
export fn loadMuscles(muscles: [*]Muscle) void {
    var tsv = tokenize(@embedFile("muscles.tsv"), "\n");
    _ = tsv.next().?; // ignore field names
    var i = @as(u8, 0);
    while (tsv.next()) |row| {
        muscles[i].load(row) catch unreachable;
        i += 1;
    }
}

/// Load audio file into an OpenAL buffer and return it.
export fn loadSound(filename: [*:0]const u8) u32 {
    const path = join(allocator, &.{ data_dir ++ "sounds", span(filename) })
        catch unreachable;
    defer allocator.free(path);
    const audio = al.Audio.read(allocator, span(path)) catch unreachable;
    defer audio.free();
    const buffer = al.Buffer.init(audio) catch unreachable;
    return buffer.reference;
}

fn check(errorString: fn (c_uint) callconv(.C) [*c]const u8,
         status: anytype) void {
    if (status != 0)
        @panic(span(errorString(@intCast(c_uint, status))));
}

/// Load PNG file into an OpenGL buffer and return it.
export fn loadTexture(filename: [*:0]const u8) GLuint {
    var dir = cwd().openDir(data_dir ++ "textures", .{}) catch unreachable;
    defer dir.close();
    const file = dir.readFileAlloc(allocator, span(filename), max_size)
        catch unreachable;
    defer allocator.free(file);

    var data: [*c]u8 = undefined;
    var w: c_uint = undefined;
    var h: c_uint = undefined;
    check(lodepng_error_text,
          lodepng_decode32(&data, &w, &h, file.ptr, file.len));
    defer free(data);

    var texture: GLuint = undefined;
    glGenTextures(1, &texture);
    glBindTexture(GL_TEXTURE_2D, texture);
    defer glBindTexture(GL_TEXTURE_2D, 0);
    glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);

    const width = @intCast(GLint, w);
    const height = @intCast(GLint, h);
    glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
    glTexImage2D(GL_TEXTURE_2D, 0, 4, width, height,
                 0, GL_RGBA, GL_UNSIGNED_BYTE, data);
    check(gluErrorString, gluBuild2DMipmaps(GL_TEXTURE_2D, 4, width, height,
                                            GL_RGBA, GL_UNSIGNED_BYTE, data));
    return texture;
}

/// Move sound source to given position and play it.
export fn playSound(source: u32, x: f32, y: f32, z: f32) void {
    const src = al.Source{ .reference = source };
    _ = alGetError(); // TODO: remove when completely migrate to zeal
    src.setPosition(.{ x / 32, y / 32, z / 32 }) catch unreachable;
    src.play() catch unreachable;
}