Struct MeowMeowRunner 

pub struct MeowMeowRunner;

Synchronous wrapper around MeowMeowEvaluator.

Spawns an evaluator thread, sends a script, drains all responses to completion, and returns the collected EvalOutput. The thread is shut down and joined before returning.

Implementations

impl MeowMeowRunner

pub fn eval(source: &str) -> EvalOutput

Evaluate source without a live ECS world, collecting emitted intents and errors.

This mode cannot allocate live ComponentIds during evaluation, so let-bound component expressions stay as ComponentExpr values rather than becoming live ComponentObject handles.

Times out after 2 seconds if the evaluator stalls.

Examples found in repository

examples/vr-input-mms.rs (line 7)

fn main() {
    mittens_engine::example_support::ensure_model_assets();
    utils::logger::init();

    let output = scripting::MeowMeowRunner::eval(include_str!("vr-input.mms"));

    for error in &output.errors {
        eprintln!("[mms] {error}");
    }
    println!("[mms] {} intent(s) from vr-input.mms", output.intents.len());

    let world = engine::ecs::World::default();
    let mut universe = engine::Universe::new(world);

    let scope = engine::ecs::ComponentId::default();
    for intent in output.intents {
        universe.command_queue.push_intent_now(scope, intent);
    }

    universe.systems.process_commands(
        &mut universe.world,
        &mut universe.visuals,
        &mut universe.render_assets,
        &mut universe.command_queue,
    );

    engine::Windowing::run_app(universe).expect("Windowing failed");
}

examples/ui-layout.rs (line 7)

fn main() {
    mittens_engine::example_support::ensure_model_assets();
    utils::logger::init();

    let output = scripting::MeowMeowRunner::eval(include_str!("ui-layout.mms"));

    for error in &output.errors {
        eprintln!("[mms] {error}");
    }
    println!(
        "[mms] {} intent(s) from ui-layout.mms",
        output.intents.len()
    );

    let world = engine::ecs::World::default();
    let mut universe = engine::Universe::new(world);

    let scope = engine::ecs::ComponentId::default();
    for intent in output.intents {
        universe.command_queue.push_intent_now(scope, intent);
    }

    universe.systems.process_commands(
        &mut universe.world,
        &mut universe.visuals,
        &mut universe.render_assets,
        &mut universe.command_queue,
    );

    universe.enable_repl();
    engine::Windowing::run_app(universe).expect("Windowing failed");
}

examples/vtuber-desktop.rs (line 7)

fn main() {
    mittens_engine::example_support::ensure_model_assets();
    utils::logger::init();

    let output = scripting::MeowMeowRunner::eval(include_str!("vtuber-desktop.mms"));

    for error in &output.errors {
        eprintln!("[mms] {error}");
    }
    println!(
        "[mms] {} intent(s) from vtuber-desktop.mms",
        output.intents.len()
    );

    let world = engine::ecs::World::default();
    let mut universe = engine::Universe::new(world);

    let scope = engine::ecs::ComponentId::default();
    for intent in output.intents {
        universe.command_queue.push_intent_now(scope, intent);
    }

    universe.systems.process_commands(
        &mut universe.world,
        &mut universe.visuals,
        &mut universe.render_assets,
        &mut universe.command_queue,
    );

    universe.enable_repl();
    engine::Windowing::run_app(universe).expect("Windowing failed");
}

examples/inline-block-layout.rs (line 7)

fn main() {
    mittens_engine::example_support::ensure_model_assets();
    utils::logger::init();

    let output = scripting::MeowMeowRunner::eval(include_str!("inline-block-layout.mms"));

    for error in &output.errors {
        eprintln!("[mms] {error}");
    }
    println!(
        "[mms] {} intent(s) from inline-block-layout.mms",
        output.intents.len()
    );

    let world = engine::ecs::World::default();
    let mut universe = engine::Universe::new(world);

    let scope = engine::ecs::ComponentId::default();
    for intent in output.intents {
        universe.command_queue.push_intent_now(scope, intent);
    }

    universe.systems.process_commands(
        &mut universe.world,
        &mut universe.visuals,
        &mut universe.render_assets,
        &mut universe.command_queue,
    );

    universe.enable_repl();
    engine::Windowing::run_app(universe).expect("Windowing failed");
}

examples/vtuber-desktop-first-person.rs (line 7)

