graphics: fix line offset

3 files changed, 46 insertions, 34 deletions

diff --git a/src/estd/graphics/curve.zig b/src/estd/graphics/curve.zig
index d4be1d7..70569a3 100644
--- a/src/estd/graphics/curve.zig
+++ b/src/estd/graphics/curve.zig
@@ -14,6 +14,14 @@ pub const Curve = struct {
 
 	color: graphics.Color,
 
+	fn distance(a: u32, b: u32) u32 {
+		if (a > b) {
+			return a - b;
+		} else {
+			return b - a;
+		}
+	}
+
 	pub fn render(self: *const Self, canvas: *const graphics.Canvas) void {
 		const start_x: f64 = @floatFromInt(self.start.x);
 		const start_y: f64 = @floatFromInt(self.start.y);
@@ -21,16 +29,30 @@ pub const Curve = struct {
 		const middle_y: f64 = @floatFromInt(self.middle.y);
 		const end_x: f64 = @floatFromInt(self.end.x);
 		const end_y: f64 = @floatFromInt(self.end.y);
+		const resolution = 2 + (
+			distance(self.start.x, self.end.x) + distance(self.start.y, self.end.y)
+		) / 8;
+
+		var last = self.start;
 
-		for (0..100) |index| {
-			const t: f64 = @as(f64, @floatFromInt(index)) / 100;
+		canvas.buffer[last.x + last.y * canvas.width] = .{ .red = 0xff, .green = 0xff, .blue = 0xff };
+
+		for (1..resolution) |index| {
+			const t: f64 = @as(f64, @floatFromInt(index)) / @as(f64, @floatFromInt(resolution));
 			const x: u32 = @intFromFloat(@round(
 				(1 - t) * ((1 - t) * start_x + t * middle_x) + t * ((1 - t) * middle_x + t * end_x)
 			));
 			const y: u32 = @intFromFloat(@round(
 				(1 - t) * ((1 - t) * start_y + t * middle_y) + t * ((1 - t) * middle_y + t * end_y)
 			));
-			canvas.buffer[x + canvas.width * y] = self.color;
+
+			(graphics.Line {
+				.start = .{ .x = last.x, .y = last.y },
+				.end = .{ .x = x, .y = y },
+				.color = self.color,
+			}).render(canvas);
+
+			last = .{ .x = x, .y = y };
 		}
 	}
 };
diff --git a/src/estd/graphics/line.zig b/src/estd/graphics/line.zig
index 93f17ff..faf801a 100644
--- a/src/estd/graphics/line.zig
+++ b/src/estd/graphics/line.zig
@@ -42,32 +42,31 @@ pub const Line = struct {
 			gradient = 1;
 		}
 
-
 		var intersect_y: f64 = @floatFromInt(start.y);
 
 		if (steep) {
 			for (start.x..end.x + 1) |x| {
-				const y: usize = @intFromFloat(intersect_y);
+				const y: u64 = @intFromFloat(intersect_y);
 				const factor = intersect_y - @as(f64, @floatFromInt(y));
 
-				var previous_color = canvas.buffer[canvas.width * x + y];
-				canvas.buffer[x * canvas.width + y] = previous_color.mix(&self.color, factor);
+				var previous_color = canvas.buffer[x * canvas.width + y];
+				canvas.buffer[x * canvas.width + y] = self.color.mix(&previous_color, factor);
 
-				previous_color = canvas.buffer[x * canvas.width + y - 1];
-				canvas.buffer[x * canvas.width + y - 1] = self.color.mix(&previous_color, factor);
+				previous_color = canvas.buffer[canvas.width * x + y + 1];
+				canvas.buffer[x * canvas.width + y + 1] = previous_color.mix(&self.color, factor);
 
 				intersect_y += gradient;
 			}
 		} else {
 			for (start.x..end.x + 1) |x| {
-				const y: u32 = @intFromFloat(intersect_y);
+				const y: u64 = @intFromFloat(intersect_y);
 				const factor = intersect_y - @as(f64, @floatFromInt(y));
 
 				var previous_color = canvas.buffer[x + canvas.width * y];
-				canvas.buffer[x + canvas.width * y] = previous_color.mix(&self.color, factor);
+				canvas.buffer[x + canvas.width * y] = self.color.mix(&previous_color, factor);
 
-				previous_color = canvas.buffer[x + canvas.width * (y - 1)];
-				canvas.buffer[x + canvas.width * (y - 1)] = self.color.mix(&previous_color, factor);
+				previous_color = canvas.buffer[x + canvas.width * (y + 1)];
+				canvas.buffer[x + canvas.width * (y + 1)] = previous_color.mix(&self.color, factor);
 
 				intersect_y += gradient;
 			}
diff --git a/src/screen/main.zig b/src/screen/main.zig
index 2cb8c03..0ee7e17 100644
--- a/src/screen/main.zig
+++ b/src/screen/main.zig
@@ -31,41 +31,32 @@ pub fn main() !void {
 	const center_x = (buffer.current.width / 2);
 	const center_y = (buffer.current.height / 2);
 
-	var line = graphics.Line {
+	var curve = graphics.Curve {
 		.start = .{ .x = center_x, .y = center_y },
+		.middle = .{ .x = center_x, .y = center_y + 150 },
 		.end = .{ .x = center_x + 110 , .y = center_y + 100  },
 		.color = .{ .red = 0xff, .green = 0, .blue = 0 },
 	};
 
 	var last_duration: f64 = 0;
 	var delta: f64 = 0;
-	var angle: f64 = 0;
 
 	while (true) {
 		const start = try std.time.Instant.now();
 		const canvas = buffer.canvas();
 
-		canvas.fill(.{ .red = 0x25, .green = 0x25, .blue = 0x25 });
+		canvas.fill(.{ .red = 0x5, .green = 0x5, .blue = 0x5 });
 
-		(graphics.Box {
-			.x = center_x - 100,
-			.y = center_y - 100,
-			.width = 200,
-			.height = 200,
-			.radius = 100,
-			.color = .{ .red = 0xff, .green = 0xff, .blue = 0xff },
-		}).render(&canvas);
+		//(graphics.Box {
+		//	.x = center_x - 100,
+		//	.y = center_y - 100,
+		//	.width = 200,
+		//	.height = 200,
+		//	.radius = 100,
+		//	.color = .{ .red = 0xff, .green = 0xff, .blue = 0xff },
+		//}).render(&canvas);
 
-		line.render(&canvas);
-		const cos = @cos(std.math.degreesToRadians(angle));
-		const sin = @sin(std.math.degreesToRadians(angle));
-		line.end.x = @intCast(@as(i64, @intCast(center_x)) + @as(i64, @intFromFloat(100 * cos)));
-		line.end.y = @intCast(@as(i64, @intCast(center_y)) + @as(i64, @intFromFloat(100 * sin)));
-
-		angle += delta;
-		if (angle > 360) {
-			angle = 0;
-		}
+		curve.render(&canvas);
 
 		const end = try std.time.Instant.now();
 		const duration: f64 = @floatFromInt(end.since(start));