modifier: Support decorating modifiers

Author: johannes-wolf

src/modifier.typ

@@ -1,13 +1,21 @@
 #import "/src/path-util.typ"
 
 /// A path modifier is a function that accepts a contex, style and
-/// a single drawable and returns a single (modified) drawable.
+/// a single drawable and returns either a single replacement drawable,
+/// or an dictionary with the keys `replacement` (single drawable) and `decoration` (list of drawables)
+/// that contain a replacement and/or additional drawable to render.
+///
+/// Arguments:
+///   - ctx (context):
+///   - style (styles):
+///   - drawable (drawable): Single drawable to modify/decorate
+///   - close (bool): Boolean if the drawable is closed
 ///
 /// Example:
 /// ```typ
-/// (ctx, style, drawable) => {
+/// (ctx, style, drawable, close) => {
 ///   // ... modify the drawable ...
-///   return drawable
+///   return (replacement: ..., decoration: ...)
 /// }
 /// ```
 
@@ -48,16 +56,39 @@
   assert(type(fn) == function,
     message: "Path modifier must be of type function.")
 
+  let new-elements = ()
   if "segments" in elem {
     let begin = style.at("begin", default: 0%)
     let end = style.at("end", default: 0%)
 
     let (head, mid, tail) = slice-segments(elem.segments, begin, end)
     let close = close and head == () and tail == ()
-    elem.segments = head + (fn)(ctx, style, mid, close) + tail
+    let result = (fn)(ctx, style, mid, close)
+    if type(result) != dictionary {
+      result = (replace: result)
+    } else {
+      new-elements += result.at("decoration", default: ())
+    }
+
+    let replace = result.at("replacement", default: none)
+    if replace != none {
+      let replacement-elem = elem
+      replacement-elem.segments = head + replace + tail
+
+      new-elements.insert(0, replacement-elem)
+    } else {
+      let head-elem = elem
+      head-elem.segments = head
+
+      let tail-elem = elem
+      tail-elem.segments = tail
+
+      new-elements.insert(0, head-elem)
+      new-elements.push(tail-elem)
+    }
   }
 
-  return elem
+  return new-elements
 }
 
 /// Apply a path modifier to a list of drawables
@@ -98,10 +129,12 @@
   style.modifier = ()
 
   // Apply function on all drawables
-  return drawables.map(d => {
+  let new = ()
+  for i in range(0, drawables.len()) {
     for fn in fns.filter(v => v.fn != none) {
-      d = apply-modifier-fn(ctx, fn.style, d, fn.fn, close)
+      new += apply-modifier-fn(ctx, fn.style, drawables.at(i), fn.fn, close)
     }
-    return d
-  })
+  }
+
+  return new
 }

src/modifiers.typ

@@ -2,6 +2,8 @@
 #import "/src/path-util.typ"
 #import "/src/bezier.typ" as bezier_
 #import "/src/vector.typ"
+#import "/src/drawable.typ"
+#import "/src/util.typ"
 
 // Call callback `fn` for each decoration segment
 // on path `segments`.
@@ -114,3 +116,53 @@
     path-util.cubic-segment(..c)
   })
 }
+
+
+
+#let ticks-default-style = (
+  step: 10%,
+  length: 1,
+  origin: 50%,
+  replace: false,
+)
+
+// Draw tick-marks along a path
+#let ticks(ctx, style, segments, close) = {
+  let style = styles.resolve(ctx.style, merge: style,
+    base: ticks-default-style)
+
+  let length = path-util.length(segments)
+  let step = if type(style.step) == ratio {
+    length * style.step / 100%
+  } else {
+    util.resolve-number(ctx, style.step)
+  }
+
+  assert(step > 1e-6,
+    message: "Tick step must be > 0!")
+
+  let tick-segments = ()
+
+  let distance = 0
+  while distance <= length {
+    let (pt, dir) = path-util.direction(segments, distance)
+
+    // Compute the tangent normal
+    let norm = vector.scale(vector.norm((-dir.at(1), dir.at(0), dir.at(2))),
+      style.length)
+
+    // Compute points
+    let p0 = vector.add(pt, vector.scale(norm, -style.origin / 100%))
+    let p1 = vector.add(pt, vector.scale(norm, (100% - style.origin) / 100%))
+
+    tick-segments.push(path-util.line-segment((p0, p1)))
+
+    distance += step
+  }
+
+  return (
+    replacement: if style.replace { none } else { segments },
+    decoration: tick-segments.map(s => {
+      drawable.path(s, stroke: style.stroke)
+    }))
+}