fn main() {
    mittens_engine::example_support::ensure_model_assets();
    utils::logger::init();

    let output = scripting::MeowMeowRunner::eval(include_str!("vtuber-desktop-first-person.mms"));

    for error in &output.errors {
        eprintln!("[mms] {error}");
    }
    println!(
        "[mms] {} intent(s) from vtuber-desktop-first-person.mms",
        output.intents.len()
    );

    let world = engine::ecs::World::default();
    let mut universe = engine::Universe::new(world);

    let scope = engine::ecs::ComponentId::default();
    for intent in output.intents {
        universe.command_queue.push_intent_now(scope, intent);
    }

    universe.systems.process_commands(
        &mut universe.world,
        &mut universe.visuals,
        &mut universe.render_assets,
        &mut universe.command_queue,
    );

    universe.enable_repl();
    engine::Windowing::run_app(universe).expect("Windowing failed");
}

examples/text-input.rs (line 7)

fn main() {
    mittens_engine::example_support::ensure_model_assets();
    utils::logger::init();

    let output = scripting::MeowMeowRunner::eval(include_str!("text-input.mms"));

    for error in &output.errors {
        eprintln!("[mms] {error}");
    }
    println!(
        "[mms] {} intent(s) from text-input.mms",
        output.intents.len()
    );

    if !output.errors.is_empty() {
        std::process::exit(1);
    }

    let world = engine::ecs::World::default();
    let mut universe = engine::Universe::new(world);

    let scope = engine::ecs::ComponentId::default();
    for intent in output.intents {
        universe.command_queue.push_intent_now(scope, intent);
    }

    universe.systems.process_commands(
        &mut universe.world,
        &mut universe.visuals,
        &mut universe.render_assets,
        &mut universe.command_queue,
    );

    universe.enable_repl();
    engine::Windowing::run_app(universe).expect("Windowing failed");
}

Additional examples can be found in:

• examples/text-editor.rs
• examples/pipe-demo.rs
• examples/mms-loops.rs
• examples/mms-functions.rs
• examples/triage/panel-pierce.rs
• examples/vtuber-mirror-example.rs
• examples/vtuber-editor-example.rs
• examples/scrolling.rs
• examples/diy-panel.rs

pub fn eval_with_timeout(source: &str, timeout: Duration) -> EvalOutput

Evaluate source with a caller-provided timeout.

pub fn eval_with_path(source: &str, path: &str) -> EvalOutput

Evaluate source knowing it came from path (enables relative imports).

pub fn eval_file(path: &str) -> EvalOutput

Read path from disk and evaluate it (enables relative imports).

Examples found in repository

examples/vtuber-secondary-motion.rs (line 7)

fn main() {
    mittens_engine::example_support::ensure_model_assets();
    utils::logger::init();
    // A path-aware evaluation is required so the scene can import its MMS preset module.
    let output = scripting::MeowMeowRunner::eval_file("examples/vtuber-secondary-motion.mms");
    for error in &output.errors {
        eprintln!("[mms] {error}");
    }
    assert!(
        output.errors.is_empty(),
        "MMS evaluation produced errors: {:?}",
        output.errors
    );

    let mut universe = engine::Universe::new(engine::ecs::World::default());
    let scope = engine::ecs::ComponentId::default();
    for intent in output.intents {
        universe.command_queue.push_intent_now(scope, intent);
    }
    universe.systems.process_commands(
        &mut universe.world,
        &mut universe.visuals,
        &mut universe.render_assets,
        &mut universe.command_queue,
    );
    universe.enable_repl();
    engine::Windowing::run_app(universe).expect("Windowing failed");
}

examples/mms-module-example.rs (line 22)

fn main() {
    mittens_engine::example_support::ensure_model_assets();
    utils::logger::init();

    // eval_file passes the path so `import "cat.mms"` resolves relative to
    // examples/ — do NOT use include_str! here (that loses the path).
    let output = scripting::MeowMeowRunner::eval_file("examples/mms-module-example.mms");

    for error in &output.errors {
        eprintln!("[mms] error: {error}");
    }
    assert!(
        output.errors.is_empty(),
        "MMS evaluation produced errors: {:?}",
        output.errors,
    );

    println!("[mms] {} intent(s):", output.intents.len());
    for intent in &output.intents {
        if let engine::ecs::IntentValue::SpawnComponentTree { root, .. } = intent {
            println!("  spawn {}", root.component_type);
        }
    }

    let world = engine::ecs::World::default();
    let mut universe = engine::Universe::new(world);

    let scope = engine::ecs::ComponentId::default();
    for intent in output.intents {
        universe.command_queue.push_intent_now(scope, intent);
    }

    // Camera placed to see the cat from slightly above and in front.
    example_util::spawn_mms_demo_rig(&mut universe, [0.0, 1.2, 4.5]);

    universe.systems.process_commands(
        &mut universe.world,
        &mut universe.visuals,
        &mut universe.render_assets,
        &mut universe.command_queue,
    );

    engine::Windowing::run_app(universe).expect("Windowing failed");
}

