8 files changed, 160 insertions, 72 deletions

diff --git a/src/blender/blender.c b/src/blender/blender.c
deleted file mode 100644
index 08cafa4..0000000
--- a/src/blender/blender.c
+++ /dev/null
@@ -1,39 +0,0 @@
-#include "blender/blender.h"
-#include <assert.h>
-#include <math.h>
-
-static inline ColorComponent blend_components(ColorComponent origin, ColorComponent target, TimeVector frame) {
-  // https://www.youtube.com/watch?v=LKnqECcg6Gw
-  return (ColorComponent) sqrt((TIME_UNIT - frame) * pow(origin, 2) + frame * pow(target, 2));
-}
-
-static inline Color blend_colors(Color origin, Color target, TimeVector frame) {
-  return (Color) {{blend_components(origin.rgba.r, target.rgba.r, frame),
-                   blend_components(origin.rgba.g, target.rgba.g, frame),
-                   blend_components(origin.rgba.b, target.rgba.b, frame),
-                   blend_components(origin.rgba.a, target.rgba.a, frame)}};
-}
-
-void blender_blend_canvas(Canvas *canvas, Canvas *source, Canvas *target, Morphing *morphing, TimeVector frame) {
-  IntVector flat_dim;
-  CartesianVector dim, point;
-  CartesianMapping mapping;
-  Color pixel;
-
-  dim = morphing->dim;
-
-  assert(dim.x > 0 && dim.y > 0);
-  assert(vector_equals(dim, canvas_get_dim(canvas)));
-  assert(vector_equals(dim, canvas_get_dim(source)));
-  assert(vector_equals(dim, canvas_get_dim(target)));
-  assert(frame >= TIME_ORIGIN && frame <= TIME_UNIT);
-
-  for (flat_dim = (dim.x - 1) * (dim.y - 1); flat_dim >= 0; --flat_dim) {
-    point.x = flat_dim % dim.y;
-    point.y = flat_dim / dim.y;
-
-    mapping = (CartesianMapping) {point, point};
-    pixel = blend_colors(canvas_get_pixel(source, mapping.origin), canvas_get_pixel(target, mapping.target), frame);
-    canvas_set_pixel(canvas, point, pixel);
-  }
-}
diff --git a/src/blender/canvas.c b/src/blender/canvas.c
deleted file mode 100644
index b7cd9dc..0000000
--- a/src/blender/canvas.c
+++ /dev/null
@@ -1,23 +0,0 @@
-#include "blender/canvas.h"
-
-void canvas_init(Canvas *canvas, IntVector width, IntVector height) {
-  canvas->mlv = MLV_create_image(width, height);
-}
-
-void canvas_free(Canvas *canvas) {
-  MLV_free_image(canvas->mlv);
-}
-
-void canvas_set_pixel(Canvas *canvas, CartesianVector position, Color color) {
-  MLV_set_pixel_on_image(position.x, position.y, color.mlv, canvas->mlv);
-}
-
-Color canvas_get_pixel(Canvas *canvas, CartesianVector position) {
-  int r, g, b, a;
-  MLV_get_pixel_on_image(canvas->mlv, position.x, position.y, &r, &g, &b, &a);
-  return (Color) {{r, g, b, a}};
-}
-
-CartesianVector canvas_get_dim(Canvas *canvas) {
-  return (CartesianVector) {MLV_get_image_width(canvas->mlv), MLV_get_image_height(canvas->mlv)};
-}
diff --git a/src/blender/color.c b/src/blender/color.c
deleted file mode 100644
index f92fba9..0000000
--- a/src/blender/color.c
+++ /dev/null
@@ -1,8 +0,0 @@
-#include "blender/color.h"
-
-bool color_equals(Color c1, Color c2) {
-  return c1.rgba.r == c2.rgba.r &&
-         c1.rgba.g == c2.rgba.g &&
-         c1.rgba.b == c2.rgba.b &&
-         c1.rgba.a == c2.rgba.a;
-}
diff --git a/src/common/geom.c b/src/common/geom.c
index 219270f..eb35727 100644
--- a/src/common/geom.c
+++ b/src/common/geom.c
@@ -1,6 +1,12 @@
 #include "common/geom.h"
