rusty_mujoco 0.3.0

Rust bindings for the MuJoCo physics simulator
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
143
144
145
146
147
148
149
150
151
152
153

//! Types that wrap raw bindgen-generated structs with safe APIs.

macro_rules! resource_wrapper {
    (
        $T:ident for $Bindgen:path;
        drop = $drop:path;
    ) => {
        #[allow(non_camel_case_types)]
        pub struct $T(*mut $Bindgen);
        impl Drop for $T {
            fn drop(&mut self) {
                $drop(self);
            }
        }
        impl $T {
            pub(crate) fn from_raw(ptr: *mut $Bindgen) -> Self {
                Self(ptr)
            }
            pub(crate) fn as_ptr(&self) -> *const $Bindgen {
                self.0
            }
            pub(crate) fn as_mut_ptr(&mut self) -> *mut $Bindgen {
                self.0
            }
        }
        impl std::ops::Deref for $T {
            type Target = $Bindgen;
            fn deref(&self) -> &Self::Target {
                unsafe { &*self.0 }
            }
        }
        impl std::ops::DerefMut for $T {
            fn deref_mut(&mut self) -> &mut Self::Target {
                unsafe { &mut *self.0 }
            }
        }
        impl std::fmt::Debug for $T {
            fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
                (**self).fmt(f)
            }
        }
    };
}

/// Generate getter and/or setter for fields of a struct for most/simple cases.
/// Write some edge cases by hand if needed.
macro_rules! fields_mapping {
    ($T:path {
        $(boolean_flags {
            $(
                $flag_name:ident $(/ $set_flag_name:ident)? = $flag_description:literal;
            )*
        })?
        $(scalars {
            $(
                $scalar_name:ident $(/ $set_scalar_name:ident)?: $Scalar:ty = $scalar_description:literal;
            )*
        })?
        $(enums {
            $(
                $enum_name:ident $(/ $set_enum_name:ident)?: $Enum:ident = $enum_description:literal;
            )*
        })?
        $(structs {
            $(
                $struct_name:ident $(/ $mut_struct_name:ident)?: $Struct:ty = $struct_description:literal;
            )*
        })?
    }) => {
        #[allow(non_snake_case)]
        impl $T {
            $($(
                #[doc = $flag_description]
                pub fn $flag_name(&self) -> bool {
                    self.$flag_name != 0
                }
                $(
                    #[doc = "set "]
                    #[doc = $flag_description]
                    pub fn $set_flag_name(&mut self, value: bool) -> &mut Self {
                        self.$flag_name = if value { 1 } else { 0 };
                        self
                    }
                )?
            )*)?
            $($(
                #[doc = $scalar_description]
                pub fn $scalar_name(&self) -> $Scalar {
                    self.$scalar_name as _
                }
                $(
                    #[doc = "set "]
                    #[doc = $scalar_description]
                    pub fn $set_scalar_name(&mut self, value: $Scalar) -> &mut Self {
                        self.$scalar_name = value as _;
                        self
                    }
                )?
            )*)?
            $($(
                #[doc = $enum_description]
                pub fn $enum_name(&self) -> $Enum {
                    $Enum(self.$enum_name as _)
                }
                $(
                    #[doc = "set "]
                    #[doc = $enum_description]
                    pub fn $set_enum_name(&mut self, value: $Enum) -> &mut Self {
                        self.$enum_name = value.0 as _;
                        self
                    }
                )?
            )*)?
            $($(
                #[doc = $struct_description]
                pub fn $struct_name(&self) -> &$Struct {
                    &self.$struct_name
                }
                $(
                    #[doc = "mutable "]
                    #[doc = $struct_description]
                    pub fn $mut_struct_name(&mut self) -> &mut $Struct {
                        &mut self.$struct_name
                    }
                )?
            )*)?
        }
    };
}

mod mjdata;
mod mjmodel;
mod mjoption;
mod model_editing;
mod auxiliary;
mod rendering;
mod sim_statistics;
mod user_interface;
mod visualization;

pub use mjdata::*;
pub use mjmodel::*;
pub use mjoption::*;
pub use model_editing::*;
pub use auxiliary::*;
pub use rendering::*;
pub use sim_statistics::*;
pub use user_interface::*;
pub use visualization::*;

pub use crate::bindgen::{
    mjtByte, mjByteVec, mjString, mjStringVec, mjIntVec, mjFloatVec, mjDoubleVec,
};