examples/render-graph-diagram.rs (line 25)

fn main() {
    mittens_engine::example_support::ensure_model_assets();
    utils::logger::init();

    let output = scripting::MeowMeowRunner::eval_file("examples/render-graph-diagram.mms");

    for error in &output.errors {
        eprintln!("[mms] error: {error}");
    }
    if !output.errors.is_empty() {
        eprintln!(
            "[mms] {} error(s) — scene may be incomplete",
            output.errors.len()
        );
    }

    println!("[mms] {} intent(s) emitted:", output.intents.len());
    for intent in &output.intents {
        if let engine::ecs::IntentValue::SpawnComponentTree { root, .. } = intent {
            println!("  spawn {}", root.component_type);
        }
    }

    let world = engine::ecs::World::default();
    let mut universe = engine::Universe::new(world);

    // Push all MMS-emitted intents into the engine.
    let scope = engine::ecs::ComponentId::default();
    for intent in output.intents {
        universe.command_queue.push_intent_now(scope, intent);
    }

    // Camera: pulled back and slightly elevated so the full scene is in view.
    // The emissive orbs above the pedestals are the focal point.
    example_util::spawn_mms_demo_rig(&mut universe, [0.0, 2.2, 7.0]);

    universe.systems.process_commands(
        &mut universe.world,
        &mut universe.visuals,
        &mut universe.render_assets,
        &mut universe.command_queue,
    );

    engine::Windowing::run_app(universe).expect("Windowing failed");
}

pub fn eval_file_with_timeout(path: &str, timeout: Duration) -> EvalOutput

Read path from disk and evaluate it (enables relative imports) with a caller-provided timeout.

Examples found in repository

examples/bloom.rs (lines 8-11)

fn main() {
    mittens_engine::example_support::ensure_model_assets();
    utils::logger::init();

    let output = scripting::MeowMeowRunner::eval_file_with_timeout(
        "examples/bloom.mms",
        Duration::from_secs(10),
    );

    for error in &output.errors {
        eprintln!("[mms] error: {error}");
    }
    assert!(
        output.errors.is_empty(),
        "MMS evaluation produced errors: {:?}",
        output.errors,
    );

    println!("[mms] {} intent(s) from bloom.mms", output.intents.len());

    let world = engine::ecs::World::default();
    let mut universe = engine::Universe::new(world);

    let scope = engine::ecs::ComponentId::default();
    for intent in output.intents {
        universe.command_queue.push_intent_now(scope, intent);
    }

    universe.systems.process_commands(
        &mut universe.world,
        &mut universe.visuals,
        &mut universe.render_assets,
        &mut universe.command_queue,
    );

    engine::Windowing::run_app(universe).expect("Windowing failed");
}

examples/camera-constraint.rs (lines 8-11)

fn main() {
    mittens_engine::example_support::ensure_model_assets();
    utils::logger::init();

    let output = scripting::MeowMeowRunner::eval_file_with_timeout(
        "examples/camera-constraint.mms",
        Duration::from_secs(10),
    );

    for error in &output.errors {
        eprintln!("[mms] error: {error}");
    }
    assert!(
        output.errors.is_empty(),
        "MMS evaluation produced errors: {:?}",
        output.errors,
    );

    println!(
        "[mms] {} intent(s) from camera-constraint.mms",
        output.intents.len()
    );

    let world = engine::ecs::World::default();
    let mut universe = engine::Universe::new(world);

    let scope = engine::ecs::ComponentId::default();
    for intent in output.intents {
        universe.command_queue.push_intent_now(scope, intent);
    }

    universe.systems.process_commands(
        &mut universe.world,
        &mut universe.visuals,
        &mut universe.render_assets,
        &mut universe.command_queue,
    );

    engine::Windowing::run_app(universe).expect("Windowing failed");
}

