+1

Cargo.lock

reviewed

··· 607 607 "indicatif", 608 608 "itertools", 609 609 "midly", 610 610 + "once_cell", 610 611 "rand", 611 612 "rust-analyzer", 612 613 "serde",

+2 -1

Cargo.toml

reviewed

··· 17 17 itertools = "0.12.1" 18 18 midly = "0.5.3" 19 19 rand = "0.8.5" 20 20 - serde = "1.0.147" 20 20 + serde = { version = "1.0.147", features = ["derive"] } 21 21 serde_cbor = "0.11.2" 22 22 serde_json = "1.0.91" 23 23 svg = "0.17.0" ··· 33 33 'Node', 34 34 'Window', 35 35 ] } 36 36 + once_cell = "1.19.0" 36 37 37 38 38 39 [dev-dependencies]

+4

src/anchors.rs

reviewed

··· 1 1 + use wasm_bindgen::prelude::wasm_bindgen; 2 2 + 3 3 + #[wasm_bindgen] 1 4 #[derive(Debug, Clone, Copy, PartialEq, Eq, Default)] 2 5 pub struct Anchor(pub i32, pub i32); 3 6 ··· 15 18 } 16 19 17 20 #[derive(Debug, Clone, Copy, PartialEq, Eq, Default)] 21 21 + #[wasm_bindgen] 18 22 pub struct CenterAnchor(pub i32, pub i32); 19 23 20 24 impl CenterAnchor {

+15 -27

src/canvas.rs

reviewed

··· 5 5 use rand::Rng; 6 6 7 7 use crate::{ 8 8 - layer::Layer, objects::Object, Anchor, CenterAnchor, Color, ColorMapping, Fill, LineSegment, 9 9 - ObjectSizes, Region, 8 8 + layer::Layer, objects::Object, random_color, Anchor, CenterAnchor, Color, ColorMapping, 9 9 + ColoredObject, Fill, LineSegment, ObjectSizes, Region, 10 10 }; 11 11 12 12 #[derive(Debug, Clone)] ··· 110 110 match self.layer_safe(layer) { 111 111 None => Err(format!("Layer {} does not exist", layer)), 112 112 Some(layer) => { 113 113 - layer.objects.insert(name.to_string(), (object, fill)); 113 113 + layer 114 114 + .objects 115 115 + .insert(name.to_string(), (object, fill).into()); 114 116 Ok(()) 115 117 } 116 118 } ··· 162 164 } 163 165 164 166 pub fn random_layer_within(&self, name: &str, region: &Region) -> Layer { 165 165 - let mut objects: HashMap<String, (Object, Option<Fill>)> = HashMap::new(); 167 167 + let mut objects: HashMap<String, ColoredObject> = HashMap::new(); 166 168 let number_of_objects = rand::thread_rng().gen_range(self.objects_count_range.clone()); 167 169 for i in 0..number_of_objects { 168 170 let object = self.random_object_within(region); 169 171 objects.insert( 170 172 format!("{}#{}", name, i), 171 171 - ( 173 173 + ColoredObject( 172 174 object, 173 175 if rand::thread_rng().gen_bool(0.5) { 174 176 Some(self.random_fill()) ··· 186 188 } 187 189 } 188 190 189 189 - pub fn random_linelikes_within(&self, layer_name: &'static str, region: &Region) -> Layer { 190 190 - let mut objects: HashMap<String, (Object, Option<Fill>)> = HashMap::new(); 191 191 + pub fn random_linelikes(&self, layer_name: &str) -> Layer { 192 192 + self.random_linelikes_within(layer_name, &self.world_region) 193 193 + } 194 194 + 195 195 + pub fn random_linelikes_within(&self, layer_name: &str, region: &Region) -> Layer { 196 196 + let mut objects: HashMap<String, ColoredObject> = HashMap::new(); 191 197 let number_of_objects = rand::thread_rng().gen_range(self.objects_count_range.clone()); 192 198 for i in 0..number_of_objects { 193 199 let object = self.random_linelike_within(region); 194 200 objects.insert( 195 201 format!("{}#{}", layer_name, i), 196 196 - ( 202 202 + ColoredObject( 197 203 object, 198 204 if rand::thread_rng().gen_bool(0.5) { 199 205 Some(self.random_fill()) ··· 341 347 } 342 348 343 349 pub fn random_fill(&self) -> Fill { 344 344 - Fill::Solid(self.random_color()) 350 350 + Fill::Solid(random_color()) 345 351 // match rand::thread_rng().gen_range(1..=3) { 346 352 // 1 => Fill::Solid(random_color()), 347 353 // 2 => Fill::Hatched, 348 354 // 3 => Fill::Dotted, 349 355 // _ => unreachable!(), 350 356 // } 351 351 - } 352 352 - 353 353 - pub fn random_color(&self) -> Color { 354 354 - match rand::thread_rng().gen_range(1..=12) { 355 355 - 1 => Color::Black, 356 356 - 2 => Color::White, 357 357 - 3 => Color::Red, 358 358 - 4 => Color::Green, 359 359 - 5 => Color::Blue, 360 360 - 6 => Color::Yellow, 361 361 - 7 => Color::Orange, 362 362 - 8 => Color::Purple, 363 363 - 9 => Color::Brown, 364 364 - 10 => Color::Pink, 365 365 - 11 => Color::Gray, 366 366 - 12 => Color::Cyan, 367 367 - _ => unreachable!(), 368 368 - } 369 357 } 370 358 371 359 pub fn clear(&mut self) {

