wasvy 0.0.9

WASI-powered modding for the Bevy engine
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120

use bevy_ecs::prelude::*;
use wasmtime::component::Resource;

use crate::{
    bindings::wasvy::ecs::app::{HostSystem, QueryFor},
    host::WasmHost,
    runner::State,
    system::{DynamicSystemId, Param},
};

pub struct WasmSystem {
    pub(crate) id: DynamicSystemId,
    pub(crate) name: String,
    pub(crate) params: Vec<Param>,
    pub(crate) after: Vec<DynamicSystemId>,
}

impl WasmSystem {
    fn new(name: String, world: &mut World) -> Self {
        Self {
            id: DynamicSystemId::new(world),
            name,
            params: Vec::new(),
            after: Vec::new(),
        }
    }

    fn add_param(
        host: &mut WasmHost,
        system: Resource<WasmSystem>,
        param: Param,
    ) -> Result<(), wasmtime::Error> {
        let State::Setup { table, .. } = host.access() else {
            return Err(wasmtime::Error::msg(
                "Systems can only be modified in a setup function",
            ));
        };

        let system = table.get_mut(&system)?;
        system.params.push(param);

        Ok(())
    }
}

impl HostSystem for WasmHost {
    fn new(&mut self, name: String) -> Result<Resource<WasmSystem>, wasmtime::Error> {
        let State::Setup { table, world, .. } = self.access() else {
            return Err(wasmtime::Error::msg(
                "Systems can only be instantiated in a setup function",
            ));
        };

        let system = table.push(WasmSystem::new(name, world))?;
        Ok(system)
    }

    fn add_commands(
        &mut self,
        system: Resource<WasmSystem>,
    ) -> std::result::Result<(), wasmtime::Error> {
        WasmSystem::add_param(self, system, Param::Commands)
    }

    fn add_query(
        &mut self,
        system: Resource<WasmSystem>,
        query: Vec<QueryFor>,
    ) -> std::result::Result<(), wasmtime::Error> {
        WasmSystem::add_param(self, system, Param::Query(query))
    }

    fn after(
        &mut self,
        system: Resource<WasmSystem>,
        other: Resource<WasmSystem>,
    ) -> std::result::Result<(), wasmtime::Error> {
        let State::Setup { table, .. } = self.access() else {
            return Err(wasmtime::Error::msg(
                "Systems can only be modified in a setup function",
            ));
        };

        let other = table.get(&other)?.id;
        let system = table.get_mut(&system)?;

        system.after.push(other);

        Ok(())
    }

    fn before(
        &mut self,
        system: Resource<WasmSystem>,
        other: Resource<WasmSystem>,
    ) -> std::result::Result<(), wasmtime::Error> {
        // In bevy, `a.before(b)` is logically equivalent to `b.after(a)`
        let State::Setup { table, .. } = self.access() else {
            return Err(wasmtime::Error::msg(
                "Systems can only be modified in a setup function",
            ));
        };

        let other = table.get(&other)?.id;
        let system = table.get_mut(&system)?;

        system.after.push(other);

        Ok(())
    }

    // Note: this is never guaranteed to be called by the wasi binary
    fn drop(&mut self, _: Resource<WasmSystem>) -> std::result::Result<(), wasmtime::Error> {
        // Don't drop! After running setup, wasvy will find and register all
        // [WasmSystems] via [AddSystems]. If they are dropped, they will not be
        // in the wasm resource table when [AddSystems::add_systems] is called.

        Ok(())
    }
}