pub fn load_module_source( source: &str, source_path: Option<&str>, ) -> Result<LoadedMmsModule, String>

pub fn load_module_file(path: &str) -> Result<LoadedMmsModule, String>

pub fn call_mms_module_fn( module: &LoadedMmsModule, name: &str, args: Vec<Value>, channels: Option<&mut EvalChannels>, world_host: Option<&mut World>, emit: Option<&mut dyn SignalEmitter>, ) -> Result<Value, String>

pub fn materialize_mms_module_component( module: &LoadedMmsModule, name: &str, args: Vec<Value>, world_host: Option<&mut World>, emit: Option<&mut dyn SignalEmitter>, ) -> Result<MaterializedCE, String>

pub fn materialize_mms_module_component_in_mode( module: &LoadedMmsModule, name: &str, args: Vec<Value>, world_host: Option<&mut World>, emit: Option<&mut dyn SignalEmitter>, mode: ModuleFactoryEvalMode, ) -> Result<MaterializedCE, String>

pub fn materialize_mms_module_component_from_file( path: &str, name: &str, args: Vec<Value>, world_host: Option<&mut World>, emit: Option<&mut dyn SignalEmitter>, ) -> Result<MaterializedCE, String>

pub fn spawn_mms_module_component_uninitialized( module: &LoadedMmsModule, name: &str, args: Vec<Value>, world: &mut World, emit: &mut dyn SignalEmitter, ) -> Result<ComponentId, String>

pub fn spawn_mms_module_component_uninitialized_with_assets( module: &LoadedMmsModule, name: &str, args: Vec<Value>, world: &mut World, render_assets: Option<&mut RenderAssets>, emit: &mut dyn SignalEmitter, ) -> Result<ComponentId, String>

pub fn spawn_mms_module_component_uninitialized_from_file( path: &str, name: &str, args: Vec<Value>, world: &mut World, emit: &mut dyn SignalEmitter, ) -> Result<ComponentId, String>

pub fn spawn_mms_module_component( module: &LoadedMmsModule, name: &str, args: Vec<Value>, parent: Option<ComponentId>, world: &mut World, emit: &mut dyn SignalEmitter, ) -> Result<ComponentId, String>

pub fn spawn_mms_module_component_from_file( path: &str, name: &str, args: Vec<Value>, parent: Option<ComponentId>, world: &mut World, emit: &mut dyn SignalEmitter, ) -> Result<ComponentId, String>

pub fn eval_with_world( source: &str, world: &mut World, rx: &mut RxWorld, emit: &mut dyn SignalEmitter, ) -> EvalOutput

Evaluate source with live world access.

Handles two HostCall kinds during evaluation:

• Spawn: spawns the component tree into world and returns the root ComponentId. let x = T {} binds a ComponentObject(id) instead of a dead ComponentExpr.
• RegisterHandler: installs an MMS function as a scoped signal handler in rx. on(obj, "Click", fn(e) { ... }) registers without blocking the evaluator.

Examples found in repository

examples/qdebug.rs (lines 8-13)

fn main() {
    mittens_engine::example_support::ensure_model_assets();
    utils::logger::init();
    let world = engine::ecs::World::default();
    let mut universe = engine::Universe::new(world);
    let src = include_str!("qdebug.mms");
    let out = scripting::MeowMeowRunner::eval_with_world(
        src,
        &mut universe.world,
        &mut universe.systems.rx,
        &mut universe.command_queue,
    );
    for e in &out.errors {
        eprintln!("[mms-err] {e}");
    }
    println!("intents: {}", out.intents.len());
    for c in universe.world.all_components() {
        if let Some(label) = universe.world.component_label(c) {
            {
                println!(
                    "  comp {:?} type={:?} name={:?}",
                    c,
                    universe.world.component_name(c),
                    label
                );
            }
        }
    }
}

examples/query-demo.rs (lines 18-23)

fn main() {
    mittens_engine::example_support::ensure_model_assets();
    utils::logger::init();

    let world = engine::ecs::World::default();
    let mut universe = engine::Universe::new(world);

    let source = include_str!("query-demo.mms");
    let output = scripting::MeowMeowRunner::eval_with_world(
        source,
        &mut universe.world,
        &mut universe.systems.rx,
        &mut universe.command_queue,
    );

    for err in &output.errors {
        eprintln!("[mms] {err}");
    }
    if !output.errors.is_empty() {
        std::process::exit(1);
    }

    for intent in output.intents {
        universe
            .command_queue
            .push_intent_now(engine::ecs::ComponentId::default(), intent);
    }

    universe.systems.process_commands(
        &mut universe.world,
        &mut universe.visuals,
        &mut universe.render_assets,
        &mut universe.command_queue,
    );

    universe.enable_repl();
    engine::Windowing::run_app(universe).expect("Windowing failed");
}

