il2cpp-bridge-rs 0.1.3

Rust library for Unity IL2CPP runtime introspection — resolve classes, invoke methods, and interact with the IL2CPP VM at runtime
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

//! Thin wrapper around `UnityEngine.Time`.
//!
//! These helpers are intentionally small and are mainly useful as examples of
//! cache-backed static property access.

use crate::api::cache;
use crate::structs::core::Class;
use std::ffi::c_void;

/// Accessors for selected `UnityEngine.Time` properties.
pub struct Time;

impl Time {
    /// Gets the `UnityEngine.Time` class
    pub fn get_class() -> Option<Class> {
        cache::coremodule().class("UnityEngine.Time")
    }

    /// The time at the beginning of this frame (Read Only)
    pub fn get_time() -> f32 {
        unsafe {
            Self::get_class()
                .and_then(|cls| cls.method(("get_time", 0)))
                .map(|method| method.call::<f32>(&[] as &[*mut c_void]).unwrap_or(0.0))
                .unwrap_or(0.0)
        }
    }

    /// The time in seconds it took to complete the last frame (Read Only)
    pub fn get_delta_time() -> f32 {
        unsafe {
            Self::get_class()
                .and_then(|cls| cls.method(("get_deltaTime", 0)))
                .map(|method| method.call::<f32>(&[] as &[*mut c_void]).unwrap_or(0.0))
                .unwrap_or(0.0)
        }
    }

    /// The interval in seconds at which physics and other fixed frame rate updates (like MonoBehaviour's FixedUpdate) are performed.
    pub fn get_fixed_delta_time() -> f32 {
        unsafe {
            Self::get_class()
                .and_then(|cls| cls.method(("get_fixedDeltaTime", 0)))
                .map(|method| method.call::<f32>(&[] as &[*mut c_void]).unwrap_or(0.0))
                .unwrap_or(0.0)
        }
    }

    /// The scale at which time passes. This can be used for slow motion effects.
    pub fn get_time_scale() -> f32 {
        unsafe {
            Self::get_class()
                .and_then(|cls| cls.method(("get_timeScale", 0)))
                .map(|method| method.call::<f32>(&[] as &[*mut c_void]).unwrap_or(1.0))
                .unwrap_or(1.0)
        }
    }

    /// Sets the scale at which time passes.
    pub fn set_time_scale(value: f32) {
        unsafe {
            if let Some(method) = Self::get_class().and_then(|cls| cls.method(("set_timeScale", 1)))
            {
                let _ = method.call::<()>(&[&mut { value } as *mut f32 as *mut c_void]);
            }
        }
    }
}