unrust 0.1.5

The rust side of the unity package to work with rust + bevy in unity!
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
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142

use std::ffi::{c_char, CStr, CString};

mod loader;
mod logger;
mod unity;

pub use bevy;

use bevy::prelude::*;
pub use codegen::generate_csharp;
pub use inbuilt::*;
pub use loader::GamePlugin;
pub use tracing;

pub use unity::{CreateFn, DestroyEntity, DestroyFn, InstantiateEntity, PrefabData, UpdateFn};
pub use unrust_proc_macro::*;

use crate::{
    logger::{setup_logging, teardown_logging, LoggerFunc},
    unity::{start_app, UnityPlugins},
};

#[repr(C)]
pub struct UnrustContextWrapper;

pub struct UnrustContext {
    pub app: App,
}

static mut GAMEPLUGIN: Option<Box<dyn GamePlugin>> = None;

#[allow(clippy::missing_safety_doc)]
pub unsafe fn setup_game(game: Box<dyn GamePlugin>) {
    GAMEPLUGIN = Some(game);
}

#[no_mangle]
#[allow(clippy::missing_safety_doc)]
pub unsafe extern "C" fn load(logger: LoggerFunc) -> *mut UnrustContextWrapper {
    setup_logging(Box::new(move |level, str| {
        let len = str.len();
        let out_str = CString::new(str).unwrap();
        let out_str = out_str.into_raw();
        (logger)(level, out_str, len);
        unsafe {
            let _ = CString::from_raw(out_str); // drop the string
        }
    }));

    let app = App::new();

    tracing::info!("setting up!");

    let ctx = Box::new(UnrustContext { app });

    Box::into_raw(ctx) as *mut UnrustContextWrapper
}

#[no_mangle]
#[allow(clippy::missing_safety_doc)]
pub unsafe extern "C" fn init(
    ctx: *mut UnrustContextWrapper,
    base_path: *const c_char,
    create: CreateFn,
    update: UpdateFn,
    destroy: DestroyFn,
) {
    let ctx = unsafe { Box::leak(Box::from_raw(ctx as *mut UnrustContext)) };
    let base_path = unsafe { get_string(base_path) };
    ctx.app
        .add_plugins(UnityPlugins::new(base_path, create, update, destroy));

    unsafe {
        if let Some(game) = &GAMEPLUGIN {
            game.initialize(&mut ctx.app);
        } else {
            tracing::info!("game  not setup!");
        }
    }

    start_app(&mut ctx.app);
}

#[no_mangle]
pub extern "C" fn register_prefabs(ctx: *mut UnrustContextWrapper, prefabs: PrefabData) {
    let ctx = unsafe { Box::leak(Box::from_raw(ctx as *mut UnrustContext)) };
    unsafe {
        if let Some(game) = &GAMEPLUGIN {
            game.register(&mut ctx.app.world, prefabs);
        }
    }
}

#[allow(clippy::missing_safety_doc)]
#[no_mangle]
pub unsafe extern "C" fn spawn(
    ctx: *mut UnrustContextWrapper,
    unity_entity: UnityEntity,
    inbuilt: *const InbuiltData,
    len: usize,
    custom: *const u8,
    custom_len: usize,
    custom_state: *const u8,
    custom_state_len: usize,
) -> u64 {
    let components = unsafe { std::slice::from_raw_parts(inbuilt, len) };
    let ctx = unsafe { Box::leak(Box::from_raw(ctx as *mut UnrustContext)) };
    let mut entity = ctx.app.world.spawn_empty();
    entity.insert(unity_entity);
    ingest_component(&mut entity, components);

    unsafe {
        if let Some(game) = &GAMEPLUGIN {
            game.spawn_custom(
                &mut entity,
                custom,
                custom_len,
                custom_state,
                custom_state_len,
            );
        }
    }

    entity.id().to_bits()
}

#[no_mangle]
pub extern "C" fn tick(ctx: *mut UnrustContextWrapper) {
    let ctx = unsafe { Box::leak(Box::from_raw(ctx as *mut UnrustContext)) };
    ctx.app.update();
}

#[no_mangle]
pub extern "C" fn unload(ctx: *mut UnrustContextWrapper) {
    teardown_logging();
    let _ = unsafe { Box::from_raw(ctx as *mut UnrustContext) };
    unsafe { GAMEPLUGIN = None };
}

unsafe fn get_string(base_path: *const i8) -> String {
    CStr::from_ptr(base_path).to_string_lossy().to_string()
}