examples/component-method-call.rs (lines 20-25)

fn main() {
    mittens_engine::example_support::ensure_model_assets();
    utils::logger::init();

    let world = engine::ecs::World::default();
    let mut universe = engine::Universe::new(world);

    let source = include_str!("component-method-call.mms");
    let output = scripting::MeowMeowRunner::eval_with_world(
        source,
        &mut universe.world,
        &mut universe.systems.rx,
        &mut universe.command_queue,
    );

    for err in &output.errors {
        eprintln!("[mms] {err}");
    }
    if !output.errors.is_empty() {
        std::process::exit(1);
    }

    for intent in output.intents {
        universe
            .command_queue
            .push_intent_now(engine::ecs::ComponentId::default(), intent);
    }

    universe.systems.process_commands(
        &mut universe.world,
        &mut universe.visuals,
        &mut universe.render_assets,
        &mut universe.command_queue,
    );

    universe.enable_repl();
    engine::Windowing::run_app(universe).expect("Windowing failed");
}

examples/signal-handler.rs (lines 19-24)

fn main() {
    mittens_engine::example_support::ensure_model_assets();
    utils::logger::init();

    let world = engine::ecs::World::default();
    let mut universe = engine::Universe::new(world);

    // Evaluate the MMS script with live world access.
    // on() calls inside the script register Click handlers into universe.systems.rx.
    let source = include_str!("signal-handler.mms");
    let output = scripting::MeowMeowRunner::eval_with_world(
        source,
        &mut universe.world,
        &mut universe.systems.rx,
        &mut universe.command_queue,
    );

    for err in &output.errors {
        eprintln!("[mms] {err}");
    }
    if !output.errors.is_empty() {
        std::process::exit(1);
    }

    // Any bare CE emissions from the script (not let-bound) are in output.intents.
    // Our script only uses let-bindings so this is empty, but handle it anyway.
    for intent in output.intents {
        universe
            .command_queue
            .push_intent_now(engine::ecs::ComponentId::default(), intent);
    }

    universe.systems.process_commands(
        &mut universe.world,
        &mut universe.visuals,
        &mut universe.render_assets,
        &mut universe.command_queue,
    );

    universe.enable_repl();
    engine::Windowing::run_app(universe).expect("Windowing failed");
}

pub fn eval_with_world_at_path( source: &str, source_path: Option<&str>, world: &mut World, rx: &mut RxWorld, emit: &mut dyn SignalEmitter, ) -> EvalOutput

Like eval_with_world, but also records the source file path so import statements resolve relative to it.

Examples found in repository

examples/mms-tables.rs (lines 10-16)

fn main() {
    mittens_engine::example_support::ensure_model_assets();
    utils::logger::init();

    let world = engine::ecs::World::default();
    let mut universe = engine::Universe::new(world);

    let output = scripting::MeowMeowRunner::eval_with_world_at_path(
        include_str!("mms-tables.mms"),
        Some("examples/mms-tables.mms"),
        &mut universe.world,
        &mut universe.systems.rx,
        &mut universe.command_queue,
    );

    for error in &output.errors {
        eprintln!("[mms] {error}");
    }
    println!(
        "[mms] {} intent(s) from mms-tables.mms",
        output.intents.len()
    );

    let scope = engine::ecs::ComponentId::default();
    for intent in output.intents {
        universe.command_queue.push_intent_now(scope, intent);
    }

    universe.systems.process_commands(
        &mut universe.world,
        &mut universe.visuals,
        &mut universe.render_assets,
        &mut universe.command_queue,
    );

    universe.enable_repl();
    engine::Windowing::run_app(universe).expect("Windowing failed");
}

examples/input-xr-gamepad.rs (lines 10-16)

