313 lines
9.1 KiB
Zig
313 lines
9.1 KiB
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 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,
|
|
};
|
|
const Direction = struct {
|
|
x: i8 = 1,
|
|
y: i8 = 1,
|
|
z: i8 = 1,
|
|
};
|
|
const Point = struct {
|
|
x: i32,
|
|
y: i32,
|
|
z: i32,
|
|
direction: Direction, //for movement state
|
|
};
|
|
const Vec3 = struct {
|
|
a: Point,
|
|
b: Point,
|
|
c: Point,
|
|
};
|
|
const Triangle = struct {
|
|
bufa: *i32,
|
|
bufb: *i32,
|
|
bufc: *i32,
|
|
};
|
|
|
|
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);
|
|
|
|
var vec = Vec3{
|
|
.a = Point{ .x = 20, .y = 30, .z = 0, .direction = .{ .x = 1, .y = 1, .z = 1 } },
|
|
.b = Point{ .x = 50, .y = 40, .z = 0, .direction = .{ .x = 1, .y = 1, .z = 1 } },
|
|
.c = Point{ .x = 30, .y = 1, .z = 0, .direction = .{ .x = 1, .y = 1, .z = 1 } },
|
|
};
|
|
var vec2 = Vec3{
|
|
.a = Point{ .x = 20, .y = 20, .z = 0, .direction = .{ .x = 1, .y = 1, .z = 1 } },
|
|
.b = Point{ .x = 50, .y = 30, .z = 0, .direction = .{ .x = 1, .y = 1, .z = 1 } },
|
|
.c = Point{ .x = 30, .y = 1, .z = 0, .direction = .{ .x = 1, .y = 1, .z = 1 } },
|
|
};
|
|
|
|
_ = 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, 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, vec);
|
|
mv_axis_border_bounce(w, &vec.a, 'x');
|
|
mv_axis_border_bounce(w, &vec.a, 'y');
|
|
mv_axis_border_bounce(w, &vec.b, 'x');
|
|
mv_axis_border_bounce(w, &vec.b, 'y');
|
|
mv_axis_border_bounce(w, &vec.c, 'x');
|
|
mv_axis_border_bounce(w, &vec.c, 'y');
|
|
|
|
try triangle(buffer, w, vec2);
|
|
mv_axis_border_bounce(w, &vec2.a, 'x');
|
|
mv_axis_border_bounce(w, &vec2.a, 'y');
|
|
mv_axis_border_bounce(w, &vec2.b, 'x');
|
|
mv_axis_border_bounce(w, &vec2.b, 'Y');
|
|
mv_axis_border_bounce(w, &vec2.c, 'x');
|
|
mv_axis_border_bounce(w, &vec2.c, 'y');
|
|
|
|
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('X', 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: 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);
|
|
}
|