+1 -1

src/examples.rs

Reviewed

··· 31 31 let red_circle_in = 32 32 Region::from_topright(draw_in.topright().translated(-3, 0), (4, 3)).unwrap(); 33 33 34 34 - let red_circle_at = red_circle_in.random_point_within(); 34 34 + let red_circle_at = red_circle_in.random_point(); 35 35 36 36 let red_dot_layer = canvas.new_layer("red dot"); 37 37 let mut red_dot_friends = Layer::new("red dot friends");

-21

src/geometry/region.rs

Reviewed

··· 25 25 self.iter().filter(|Point(x, y)| x >= y) 26 26 } 27 27 28 28 - pub fn random_point_within(&self) -> Point { 29 29 - Point::from(self.random_coordinates_within()) 30 30 - } 31 31 - 32 32 - pub fn random_point_within_except(&self, except: &Region) -> Point { 33 33 - // XXX this is probably not a good idea lmao 34 34 - loop { 35 35 - let point = self.random_point_within(); 36 36 - if !except.contains(&point) { 37 37 - return point; 38 38 - } 39 39 - } 40 40 - } 41 41 - 42 28 pub fn ensure_nonempty(&self) -> Result<()> { 43 29 if self.width() == 0 || self.height() == 0 { 44 30 return Err(format_err!("Region {} is empty", self)); ··· 172 158 } else { 173 159 self 174 160 } 175 175 - } 176 176 - 177 177 - pub fn random_coordinates_within(&self) -> (i32, i32) { 178 178 - ( 179 179 - rand::thread_rng().gen_range(self.start.0..self.end.0) as i32, 180 180 - rand::thread_rng().gen_range(self.start.1..self.end.1) as i32, 181 181 - ) 182 161 } 183 162 184 163 pub fn from_origin(end: Point) -> Result<Self> {

-189

src/graphics/canvas.rs

Reviewed

··· 218 218 Ok(()) 219 219 } 220 220 221 221 - pub fn random_layer(&self, name: &str) -> Layer { 222 222 - self.random_layer_within(name, &self.world_region) 223 223 - } 224 224 - 225 225 - pub fn random_object(&self) -> Object { 226 226 - self.random_object_within(&self.world_region) 227 227 - } 228 228 - 229 221 pub fn add_or_replace_layer(&mut self, layer: Layer) { 230 222 if let Some(existing_layer) = self.layer_safe(&layer.name) { 231 223 existing_layer.replace(layer); ··· 234 226 } 235 227 } 236 228 237 237 - pub fn random_layer_within(&self, name: &str, region: &Region) -> Layer { 238 238 - let mut objects: HashMap<String, ColoredObject> = HashMap::new(); 239 239 - let number_of_objects = rand::thread_rng().gen_range(self.objects_count_range.clone()); 240 240 - for i in 0..number_of_objects { 241 241 - let object = self.random_object_within(region); 242 242 - let hatchable = object.hatchable(); 243 243 - objects.insert( 244 244 - format!("{}#{}", name, i), 245 245 - object.color(if hatchable { 246 246 - Fill::random_hatches(self.background) 247 247 - } else { 248 248 - Fill::random_solid(self.background) 249 249 - }), 250 250 - ); 251 251 - } 252 252 - Layer { 253 253 - object_sizes: self.object_sizes, 254 254 - name: name.to_string(), 255 255 - objects, 256 256 - _render_cache: None, 257 257 - hidden: false, 258 258 - } 259 259 - } 260 260 - 261 261 - pub fn random_linelikes(&self, layer_name: &str) -> Layer { 262 262 - self.random_linelikes_within(layer_name, &self.world_region) 263 263 - } 264 264 - 265 265 - pub fn n_random_linelikes_within( 266 266 - &self, 267 267 - layer_name: &str, 268 268 - region: &Region, 269 269 - count: usize, 270 270 - ) -> Layer { 271 271 - let mut objects: HashMap<String, ColoredObject> = HashMap::new(); 272 272 - for i in 0..count { 273 273 - let object = self.random_linelike_within(region); 274 274 - let hatchable = object.fillable(); 275 275 - objects.insert( 276 276 - format!("{}#{}", layer_name, i), 277 277 - ColoredObject::from(( 278 278 - object, 279 279 - if rand::thread_rng().gen_bool(0.5) { 280 280 - Some(Fill::random_solid(self.background)) 281 281 - } else { 282 282 - None 283 283 - }, 284 284 - )), 285 285 - ); 286 286 - } 287 287 - Layer { 288 288 - object_sizes: self.object_sizes, 289 289 - name: layer_name.to_owned(), 290 290 - objects, 291 291 - _render_cache: None, 292 292 - hidden: false, 293 293 - } 294 294 - } 295 295 - 296 296 - pub fn random_linelikes_within(&self, layer_name: &str, region: &Region) -> Layer { 297 297 - let number_of_objects = rand::thread_rng().gen_range(self.objects_count_range.clone()); 298 298 - self.n_random_linelikes_within(layer_name, region, number_of_objects) 299 299 - } 300 300 - 301 301 - pub fn random_object_within(&self, region: &Region) -> Object { 302 302 - let start = self.random_point(region); 303 303 - match rand::thread_rng().gen_range(1..=7) { 304 304 - 1 => self.random_polygon(region), 305 305 - 2 => Object::BigCircle(start), 306 306 - 3 => Object::SmallCircle(start), 307 307 - 4 => Object::Dot(start), 308 308 - 5 => Object::CurveInward( 309 309 - start, 310 310 - self.random_end_anchor(start, region), 311 311 - self.object_sizes.default_line_width, 312 312 - ), 313 313 - 6 => Object::CurveOutward( 314 314 - start, 315 315 - self.random_end_anchor(start, region), 316 316 - self.object_sizes.default_line_width, 317 317 - ), 318 318 - 7 => Object::Line( 319 319 - self.random_point(region), 320 320 - self.random_point(region), 321 321 - self.object_sizes.default_line_width, 322 322 - ), 323 323 - _ => unreachable!(), 324 324 - } 325 325 - } 326 326 - 327 327 - pub fn random_linelike_within(&self, region: &Region) -> Object { 328 328 - let start = self.random_point(region); 329 329 - match rand::thread_rng().gen_range(1..=3) { 330 330 - 1 => Object::CurveInward( 331 331 - start, 332 332 - self.random_end_anchor(start, region), 333 333 - self.object_sizes.default_line_width, 334 334 - ), 335 335 - 2 => Object::CurveOutward( 336 336 - start, 337 337 - self.random_end_anchor(start, region), 338 338 - self.object_sizes.default_line_width, 339 339 - ), 340 340 - 3 => Object::Line( 341 341 - self.random_point(region), 342 342 - self.random_point(region), 343 343 - self.object_sizes.default_line_width, 344 344 - ), 345 345 - _ => unreachable!(), 346 346 - } 347 347 - } 348 348 - 349 349 - pub fn random_end_anchor(&self, start: Point, region: &Region) -> Point { 350 350 - // End anchors are always a square diagonal from the start anchor (for now) 351 351 - // that means taking steps of the form n * (one of (1, 1), (1, -1), (-1, 1), (-1, -1)) 352 352 - // Except that the end anchor needs to stay in the bounds of the shape. 353 353 - 354 354 - // Determine all possible end anchors that are in a square diagonal from the start anchor 355 355 - let mut possible_end_anchors = vec![]; 356 356 - 357 357 - // shapes can end on the next cell, since that's where they end 358 358 - let actual_region = region.enlarged(1, 1); 359 359 - 360 360 - for x in actual_region.mirrored_width_range() { 361 361 - for y in actual_region.mirrored_height_range() { 362 362 - let end_anchor = start.translated(x, y); 363 363 - 364 364 - if end_anchor == start { 365 365 - continue; 366 366 - } 367 367 - 368 368 - // Check that the end anchor is in a square diagonal from the start anchor and that the end anchor is in bounds 369 369 - if x.abs() == y.abs() && actual_region.contains(&end_anchor) { 370 370 - possible_end_anchors.push(end_anchor); 371 371 - } 372 372 - } 373 373 - } 374 374 - 375 375 - // Pick a random end anchor from the possible end anchors 376 376 - possible_end_anchors[rand::thread_rng().gen_range(0..possible_end_anchors.len())] 377 377 - } 378 378 - 379 379 - pub fn random_polygon(&self, region: &Region) -> Object { 380 380 - let number_of_anchors = rand::thread_rng().gen_range(self.polygon_vertices_range.clone()); 381 381 - let start = self.random_point(region); 382 382 - let mut lines: Vec<LineSegment> = vec![]; 383 383 - for _ in 0..number_of_anchors { 384 384 - let next_anchor = self.random_point(region); 385 385 - lines.push(self.random_line(next_anchor)); 386 386 - } 387 387 - Object::Polygon(start, lines) 388 388 - } 389 389 - 390 390 - pub fn random_line(&self, end: Point) -> LineSegment { 391 391 - match rand::thread_rng().gen_range(1..=3) { 392 392 - 1 => LineSegment::Straight(end), 393 393 - 2 => LineSegment::InwardCurve(end), 394 394 - 3 => LineSegment::OutwardCurve(end), 395 395 - _ => unreachable!(), 396 396 - } 397 397 - } 398 398 - 399 229 pub fn region_is_whole_grid(&self, region: &Region) -> bool { 400 230 region.start == (0, 0) && region.end == self.grid_size 401 231 } 402 402 - 403 403 - pub fn random_region(&self) -> Region { 404 404 - let start = self.random_point(&self.world_region); 405 405 - let end = self.random_end_anchor(start, &self.world_region); 406 406 - Region::from(if start.0 > end.0 { 407 407 - (end, start) 408 408 - } else { 409 409 - (start, end) 410 410 - }) 411 411 - } 412 412 - 413 413 - pub fn random_point(&self, region: &Region) -> Point { 414 414 - region.ensure_nonempty().unwrap(); 415 415 - Point( 416 416 - rand::thread_rng().gen_range(region.x_range()), 417 417 - rand::thread_rng().gen_range(region.y_range()), 418 418 - ) 419 419 - } 420 420 - 421 232 pub fn clear(&mut self) { 422 233 self.layers.clear(); 423 234 self.remove_background()

+1

src/lib.rs

Reviewed

··· 9 9 pub mod rendering; 10 10 pub mod synchronization; 11 11 pub mod video; 12 12 + pub mod wasm; 12 13 13 14 pub use geometry::{Angle, Containable, Point, Region}; 14 15 pub use graphics::{

+102

src/random/canvas.rs

Reviewed

··· 1 1 + use crate::{Canvas, ColoredObject, Containable, Fill, Layer, LineSegment, Object, Point, Region}; 2 2 + use rand::{distributions::uniform::SampleRange, Rng}; 3 3 + use std::collections::HashMap; 4 4 + 5 5 + impl Canvas { 6 6 + pub fn random_layer(&self, name: &str) -> Layer { 7 7 + self.random_layer_within(name, &self.world_region) 8 8 + } 9 9 + 10 10 + pub fn random_object(&self) -> Object { 11 11 + Object::random( 12 12 + &self.world_region, 13 13 + self.object_sizes.default_line_width, 14 14 + self.polygon_vertices_range.clone(), 15 15 + ) 16 16 + } 17 17 + 18 18 + pub fn n_random_linelikes_within( 19 19 + &self, 20 20 + layer_name: &str, 21 21 + region: &Region, 22 22 + count: usize, 23 23 + ) -> Layer { 24 24 + let mut objects: HashMap<String, ColoredObject> = HashMap::new(); 25 25 + for i in 0..count { 26 26 + let object = 27 27 + Object::random_linelike_within(region, self.object_sizes.default_line_width); 28 28 + objects.insert( 29 29 + format!("{}#{}", layer_name, i), 30 30 + ColoredObject::from(( 31 31 + object, 32 32 + if rand::thread_rng().gen_bool(0.5) { 33 33 + Some(Fill::random_solid(self.background)) 34 34 + } else { 35 35 + None 36 36 + }, 37 37 + )), 38 38 + ); 39 39 + } 40 40 + Layer { 41 41 + object_sizes: self.object_sizes.clone(), 42 42 + name: layer_name.to_owned(), 43 43 + objects, 44 44 + _render_cache: None, 45 45 + hidden: false, 46 46 + } 47 47 + } 48 48 + 49 49 + pub fn random_linelikes_within( 50 50 + &self, 51 51 + layer_name: &str, 52 52 + region: &Region, 53 53 + object_counts: impl SampleRange<usize>, 54 54 + ) -> Layer { 55 55 + let number_of_objects = rand::thread_rng().gen_range(object_counts); 56 56 + self.n_random_linelikes_within(layer_name, region, number_of_objects) 57 57 + } 58 58 + 59 59 + pub fn random_layer_within(&self, name: &str, region: &Region) -> Layer { 60 60 + let mut objects: HashMap<String, ColoredObject> = HashMap::new(); 61 61 + let number_of_objects = rand::thread_rng().gen_range(self.objects_count_range.clone()); 62 62 + for i in 0..number_of_objects { 63 63 + let object = Object::random( 64 64 + region, 65 65 + self.object_sizes.default_line_width, 66 66 + self.polygon_vertices_range.clone(), 67 67 + ); 68 68 + let hatchable = object.hatchable(); 69 69 + objects.insert( 70 70 + format!("{}#{}", name, i), 71 71 + object.color(if hatchable { 72 72 + Fill::random_hatches(self.background) 73 73 + } else { 74 74 + Fill::random_solid(self.background) 75 75 + }), 76 76 + ); 77 77 + } 78 78 + Layer { 79 79 + object_sizes: self.object_sizes, 80 80 + name: name.to_string(), 81 81 + objects, 82 82 + _render_cache: None, 83 83 + hidden: false, 84 84 + } 85 85 + } 86 86 + 87 87 + pub fn random_linelikes(&self, layer_name: &str) -> Layer { 88 88 + self.random_linelikes_within( 89 89 + layer_name, 90 90 + &self.world_region, 91 91 + self.objects_count_range.clone(), 92 92 + ) 93 93 + } 94 94 + 95 95 + pub fn random_region(&self) -> Region { 96 96 + Region::random(&self.world_region) 97 97 + } 98 98 + 99 99 + pub(crate) fn random_point(&self, region: &Region) -> Point { 100 100 + Point::random(region) 101 101 + } 102 102 + }

+2

src/random/mod.rs

Reviewed

··· 4 4 pub mod layer; 5 5 pub mod objects; 6 6 pub mod region; 7 7 + pub mod point; 7 8 8 9 pub use canvas::*; 9 10 pub use color::*; ··· 11 12 pub use layer::*; 12 13 pub use objects::*; 13 14 pub use region::*; 15 15 + pub use point::*;

+65

src/random/objects.rs

Reviewed

··· 1 1 + use std::collections::HashMap; 2 2 + 3 3 + use rand::{distributions::uniform::SampleRange, Rng}; 4 4 + 5 5 + use crate::{ColoredObject, Layer, LineSegment, Object, ObjectSizes, Point, Region}; 6 6 + 7 7 + impl Object { 8 8 + pub fn random_starting_at( 9 9 + start: Point, 10 10 + region: &Region, 11 11 + line_width: f32, 12 12 + polygon_vertices_range: impl SampleRange<usize>, 13 13 + ) -> Self { 14 14 + match rand::thread_rng().gen_range(1..=7) { 15 15 + 1 => Self::random_polygon(region, polygon_vertices_range), 16 16 + 2 => Self::BigCircle(start), 17 17 + 3 => Self::SmallCircle(start), 18 18 + 4 => Self::Dot(start), 19 19 + 5 => Self::CurveInward(start, region.random_end(start), line_width), 20 20 + 6 => Self::CurveOutward(start, region.random_end(start), line_width), 21 21 + 7 => Self::Line(Point::random(region), Point::random(region), line_width), 22 22 + _ => unreachable!(), 23 23 + } 24 24 + } 25 25 + 26 26 + pub fn random_polygon(region: &Region, vertices_range: impl SampleRange<usize>) -> Object { 27 27 + let number_of_anchors = rand::thread_rng().gen_range(vertices_range); 28 28 + let start = Point::random(region); 29 29 + let mut lines: Vec<LineSegment> = vec![]; 30 30 + for _ in 0..number_of_anchors { 31 31 + let next_anchor = Point::random(region); 32 32 + lines.push(Self::random_line(next_anchor)); 33 33 + } 34 34 + Object::Polygon(start, lines) 35 35 + } 36 36 + 37 37 + pub fn random_line(end: Point) -> LineSegment { 38 38 + match rand::thread_rng().gen_range(1..=3) { 39 39 + 1 => LineSegment::Straight(end), 40 40 + 2 => LineSegment::InwardCurve(end), 41 41 + 3 => LineSegment::OutwardCurve(end), 42 42 + _ => unreachable!(), 43 43 + } 44 44 + } 45 45 + 46 46 + 47 47 + pub fn random( 48 48 + region: &Region, 49 49 + line_width: f32, 50 50 + polygon_vertices_range: impl SampleRange<usize>, 51 51 + ) -> Object { 52 52 + let start = Point::random(region); 53 53 + Object::random_starting_at(start, region, line_width, polygon_vertices_range) 54 54 + } 55 55 + 56 56 + pub fn random_linelike_within(region: &Region, line_width: f32) -> Object { 57 57 + let start = region.random_point(); 58 58 + match rand::thread_rng().gen_range(1..=3) { 59 59 + 1 => Object::CurveInward(start, region.random_end(start), line_width), 60 60 + 2 => Object::CurveOutward(start, region.random_end(start), line_width), 61 61 + 3 => Object::Line(Point::random(region), Point::random(region), line_width), 62 62 + _ => unreachable!(), 63 63 + } 64 64 + } 65 65 + }

+13

src/random/point.rs

Reviewed

··· 1 1 + use rand::Rng; 2 2 + 3 3 + use crate::{Point, Region}; 4 4 + 5 5 + impl Point { 6 6 + pub fn random(within: &Region) -> Self { 7 7 + within.ensure_nonempty().unwrap(); 8 8 + Self( 9 9 + rand::thread_rng().gen_range(within.x_range()), 10 10 + rand::thread_rng().gen_range(within.y_range()), 11 11 + ) 12 12 + } 13 13 + }

+58

src/random/region.rs

Reviewed

··· 1 1 + use crate::{Containable, Point, Region}; 2 2 + use rand::Rng; 3 3 + 4 4 + impl Region { 5 5 + pub fn random_end(&self, start: Point) -> Point { 6 6 + // End anchors are always a square diagonal from the start anchor (for now) 7 7 + // that means taking steps of the form n * (one of (1, 1), (1, -1), (-1, 1), (-1, -1)) 8 8 + // Except that the end anchor needs to stay in the bounds of the shape. 9 9 + 10 10 + // Determine all possible end anchors that are in a square diagonal from the start anchor 11 11 + let mut possible_end_anchors = vec![]; 12 12 + 13 13 + // shapes can end on the next cell, since that's where they end 14 14 + let actual_region = self.enlarged(1, 1); 15 15 + 16 16 + for x in actual_region.mirrored_width_range() { 17 17 + for y in actual_region.mirrored_height_range() { 18 18 + let end_anchor = start.translated(x, y); 19 19 + 20 20 + if end_anchor == start { 21 21 + continue; 22 22 + } 23 23 + 24 24 + // Check that the end anchor is in a square diagonal from the start anchor and that the end anchor is in bounds 25 25 + if x.abs() == y.abs() && actual_region.contains(&end_anchor) { 26 26 + possible_end_anchors.push(end_anchor); 27 27 + } 28 28 + } 29 29 + } 30 30 + 31 31 + // Pick a random end anchor from the possible end anchors 32 32 + possible_end_anchors[rand::thread_rng().gen_range(0..possible_end_anchors.len())] 33 33 + } 34 34 + 35 35 + pub fn random(within: &Region) -> Self { 36 36 + let start = Point::random(within); 37 37 + let end = within.random_end(start); 38 38 + Region::from(if start.0 > end.0 { 39 39 + (end, start) 40 40 + } else { 41 41 + (start, end) 42 42 + }) 43 43 + } 44 44 + 45 45 + pub fn random_point(&self) -> Point { 46 46 + Point::random(self) 47 47 + } 48 48 + 49 49 + pub fn random_point_except(&self, except: &Region) -> Point { 50 50 + // XXX this is probably not a good idea lmao 51 51 + loop { 52 52 + let point = self.random_point(); 53 53 + if !except.contains(&point) { 54 54 + return point; 55 55 + } 56 56 + } 57 57 + } 58 58 + }

+115

src/wasm/layer.rs

Reviewed

··· 1 1 + use super::canvas; 2 2 + use crate::{ 3 3 + wasm::{append_new_div_inside, render_canvas, replace_content_with}, 4 4 + Color, Fill, Filter, Layer, Object, Point, 5 5 + }; 6 6 + use wasm_bindgen::prelude::wasm_bindgen; 7 7 + 8 8 + #[wasm_bindgen(getter_with_clone)] 9 9 + pub struct LayerWeb { 10 10 + pub name: String, 11 11 + } 12 12 + 13 13 + #[wasm_bindgen] 14 14 + pub fn new_layer(name: &str) -> LayerWeb { 15 15 + canvas().add_or_replace_layer(Layer::new(name)); 16 16 + LayerWeb { 17 17 + name: name.to_string(), 18 18 + } 19 19 + } 20 20 + 21 21 + // #[wasm_bindgen()] 22 22 + 23 23 + #[wasm_bindgen] 24 24 + impl LayerWeb { 25 25 + pub fn render(&self) -> String { 26 26 + render_canvas() 27 27 + } 28 28 + 29 29 + pub fn render_into(&self, selector: String) { 30 30 + append_new_div_inside(self.render(), selector) 31 31 + } 32 32 + 33 33 + pub fn render_at(self, selector: String) { 34 34 + replace_content_with(self.render(), selector) 35 35 + } 36 36 + 37 37 + pub fn paint_all(&self, color: Color, opacity: Option<f32>, filter: Filter) { 38 38 + canvas() 39 39 + .layer(&self.name) 40 40 + .paint_all_objects(Fill::Translucent(color, opacity.unwrap_or(1.0))); 41 41 + canvas().layer(&self.name).filter_all_objects(filter); 42 42 + } 43 43 + 44 44 + pub fn random(name: &str) -> Self { 45 45 + let layer = canvas().random_layer(name); 46 46 + canvas().add_or_replace_layer(layer); 47 47 + LayerWeb { 48 48 + name: name.to_string(), 49 49 + } 50 50 + } 51 51 + 52 52 + pub fn new_line(&self, name: &str, start: Point, end: Point, thickness: f32, color: Color) { 53 53 + canvas().layer(name).add_object( 54 54 + name, 55 55 + ( 56 56 + Object::Line(start, end, thickness), 57 57 + Some(Fill::Solid(color)), 58 58 + ) 59 59 + .into(), 60 60 + ) 61 61 + } 62 62 + pub fn new_curve_outward( 63 63 + &self, 64 64 + name: &str, 65 65 + start: Point, 66 66 + end: Point, 67 67 + thickness: f32, 68 68 + color: Color, 69 69 + ) { 70 70 + canvas().layer(name).add_object( 71 71 + name, 72 72 + Object::CurveOutward(start, end, thickness).color(Fill::Solid(color)), 73 73 + ) 74 74 + } 75 75 + pub fn new_curve_inward( 76 76 + &self, 77 77 + name: &str, 78 78 + start: Point, 79 79 + end: Point, 80 80 + thickness: f32, 81 81 + color: Color, 82 82 + ) { 83 83 + canvas().layer(name).add_object( 84 84 + name, 85 85 + Object::CurveInward(start, end, thickness).color(Fill::Solid(color)), 86 86 + ) 87 87 + } 88 88 + pub fn new_small_circle(&self, name: &str, center: Point, color: Color) { 89 89 + canvas() 90 90 + .layer(name) 91 91 + .add_object(name, Object::SmallCircle(center).color(Fill::Solid(color))) 92 92 + } 93 93 + pub fn new_dot(&self, name: &str, center: Point, color: Color) { 94 94 + canvas() 95 95 + .layer(name) 96 96 + .add_object(name, Object::Dot(center).color(Fill::Solid(color))) 97 97 + } 98 98 + pub fn new_big_circle(&self, name: &str, center: Point, color: Color) { 99 99 + canvas() 100 100 + .layer(name) 101 101 + .add_object(name, Object::BigCircle(center).color(Fill::Solid(color))) 102 102 + } 103 103 + pub fn new_text(&self, name: &str, anchor: Point, text: String, font_size: f32, color: Color) { 104 104 + canvas().layer(name).add_object( 105 105 + name, 106 106 + Object::Text(anchor, text, font_size).color(Fill::Solid(color)), 107 107 + ) 108 108 + } 109 109 + pub fn new_rectangle(&self, name: &str, topleft: Point, bottomright: Point, color: Color) { 110 110 + canvas().layer(name).add_object( 111 111 + name, 112 112 + Object::Rectangle(topleft, bottomright).color(Fill::Solid(color)), 113 113 + ) 114 114 + } 115 115 + }

+7

src/wasm/mod.rs

Reviewed

··· 1 1 + pub mod layer; 2 2 + pub mod transform; 3 3 + pub mod web; 4 4 + 5 5 + pub use layer::*; 6 6 + pub use transform::*; 7 7 + pub use web::*;

+1

src/wasm/transform.rs

Reviewed

··· 1 1 + use crate::{graphics::TransformationType, Transformation}; 1 2 use wasm_bindgen::prelude::*; 2 3 3 4 #[wasm_bindgen(getter_with_clone)]

+20 -119

src/wasm/web.rs

Reviewed

··· 6 6 use wasm_bindgen::prelude::wasm_bindgen; 7 7 use wasm_bindgen::{JsValue, UnwrapThrowExt}; 8 8 9 9 - use crate::{examples, Canvas, Color, ColorMapping, Fill, Filter, Layer, Object, Point}; 9 9 + use crate::{ 10 10 + examples, Canvas, Color, ColorMapping, Fill, Filter, Layer, Object, Point, SVGRenderable, 11 11 + }; 12 12 + 13 13 + use super::LayerWeb; 10 14 11 15 static WEB_CANVAS: Lazy<Mutex<Canvas>> = Lazy::new(|| Mutex::new(Canvas::default_settings())); 12 16 13 13 - fn canvas() -> std::sync::MutexGuard<'static, Canvas> { 17 17 + pub(super) fn canvas() -> std::sync::MutexGuard<'static, Canvas> { 14 18 WEB_CANVAS.lock().unwrap() 15 19 } 16 20 ··· 59 63 60 64 #[wasm_bindgen] 61 65 pub fn render_canvas_into(selector: String) { 62 62 - let svgstring = canvas().render_to_svg().unwrap_throw(); 63 63 - append_new_div_inside(svgstring, selector) 66 66 + append_new_div_inside(render_canvas(), selector) 64 67 } 65 68 66 69 #[wasm_bindgen] 67 70 pub fn render_canvas_at(selector: String) { 68 68 - let svgstring = canvas().render_to_svg().unwrap_throw(); 69 69 - replace_content_with(svgstring, selector) 71 71 + replace_content_with(render_canvas(), selector); 70 72 } 71 73 72 74 #[wasm_bindgen] ··· 129 131 } 130 132 131 133 #[wasm_bindgen] 132 132 - pub fn render_canvas() { 133 133 - canvas().render_to_svg().unwrap_throw(); 134 134 + pub fn render_canvas() -> String { 135 135 + let can = canvas(); 136 136 + can.render_to_svg( 137 137 + can.colormap.clone(), 138 138 + can.cell_size, 139 139 + can.object_sizes, 140 140 + "web_root_canvas", 141 141 + ) 142 142 + .unwrap_throw() 143 143 + .to_string() 134 144 } 135 145 136 146 #[wasm_bindgen] 137 147 pub fn set_palette(palette: ColorMapping) { 138 148 canvas().colormap = palette; 139 139 - } 140 140 - 141 141 - #[wasm_bindgen] 142 142 - pub fn new_layer(name: &str) -> LayerWeb { 143 143 - canvas().add_or_replace_layer(Layer::new(name)); 144 144 - LayerWeb { 145 145 - name: name.to_string(), 146 146 - } 147 149 } 148 150 149 151 #[wasm_bindgen] ··· 179 181 .expect_throw("could not get the element, but is was found (shouldn't happen)") 180 182 } 181 183 182 182 - fn append_new_div_inside(content: String, selector: String) { 184 184 + pub(super) fn append_new_div_inside(content: String, selector: String) { 183 185 let output = document().create_element("div").unwrap(); 184 186 output.set_class_name("frame"); 185 187 output.set_inner_html(&content); 186 188 query_selector(selector).append_child(&output).unwrap(); 187 189 } 188 190 189 189 - fn replace_content_with(content: String, selector: String) { 191 191 + pub(super) fn replace_content_with(content: String, selector: String) { 190 192 query_selector(selector).set_inner_html(&content); 191 193 } 192 192 - 193 193 - #[wasm_bindgen(getter_with_clone)] 194 194 - pub struct LayerWeb { 195 195 - pub name: String, 196 196 - } 197 197 - 198 198 - // #[wasm_bindgen()] 199 199 - 200 200 - #[wasm_bindgen] 201 201 - impl LayerWeb { 202 202 - pub fn render(&self) -> String { 203 203 - canvas().render_to_svg().unwrap_throw() 204 204 - } 205 205 - 206 206 - pub fn render_into(&self, selector: String) { 207 207 - append_new_div_inside(self.render(), selector) 208 208 - } 209 209 - 210 210 - pub fn render_at(self, selector: String) { 211 211 - replace_content_with(self.render(), selector) 212 212 - } 213 213 - 214 214 - pub fn paint_all(&self, color: Color, opacity: Option<f32>, filter: Filter) { 215 215 - canvas() 216 216 - .layer(&self.name) 217 217 - .paint_all_objects(Fill::Translucent(color, opacity.unwrap_or(1.0))); 218 218 - canvas().layer(&self.name).filter_all_objects(filter); 219 219 - } 220 220 - 221 221 - pub fn random(name: &str) -> Self { 222 222 - let layer = canvas().random_layer(name); 223 223 - canvas().add_or_replace_layer(layer); 224 224 - LayerWeb { 225 225 - name: name.to_string(), 226 226 - } 227 227 - } 228 228 - 229 229 - pub fn new_line(&self, name: &str, start: Point, end: Point, thickness: f32, color: Color) { 230 230 - canvas().layer(name).add_object( 231 231 - name, 232 232 - ( 233 233 - Object::Line(start, end, thickness), 234 234 - Some(Fill::Solid(color)), 235 235 - ) 236 236 - .into(), 237 237 - ) 238 238 - } 239 239 - pub fn new_curve_outward( 240 240 - &self, 241 241 - name: &str, 242 242 - start: Point, 243 243 - end: Point, 244 244 - thickness: f32, 245 245 - color: Color, 246 246 - ) { 247 247 - canvas().layer(name).add_object( 248 248 - name, 249 249 - Object::CurveOutward(start, end, thickness).color(Fill::Solid(color)), 250 250 - ) 251 251 - } 252 252 - pub fn new_curve_inward( 253 253 - &self, 254 254 - name: &str, 255 255 - start: Point, 256 256 - end: Point, 257 257 - thickness: f32, 258 258 - color: Color, 259 259 - ) { 260 260 - canvas().layer(name).add_object( 261 261 - name, 262 262 - Object::CurveInward(start, end, thickness).color(Fill::Solid(color)), 263 263 - ) 264 264 - } 265 265 - pub fn new_small_circle(&self, name: &str, center: Point, color: Color) { 266 266 - canvas() 267 267 - .layer(name) 268 268 - .add_object(name, Object::SmallCircle(center).color(Fill::Solid(color))) 269 269 - } 270 270 - pub fn new_dot(&self, name: &str, center: Point, color: Color) { 271 271 - canvas() 272 272 - .layer(name) 273 273 - .add_object(name, Object::Dot(center).color(Fill::Solid(color))) 274 274 - } 275 275 - pub fn new_big_circle(&self, name: &str, center: Point, color: Color) { 276 276 - canvas() 277 277 - .layer(name) 278 278 - .add_object(name, Object::BigCircle(center).color(Fill::Solid(color))) 279 279 - } 280 280 - pub fn new_text(&self, name: &str, anchor: Point, text: String, font_size: f32, color: Color) { 281 281 - canvas().layer(name).add_object( 282 282 - name, 283 283 - Object::Text(anchor, text, font_size).color(Fill::Solid(color)), 284 284 - ) 285 285 - } 286 286 - pub fn new_rectangle(&self, name: &str, topleft: Point, bottomright: Point, color: Color) { 287 287 - canvas().layer(name).add_object( 288 288 - name, 289 289 - Object::Rectangle(topleft, bottomright).color(Fill::Solid(color)), 290 290 - ) 291 291 - } 292 292 - }