fn main() {
    mittens_engine::example_support::ensure_model_assets();
    utils::logger::init();

    let world = engine::ecs::World::default();
    let mut universe = engine::Universe::new(world);

    let output = scripting::MeowMeowRunner::eval_with_world_at_path(
        include_str!("input-xr-gamepad.mms"),
        Some("examples/input-xr-gamepad.mms"),
        &mut universe.world,
        &mut universe.systems.rx,
        &mut universe.command_queue,
    );

    for error in &output.errors {
        eprintln!("[mms] {error}");
    }
    println!(
        "[mms] {} intent(s) from input-xr-gamepad.mms",
        output.intents.len()
    );

    let scope = engine::ecs::ComponentId::default();
    for intent in output.intents {
        universe.command_queue.push_intent_now(scope, intent);
    }

    universe.systems.process_commands(
        &mut universe.world,
        &mut universe.visuals,
        &mut universe.render_assets,
        &mut universe.command_queue,
    );

    universe.enable_repl();
    engine::Windowing::run_app(universe).expect("Windowing failed");
}

examples/font-size.rs (lines 11-17)

fn main() {
    mittens_engine::example_support::ensure_model_assets();
    utils::logger::init();

    let world = engine::ecs::World::default();
    let mut universe = engine::Universe::new(world);

    let source = include_str!("font-size.mms");
    let output = scripting::MeowMeowRunner::eval_with_world_at_path(
        source,
        Some("examples/font-size.mms"),
        &mut universe.world,
        &mut universe.systems.rx,
        &mut universe.command_queue,
    );

    for error in &output.errors {
        eprintln!("[mms] {error}");
    }
    println!(
        "[mms] {} intent(s) from font-size.mms",
        output.intents.len()
    );

    for intent in output.intents {
        universe
            .command_queue
            .push_intent_now(engine::ecs::ComponentId::default(), intent);
    }

    universe.systems.process_commands(
        &mut universe.world,
        &mut universe.visuals,
        &mut universe.render_assets,
        &mut universe.command_queue,
    );

    universe.enable_repl();
    engine::Windowing::run_app(universe).expect("Windowing failed");
}

examples/table-field-reassign.rs (lines 10-16)

fn main() {
    mittens_engine::example_support::ensure_model_assets();
    utils::logger::init();

    let world = engine::ecs::World::default();
    let mut universe = engine::Universe::new(world);

    let output = scripting::MeowMeowRunner::eval_with_world_at_path(
        include_str!("table-field-reassign.mms"),
        Some("examples/table-field-reassign.mms"),
        &mut universe.world,
        &mut universe.systems.rx,
        &mut universe.command_queue,
    );

    for error in &output.errors {
        eprintln!("[mms] {error}");
    }
    println!(
        "[mms] {} intent(s) from table-field-reassign.mms",
        output.intents.len()
    );

    let scope = engine::ecs::ComponentId::default();
    for intent in output.intents {
        universe.command_queue.push_intent_now(scope, intent);
    }

    universe.systems.process_commands(
        &mut universe.world,
        &mut universe.visuals,
        &mut universe.render_assets,
        &mut universe.command_queue,
    );

    universe.enable_repl();
    engine::Windowing::run_app(universe).expect("Windowing failed");
}

examples/world-panel.rs (lines 11-17)

fn main() {
    mittens_engine::example_support::ensure_model_assets();
    utils::logger::init();

    let world = engine::ecs::World::default();
    let mut universe = engine::Universe::new(world);

    let source = include_str!("world-panel.mms");
    let output = scripting::MeowMeowRunner::eval_with_world_at_path(
        source,
        Some("examples/world-panel.mms"),
        &mut universe.world,
        &mut universe.systems.rx,
        &mut universe.command_queue,
    );

    for error in &output.errors {
        eprintln!("[mms] {error}");
    }
    println!(
        "[mms] {} intent(s) from world-panel.mms",
        output.intents.len()
    );

    for intent in output.intents {
        universe
            .command_queue
            .push_intent_now(engine::ecs::ComponentId::default(), intent);
    }

    universe.systems.process_commands(
        &mut universe.world,
        &mut universe.visuals,
        &mut universe.render_assets,
        &mut universe.command_queue,
    );

    universe.enable_repl();
    engine::Windowing::run_app(universe).expect("Windowing failed");
}

examples/padding-demo.rs (lines 11-17)

