2024-10-30 09:38:15 +00:00
|
|
|
const std = @import("std");
|
|
|
|
const term = @import("term.zig");
|
|
|
|
const Winsize = term.Winsize;
|
|
|
|
|
2024-10-29 10:47:39 +00:00
|
|
|
pub const Direction = struct {
|
|
|
|
x: i8 = 1,
|
|
|
|
y: i8 = 1,
|
|
|
|
z: i8 = 1,
|
|
|
|
};
|
|
|
|
pub const Point = struct {
|
2024-10-29 14:02:03 +00:00
|
|
|
x: i32 = 0,
|
|
|
|
y: i32 = 0,
|
|
|
|
z: i32 = 0,
|
2024-10-31 10:38:03 +00:00
|
|
|
direction: Direction = .{ .x = 1, .y = 1, .z = 1 }, //for movement state
|
2024-10-29 10:47:39 +00:00
|
|
|
};
|
|
|
|
pub const Vec3 = struct {
|
2024-10-29 14:02:03 +00:00
|
|
|
a: Point = .{ .x = 0, .y = 0, .z = 0, .direction = .{ .x = 0, .y = 0, .z = 0 } },
|
|
|
|
b: Point = .{ .x = 0, .y = 0, .z = 0, .direction = .{ .x = 0, .y = 0, .z = 0 } },
|
|
|
|
c: Point = .{ .x = 0, .y = 0, .z = 0, .direction = .{ .x = 0, .y = 0, .z = 0 } },
|
2024-10-29 10:47:39 +00:00
|
|
|
};
|
|
|
|
pub const Triangle = struct {
|
|
|
|
bufa: *i32,
|
|
|
|
bufb: *i32,
|
|
|
|
bufc: *i32,
|
|
|
|
};
|
2024-10-30 09:38:15 +00:00
|
|
|
|
2024-10-31 10:38:03 +00:00
|
|
|
pub fn LinkedList() type {
|
|
|
|
return struct {
|
|
|
|
const Self = @This(); //means this struc,ref to the most inner scope
|
2024-10-30 13:56:09 +00:00
|
|
|
|
2024-10-31 10:38:03 +00:00
|
|
|
const Node = struct { point: Point, next: ?*Node };
|
|
|
|
head: ?*Node,
|
|
|
|
length: u32,
|
2024-10-30 13:56:09 +00:00
|
|
|
|
2024-10-31 10:38:03 +00:00
|
|
|
pub fn new() Self {
|
|
|
|
return .{
|
|
|
|
.head = null,
|
|
|
|
.length = 0,
|
|
|
|
};
|
|
|
|
}
|
|
|
|
pub fn add(self: *Self, allocator: std.mem.Allocator, point: Point) void {
|
|
|
|
var newNode = allocator.create(Node) catch |err| {
|
|
|
|
std.debug.print("error allocation, {}", .{err});
|
|
|
|
return;
|
|
|
|
};
|
|
|
|
|
|
|
|
newNode.point = point;
|
|
|
|
newNode.next = self.head;
|
|
|
|
|
|
|
|
self.head = newNode;
|
|
|
|
self.length += 1;
|
|
|
|
}
|
|
|
|
pub fn dump(self: *Self) ![]Point {
|
|
|
|
const allocator = std.heap.page_allocator;
|
|
|
|
var node = self.head;
|
|
|
|
var point: []Point = &.{}; //empty slice
|
|
|
|
var i: usize = 0;
|
|
|
|
|
|
|
|
while (node != null) : (i += 1) {
|
|
|
|
point = allocator.realloc(point, i + 1) catch |err| {
|
|
|
|
std.debug.print("error allocation for slice:{}\n", .{err});
|
|
|
|
return err;
|
|
|
|
};
|
|
|
|
point[i] = node.?.point;
|
|
|
|
node = node.?.next;
|
|
|
|
}
|
|
|
|
//TODO: free memory but how to?, when out of scope or dont use slices? or copy them, or outsource allocation?
|
|
|
|
return point;
|
|
|
|
}
|
|
|
|
};
|
|
|
|
}
|
|
|
|
test "test linked list" {
|
|
|
|
var polygon = LinkedList().new();
|
|
|
|
polygon.add(std.heap.page_allocator, .{ .x = 10, .y = 11, .z = 0 });
|
|
|
|
polygon.add(std.heap.page_allocator, .{ .x = 11, .y = 12, .z = 0 });
|
|
|
|
polygon.add(std.heap.page_allocator, .{ .x = 12, .y = 13, .z = 0 });
|
|
|
|
polygon.add(std.heap.page_allocator, .{ .x = 12, .y = 14, .z = 0 });
|
|
|
|
polygon.add(std.heap.page_allocator, .{ .x = 12, .y = 15, .z = 0 });
|
|
|
|
polygon.add(std.heap.page_allocator, .{ .x = 12, .y = 16, .z = 0 });
|
|
|
|
const points: []Point = try polygon.dump();
|
|
|
|
for (points) |point| {
|
|
|
|
std.debug.print("x:{}\n", .{point.x});
|
|
|
|
std.debug.print("y:{}\n", .{point.y});
|
|
|
|
std.debug.print("z:{}\n", .{point.z});
|
|
|
|
}
|
|
|
|
std.heap.page_allocator.free(points);
|
|
|
|
}
|
2024-10-30 13:56:09 +00:00
|
|
|
|
2024-10-30 09:38:15 +00:00
|
|
|
pub 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", .{});
|
|
|
|
}
|
|
|
|
}
|
|
|
|
pub 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);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
pub fn triangle(buffer: []u8, w: Winsize, vector: Vec3) !void {
|
|
|
|
try bresenham(buffer, w, vector.a, vector.b);
|
|
|
|
try bresenham(buffer, w, vector.b, vector.c);
|
|
|
|
try bresenham(buffer, w, vector.c, vector.a);
|
|
|
|
}
|