// Port of p5.js src/core/{main,structure}.js: the setup/draw lifecycle.

///|
/// Starts a sketch in the browser, like creating `new p5(sketch)`.
///
/// A 100×100 canvas is created before `setup` runs (call `create_canvas`
/// in `setup` to resize it). `preload` may start asset loads such as
/// `load_image`; `setup` runs once they have all finished. Then `draw` is
/// called once per frame. Every callback is optional.
///
/// `container` is the id of an element to put the canvas in (by default the
/// canvas goes into `
`). `seed` seeds `random()` and `noise()` /// (random by default). /// /// ```mbt nocheck /// fn main { /// @p5.run(setup=p => p.create_canvas(400, 400), draw=p => { /// p.background(220) /// p.circle(p.mouse_x, p.mouse_y, 50) /// }) /// } /// ``` pub fn run( preload? : (P5) -> Unit, setup? : (P5) -> Unit, draw? : (P5) -> Unit, mouse_pressed? : (P5) -> Unit, mouse_released? : (P5) -> Unit, mouse_clicked? : (P5) -> Unit, double_clicked? : (P5) -> Unit, mouse_moved? : (P5) -> Unit, mouse_dragged? : (P5) -> Unit, mouse_wheel? : (P5, Double) -> Unit, key_pressed? : (P5) -> Unit, key_released? : (P5) -> Unit, key_typed? : (P5) -> Unit, touch_started? : (P5) -> Unit, touch_moved? : (P5) -> Unit, touch_ended? : (P5) -> Unit, window_resized? : (P5) -> Unit, device_moved? : (P5) -> Unit, device_turned? : (P5) -> Unit, device_shaken? : (P5) -> Unit, container~ : String = "", seed? : Double, ) -> Unit { @dom.on_ready(() => { let density = @dom.device_pixel_ratio().ceil() let canvas = @dom.create_canvas(100, 100, density, container, true) let seed = match seed { Some(s) => s None => (@dom.math_random() * 4294967296.0).floor() } let p = P5::make(CanvasSurface::new(canvas), 100, 100, density, seed) p.canvas = Some(canvas) p.is_main = true p.container = container p.window_width = @dom.window_width() p.window_height = @dom.window_height() p.focused = @dom.document_has_focus() let cb = p.callbacks if setup is Some(f) { cb.setup = f } cb.draw = draw if mouse_pressed is Some(f) { cb.mouse_pressed = f } if mouse_released is Some(f) { cb.mouse_released = f } if mouse_clicked is Some(f) { cb.mouse_clicked = f } if double_clicked is Some(f) { cb.double_clicked = f } if mouse_moved is Some(f) { cb.mouse_moved = f } if mouse_dragged is Some(f) { cb.mouse_dragged = f } if mouse_wheel is Some(f) { cb.mouse_wheel = f } if key_pressed is Some(f) { cb.key_pressed = f } if key_released is Some(f) { cb.key_released = f } if key_typed is Some(f) { cb.key_typed = f } if touch_started is Some(f) { cb.touch_started = f } if touch_moved is Some(f) { cb.touch_moved = f } if touch_ended is Some(f) { cb.touch_ended = f } if window_resized is Some(f) { cb.window_resized = f } cb.device_moved = device_moved cb.device_turned = device_turned cb.device_shaken = device_shaken p.device_orientation = if p.window_width / p.window_height > 1.0 { "landscape" } else { "portrait" } p.apply_defaults() p.install_events(canvas) if preload is Some(f) { f(p) } p.when_loaded(() => p.start()) }) } ///| /// Calls `f` once every pending asset load has finished. fn P5::when_loaded(self : P5, f : () -> Unit) -> Unit { if self.pending_loads == 0 { f() } else { self.on_loads_done = f } } ///| fn P5::begin_load(self : P5) -> Unit { self.pending_loads += 1 } ///| fn P5::end_load(self : P5) -> Unit { self.pending_loads -= 1 if self.pending_loads == 0 { let f = self.on_loads_done self.on_loads_done = () => () f() } } ///| fn P5::start(self : P5) -> Unit { self.millis_start = @dom.now() (self.callbacks.setup)(self) self.update_accs_outputs() let now = @dom.now() self.last_target_frame_time = now self.last_real_frame_time = now self.setup_done = true self.millis_start = now if self.recording is Some(_) { self.record_step() } else { self.schedule_frame(immediate=true) } } ///| fn P5::schedule_frame(self : P5, immediate~ : Bool = false) -> Unit { if self.draw_scheduled { return } self.draw_scheduled = true if immediate { self.frame(@dom.now()) } else { @dom.request_animation_frame(ts => self.frame(ts)) } } ///| fn P5::frame(self : P5, now : Double) -> Unit { self.draw_scheduled = false let since = now - self.last_target_frame_time let target = 1000.0 / self.target_frame_rate if !self.looping || since >= target - 5 { self.delta_time = now - self.last_real_frame_time self.frame_rate_value = if self.delta_time > 0 { 1000.0 / self.delta_time } else { 0 } self.redraw_once() self.last_target_frame_time = (self.last_target_frame_time + target).max( now, ) self.last_real_frame_time = now self.update_mouse_coords() self.moved_x = 0 self.moved_y = 0 } if self.looping { self.schedule_frame() } } ///| fn P5::redraw_once(self : P5) -> Unit { guard self.callbacks.draw is Some(draw) else { return } if self.pending_svg is Some(filename) { self.pending_svg = None let coll = self.build_shape(() => self.redraw_frame(draw), draw=true) self.save_svg(coll, filename~) return } self.redraw_frame(draw) } ///| fn P5::redraw_frame(self : P5, draw : (P5) -> Unit) -> Unit { self.reset_matrix() if self.gl is Some(r) { r.update() self.state.tint = None } self.frame_count += 1 self.in_draw = true // Clipping applied during a frame ends with the frame. self.surface.save() draw(self) self.in_draw = false self.update_accs_outputs() self.draw_debug_mode() // Undo unbalanced push() calls. while !self.stack.is_empty() { self.pop() } self.surface.restore() self.surface.set_blend_mode( if self.state.erasing { Remove } else { self.state.blend_mode }, ) self.surface.set_smoothing(self.state.smooth) } ///| /// Sets the function called by `redraw()` (for headless sketches). pub fn P5::set_draw(self : P5, draw : (P5) -> Unit) -> Unit { self.callbacks.draw = Some(draw) self.setup_done = true } ///| /// Runs `draw` `n` times (once by default), e.g. after `no_loop()`. pub fn P5::redraw(self : P5, n~ : Int32 = 1) -> Unit { if self.in_draw || !self.setup_done { return } for _ in 0.. Unit { self.looping = false } ///| /// Resumes calling `draw` every frame. pub fn P5::loop_(self : P5) -> Unit { if !self.looping { self.looping = true if self.setup_done && self.is_main { self.schedule_frame() } } } ///| /// Whether `draw` is called every frame. pub fn P5::is_looping(self : P5) -> Bool { self.looping }