Crate whiskers

Whiskers is an interactive environment for pen-plotter generative art sketches.

Native sketch

To create a whiskers sketch that will only be run natively, create a new Rust project and add the whiskers crate as a dependency:

cargo add whiskers

Then, add the following content to the main.rs file:

use whiskers::prelude::*;

#[sketch_app]
struct MySketch {
    /* add sketch parameters here */
}

impl Default for MySketch {
    fn default() -> Self {
        Self {
            /* initialize sketch parameters to default values here */
        }
    }
}

impl App for MySketch {
    fn update(&mut self, sketch: &mut Sketch, _ctx: &mut Context) -> anyhow::Result<()> {
        // draw code goes here
        sketch
            .color(Color::DARK_RED)
            .rect(200., 200., 150., 50.);

        Ok(())
    }
}

fn main() -> Result {
    MySketch::runner()
        .with_page_size_options(PageSize::A5H)
        /* add other Runner default configuration here */
        .run()
}

See the crate::Sketch type documentation for more information on the drawing code. See the crate::Runner type documentation for more information on the available configurations.

Sketches with Wasm support

For sketches that target both native and Wasm, your crate should be structured as both a library and a binary. The library should contain the sketch code as well as the wasm_sketch! macro:

// lib.rs

use whiskers::prelude::*;
use whiskers::wasm_main;

#[sketch_app]
struct MySketch { }

impl Default for MySketch {
    fn default() -> Self {
        Self { }
    }
}

impl App for MySketch {
    fn update(&mut self, sketch: &mut Sketch, _ctx: &mut Context) -> anyhow::Result<()> {
        Ok(())
    }
}
wasm_sketch!(MySketch::runner());

The binary should then call the wasm_main! macro:

// main.rs

wasm_main!(my_sketch);  // `my_sketch` is the crate name

Deploying the Wasm sketch additionally requires a spacial index.html file. See the whiskers-web-demo crate for an example.

Modules

prelude

This module re-export all the types, traits, macros, and dependencies needed to run a sketch.

Macros

wasm_main

Declare the binary entry point in Wasm-ready sketch crates.

wasm_sketch

Declare the main entry point for wasm builds.

Structs

AnimationOptions

Controls the animation feature of the runner.

Context

Context passed to crate::App::update.

Grid

2-dimensional square grid module

GridCell

Stores basic grid’s cell data, like column, row and canvas position

HexGrid

Hexagonal grid module

HexGridCell

Stores basic hex grid’s cell data, like size, orientation, or canvas position

InfoOptions

Controls the info section of the runner.

PageSizeOptions

Controls the page size feature of the runner.

Runner

The Runner is the main entry point for executing a crate::SketchApp.

Sketch

Primary interface for drawing.

Enums

LayoutOptions

Controls the layout feature of the runner.

Traits

App

This is the trait that your sketch app must explicitly implement. The App::update function is where the sketch draw code goes.

SketchApp

This trait is implemented by the whiskers_widgets::Sketch derive macro and makes it possible for the Runner to execute your sketch.s

Type Aliases

Result

This is a convenience alias to the anyhow::Result type, which you can use for your sketch’s main function.