+#include <math.h>
+#include <common/geom.h>
 #include "morpher/matrix.h"
 
+static inline IntVector int_round(RealVector x) {
+  return (IntVector) round(x);
+}
+
 CartesianMapping m(int x, int y) {
   return (CartesianMapping) {{x, y},
                              {x, y}};
@@ -10,6 +16,10 @@ CartesianVector v(int x, int y) {
   return (CartesianVector) {x, y};
 }
 
+BarycentricVector b(double a, double b) {
+  return (BarycentricVector) {a, b};
+}
+
 bool mappings_equals(CartesianMapping m1, CartesianMapping m2) {
   return vector_equals(m1.origin, m2.origin) && vector_equals(m1.target, m2.target);
 }
@@ -18,7 +28,22 @@ bool vector_equals(CartesianVector v1, CartesianVector v2) {
   return v1.x == v2.x && v1.y == v2.y;
 }
 
-IntVector triangle_area(CartesianVector v1, CartesianVector v2, CartesianVector v3) {
+bool barycentric_vector_equals(BarycentricVector b1, BarycentricVector b2) {
+  return b1.a == b2.a && b1.b == b2.b;
+}
+
+IntVector square_area(CartesianVector v1, CartesianVector v2, CartesianVector v3) {
   return matrix_int_det2(v1.x - v3.x, v2.x - v3.x,
                          v1.y - v3.y, v2.y - v3.y);
 }
+
+BarycentricVector cartesian_to_barycentric(Triangle t, CartesianVector p) {
+  RealVector total_area = square_area(t.v[0], t.v[1], t.v[2]);
+  return (BarycentricVector) {square_area(t.v[1], t.v[2], p) / total_area,
+                              square_area(t.v[2], t.v[0], p) / total_area};
+}
+
+CartesianVector barycentric_to_cartesian(Triangle t, BarycentricVector p) {
+  return (CartesianVector) {int_round(p.a * (t.v[0].x - t.v[2].x) + p.b * (t.v[1].x - t.v[2].x) + t.v[2].x),
+                            int_round(p.a * (t.v[0].y - t.v[2].y) + p.b * (t.v[1].y - t.v[2].y) + t.v[2].y)};
+}
diff --git a/src/morpher/trianglemap.c b/src/morpher/trianglemap.c
index e2f3eb9..ad526bc 100644
--- a/src/morpher/trianglemap.c
+++ b/src/morpher/trianglemap.c
@@ -30,7 +30,7 @@ TriangleMap *trianglemap_to(TriangleMap *t, CartesianVector v) {
   int edge;
 
   for (edge = 0; edge < 3; ++edge)
-    if (triangle_area(t->vertices[edge].origin, t->vertices[(edge + 1) % 3].origin, v) > 0)
+    if (square_area(t->vertices[edge].origin, t->vertices[(edge + 1) % 3].origin, v) > 0)
       return t->neighbors[edge];
 
   return t;
diff --git a/src/painter/canvas.c b/src/painter/canvas.c
new file mode 100644
index 0000000..53deeb9
--- /dev/null
+++ b/src/painter/canvas.c
@@ -0,0 +1,27 @@
+#include "painter/canvas.h"
+#include "common/mem.h"
+
+Canvas *canvas_create(IntVector width, IntVector height) {
+  Canvas *c = malloc_or_die(sizeof(Canvas));
+  c->mlv = MLV_create_image(width, height);
+  return c;
+}
+
+void canvas_destroy(Canvas *c) {
+  MLV_free_image(c->mlv);
+  free(c);
+}
+
+void canvas_set_pixel(Canvas *c, CartesianVector pos, Color color) {
+  MLV_set_pixel_on_image(pos.x, pos.y, color.mlv, c->mlv);
+}
+
+Color canvas_get_pixel(Canvas *c, CartesianVector pos) {
+  int r, g, b, a;
+  MLV_get_pixel_on_image(c->mlv, pos.x, pos.y, &r, &g, &b, &a);
+  return (Color) {{a, b, g, r}};
+}
+
+CartesianVector canvas_get_dim(Canvas *c) {
+  return (CartesianVector) {MLV_get_image_width(c->mlv), MLV_get_image_height(c->mlv)};
+}
diff --git a/src/painter/color.c b/src/painter/color.c
new file mode 100644
index 0000000..65c4f20
--- /dev/null
+++ b/src/painter/color.c
@@ -0,0 +1,20 @@
+#include "painter/color.h"
+#include <math.h>
+
+static inline ColorComponent blend_component(ColorComponent origin, ColorComponent target, TimeVector frame) {
+  return (ColorComponent) round(sqrt((TIME_UNIT - frame) * pow(origin, 2) + frame * pow(target, 2)));
+}
+
+bool color_equals(Color c1, Color c2) {
+  return c1.rgba.r == c2.rgba.r &&
+         c1.rgba.g == c2.rgba.g &&
+         c1.rgba.b == c2.rgba.b &&
+         c1.rgba.a == c2.rgba.a;
+}
+
+Color color_blend(Color origin, Color target, TimeVector distance) {
+  return (Color) {{blend_component(origin.rgba.a, target.rgba.a, distance),
+                   blend_component(origin.rgba.b, target.rgba.b, distance),
+                   blend_component(origin.rgba.g, target.rgba.g, distance),
+                   blend_component(origin.rgba.r, target.rgba.r, distance)}};
+}
diff --git a/src/painter/rasterizer.c b/src/painter/rasterizer.c
new file mode 100644
index 0000000..881920a
--- /dev/null
+++ b/src/painter/rasterizer.c
@@ -0,0 +1,86 @@
+#include "painter/rasterizer.h"
+#include <math.h>
+#include <assert.h>
+
+static inline IntVector i(double (*f)(double, double), RealVector a, RealVector b) {
+  return (IntVector) floor(f(a, b));
+}
+
+static inline CartesianVector vertex_at_frame(CartesianMapping m, TimeVector t) {
+  return (CartesianVector) {(IntVector) round((TIME_UNIT - t) * m.origin.x + t * m.target.x),
+                            (IntVector) round((TIME_UNIT - t) * m.origin.y + t * m.target.y)};
+}
+
+static inline RealVector slope(CartesianVector a, CartesianVector b) {
+  return (((RealVector) b.x) - ((RealVector) a.x)) / (((RealVector) b.y) - ((RealVector) a.y));
+}
+
+static inline int positive_y_vertex_comparator(const void *l, const void *r) {
+  return ((CartesianVector *) l)->y - ((CartesianVector *) r)->y;
+}
+
+static inline Color color_at(Canvas *c, Triangle ref, BarycentricVector b) {
+  CartesianVector v = barycentric_to_cartesian(ref, b);
+  return canvas_get_pixel(c, v);
+}
+
+static inline TriangleContext build_triangle_context(Triangle current, TriangleMap *map) {
+  TriangleContext c;
+  int cursor;
+
+  for (cursor = 0; cursor < 3; ++cursor) {
+    c.current.v[cursor] = current.v[cursor];
+    c.source.v[cursor] = map->vertices[cursor].origin;
+    c.target.v[cursor] = map->vertices[cursor].target;
+  }
+
+  return c;
+}
+
+static inline void draw_pixel(CartesianVector pos, TriangleContext *tctx, RasterizationContext *rctx) {
+  BarycentricVector b = cartesian_to_barycentric(tctx->current, pos);
+  Color c = color_blend(color_at(rctx->source, tctx->source, b), color_at(rctx->target, tctx->target, b), rctx->frame);
+  canvas_set_pixel(rctx->result, pos, c);