zig-learn/main.zig

const std = @import("std");
const expect = std.testing.expect;
const print = std.debug.print;
const getenv = std.posix.getenv;
const ioctl = std.c.ioctl;
const stdout = std.io.getStdOut();
const out = stdout.writer();
const stdin = std.io.getStdIn().reader();
const sleep = std.time.sleep;
const primitive = @import("primitives.zig");
const Point = primitive.Point;

const c = @cImport({
    @cDefine("_NO_CRT_STDIO_INLINE", "1");
    @cInclude("sys/ioctl.h");
    @cInclude("stdio.h");
});

const Winsize = struct {
    ws_row: c_ushort = 0,
    ws_col: c_ushort = 0,
    ws_xpixel: c_ushort = 0,
    ws_ypixel: c_ushort = 0,
};

pub fn main() !void {
    var win = Winsize{};

    win = try getTermDimension();

    print("winsize.ws_row: {}\nws_col: {}\nws_xpixel: {} \nws_ypixel: {}\n", .{ win.ws_row, win.ws_col, win.ws_xpixel, win.ws_ypixel });
    try draw();
}

fn getTermDimension() !Winsize {
    var w = Winsize{};
    var ret: u16 = 0;
    const err = error{CUnknown};
    //print("stdout_fileno: {}\n", .{@TypeOf(std.c.STDOUT_FILENO)});
    ret = @intCast(ioctl(std.c.STDOUT_FILENO, c.TIOCGWINSZ, &w));
    if (ret > 0) {
        return err.CUnknown;
    }
    //print("winsize.ws_row: {}\nws_line: {}\nws_xpixel: {} \nws_ypixel: {}\n", .{ w.ws_row, w.ws_col, w.ws_xpixel, w.ws_ypixel });
    return w;
}

fn draw() !void {
    const allocator = std.heap.page_allocator;

    var w = Winsize{};
    var i: u64 = 0;
    var ii: u64 = 0;
    var buf = std.mem.zeroes([2]u8);
    var slice: []u8 = undefined;
    var bytes_written: u3 = 0;
    var buffer_size: u32 = 0;

    buf[0] = 0;

    w = try getTermDimension();
    buffer_size = w.ws_row;
    buffer_size = buffer_size * w.ws_col * 4;

    var buffer = try allocator.alloc(u8, buffer_size); //utf-8 can be 4 bytes long
    defer allocator.free(buffer);

    primitive.vec3[0].a.x = 10;
    print("primitive.vec3[0].a.x:{}\n", .{primitive.vec3[0].a.x});
    print("primitive.vec3[0].b.x:{}\n", .{primitive.vec3[0].b.x});
    print("primitive.vec3[9].b.x:{}\n", .{primitive.vec3[9].b.x});
    _ = try stdin.readUntilDelimiterOrEof(&buf, '\n');
    //video loop
    while (true) {
        buffer[0] = 0;
        i = 0;
        //clear buffer
        while (i < buffer.len) : (i += 4) {
            slice = buffer[i .. i + 4];
            bytes_written = try std.unicode.utf8Encode(' ', slice);
            ii = 0;
            while ((bytes_written + ii) < 4) : (ii += 1) {
                slice[bytes_written + ii] = 0;
            }
        }
        try triangle(buffer, w, primitive.vec);
        //_ = try bresenham(buffer, w, Point{ .x = 10, .y = 10, .z = 0 }, Point{ .x = 30, .y = 12, .z = 0 });

        try out.print("\x1B[2J", .{});
        //sleep(100000);

        // try triangle(buffer, w, primitive.vec);
        // mv_axis_border_bounce(w, &primitive.vec.a, 'x');
        // mv_axis_border_bounce(w, &primitive.vec.a, 'y');
        // mv_axis_border_bounce(w, &primitive.vec.b, 'x');
        // mv_axis_border_bounce(w, &primitive.vec.b, 'y');
        // mv_axis_border_bounce(w, &primitive.vec.c, 'x');
        // mv_axis_border_bounce(w, &primitive.vec.c, 'y');

        // try triangle(buffer, w, primitive.vec2);
        // mv_axis_border_bounce(w, &primitive.vec2.a, 'x');
        // mv_axis_border_bounce(w, &primitive.vec2.a, 'y');
        // mv_axis_border_bounce(w, &primitive.vec2.b, 'x');
        // mv_axis_border_bounce(w, &primitive.vec2.b, 'Y');
        // mv_axis_border_bounce(w, &primitive.vec2.c, 'x');
        // mv_axis_border_bounce(w, &primitive.vec2.c, 'y');
        //try triangle(buffer, w, primitive.obj.vec);

        try fill_draw(w, buffer);
        try out.print("{s}", .{buffer});
        //_ = try stdin.readUntilDelimiterOrEof(&buf, '\n');
        sleep(30000000);
    }
}
fn fill_draw(w: Winsize, buffer: []u8) !void {
    var i: u64 = 0;
    var ii: u16 = 0;
    var iii: u16 = 0;
    var fill: u8 = 0;
    var start: u16 = 0;
    var end: u16 = 0;
    var code: [4]u8 = std.mem.zeroes([4]u8);
    _ = try std.unicode.utf8Encode('█', &code);

    while (i < buffer.len - w.ws_col * 4) : (i += w.ws_col * 4) {
        var line: []u8 = buffer[i .. i + w.ws_col * 4];
        fill = 0;
        start = 0;
        end = 0;
        ii = 0;
        iii = 0;
        while (ii < line.len - 4) : (ii += 4) {
            const utf_slice: []u8 = line[ii .. ii + 4];
            if (std.mem.eql(u8, utf_slice, &code) == true and fill == 0) {
                fill = 1;
                start = ii;
                iii = ii;
                while (iii < line.len - 4) : (iii += 4) {
                    const lookahead: []u8 = line[iii .. iii + 4];
                    if (std.mem.eql(u8, lookahead, &code) == true) {
                        end = iii;
                    }
                }
            }
            if (ii > start and ii < end and fill == 1 and std.mem.eql(u8, utf_slice, &code) == false) {
                _ = try std.unicode.utf8Encode('●', utf_slice);
            }
        }
    }
}
fn mv_axis_border_bounce(w: Winsize, point: *Point, axis: u8) void {
    var cor = &point.x;
    var dir = &point.direction.x;
    var upper = w.ws_col;

    switch (axis) {
        'x' => {
            cor = &point.x;
            upper = w.ws_col;
            dir = &point.direction.x;
        },
        'y' => {
            cor = &point.y;
            upper = w.ws_row;
            dir = &point.direction.y;
        },
        'X' => {
            cor = &point.x;
            upper = w.ws_col;
            dir = &point.direction.x;
            dir.* = -1;
        },
        'Y' => {
            cor = &point.y;
            upper = w.ws_row;
            dir = &point.direction.y;
            dir.* = -1;
        },
        else => {},
    }

    if (cor.* < upper and cor.* > 0) {
        cor.* += dir.*;
    }
    if (cor.* >= upper or cor.* <= 0) {
        dir.* *= -1;
        cor.* += dir.*;
    }
}