+38 -1

src/color.rs

reviewed

··· 6 6 }; 7 7 8 8 use serde::Deserialize; 9 9 + use rand::Rng; 9 10 use wasm_bindgen::prelude::*; 10 11 11 12 #[wasm_bindgen] ··· 23 24 Cyan, 24 25 Pink, 25 26 Gray, 27 27 + } 28 28 + 29 29 + #[wasm_bindgen] 30 30 + pub fn random_color() -> Color { 31 31 + match rand::thread_rng().gen_range(1..=12) { 32 32 + 1 => Color::Black, 33 33 + 2 => Color::White, 34 34 + 3 => Color::Red, 35 35 + 4 => Color::Green, 36 36 + 5 => Color::Blue, 37 37 + 6 => Color::Yellow, 38 38 + 7 => Color::Orange, 39 39 + 8 => Color::Purple, 40 40 + 9 => Color::Brown, 41 41 + 10 => Color::Pink, 42 42 + 11 => Color::Gray, 43 43 + 12 => Color::Cyan, 44 44 + _ => unreachable!(), 45 45 + } 26 46 } 27 47 28 48 impl Default for Color { ··· 88 108 } 89 109 } 90 110 111 111 + #[wasm_bindgen(getter_with_clone)] 91 112 #[derive(Debug, Deserialize, Clone)] 92 113 pub struct ColorMapping { 93 114 pub black: String, ··· 104 125 pub gray: String, 105 126 } 106 127 128 128 + #[wasm_bindgen] 107 129 impl ColorMapping { 108 130 pub fn default() -> Self { 109 131 ColorMapping { ··· 122 144 } 123 145 } 124 146 147 147 + pub fn from_json(content: &str) -> ColorMapping { 148 148 + let json: HashMap<String, String> = serde_json::from_str(content).unwrap(); 149 149 + ColorMapping::from_hashmap(json) 150 150 + } 151 151 + 152 152 + pub fn from_css(content: &str) -> ColorMapping { 153 153 + let mut mapping = ColorMapping::default(); 154 154 + for line in content.lines() { 155 155 + mapping.from_css_line(&line); 156 156 + } 157 157 + mapping 158 158 + } 159 159 + } 160 160 + 161 161 + impl ColorMapping { 125 162 pub fn from_cli_args(args: &Vec<String>) -> ColorMapping { 126 163 let mut colormap: HashMap<String, String> = HashMap::new(); 127 164 for mapping in args { ··· 209 246 } 210 247 211 248 pub fn from_css_file(path: PathBuf) -> ColorMapping { 249 249 + let mut mapping = ColorMapping::default(); 212 250 let file = File::open(path).unwrap(); 213 251 let lines = std::io::BufReader::new(file).lines(); 214 214 - let mut mapping = ColorMapping::default(); 215 252 for line in lines { 216 253 if let Ok(line) = line { 217 254 mapping.from_css_line(&line);

