shapemaker 1.1.1

An experimental WASM-capable, generative SVG-based video rendering engine that reacts to MIDI or audio data
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95

use crate::{graphics::objects::ObjectSizes, ColorMapping};
use anyhow::Result;
use itertools::Itertools;
use std::collections::HashMap;

/// Struct can be rendered as a SVG element
pub trait SVGRenderable {
    fn render_to_svg(
        &self,
        colormap: ColorMapping,
        cell_size: usize,
        object_sizes: ObjectSizes,
        id: &str,
    ) -> Result<svg::node::element::Element>;
}

/// Struct can be rendered as attributes of a SVG element
pub trait SVGAttributesRenderable {
    /// When merging multiple SVGAttributesRenderable, this string is used to join multiple values for the same key
    const MULTIPLE_VALUES_JOIN_BY: &'static str = ", ";

    fn render_to_svg_attributes(
        &self,
        colormap: ColorMapping,
        cell_size: usize,
        object_sizes: ObjectSizes,
        id: &str,
    ) -> Result<HashMap<String, String>>;
}

/// Struct can be rendered as a CSS ruleset (e.g. no selectors)
pub trait CSSRenderable {
    fn render_to_css_filled(&self, colormap: &ColorMapping) -> String;
    fn render_to_css_stroked(&self, colormap: &ColorMapping) -> String;
    fn render_to_css(&self, colormap: &ColorMapping, fill_as_stroke_color: bool) -> String {
        if fill_as_stroke_color {
            self.render_to_css_stroked(colormap)
        } else {
            self.render_to_css_filled(colormap)
        }
    }
}

impl<T: CSSRenderable, V: Clone + IntoIterator<Item = T>> CSSRenderable for V {
    fn render_to_css_filled(&self, colormap: &ColorMapping) -> String {
        self.clone()
            .into_iter()
            .map(|v| v.render_to_css_filled(colormap))
            .join("\n")
    }

    fn render_to_css_stroked(&self, colormap: &ColorMapping) -> String {
        self.clone()
            .into_iter()
            .map(|v| v.render_to_css_stroked(colormap))
            .join("\n")
    }
}

// We get the Option<T> implementation for free since Option<T> implements IntoIterator, and it works:
// None => empty iterator => empty hashmap,
// Some(T) => iterator with one element => one hashmap, no merging.
// I love Rust <3.

impl<T, V> SVGAttributesRenderable for V
where
    T: SVGAttributesRenderable,
    V: Clone + IntoIterator<Item = T>,
{
    fn render_to_svg_attributes(
        &self,
        colormap: ColorMapping,
        cell_size: usize,
        object_sizes: ObjectSizes,
        id: &str,
    ) -> Result<HashMap<String, String>> {
        let mut attrs = HashMap::<String, String>::new();
        for attrmap in self.clone().into_iter().map(|v| {
            v.render_to_svg_attributes(colormap.clone(), cell_size, object_sizes, id)
                .unwrap()
        }) {
            for (key, value) in attrmap {
                if attrs.contains_key(&key) {
                    attrs.insert(
                        key.clone(),
                        format!("{}{}{}", attrs[&key], T::MULTIPLE_VALUES_JOIN_BY, value),
                    );
                } else {
                    attrs.insert(key, value);
                }
            }
        }
        Ok(attrs)
    }
}