fn pixel(buffer: []u8, w: Winsize, x: i64, y: i64, symbol: u21) !void {
    const i: usize = @intCast(4 * (x + y * w.ws_col));
    if (i < buffer.len) { //-1 ??
        const slice = buffer[i .. i + 4];
        _ = try std.unicode.utf8Encode(symbol, slice);
        //TODO: check length, set not used bytes to zero
    } else {
        //print("Error illegal memory access\n", .{});
    }
}
fn bresenham(buf: []u8, w: Winsize, p1: Point, p2: Point) !void {
    var x: i32 = p1.x;
    var y: i32 = p1.y;
    const dx = (p2.x - p1.x);
    const dy = (p2.y - p1.y);
    var er: i64 = 0;
    if (dx >= dy and dy > 0 and dx > 0) {
        while (x <= p2.x) : (x += 1) {
            _ = try pixel(buf, w, x, y, '█');
            er += dy;
            if (2 * er >= dx) {
                y += 1;
                er -= dx;
            }
        }
    } else if (dx <= dy and dy >= 0 and dx >= 0) {
        while (y <= p2.y) : (y += 1) {
            _ = try pixel(buf, w, x, y, '█');
            er += dx;
            if (2 * er >= dy) {
                x += 1;
                er -= dy;
            }
        }
    } else if (@abs(dy) <= dx and dy <= 0 and dx >= 0) {
        while (x <= p2.x) : (x += 1) {
            _ = try pixel(buf, w, x, y, '█');
            er -= dy;
            if (2 * er >= dx) {
                y -= 1;
                er -= dx;
            }
        }
    } else if (@abs(dy) >= dx and dy <= 0 and dx >= 0) {
        while (y >= p2.y) : (y -= 1) {
            _ = try pixel(buf, w, x, y, '█');
            er += dx;
            if (2 * er >= dy) {
                x += 1;
                er += dy;
            }
        }
    } else if (@abs(dx) <= dy and dx <= 0 and dy >= 0) {
        while (y <= p2.y) : (y += 1) {
            _ = try pixel(buf, w, x, y, '█');
            er += @abs(dx);
            if (2 * er >= dy) {
                x -= 1;
                er -= dy;
            }
        }
    } else if (@abs(dx) >= dy and dy >= 0 and dx <= 0) {
        while (x >= p2.x) : (x -= 1) {
            _ = try pixel(buf, w, x, y, '█');
            er += dy;
            if (2 * er >= @abs(dx)) {
                y += 1;
                er -= @abs(dx);
            }
        }
    } else if (dx <= dy and dx <= 0 and dy <= 0) {
        while (x >= p2.x) : (x -= 1) {
            _ = try pixel(buf, w, x, y, '█');
            er += @abs(dy);
            if (2 * er >= @abs(dx)) {
                y -= 1;
                er -= @abs(dx);
            }
        }
    } else if (dx >= dy and dy <= 0 and dx <= 0) {
        while (y >= p2.y) : (y -= 1) {
            //print("x:{},y:{},er:{},dx:{},dy:{}\n", .{ x, y, er, dx, dy });
            _ = try pixel(buf, w, x, y, '█');
            er += @abs(dx);
            if (2 * er >= @abs(dx)) {
                x -= 1;
                er -= @abs(dy);
            }
        }
    }
}

fn triangle(buffer: []u8, w: Winsize, vec: primitive.Vec3) !void {
    try bresenham(buffer, w, vec.a, vec.b);
    try bresenham(buffer, w, vec.b, vec.c);
    try bresenham(buffer, w, vec.c, vec.a);
}