fn main() {
    mittens_engine::example_support::ensure_model_assets();
    utils::logger::init();

    let world = engine::ecs::World::default();
    let mut universe = engine::Universe::new(world);

    let source = include_str!("padding-demo.mms");
    let output = scripting::MeowMeowRunner::eval_with_world_at_path(
        source,
        Some("examples/padding-demo.mms"),
        &mut universe.world,
        &mut universe.systems.rx,
        &mut universe.command_queue,
    );

    for error in &output.errors {
        eprintln!("[mms] {error}");
    }
    println!(
        "[mms] {} intent(s) from padding-demo.mms",
        output.intents.len()
    );

    for intent in output.intents {
        universe
            .command_queue
            .push_intent_now(engine::ecs::ComponentId::default(), intent);
    }

    universe.systems.process_commands(
        &mut universe.world,
        &mut universe.visuals,
        &mut universe.render_assets,
        &mut universe.command_queue,
    );

    universe.enable_repl();
    engine::Windowing::run_app(universe).expect("Windowing failed");
}

Additional examples can be found in:

• examples/observer-router.rs
• examples/percentage-layout.rs
• examples/bisket-bones-and-ik.rs
• examples/router.rs
• examples/camera-toggle.rs
• examples/audio-clip-instance-demo.rs
• examples/audio-music-demo.rs
• examples/bisket-vr-debug.rs

pub fn eval_with_world_and_assets( source: &str, world: &mut World, rx: &mut RxWorld, render_assets: &mut RenderAssets, emit: &mut dyn SignalEmitter, ) -> EvalOutput

Evaluate source with live world + render-asset access.

pub fn eval_with_world_and_assets_at_path( source: &str, source_path: Option<&str>, world: &mut World, rx: &mut RxWorld, render_assets: Option<&mut RenderAssets>, emit: &mut dyn SignalEmitter, ) -> EvalOutput

Like eval_with_world_and_assets, but also records the source file path so import statements resolve relative to it.

Examples found in repository

examples/pride.rs (lines 10-17)

fn main() {
    mittens_engine::example_support::ensure_model_assets();
    utils::logger::init();

    let world = engine::ecs::World::default();
    let mut universe = engine::Universe::new(world);

    let output = scripting::MeowMeowRunner::eval_with_world_and_assets_at_path(
        include_str!("pride.mms"),
        Some("examples/pride.mms"),
        &mut universe.world,
        &mut universe.systems.rx,
        Some(&mut universe.render_assets),
        &mut universe.command_queue,
    );

    for error in &output.errors {
        eprintln!("[mms] {error}");
    }
    assert!(
        output.errors.is_empty(),
        "MMS evaluation produced errors: {:?}",
        output.errors,
    );

    let scope = engine::ecs::ComponentId::default();
    for intent in output.intents {
        universe.command_queue.push_intent_now(scope, intent);
    }

    universe.systems.process_commands(
        &mut universe.world,
        &mut universe.visuals,
        &mut universe.render_assets,
        &mut universe.command_queue,
    );

    engine::Windowing::run_app(universe).expect("Windowing failed");
}

examples/clip-shape.rs (lines 10-17)

fn main() {
    mittens_engine::example_support::ensure_model_assets();
    utils::logger::init();

    let world = engine::ecs::World::default();
    let mut universe = engine::Universe::new(world);

    let output = scripting::MeowMeowRunner::eval_with_world_and_assets_at_path(
        include_str!("clip-shape.mms"),
        Some("examples/clip-shape.mms"),
        &mut universe.world,
        &mut universe.systems.rx,
        Some(&mut universe.render_assets),
        &mut universe.command_queue,
    );

    for error in &output.errors {
        eprintln!("[mms] {error}");
    }
    assert!(
        output.errors.is_empty(),
        "MMS evaluation produced errors: {:?}",
        output.errors,
    );

    let scope = engine::ecs::ComponentId::default();
    for intent in output.intents {
        universe.command_queue.push_intent_now(scope, intent);
    }

    universe.systems.process_commands(
        &mut universe.world,
        &mut universe.visuals,
        &mut universe.render_assets,
        &mut universe.command_queue,
    );

    engine::Windowing::run_app(universe).expect("Windowing failed");
}

examples/neon-kawaii.rs (lines 10-17)