+2 -2

src/fill.rs

reviewed

··· 69 69 fn render_stroke_css(&self, colormap: &ColorMapping) -> String { 70 70 match self { 71 71 Fill::Solid(color) => { 72 72 - format!("stroke: {};", color.to_string(colormap)) 72 72 + format!("stroke: {}; fill: transparent;", color.to_string(colormap)) 73 73 } 74 74 Fill::Translucent(color, opacity) => { 75 75 format!( 76 76 - "stroke: {}; opacity: {};", 76 76 + "stroke: {}; opacity: {}; fill: transparent;", 77 77 color.to_string(colormap), 78 78 opacity 79 79 )

+9 -7

src/layer.rs

reviewed

··· 1 1 - use crate::{ColorMapping, Fill, Object, ObjectSizes}; 1 1 + use crate::{ColorMapping, ColoredObject, Fill, Object, ObjectSizes}; 2 2 use std::collections::HashMap; 3 3 + use wasm_bindgen::prelude::*; 3 4 4 5 #[derive(Debug, Clone, Default)] 6 6 + // #[wasm_bindgen(getter_with_clone)] 5 7 pub struct Layer { 6 8 pub object_sizes: ObjectSizes, 7 7 - pub objects: HashMap<String, (Object, Option<Fill>)>, 9 9 + pub objects: HashMap<String, ColoredObject>, 8 10 pub name: String, 9 11 pub _render_cache: Option<svg::node::element::Group>, 10 12 } ··· 19 21 } 20 22 } 21 23 22 22 - pub fn object(&mut self, name: &str) -> &mut (Object, Option<Fill>) { 24 24 + pub fn object(&mut self, name: &str) -> &mut ColoredObject { 23 25 self.objects.get_mut(name).unwrap() 24 26 } 25 27 ··· 34 36 } 35 37 36 38 pub fn paint_all_objects(&mut self, fill: Fill) { 37 37 - for (_id, (_, maybe_fill)) in &mut self.objects { 39 39 + for (_id, ColoredObject(_, ref mut maybe_fill)) in &mut self.objects { 38 40 *maybe_fill = Some(fill.clone()); 39 41 } 40 42 self.flush(); ··· 43 45 pub fn move_all_objects(&mut self, dx: i32, dy: i32) { 44 46 self.objects 45 47 .iter_mut() 46 46 - .for_each(|(_, (obj, _))| obj.translate(dx, dy)); 48 48 + .for_each(|(_, ColoredObject(obj, _))| obj.translate(dx, dy)); 47 49 self.flush(); 48 50 } 49 51 50 52 pub fn add_object(&mut self, name: &str, object: Object, fill: Option<Fill>) { 51 51 - self.objects.insert(name.to_string(), (object, fill)); 53 53 + self.objects.insert(name.to_string(), (object, fill).into()); 52 54 self.flush(); 53 55 } 54 56 ··· 77 79 .set("class", "layer") 78 80 .set("data-layer", self.name.clone()); 79 81 80 80 - for (id, (object, maybe_fill)) in &self.objects { 82 82 + for (id, ColoredObject(object, maybe_fill)) in &self.objects { 81 83 layer_group = layer_group.add(object.render( 82 84 cell_size, 83 85 object_sizes,

src/main.rs

reviewed

This is a binary file and will not be displayed.

+11

src/objects.rs

reviewed

··· 1 1 use crate::{Anchor, CenterAnchor, ColorMapping, Coordinates, Fill, Region}; 2 2 + use wasm_bindgen::prelude::*; 2 3 3 4 #[derive(Debug, Clone, PartialEq, Eq)] 4 5 pub enum LineSegment { ··· 21 22 RawSVG(Box<dyn svg::Node>), 22 23 } 23 24 25 25 + #[derive(Debug, Clone)] 26 26 + pub struct ColoredObject(pub Object, pub Option<Fill>); 27 27 + 28 28 + impl From<(Object, Option<Fill>)> for ColoredObject { 29 29 + fn from(value: (Object, Option<Fill>)) -> Self { 30 30 + ColoredObject(value.0, value.1) 31 31 + } 32 32 + } 33 33 + 34 34 + #[wasm_bindgen] 24 35 #[derive(Debug, Clone, Copy)] 25 36 pub struct ObjectSizes { 26 37 pub empty_shape_stroke_width: f32,

+241 -3

src/web.rs

reviewed

··· 1 1 - use wasm_bindgen::prelude::wasm_bindgen; 2 2 - use wasm_bindgen::JsValue; 1 1 + use std::ptr::NonNull; 2 2 + use std::sync::Mutex; 3 3 4 4 - use crate::{Canvas, Color, ColorMapping, Fill}; 4 4 + use once_cell::sync::Lazy; 5 5 + use wasm_bindgen::{closure::Closure, prelude::wasm_bindgen}; 6 6 + use wasm_bindgen::{JsValue, UnwrapThrowExt}; 7 7 + 8 8 + use crate::{layer, Anchor, Canvas, CenterAnchor, Color, ColorMapping, Fill, Layer, Object}; 9 9 + 10 10 + static WEB_CANVAS: Lazy<Mutex<Canvas>> = Lazy::new(|| Mutex::new(Canvas::default_settings())); 11 11 + 12 12 + fn canvas() -> std::sync::MutexGuard<'static, Canvas> { 13 13 + WEB_CANVAS.lock().unwrap() 14 14 + } 5 15 6 16 #[wasm_bindgen(start)] 7 17 pub fn main() -> Result<(), JsValue> { ··· 50 60 body.append_child(&output)?; 51 61 Ok(()) 52 62 } 63 63 + 64 64 + #[wasm_bindgen] 65 65 + pub enum MidiEvent { 66 66 + Note, 67 67 + ControlChange, 68 68 + } 69 69 + 70 70 + #[wasm_bindgen] 71 71 + pub struct MidiEventData([u8; 3]); 72 72 + 73 73 + #[wasm_bindgen] 74 74 + pub struct MidiPitch(u8); 75 75 + 76 76 + #[wasm_bindgen] 77 77 + impl MidiPitch { 78 78 + pub fn octave(&self) -> u8 { 79 79 + self.0 / 12 80 80 + } 81 81 + } 82 82 + 83 83 + pub struct Percentage(pub f32); 84 84 + 85 85 + impl From<u8> for Percentage { 86 86 + fn from(value: u8) -> Self { 87 87 + Self(value as f32 / 127.0) 88 88 + } 89 89 + } 90 90 + 91 91 + pub enum MidiMessage { 92 92 + NoteOn(MidiPitch, Percentage), 93 93 + NoteOff(MidiPitch), 94 94 + PedalOn, 95 95 + PedalOff, 96 96 + ControlChange(u8, Percentage), 97 97 + } 98 98 + 99 99 + impl From<(MidiEvent, MidiEventData)> for MidiMessage { 100 100 + fn from(value: (MidiEvent, MidiEventData)) -> Self { 101 101 + match value { 102 102 + (MidiEvent::Note, MidiEventData([pitch, velocity, _])) => { 103 103 + if velocity == 0 { 104 104 + MidiMessage::NoteOff(MidiPitch(pitch)) 105 105 + } else { 106 106 + MidiMessage::NoteOn(MidiPitch(pitch), velocity.into()) 107 107 + } 108 108 + } 109 109 + (MidiEvent::ControlChange, MidiEventData([64, value, _])) => { 110 110 + if value == 0 { 111 111 + MidiMessage::PedalOff 112 112 + } else { 113 113 + MidiMessage::PedalOn 114 114 + } 115 115 + } 116 116 + (MidiEvent::ControlChange, MidiEventData([controller, value, _])) => { 117 117 + MidiMessage::ControlChange(controller, value.into()) 118 118 + } 119 119 + } 120 120 + } 121 121 + } 122 122 + 123 123 + #[wasm_bindgen] 124 124 + pub fn render_canvas(layers_pattern: Option<String>, render_background: Option<bool>) -> String { 125 125 + canvas().render( 126 126 + &match layers_pattern { 127 127 + Some(ref pattern) => vec![pattern], 128 128 + None => vec!["*"], 129 129 + }, 130 130 + render_background.unwrap_or(false), 131 131 + ) 132 132 + } 133 133 + 134 134 + #[wasm_bindgen] 135 135 + pub fn set_palette(palette: ColorMapping) -> () { 136 136 + canvas().colormap = palette; 137 137 + } 138 138 + 139 139 + #[wasm_bindgen] 140 140 + pub fn new_layer(name: &str) -> LayerWeb { 141 141 + canvas().add_or_replace_layer(Layer::new(name)); 142 142 + LayerWeb { 143 143 + name: name.to_string(), 144 144 + } 145 145 + } 146 146 + 147 147 + #[wasm_bindgen] 148 148 + pub fn get_layer(name: &str) -> Result<LayerWeb, JsValue> { 149 149 + match canvas().layer_safe(name) { 150 150 + Some(layer) => Ok(LayerWeb { 151 151 + name: layer.name.clone(), 152 152 + }), 153 153 + None => Err(JsValue::from_str("Layer not found")), 154 154 + } 155 155 + } 156 156 + 157 157 + #[wasm_bindgen] 158 158 + pub fn random_linelikes(name: &str) -> LayerWeb { 159 159 + canvas().add_or_replace_layer(canvas().random_linelikes(name)); 160 160 + LayerWeb { 161 161 + name: name.to_string(), 162 162 + } 163 163 + } 164 164 + 165 165 + #[wasm_bindgen(getter_with_clone)] 166 166 + pub struct LayerWeb { 167 167 + pub name: String, 168 168 + } 169 169 + 170 170 + #[wasm_bindgen] 171 171 + impl LayerWeb { 172 172 + pub fn render(&self) -> String { 173 173 + canvas().render(&vec![&self.name], false) 174 174 + } 175 175 + 176 176 + pub fn render_into(&self, selector: String) -> () { 177 177 + let window = web_sys::window().expect_throw("no global `window` exists"); 178 178 + let document = window 179 179 + .document() 180 180 + .expect_throw("should have a document on window"); 181 181 + let element = document 182 182 + .query_selector(&selector) 183 183 + .expect_throw(&format!("selector '{}' not found", selector)) 184 184 + .expect_throw("could not get the element, but is was found (shouldn't happen)"); 185 185 + 186 186 + let output = document.create_element("div").unwrap(); 187 187 + output.set_class_name("frame"); 188 188 + output.set_inner_html(&self.render()); 189 189 + element.append_child(&output).unwrap(); 190 190 + } 191 191 + 192 192 + pub fn paint_all(&self, color: Color, opacity: Option<f32>) -> () { 193 193 + canvas() 194 194 + .layer(&self.name) 195 195 + .paint_all_objects(Fill::Translucent(color, opacity.unwrap_or(1.0))); 196 196 + } 197 197 + 198 198 + pub fn random(name: &str) -> Self { 199 199 + let layer = canvas().random_layer(name); 200 200 + canvas().add_or_replace_layer(layer); 201 201 + LayerWeb { 202 202 + name: name.to_string(), 203 203 + } 204 204 + } 205 205 + 206 206 + pub fn new_line( 207 207 + &self, 208 208 + name: &str, 209 209 + start: Anchor, 210 210 + end: Anchor, 211 211 + thickness: f32, 212 212 + color: Color, 213 213 + ) -> () { 214 214 + canvas().layer(name).add_object( 215 215 + name, 216 216 + Object::Line(start, end, thickness), 217 217 + Some(Fill::Solid(color)), 218 218 + ) 219 219 + } 220 220 + pub fn new_curve_outward( 221 221 + &self, 222 222 + name: &str, 223 223 + start: Anchor, 224 224 + end: Anchor, 225 225 + thickness: f32, 226 226 + color: Color, 227 227 + ) -> () { 228 228 + canvas().layer(name).add_object( 229 229 + name, 230 230 + Object::CurveOutward(start, end, thickness), 231 231 + Some(Fill::Solid(color)), 232 232 + ) 233 233 + } 234 234 + pub fn new_curve_inward( 235 235 + &self, 236 236 + name: &str, 237 237 + start: Anchor, 238 238 + end: Anchor, 239 239 + thickness: f32, 240 240 + color: Color, 241 241 + ) -> () { 242 242 + canvas().layer(name).add_object( 243 243 + name, 244 244 + Object::CurveInward(start, end, thickness), 245 245 + Some(Fill::Solid(color)), 246 246 + ) 247 247 + } 248 248 + pub fn new_small_circle(&self, name: &str, center: Anchor, color: Color) -> () { 249 249 + canvas() 250 250 + .layer(name) 251 251 + .add_object(name, Object::SmallCircle(center), Some(Fill::Solid(color))) 252 252 + } 253 253 + pub fn new_dot(&self, name: &str, center: Anchor, color: Color) -> () { 254 254 + canvas() 255 255 + .layer(name) 256 256 + .add_object(name, Object::Dot(center), Some(Fill::Solid(color))) 257 257 + } 258 258 + pub fn new_big_circle(&self, name: &str, center: CenterAnchor, color: Color) -> () { 259 259 + canvas() 260 260 + .layer(name) 261 261 + .add_object(name, Object::BigCircle(center), Some(Fill::Solid(color))) 262 262 + } 263 263 + pub fn new_text( 264 264 + &self, 265 265 + name: &str, 266 266 + anchor: Anchor, 267 267 + text: String, 268 268 + font_size: f32, 269 269 + color: Color, 270 270 + ) -> () { 271 271 + canvas().layer(name).add_object( 272 272 + name, 273 273 + Object::Text(anchor, text, font_size), 274 274 + Some(Fill::Solid(color)), 275 275 + ) 276 276 + } 277 277 + pub fn new_rectangle( 278 278 + &self, 279 279 + name: &str, 280 280 + topleft: Anchor, 281 281 + bottomright: Anchor, 282 282 + color: Color, 283 283 + ) -> () { 284 284 + canvas().layer(name).add_object( 285 285 + name, 286 286 + Object::Rectangle(topleft, bottomright), 287 287 + Some(Fill::Solid(color)), 288 288 + ) 289 289 + } 290 290 + }

+40 -2

web/index.html

reviewed

··· 6 6 <title>Shapemaker Web</title> 7 7 </head> 8 8 <body> 9 9 + <div class="prev"></div> 9 10 <script type="module"> 10 10 - import init, { render_image, Color, color_name } from "./shapemaker.js" 11 11 + import init, { 12 12 + render_image, 13 13 + LayerWeb, 14 14 + render_canvas, 15 15 + Color, 16 16 + color_name, 17 17 + set_palette, 18 18 + random_linelikes, 19 19 + ColorMapping, 20 20 + random_color, 21 21 + } from "./shapemaker.js" 11 22 async function run() { 12 23 await init() 13 24 window.renderImage = (vel, col) => { ··· 16 27 ?.forEach((el) => el.remove()) 17 28 render_image(vel, col) 18 29 } 30 30 + 31 31 + set_palette( 32 32 + ColorMapping.from_css(` 33 33 + :root { 34 34 + black: #000000; 35 35 + white: #ffffff; 36 36 + red: #cf0a2b; 37 37 + green: #22e753; 38 38 + blue: #2734e6; 39 39 + yellow: #f8e21e; 40 40 + orange: #f05811; 41 41 + purple: #6a24ec; 42 42 + brown: #a05634; 43 43 + pink: #e92e76; 44 44 + gray: #81a0a8; 45 45 + cyan: #4fecec; 46 46 + } 47 47 + `) 48 48 + ) 19 49 } 20 50 run() 21 51 ··· 32 62 } 33 63 34 64 window.pedal_held = false 65 65 + window.previousColor = null 35 66 36 67 window.addEventListener("keypress", (e) => { 37 68 if (e.key === " ") { 38 38 - window.renderImage(1, Color.White) 69 69 + const layer = random_linelikes("feur") 70 70 + let color = random_color() 71 71 + while ([Color.Black, Color.Gray, window.previousColor].includes(color)) { 72 72 + color = random_color() 73 73 + } 74 74 + window.previousColor = color 75 75 + layer.paint_all(color, 0.75) 76 76 + layer.render_into("body") 39 77 } 40 78 }) 41 79