chore: add modifier pipeline

src/core/modifier.c

@@ -1,14 +1,69 @@
 #include "modifier.h"
+#include <glib.h>
 
-VektorShapeNode vektor_shapenode_new(VektorShape shape) {
+VektorShapeNode vektor_shapenode_new(VektorShape* shape) {
     VektorShapeNode node = (VektorShapeNode){
-        .base = shape, .modifier_count = 0, .evaluated = shape};
+        .base = shape, 
+        .modifier_count = 0, 
+        .evaluated = shape,
+        .base_dirty = true
+    };
     return node;
 }
 
-VektorShape* vektor_shapenode_get_evaluated(VektorShapeNode* shapeNode) {
+void vektor_shapenode_free(VektorShapeNode* shapeNode) {
+    if(shapeNode->base == shapeNode->evaluated) {
+        free(shapeNode->base); // avoid double free()
+    } else {
+        free(shapeNode->base);
+        free(shapeNode->evaluated);
+    }
+    free(shapeNode->modifiers);
+}
+
+VektorShape* vektor_shapenode_get_evaluated(VektorShapeNode* shapeNode) {
+    return shapeNode->evaluated;
+}
+
+VektorShape vektor_modifier_apply(VektorModifier* mod, VektorShape* input) {
+    mod->cachedEvaluatedShape = mod->apply(mod, input);
+    return mod->cachedEvaluatedShape;
+}
+
+// lots of copies by value here, could be problematic
+void vektor_shapenode_update(VektorShapeNode* shapeNode) {
+    // if the base is dirty, apply EVERY modifier
+    if(shapeNode->base_dirty) {
+        VektorShape* evaluated = shapeNode->base;
+        for(size_t i = 0; i < shapeNode->modifier_count; i++) {
+            *evaluated = vektor_modifier_apply(&shapeNode->modifiers[i], evaluated);
+            shapeNode->modifiers[i].dirty = false;
+        }
+        shapeNode->evaluated = evaluated;
+        shapeNode->base_dirty = false;
+        return;
+    }
+
+    // if the base is not dirty, start applying modifiers upstream
+    // starting from the first dirty
+    bool encountered_dirty = false;
+    
+    for(size_t i = 0; i < shapeNode->modifier_count; i++) {
+        if(shapeNode->modifiers[i].dirty) { encountered_dirty = true; }
+        if(encountered_dirty) {
+            if(i == 0) {
+                vektor_modifier_apply(&shapeNode->modifiers[i], shapeNode->base);
+            } else {
+                vektor_modifier_apply(&shapeNode->modifiers[i], &shapeNode->modifiers[i - 1].cachedEvaluatedShape);
+            }
+            shapeNode->modifiers[i].dirty = false;
+        }
+    }
+
+    if (encountered_dirty) {
+        *shapeNode->evaluated = shapeNode->modifiers[shapeNode->modifier_count - 1].cachedEvaluatedShape;
+    }
 
-    return &shapeNode->evaluated;
 }
 
 void vektor_shapenodebuf_add(VektorShapeNodeBuffer* buffer,

src/core/modifier.h

@@ -3,7 +3,10 @@
 
 #include "src/core/primitives.h"
 
-typedef enum { VEKTOR_MODIFIER_BEVEL } VektorModifierType;
+typedef enum { 
+    VEKTOR_MODIFIER_IDENTITY,
+    VEKTOR_MODIFIER_BEVEL 
+} VektorModifierType;
 
 typedef struct VektorModifier {
     VektorModifierType type;
@@ -11,13 +14,14 @@ typedef struct VektorModifier {
     bool dirty;
     void* parameters;
 
-    VektorShape (*apply)(struct VektorModifier mod, VektorShape input);
+    VektorShape (*apply)(struct VektorModifier* mod, VektorShape* input);
+    VektorShape cachedEvaluatedShape;
 
 } VektorModifier;
 
 typedef struct VektorShapeNode {
-    VektorShape base;
-    VektorShape evaluated;
+    VektorShape* base;
+    VektorShape* evaluated;
 
     VektorModifier* modifiers;
     size_t modifier_count;
@@ -31,8 +35,12 @@ typedef struct VektorShapeNodeBuffer {
     size_t capacity;
 } VektorShapeNodeBuffer;
 
-VektorShapeNode vektor_shapenode_new(VektorShape shape);
+VektorShape vektor_modifier_apply(VektorModifier* mod, VektorShape* input);
+
+VektorShapeNode vektor_shapenode_new(VektorShape* shape);
+void vektor_shapenode_free(VektorShapeNode* shapeNode);
 VektorShape* vektor_shapenode_get_evaluated(VektorShapeNode* shapeNode);
+void vektor_shapenode_update(VektorShapeNode* shapeNode);
 void vektor_shapenode_modifier_add(VektorShapeNode* shapeNode,
                                    VektorModifier* mod);
 void vektor_shapenode_modifier_remove(VektorShapeNode* shapeNode,

src/core/modifiers/m_identity.c

@@ -0,0 +1,16 @@
+#include "../modifier.h"
+
+static VektorShape vektor_m_identity_apply(VektorModifier* m, VektorShape* input) {
+    return *input;
+}
+
+VektorModifier vektor_m_identity_new() {
+    return (VektorModifier) {
+        .type = VEKTOR_MODIFIER_IDENTITY,
+        .enabled = true,
+        .dirty = true,
+        .parameters = NULL,
+        .apply = vektor_m_identity_apply
+    };
+}
+

src/core/primitives.c

@@ -450,9 +450,10 @@ VektorBBox vektor_bbox_expand(VektorBBox bbox, float val) {
 
 // ------ SHAPE METHODS ------
 
-VektorShape vektor_shape_new(VektorPrimitive prim, VektorStyle style,
+VektorShape* vektor_shape_new(VektorPrimitive prim, VektorStyle style,
                              int z_index) {
-    VektorShape shape = (VektorShape){.primitive = prim,
+    VektorShape* shape = malloc(sizeof(VektorShape));
+    *shape = (VektorShape){.primitive = prim,
                                       .style = style,
                                       .transform = m33_identity(),
                                       .z_index = z_index,
@@ -464,7 +465,7 @@ VektorShape vektor_shape_new(VektorPrimitive prim, VektorStyle style,
     the passed value's pointer to an array of handles remains valid in the
     passed copy.
     */
-    vektor_shape_create_handles(&shape);
+    vektor_shape_create_handles(shape);
     return shape;
 }
 

src/core/primitives.h

@@ -85,7 +85,7 @@ void vektor_rectangle_set_end(VektorRectangle* rct, V2 point);
 void vektor_rectangle_set_start(VektorRectangle* rct, V2 point);
 void vektor_rectangle_free(VektorRectangle* rct);
 
-VektorShape vektor_shape_new(VektorPrimitive prim, VektorStyle style,
+VektorShape* vektor_shape_new(VektorPrimitive prim, VektorStyle style,
                              int z_index);
 
 VektorBBox vektor_polyline_get_bbox(VektorPrimitive prim);

src/core/raster.c

@@ -74,9 +74,13 @@ void vektor_vb_rasterize(VertexBuffer* vb, VektorShapeNodeBuffer* nodebuf,
                          double scale) {
     for (size_t i = 0; i < nodebuf->count; i++) {
         EdgeBuffer edges = {0};
-        VektorPrimitive* p = &nodebuf->nodes[i].base.primitive;
-        VektorStyle style = nodebuf->nodes[i].base.style;
-        M33 transform = nodebuf->nodes[i].base.transform;
+
+        vektor_shapenode_update(&nodebuf->nodes[i]);
+        VektorShape* currentShape = vektor_shapenode_get_evaluated(&nodebuf->nodes[i]);
+
+        VektorPrimitive* p = &currentShape->primitive;
+        VektorStyle style = currentShape->style;
+        M33 transform = currentShape->transform;
 
         switch (p->kind) {
         case VEKTOR_POLYLINE: