Skip to main content

engage/generated/app/
capabilityfloat.rs

1// @generated by il2cpp-bindgen — do not edit by hand.
2
3#[cfg(feature = "app-capabilityfloat-types")]
4mod __types {
5    #[allow(unused_imports)] use ::unity::prelude::*;
6
7    use super::*;
8    use crate::{
9        app::{
10            capabilitybase_1::{CapabilityBase_1, ICapabilityBase_1},
11            capabilitydefinition::{CapabilityDefinition, ICapabilityDefinition},
12        },
13        system::object::{IObject, Object},
14    };
15
16    #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/capabilityfloat/CapabilityFloat.md"))]
17    #[::unity::class(namespace = "App", name = "CapabilityFloat")]
18    #[parent(crate::app::capabilitybase_1::CapabilityBase_1<f32>)]
19    pub struct CapabilityFloat {}
20}
21
22#[cfg(feature = "app-capabilityfloat-types")]
23pub use __types::*;
24
25#[cfg(feature = "app-capabilityfloat")]
26pub trait ICapabilityFloatMethods: ICapabilityFloat {
27    #[doc = "`.ctor(f32)` overload"]
28    fn ctor(self, value: impl ::core::convert::Into<f32>) -> () {
29        unsafe {
30            let __receiver = <CapabilityFloat as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
31            ::unity::il2cpp_call!((::unity::module_base()+0x25bd910usize)as*mut u8,();
32(CapabilityFloat)__receiver,(f32)::core::convert::Into::into(value))
33        }
34    }
35    #[doc = "`Add(i32, f32)` overload"]
36    fn add(self, i: impl ::core::convert::Into<i32>, v: impl ::core::convert::Into<f32>) -> () {
37        unsafe {
38            let __receiver = <CapabilityFloat as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
39            {
40                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
41                let __vi = *__vt.get(5usize).unwrap_or_else(|| {
42                    panic!(
43                        "unity: virtual slot {}
44 out of range (vtable len {}
45) on the runtime class behind {}
46 (method `{}
47`)",
48                        5usize,
49                        __vt.len(),
50                        <CapabilityFloat as ::unity::ClassIdentity>::NAME,
51                        "Add",
52                    )
53                });
54                let __inner: extern "C" fn(CapabilityFloat, i32, f32, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__vi.method_ptr);
55                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
56                __inner(__receiver, ::core::convert::Into::into(i), ::core::convert::Into::into(v), __mi)
57            }
58        }
59    }
60    #[doc = "`IsZero()` overload"]
61    fn is_zero(self) -> bool {
62        unsafe {
63            let __receiver = <CapabilityFloat as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
64            {
65                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
66                let __vi = *__vt.get(6usize).unwrap_or_else(|| {
67                    panic!(
68                        "unity: virtual slot {}
69 out of range (vtable len {}
70) on the runtime class behind {}
71 (method `{}
72`)",
73                        6usize,
74                        __vt.len(),
75                        <CapabilityFloat as ::unity::ClassIdentity>::NAME,
76                        "IsZero",
77                    )
78                });
79                let __inner: extern "C" fn(CapabilityFloat, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__vi.method_ptr);
80                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
81                __inner(__receiver, __mi)
82            }
83        }
84    }
85    #[doc = "`IsOne()` overload"]
86    fn is_one(self) -> bool {
87        unsafe {
88            let __receiver = <CapabilityFloat as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
89            ::unity::il2cpp_call!((::unity::module_base()+0x25bdad0usize)as*mut u8,bool;
90(CapabilityFloat)__receiver)
91        }
92    }
93    #[doc = "`WriteToStream(crate::app::stream_2::Stream_2, f32)` overload"]
94    fn write_to_stream(self, stream: impl ::core::convert::Into<crate::app::stream_2::Stream_2>, v: impl ::core::convert::Into<f32>) -> () {
95        unsafe {
96            let __receiver = <CapabilityFloat as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
97            {
98                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
99                let __vi = *__vt.get(7usize).unwrap_or_else(|| {
100                    panic!(
101                        "unity: virtual slot {}
102 out of range (vtable len {}
103) on the runtime class behind {}
104 (method `{}
105`)",
106                        7usize,
107                        __vt.len(),
108                        <CapabilityFloat as ::unity::ClassIdentity>::NAME,
109                        "WriteToStream",
110                    )
111                });
112                let __inner: extern "C" fn(CapabilityFloat, crate::app::stream_2::Stream_2, f32, ::unity::OptionalMethod) -> () =
113                    ::core::mem::transmute(__vi.method_ptr);
114                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
115                __inner(__receiver, ::core::convert::Into::into(stream), ::core::convert::Into::into(v), __mi)
116            }
117        }
118    }
119    #[doc = "`ReadFromStream(crate::app::stream_2::Stream_2)` overload"]
120    fn read_from_stream(self, stream: impl ::core::convert::Into<crate::app::stream_2::Stream_2>) -> f32 {
121        unsafe {
122            let __receiver = <CapabilityFloat as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
123            {
124                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
125                let __vi = *__vt.get(8usize).unwrap_or_else(|| {
126                    panic!(
127                        "unity: virtual slot {}
128 out of range (vtable len {}
129) on the runtime class behind {}
130 (method `{}
131`)",
132                        8usize,
133                        __vt.len(),
134                        <CapabilityFloat as ::unity::ClassIdentity>::NAME,
135                        "ReadFromStream",
136                    )
137                });
138                let __inner: extern "C" fn(CapabilityFloat, crate::app::stream_2::Stream_2, ::unity::OptionalMethod) -> f32 =
139                    ::core::mem::transmute(__vi.method_ptr);
140                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
141                __inner(__receiver, ::core::convert::Into::into(stream), __mi)
142            }
143        }
144    }
145}
146
147#[cfg(feature = "app-capabilityfloat")]
148impl<__T: ICapabilityFloat> ICapabilityFloatMethods for __T {}
149
150#[cfg(feature = "app-capabilityfloat")]
151impl CapabilityFloat {
152    pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
153        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
154    }
155
156    pub fn add_method_info() -> &'static ::unity::il2cpp::MethodInfo {
157        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
158    }
159
160    pub fn is_zero_method_info() -> &'static ::unity::il2cpp::MethodInfo {
161        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
162    }
163
164    pub fn is_one_method_info() -> &'static ::unity::il2cpp::MethodInfo {
165        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
166    }
167
168    pub fn write_to_stream_method_info() -> &'static ::unity::il2cpp::MethodInfo {
169        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
170    }
171
172    pub fn read_from_stream_method_info() -> &'static ::unity::il2cpp::MethodInfo {
173        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[5]
174    }
175}
176
177#[cfg(feature = "app-capabilityfloat")]
178impl CapabilityFloat {
179    #[doc = "Direct (non-virtual) call to `CapabilityFloat`'s own `Add`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
180    pub unsafe fn add(this: impl ::core::convert::Into<::unity::IlInstance>, i: i32, v: f32) -> () {
181        let __mi = Self::add_method_info();
182        let __inner: extern "C" fn(::unity::IlInstance, i32, f32, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
183        __inner(this.into(), i, v, ::core::option::Option::None)
184    }
185
186    #[doc = "Direct (non-virtual) call to `CapabilityFloat`'s own `IsZero`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
187    pub unsafe fn is_zero(this: impl ::core::convert::Into<::unity::IlInstance>) -> bool {
188        let __mi = Self::is_zero_method_info();
189        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__mi.method_ptr);
190        __inner(this.into(), ::core::option::Option::None)
191    }
192
193    #[doc = "Direct (non-virtual) call to `CapabilityFloat`'s own `WriteToStream`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
194    pub unsafe fn write_to_stream(this: impl ::core::convert::Into<::unity::IlInstance>, stream: crate::app::stream_2::Stream_2, v: f32) -> () {
195        let __mi = Self::write_to_stream_method_info();
196        let __inner: extern "C" fn(::unity::IlInstance, crate::app::stream_2::Stream_2, f32, ::unity::OptionalMethod) -> () =
197            ::core::mem::transmute(__mi.method_ptr);
198        __inner(this.into(), stream, v, ::core::option::Option::None)
199    }
200
201    #[doc = "Direct (non-virtual) call to `CapabilityFloat`'s own `ReadFromStream`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
202    pub unsafe fn read_from_stream(this: impl ::core::convert::Into<::unity::IlInstance>, stream: crate::app::stream_2::Stream_2) -> f32 {
203        let __mi = Self::read_from_stream_method_info();
204        let __inner: extern "C" fn(::unity::IlInstance, crate::app::stream_2::Stream_2, ::unity::OptionalMethod) -> f32 =
205            ::core::mem::transmute(__mi.method_ptr);
206        __inner(this.into(), stream, ::core::option::Option::None)
207    }
208}
209
210#[cfg(feature = "app-capabilityfloat")]
211impl CapabilityFloat {
212    #[doc = "`.ctor(f32)` — overload selector"]
213    pub fn new(value: f32) -> Self {
214        let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
215            panic!(
216                "{}
217::{}
218 failed to instantiate",
219                ::core::stringify!(CapabilityFloat),
220                ::core::stringify!(new),
221            )
222        });
223        <Self as ICapabilityFloatMethods>::ctor(this, value);
224        this
225    }
226}
227
228#[cfg(feature = "app-capabilityfloat")]
229#[doc(hidden)]
230pub mod prelude {
231    pub use super::{CapabilityFloat, ICapabilityFloat, ICapabilityFloatMethods};
232    #[cfg(feature = "app-capabilitybase_1")]
233    pub use crate::app::capabilitybase_1::ICapabilityBase_1Methods;
234    #[cfg(feature = "app-capabilitydefinition")]
235    pub use crate::app::capabilitydefinition::ICapabilityDefinitionMethods;
236    #[cfg(feature = "system-object")]
237    pub use crate::system::object::IObjectMethods;
238    pub use crate::{
239        app::{capabilitybase_1::ICapabilityBase_1, capabilitydefinition::ICapabilityDefinition},
240        system::object::IObject,
241    };
242}