fn main() {
    mittens_engine::example_support::ensure_model_assets();
    utils::logger::init();

    let world = engine::ecs::World::default();
    let mut universe = engine::Universe::new(world);

    let output = scripting::MeowMeowRunner::eval_with_world_and_assets_at_path(
        include_str!("neon-kawaii.mms"),
        Some("examples/neon-kawaii.mms"),
        &mut universe.world,
        &mut universe.systems.rx,
        Some(&mut universe.render_assets),
        &mut universe.command_queue,
    );

    for error in &output.errors {
        eprintln!("[mms] {error}");
    }
    assert!(
        output.errors.is_empty(),
        "MMS evaluation produced errors: {:?}",
        output.errors,
    );

    let scope = engine::ecs::ComponentId::default();
    for intent in output.intents {
        universe.command_queue.push_intent_now(scope, intent);
    }

    universe.systems.process_commands(
        &mut universe.world,
        &mut universe.visuals,
        &mut universe.render_assets,
        &mut universe.command_queue,
    );

    engine::Windowing::run_app(universe).expect("Windowing failed");
}

examples/bisket-desktop-demo.rs (lines 10-17)

fn main() {
    mittens_engine::example_support::ensure_model_assets();
    utils::logger::init();

    let world = engine::ecs::World::default();
    let mut universe = engine::Universe::new(world);

    let output = scripting::MeowMeowRunner::eval_with_world_and_assets_at_path(
        include_str!("bisket-desktop-demo.mms"),
        Some("examples/bisket-desktop-demo.mms"),
        &mut universe.world,
        &mut universe.systems.rx,
        Some(&mut universe.render_assets),
        &mut universe.command_queue,
    );

    for error in &output.errors {
        eprintln!("[mms] {error}");
    }
    assert!(
        output.errors.is_empty(),
        "MMS evaluation produced errors: {:?}",
        output.errors,
    );

    let scope = engine::ecs::ComponentId::default();
    for intent in output.intents {
        universe.command_queue.push_intent_now(scope, intent);
    }

    universe.systems.process_commands(
        &mut universe.world,
        &mut universe.visuals,
        &mut universe.render_assets,
        &mut universe.command_queue,
    );

    engine::Windowing::run_app(universe).expect("Windowing failed");
}

examples/bisket-vr-only-example.rs (lines 9-16)

fn main() {
    mittens_engine::example_support::ensure_model_assets();
    utils::logger::init();

    let world = engine::ecs::World::default();
    let mut universe = engine::Universe::new(world);
    let output = scripting::MeowMeowRunner::eval_with_world_and_assets_at_path(
        include_str!("bisket-vr-only-example.mms"),
        Some("examples/bisket-vr-only-example.mms"),
        &mut universe.world,
        &mut universe.systems.rx,
        Some(&mut universe.render_assets),
        &mut universe.command_queue,
    );

    for error in &output.errors {
        eprintln!("[mms] {error}");
    }
    assert!(
        output.errors.is_empty(),
        "MMS evaluation produced errors: {:?}",
        output.errors,
    );

    let scope = engine::ecs::ComponentId::default();
    for intent in output.intents {
        universe.command_queue.push_intent_now(scope, intent);
    }
    universe.systems.process_commands(
        &mut universe.world,
        &mut universe.visuals,
        &mut universe.render_assets,
        &mut universe.command_queue,
    );

    engine::Windowing::run_app(universe).expect("Windowing failed");
}

examples/rotate-look-at-example.rs (lines 10-17)

fn main() {
    mittens_engine::example_support::ensure_model_assets();
    utils::logger::init();

    let world = engine::ecs::World::default();
    let mut universe = engine::Universe::new(world);

    let output = scripting::MeowMeowRunner::eval_with_world_and_assets_at_path(
        include_str!("rotate-look-at-example.mms"),
        Some("examples/rotate-look-at-example.mms"),
        &mut universe.world,
        &mut universe.systems.rx,
        Some(&mut universe.render_assets),
        &mut universe.command_queue,
    );

    for error in &output.errors {
        eprintln!("[mms] {error}");
    }
    assert!(
        output.errors.is_empty(),
        "MMS evaluation produced errors: {:?}",
        output.errors,
    );

    let scope = engine::ecs::ComponentId::default();
    for intent in output.intents {
        universe.command_queue.push_intent_now(scope, intent);
    }

    universe.systems.process_commands(
        &mut universe.world,
        &mut universe.visuals,
        &mut universe.render_assets,
        &mut universe.command_queue,
    );

    engine::Windowing::run_app(universe).expect("Windowing failed");
}

Additional examples can be found in:

• examples/http-server-example.rs
• examples/transition.rs
• examples/bisket-vr-demo.rs