1#[cfg(feature = "app-myroomrecallmenu-types")]
4mod __types {
5 #[allow(unused_imports)] use ::unity::prelude::*;
6
7 use super::*;
8 use crate::{
9 app::{
10 basicmenu::{BasicMenu, IBasicMenu},
11 basicmenuitem::{BasicMenuItem, IBasicMenuItem},
12 procinst::{IProcInst, ProcInst},
13 },
14 system::{
15 delegate::{Delegate, IDelegate},
16 multicastdelegate::{IMulticastDelegate, MulticastDelegate},
17 object::{IObject, Object},
18 r#enum::{Enum, IEnum},
19 valuetype::{IValueType, ValueType},
20 },
21 };
22
23 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/myroomrecallmenu/MyRoomRecallMenu_RelianceMenuItem.md"))]
24 #[::unity::class(namespace = "App", name = "MyRoomRecallMenu.RelianceMenuItem")]
25 #[parent(crate::app::basicmenuitem::BasicMenuItem)]
26 pub struct MyRoomRecallMenu_RelianceMenuItem {
27 #[offset(104)]
28 #[rename(name = "m_DecideEventHandler")]
29 pub m_decide_event_handler: crate::app::myroomrecallmenu::MyRoomRecallMenu_DecideEventHandler,
30 }
31
32 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/myroomrecallmenu/MyRoomRecallMenu_WakeupMenuItem.md"))]
33 #[::unity::class(namespace = "App", name = "MyRoomRecallMenu.WakeupMenuItem")]
34 #[parent(crate::app::basicmenuitem::BasicMenuItem)]
35 pub struct MyRoomRecallMenu_WakeupMenuItem {
36 #[offset(104)]
37 #[rename(name = "m_DecideEventHandler")]
38 pub m_decide_event_handler: crate::app::myroomrecallmenu::MyRoomRecallMenu_DecideEventHandler,
39 }
40
41 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/myroomrecallmenu/MyRoomRecallMenu.md"))]
42 #[::unity::class(namespace = "App", name = "MyRoomRecallMenu")]
43 #[parent(crate::app::basicmenu::BasicMenu)]
44 pub struct MyRoomRecallMenu {}
45
46 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/myroomrecallmenu/MyRoomRecallMenu_MenuResult.md"))]
47 #[repr(C)]
48 #[derive(::core::clone::Clone, ::core::marker::Copy, ::core::fmt::Debug, ::core::cmp::PartialEq, ::core::cmp::Eq)]
49 pub struct MyRoomRecallMenu_MenuResult {
50 pub value: i32,
51 }
52 impl ::unity::ClassIdentity for MyRoomRecallMenu_MenuResult {
53 const NAME: &'static str = "MyRoomRecallMenu.MenuResult";
54 const NAMESPACE: &'static str = "App";
55
56 fn class() -> ::unity::Class {
57 static CACHE: ::std::sync::OnceLock<::unity::Class> = ::std::sync::OnceLock::new();
58 *CACHE.get_or_init(|| ::unity::Class::lookup(Self::NAMESPACE, Self::NAME))
59 }
60 }
61 impl ::unity::IlType for MyRoomRecallMenu_MenuResult {
62 fn il_type() -> &'static ::unity::il2cpp::Il2CppType {
63 &<Self as ::unity::ClassIdentity>::class().raw()._1.byval_arg
64 }
65 }
66 impl MyRoomRecallMenu_MenuResult {
67 pub fn reliance() -> Self {
68 Self { value: 0 }
69 }
70
71 pub fn god_reliance() -> Self {
72 Self { value: 1 }
73 }
74
75 pub fn wakeup() -> Self {
76 Self { value: 2 }
77 }
78
79 pub fn movie() -> Self {
80 Self { value: 3 }
81 }
82
83 pub fn music() -> Self {
84 Self { value: 4 }
85 }
86
87 pub fn end() -> Self {
88 Self { value: 5 }
89 }
90 }
91
92 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/myroomrecallmenu/MyRoomRecallMenu_MusicMenuItem.md"))]
93 #[::unity::class(namespace = "App", name = "MyRoomRecallMenu.MusicMenuItem")]
94 #[parent(crate::app::basicmenuitem::BasicMenuItem)]
95 pub struct MyRoomRecallMenu_MusicMenuItem {
96 #[offset(104)]
97 #[rename(name = "m_DecideEventHandler")]
98 pub m_decide_event_handler: crate::app::myroomrecallmenu::MyRoomRecallMenu_DecideEventHandler,
99 }
100
101 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/myroomrecallmenu/MyRoomRecallMenu_MovieMenuItem.md"))]
102 #[::unity::class(namespace = "App", name = "MyRoomRecallMenu.MovieMenuItem")]
103 #[parent(crate::app::basicmenuitem::BasicMenuItem)]
104 pub struct MyRoomRecallMenu_MovieMenuItem {
105 #[offset(104)]
106 #[rename(name = "m_DecideEventHandler")]
107 pub m_decide_event_handler: crate::app::myroomrecallmenu::MyRoomRecallMenu_DecideEventHandler,
108 }
109
110 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/myroomrecallmenu/MyRoomRecallMenu_GodRelianceMenuItem.md"))]
111 #[::unity::class(namespace = "App", name = "MyRoomRecallMenu.GodRelianceMenuItem")]
112 #[parent(crate::app::basicmenuitem::BasicMenuItem)]
113 pub struct MyRoomRecallMenu_GodRelianceMenuItem {
114 #[offset(104)]
115 #[rename(name = "m_DecideEventHandler")]
116 pub m_decide_event_handler: crate::app::myroomrecallmenu::MyRoomRecallMenu_DecideEventHandler,
117 }
118
119 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/myroomrecallmenu/MyRoomRecallMenu_DecideEventHandler.md"))]
120 #[::unity::class(namespace = "App", name = "MyRoomRecallMenu.DecideEventHandler")]
121 #[parent(crate::system::multicastdelegate::MulticastDelegate)]
122 pub struct MyRoomRecallMenu_DecideEventHandler {}
123}
124
125#[cfg(feature = "app-myroomrecallmenu-types")]
126pub use __types::*;
127
128#[cfg(feature = "app-myroomrecallmenu")]
129pub trait IMyRoomRecallMenu_RelianceMenuItemMethods: IMyRoomRecallMenu_RelianceMenuItem {
130 #[doc = "`.ctor(crate::app::myroomrecallmenu::MyRoomRecallMenu_DecideEventHandler)` overload"]
131 fn ctor(self, event_handler: impl ::core::convert::Into<crate::app::myroomrecallmenu::MyRoomRecallMenu_DecideEventHandler>) -> () {
132 unsafe {
133 let __receiver =
134 <MyRoomRecallMenu_RelianceMenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
135 ::unity::il2cpp_call!((::unity::module_base()+0x2094980usize)as*mut u8,();
136(MyRoomRecallMenu_RelianceMenuItem)__receiver,(crate::app::myroomrecallmenu::MyRoomRecallMenu_DecideEventHandler)::core::convert::Into::into(event_handler))
137 }
138 }
139 #[doc = "`GetName()` overload"]
140 fn get_name(self) -> ::unity::Il2CppString {
141 unsafe {
142 let __receiver =
143 <MyRoomRecallMenu_RelianceMenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
144 {
145 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
146 let __vi = *__vt.get(4usize).unwrap_or_else(|| {
147 panic!(
148 "unity: virtual slot {}
149 out of range (vtable len {}
150) on the runtime class behind {}
151 (method `{}
152`)",
153 4usize,
154 __vt.len(),
155 <MyRoomRecallMenu_RelianceMenuItem as ::unity::ClassIdentity>::NAME,
156 "GetName",
157 )
158 });
159 let __inner: extern "C" fn(MyRoomRecallMenu_RelianceMenuItem, ::unity::OptionalMethod) -> ::unity::Il2CppString =
160 ::core::mem::transmute(__vi.method_ptr);
161 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
162 __inner(__receiver, __mi)
163 }
164 }
165 }
166 #[doc = "`BuildAttribute()` overload"]
167 fn build_attribute(self) -> crate::app::basicmenuitem::BasicMenuItem_Attribute {
168 unsafe {
169 let __receiver =
170 <MyRoomRecallMenu_RelianceMenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
171 {
172 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
173 let __vi = *__vt.get(8usize).unwrap_or_else(|| {
174 panic!(
175 "unity: virtual slot {}
176 out of range (vtable len {}
177) on the runtime class behind {}
178 (method `{}
179`)",
180 8usize,
181 __vt.len(),
182 <MyRoomRecallMenu_RelianceMenuItem as ::unity::ClassIdentity>::NAME,
183 "BuildAttribute",
184 )
185 });
186 let __inner: extern "C" fn(
187 MyRoomRecallMenu_RelianceMenuItem,
188 ::unity::OptionalMethod,
189 ) -> crate::app::basicmenuitem::BasicMenuItem_Attribute = ::core::mem::transmute(__vi.method_ptr);
190 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
191 __inner(__receiver, __mi)
192 }
193 }
194 }
195 #[doc = "`ACall()` overload"]
196 fn a_call(self) -> crate::app::basicmenu::BasicMenu_Result {
197 unsafe {
198 let __receiver =
199 <MyRoomRecallMenu_RelianceMenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
200 {
201 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
202 let __vi = *__vt.get(18usize).unwrap_or_else(|| {
203 panic!(
204 "unity: virtual slot {}
205 out of range (vtable len {}
206) on the runtime class behind {}
207 (method `{}
208`)",
209 18usize,
210 __vt.len(),
211 <MyRoomRecallMenu_RelianceMenuItem as ::unity::ClassIdentity>::NAME,
212 "ACall",
213 )
214 });
215 let __inner: extern "C" fn(MyRoomRecallMenu_RelianceMenuItem, ::unity::OptionalMethod) -> crate::app::basicmenu::BasicMenu_Result =
216 ::core::mem::transmute(__vi.method_ptr);
217 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
218 __inner(__receiver, __mi)
219 }
220 }
221 }
222 #[doc = "`BCall()` overload"]
223 fn b_call(self) -> crate::app::basicmenu::BasicMenu_Result {
224 unsafe {
225 let __receiver =
226 <MyRoomRecallMenu_RelianceMenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
227 {
228 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
229 let __vi = *__vt.get(19usize).unwrap_or_else(|| {
230 panic!(
231 "unity: virtual slot {}
232 out of range (vtable len {}
233) on the runtime class behind {}
234 (method `{}
235`)",
236 19usize,
237 __vt.len(),
238 <MyRoomRecallMenu_RelianceMenuItem as ::unity::ClassIdentity>::NAME,
239 "BCall",
240 )
241 });
242 let __inner: extern "C" fn(MyRoomRecallMenu_RelianceMenuItem, ::unity::OptionalMethod) -> crate::app::basicmenu::BasicMenu_Result =
243 ::core::mem::transmute(__vi.method_ptr);
244 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
245 __inner(__receiver, __mi)
246 }
247 }
248 }
249}
250
251#[cfg(feature = "app-myroomrecallmenu")]
252impl<__T: IMyRoomRecallMenu_RelianceMenuItem> IMyRoomRecallMenu_RelianceMenuItemMethods for __T {}
253
254#[cfg(feature = "app-myroomrecallmenu")]
255impl MyRoomRecallMenu_RelianceMenuItem {
256 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
257 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
258 }
259
260 pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
261 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
262 }
263
264 pub fn build_attribute_method_info() -> &'static ::unity::il2cpp::MethodInfo {
265 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
266 }
267
268 pub fn a_call_method_info() -> &'static ::unity::il2cpp::MethodInfo {
269 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
270 }
271
272 pub fn b_call_method_info() -> &'static ::unity::il2cpp::MethodInfo {
273 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
274 }
275}
276
277#[cfg(feature = "app-myroomrecallmenu")]
278impl MyRoomRecallMenu_RelianceMenuItem {
279 #[doc = "Direct (non-virtual) call to `MyRoomRecallMenu_RelianceMenuItem`'s own `GetName`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
280 pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
281 let __mi = Self::get_name_method_info();
282 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
283 __inner(this.into(), ::core::option::Option::None)
284 }
285
286 #[doc = "Direct (non-virtual) call to `MyRoomRecallMenu_RelianceMenuItem`'s own `BuildAttribute`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
287 pub unsafe fn build_attribute(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::basicmenuitem::BasicMenuItem_Attribute {
288 let __mi = Self::build_attribute_method_info();
289 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::basicmenuitem::BasicMenuItem_Attribute =
290 ::core::mem::transmute(__mi.method_ptr);
291 __inner(this.into(), ::core::option::Option::None)
292 }
293
294 #[doc = "Direct (non-virtual) call to `MyRoomRecallMenu_RelianceMenuItem`'s own `ACall`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
295 pub unsafe fn a_call(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::basicmenu::BasicMenu_Result {
296 let __mi = Self::a_call_method_info();
297 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::basicmenu::BasicMenu_Result =
298 ::core::mem::transmute(__mi.method_ptr);
299 __inner(this.into(), ::core::option::Option::None)
300 }
301
302 #[doc = "Direct (non-virtual) call to `MyRoomRecallMenu_RelianceMenuItem`'s own `BCall`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
303 pub unsafe fn b_call(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::basicmenu::BasicMenu_Result {
304 let __mi = Self::b_call_method_info();
305 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::basicmenu::BasicMenu_Result =
306 ::core::mem::transmute(__mi.method_ptr);
307 __inner(this.into(), ::core::option::Option::None)
308 }
309}
310
311#[cfg(feature = "app-myroomrecallmenu")]
312impl MyRoomRecallMenu_RelianceMenuItem {
313 #[doc = "`.ctor(crate::app::myroomrecallmenu::MyRoomRecallMenu_DecideEventHandler)` — overload selector"]
314 pub fn new(event_handler: crate::app::myroomrecallmenu::MyRoomRecallMenu_DecideEventHandler) -> Self {
315 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
316 panic!(
317 "{}
318::{}
319 failed to instantiate",
320 ::core::stringify!(MyRoomRecallMenu_RelianceMenuItem),
321 ::core::stringify!(new),
322 )
323 });
324 <Self as IMyRoomRecallMenu_RelianceMenuItemMethods>::ctor(this, event_handler);
325 this
326 }
327}
328
329#[cfg(feature = "app-myroomrecallmenu")]
330pub trait IMyRoomRecallMenu_WakeupMenuItemMethods: IMyRoomRecallMenu_WakeupMenuItem {
331 #[doc = "`.ctor(crate::app::myroomrecallmenu::MyRoomRecallMenu_DecideEventHandler)` overload"]
332 fn ctor(self, event_handler: impl ::core::convert::Into<crate::app::myroomrecallmenu::MyRoomRecallMenu_DecideEventHandler>) -> () {
333 unsafe {
334 let __receiver =
335 <MyRoomRecallMenu_WakeupMenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
336 ::unity::il2cpp_call!((::unity::module_base()+0x2094d00usize)as*mut u8,();
337(MyRoomRecallMenu_WakeupMenuItem)__receiver,(crate::app::myroomrecallmenu::MyRoomRecallMenu_DecideEventHandler)::core::convert::Into::into(event_handler))
338 }
339 }
340 #[doc = "`GetName()` overload"]
341 fn get_name(self) -> ::unity::Il2CppString {
342 unsafe {
343 let __receiver =
344 <MyRoomRecallMenu_WakeupMenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
345 {
346 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
347 let __vi = *__vt.get(4usize).unwrap_or_else(|| {
348 panic!(
349 "unity: virtual slot {}
350 out of range (vtable len {}
351) on the runtime class behind {}
352 (method `{}
353`)",
354 4usize,
355 __vt.len(),
356 <MyRoomRecallMenu_WakeupMenuItem as ::unity::ClassIdentity>::NAME,
357 "GetName",
358 )
359 });
360 let __inner: extern "C" fn(MyRoomRecallMenu_WakeupMenuItem, ::unity::OptionalMethod) -> ::unity::Il2CppString =
361 ::core::mem::transmute(__vi.method_ptr);
362 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
363 __inner(__receiver, __mi)
364 }
365 }
366 }
367 #[doc = "`BuildAttribute()` overload"]
368 fn build_attribute(self) -> crate::app::basicmenuitem::BasicMenuItem_Attribute {
369 unsafe {
370 let __receiver =
371 <MyRoomRecallMenu_WakeupMenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
372 {
373 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
374 let __vi = *__vt.get(8usize).unwrap_or_else(|| {
375 panic!(
376 "unity: virtual slot {}
377 out of range (vtable len {}
378) on the runtime class behind {}
379 (method `{}
380`)",
381 8usize,
382 __vt.len(),
383 <MyRoomRecallMenu_WakeupMenuItem as ::unity::ClassIdentity>::NAME,
384 "BuildAttribute",
385 )
386 });
387 let __inner: extern "C" fn(
388 MyRoomRecallMenu_WakeupMenuItem,
389 ::unity::OptionalMethod,
390 ) -> crate::app::basicmenuitem::BasicMenuItem_Attribute = ::core::mem::transmute(__vi.method_ptr);
391 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
392 __inner(__receiver, __mi)
393 }
394 }
395 }
396 #[doc = "`ACall()` overload"]
397 fn a_call(self) -> crate::app::basicmenu::BasicMenu_Result {
398 unsafe {
399 let __receiver =
400 <MyRoomRecallMenu_WakeupMenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
401 {
402 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
403 let __vi = *__vt.get(18usize).unwrap_or_else(|| {
404 panic!(
405 "unity: virtual slot {}
406 out of range (vtable len {}
407) on the runtime class behind {}
408 (method `{}
409`)",
410 18usize,
411 __vt.len(),
412 <MyRoomRecallMenu_WakeupMenuItem as ::unity::ClassIdentity>::NAME,
413 "ACall",
414 )
415 });
416 let __inner: extern "C" fn(MyRoomRecallMenu_WakeupMenuItem, ::unity::OptionalMethod) -> crate::app::basicmenu::BasicMenu_Result =
417 ::core::mem::transmute(__vi.method_ptr);
418 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
419 __inner(__receiver, __mi)
420 }
421 }
422 }
423 #[doc = "`BCall()` overload"]
424 fn b_call(self) -> crate::app::basicmenu::BasicMenu_Result {
425 unsafe {
426 let __receiver =
427 <MyRoomRecallMenu_WakeupMenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
428 {
429 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
430 let __vi = *__vt.get(19usize).unwrap_or_else(|| {
431 panic!(
432 "unity: virtual slot {}
433 out of range (vtable len {}
434) on the runtime class behind {}
435 (method `{}
436`)",
437 19usize,
438 __vt.len(),
439 <MyRoomRecallMenu_WakeupMenuItem as ::unity::ClassIdentity>::NAME,
440 "BCall",
441 )
442 });
443 let __inner: extern "C" fn(MyRoomRecallMenu_WakeupMenuItem, ::unity::OptionalMethod) -> crate::app::basicmenu::BasicMenu_Result =
444 ::core::mem::transmute(__vi.method_ptr);
445 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
446 __inner(__receiver, __mi)
447 }
448 }
449 }
450}
451
452#[cfg(feature = "app-myroomrecallmenu")]
453impl<__T: IMyRoomRecallMenu_WakeupMenuItem> IMyRoomRecallMenu_WakeupMenuItemMethods for __T {}
454
455#[cfg(feature = "app-myroomrecallmenu")]
456impl MyRoomRecallMenu_WakeupMenuItem {
457 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
458 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
459 }
460
461 pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
462 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
463 }
464
465 pub fn build_attribute_method_info() -> &'static ::unity::il2cpp::MethodInfo {
466 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
467 }
468
469 pub fn a_call_method_info() -> &'static ::unity::il2cpp::MethodInfo {
470 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
471 }
472
473 pub fn b_call_method_info() -> &'static ::unity::il2cpp::MethodInfo {
474 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
475 }
476}
477
478#[cfg(feature = "app-myroomrecallmenu")]
479impl MyRoomRecallMenu_WakeupMenuItem {
480 #[doc = "Direct (non-virtual) call to `MyRoomRecallMenu_WakeupMenuItem`'s own `GetName`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
481 pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
482 let __mi = Self::get_name_method_info();
483 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
484 __inner(this.into(), ::core::option::Option::None)
485 }
486
487 #[doc = "Direct (non-virtual) call to `MyRoomRecallMenu_WakeupMenuItem`'s own `BuildAttribute`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
488 pub unsafe fn build_attribute(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::basicmenuitem::BasicMenuItem_Attribute {
489 let __mi = Self::build_attribute_method_info();
490 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::basicmenuitem::BasicMenuItem_Attribute =
491 ::core::mem::transmute(__mi.method_ptr);
492 __inner(this.into(), ::core::option::Option::None)
493 }
494
495 #[doc = "Direct (non-virtual) call to `MyRoomRecallMenu_WakeupMenuItem`'s own `ACall`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
496 pub unsafe fn a_call(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::basicmenu::BasicMenu_Result {
497 let __mi = Self::a_call_method_info();
498 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::basicmenu::BasicMenu_Result =
499 ::core::mem::transmute(__mi.method_ptr);
500 __inner(this.into(), ::core::option::Option::None)
501 }
502
503 #[doc = "Direct (non-virtual) call to `MyRoomRecallMenu_WakeupMenuItem`'s own `BCall`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
504 pub unsafe fn b_call(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::basicmenu::BasicMenu_Result {
505 let __mi = Self::b_call_method_info();
506 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::basicmenu::BasicMenu_Result =
507 ::core::mem::transmute(__mi.method_ptr);
508 __inner(this.into(), ::core::option::Option::None)
509 }
510}
511
512#[cfg(feature = "app-myroomrecallmenu")]
513impl MyRoomRecallMenu_WakeupMenuItem {
514 #[doc = "`.ctor(crate::app::myroomrecallmenu::MyRoomRecallMenu_DecideEventHandler)` — overload selector"]
515 pub fn new(event_handler: crate::app::myroomrecallmenu::MyRoomRecallMenu_DecideEventHandler) -> Self {
516 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
517 panic!(
518 "{}
519::{}
520 failed to instantiate",
521 ::core::stringify!(MyRoomRecallMenu_WakeupMenuItem),
522 ::core::stringify!(new),
523 )
524 });
525 <Self as IMyRoomRecallMenu_WakeupMenuItemMethods>::ctor(this, event_handler);
526 this
527 }
528}
529
530#[cfg(feature = "app-myroomrecallmenu")]
531impl MyRoomRecallMenu {
532 #[doc = "`CreateBind(crate::app::procinst::ProcInst, crate::app::myroomrecallmenu::MyRoomRecallMenu_MenuResult, crate::app::myroomrecallmenu::MyRoomRecallMenu_DecideEventHandler)` overload"]
533 pub fn create_bind(
534 super_: impl ::core::convert::Into<crate::app::procinst::ProcInst>,
535 initial_selected: impl ::core::convert::Into<crate::app::myroomrecallmenu::MyRoomRecallMenu_MenuResult>,
536 event_handler: impl ::core::convert::Into<crate::app::myroomrecallmenu::MyRoomRecallMenu_DecideEventHandler>,
537 ) -> () {
538 unsafe {
539 ::unity::il2cpp_call!((::unity::module_base()+0x23938e0usize)as*mut u8,();
540(crate::app::procinst::ProcInst)::core::convert::Into::into(super_),(crate::app::myroomrecallmenu::MyRoomRecallMenu_MenuResult)::core::convert::Into::into(initial_selected),(crate::app::myroomrecallmenu::MyRoomRecallMenu_DecideEventHandler)::core::convert::Into::into(event_handler))
541 }
542 }
543}
544
545#[cfg(feature = "app-myroomrecallmenu")]
546pub trait IMyRoomRecallMenuMethods: IMyRoomRecallMenu {
547 #[doc = "`get_m_DecideEventHandler()` overload"]
548 fn get_m_decide_event_handler(self) -> crate::app::myroomrecallmenu::MyRoomRecallMenu_DecideEventHandler {
549 unsafe {
550 let __receiver = <MyRoomRecallMenu as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
551 ::unity::il2cpp_call!((::unity::module_base()+0x23936a0usize)as*mut u8,crate::app::myroomrecallmenu::MyRoomRecallMenu_DecideEventHandler;
552(MyRoomRecallMenu)__receiver)
553 }
554 }
555 #[doc = "`set_m_DecideEventHandler(crate::app::myroomrecallmenu::MyRoomRecallMenu_DecideEventHandler)` overload"]
556 fn set_m_decide_event_handler(self, value: impl ::core::convert::Into<crate::app::myroomrecallmenu::MyRoomRecallMenu_DecideEventHandler>) -> () {
557 unsafe {
558 let __receiver = <MyRoomRecallMenu as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
559 ::unity::il2cpp_call!((::unity::module_base()+0x23936b0usize)as*mut u8,();
560(MyRoomRecallMenu)__receiver,(crate::app::myroomrecallmenu::MyRoomRecallMenu_DecideEventHandler)::core::convert::Into::into(value))
561 }
562 }
563 #[doc = "`BCall()` overload"]
564 fn b_call(self) -> crate::app::basicmenu::BasicMenu_Result {
565 unsafe {
566 let __receiver = <MyRoomRecallMenu as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
567 {
568 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
569 let __vi = *__vt.get(51usize).unwrap_or_else(|| {
570 panic!(
571 "unity: virtual slot {}
572 out of range (vtable len {}
573) on the runtime class behind {}
574 (method `{}
575`)",
576 51usize,
577 __vt.len(),
578 <MyRoomRecallMenu as ::unity::ClassIdentity>::NAME,
579 "BCall",
580 )
581 });
582 let __inner: extern "C" fn(MyRoomRecallMenu, ::unity::OptionalMethod) -> crate::app::basicmenu::BasicMenu_Result =
583 ::core::mem::transmute(__vi.method_ptr);
584 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
585 __inner(__receiver, __mi)
586 }
587 }
588 }
589 #[doc = "`.ctor(crate::system::collections::generic::list_1::List_1<crate::app::basicmenuitem::BasicMenuItem>, crate::app::basicmenucontent::BasicMenuContent, crate::app::myroomrecallmenu::MyRoomRecallMenu_MenuResult, crate::app::myroomrecallmenu::MyRoomRecallMenu_DecideEventHandler)` overload"]
590 fn ctor(
591 self,
592 menu_item_list: impl ::core::convert::Into<crate::system::collections::generic::list_1::List_1<crate::app::basicmenuitem::BasicMenuItem>>,
593 menu_content: impl ::core::convert::Into<crate::app::basicmenucontent::BasicMenuContent>,
594 initial_selected: impl ::core::convert::Into<crate::app::myroomrecallmenu::MyRoomRecallMenu_MenuResult>,
595 event_handler: impl ::core::convert::Into<crate::app::myroomrecallmenu::MyRoomRecallMenu_DecideEventHandler>,
596 ) -> () {
597 unsafe {
598 let __receiver = <MyRoomRecallMenu as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
599 ::unity::il2cpp_call!((::unity::module_base()+0x2393760usize)as*mut u8,();
600(MyRoomRecallMenu)__receiver,(crate::system::collections::generic::list_1::List_1<crate::app::basicmenuitem::BasicMenuItem>)::core::convert::Into::into(menu_item_list),(crate::app::basicmenucontent::BasicMenuContent)::core::convert::Into::into(menu_content),(crate::app::myroomrecallmenu::MyRoomRecallMenu_MenuResult)::core::convert::Into::into(initial_selected),(crate::app::myroomrecallmenu::MyRoomRecallMenu_DecideEventHandler)::core::convert::Into::into(event_handler))
601 }
602 }
603 #[doc = "`GetName()` overload"]
604 fn get_name(self) -> ::unity::Il2CppString {
605 unsafe {
606 let __receiver = <MyRoomRecallMenu as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
607 {
608 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
609 let __vi = *__vt.get(30usize).unwrap_or_else(|| {
610 panic!(
611 "unity: virtual slot {}
612 out of range (vtable len {}
613) on the runtime class behind {}
614 (method `{}
615`)",
616 30usize,
617 __vt.len(),
618 <MyRoomRecallMenu as ::unity::ClassIdentity>::NAME,
619 "GetName",
620 )
621 });
622 let __inner: extern "C" fn(MyRoomRecallMenu, ::unity::OptionalMethod) -> ::unity::Il2CppString =
623 ::core::mem::transmute(__vi.method_ptr);
624 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
625 __inner(__receiver, __mi)
626 }
627 }
628 }
629 #[doc = "`OnClose()` overload"]
630 fn on_close(self) -> () {
631 unsafe {
632 let __receiver = <MyRoomRecallMenu as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
633 {
634 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
635 let __vi = *__vt.get(26usize).unwrap_or_else(|| {
636 panic!(
637 "unity: virtual slot {}
638 out of range (vtable len {}
639) on the runtime class behind {}
640 (method `{}
641`)",
642 26usize,
643 __vt.len(),
644 <MyRoomRecallMenu as ::unity::ClassIdentity>::NAME,
645 "OnClose",
646 )
647 });
648 let __inner: extern "C" fn(MyRoomRecallMenu, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__vi.method_ptr);
649 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
650 __inner(__receiver, __mi)
651 }
652 }
653 }
654}
655
656#[cfg(feature = "app-myroomrecallmenu")]
657impl<__T: IMyRoomRecallMenu> IMyRoomRecallMenuMethods for __T {}
658
659#[cfg(feature = "app-myroomrecallmenu")]
660impl MyRoomRecallMenu {
661 pub fn get_m_decide_event_handler_method_info() -> &'static ::unity::il2cpp::MethodInfo {
662 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
663 }
664
665 pub fn set_m_decide_event_handler_method_info() -> &'static ::unity::il2cpp::MethodInfo {
666 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
667 }
668
669 pub fn b_call_method_info() -> &'static ::unity::il2cpp::MethodInfo {
670 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
671 }
672
673 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
674 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
675 }
676
677 pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
678 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
679 }
680
681 pub fn on_close_method_info() -> &'static ::unity::il2cpp::MethodInfo {
682 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[5]
683 }
684
685 pub fn create_bind_method_info() -> &'static ::unity::il2cpp::MethodInfo {
686 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[6]
687 }
688}
689
690#[cfg(feature = "app-myroomrecallmenu")]
691impl MyRoomRecallMenu {
692 #[doc = "Direct (non-virtual) call to `MyRoomRecallMenu`'s own `BCall`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
693 pub unsafe fn b_call(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::basicmenu::BasicMenu_Result {
694 let __mi = Self::b_call_method_info();
695 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::basicmenu::BasicMenu_Result =
696 ::core::mem::transmute(__mi.method_ptr);
697 __inner(this.into(), ::core::option::Option::None)
698 }
699
700 #[doc = "Direct (non-virtual) call to `MyRoomRecallMenu`'s own `GetName`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
701 pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
702 let __mi = Self::get_name_method_info();
703 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
704 __inner(this.into(), ::core::option::Option::None)
705 }
706
707 #[doc = "Direct (non-virtual) call to `MyRoomRecallMenu`'s own `OnClose`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
708 pub unsafe fn on_close(this: impl ::core::convert::Into<::unity::IlInstance>) -> () {
709 let __mi = Self::on_close_method_info();
710 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
711 __inner(this.into(), ::core::option::Option::None)
712 }
713}
714
715#[cfg(feature = "app-myroomrecallmenu")]
716impl MyRoomRecallMenu {
717 #[doc = "`.ctor(crate::system::collections::generic::list_1::List_1<crate::app::basicmenuitem::BasicMenuItem>, crate::app::basicmenucontent::BasicMenuContent, crate::app::myroomrecallmenu::MyRoomRecallMenu_MenuResult, crate::app::myroomrecallmenu::MyRoomRecallMenu_DecideEventHandler)` — overload selector"]
718 pub fn new(
719 menu_item_list: crate::system::collections::generic::list_1::List_1<crate::app::basicmenuitem::BasicMenuItem>,
720 menu_content: crate::app::basicmenucontent::BasicMenuContent,
721 initial_selected: crate::app::myroomrecallmenu::MyRoomRecallMenu_MenuResult,
722 event_handler: crate::app::myroomrecallmenu::MyRoomRecallMenu_DecideEventHandler,
723 ) -> Self {
724 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
725 panic!(
726 "{}
727::{}
728 failed to instantiate",
729 ::core::stringify!(MyRoomRecallMenu),
730 ::core::stringify!(new),
731 )
732 });
733 <Self as IMyRoomRecallMenuMethods>::ctor(this, menu_item_list, menu_content, initial_selected, event_handler);
734 this
735 }
736}
737
738#[cfg(feature = "app-myroomrecallmenu")]
739pub trait IMyRoomRecallMenu_MusicMenuItemMethods: IMyRoomRecallMenu_MusicMenuItem {
740 #[doc = "`.ctor(crate::app::myroomrecallmenu::MyRoomRecallMenu_DecideEventHandler)` overload"]
741 fn ctor(self, event_handler: impl ::core::convert::Into<crate::app::myroomrecallmenu::MyRoomRecallMenu_DecideEventHandler>) -> () {
742 unsafe {
743 let __receiver =
744 <MyRoomRecallMenu_MusicMenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
745 ::unity::il2cpp_call!((::unity::module_base()+0x2094870usize)as*mut u8,();
746(MyRoomRecallMenu_MusicMenuItem)__receiver,(crate::app::myroomrecallmenu::MyRoomRecallMenu_DecideEventHandler)::core::convert::Into::into(event_handler))
747 }
748 }
749 #[doc = "`GetName()` overload"]
750 fn get_name(self) -> ::unity::Il2CppString {
751 unsafe {
752 let __receiver =
753 <MyRoomRecallMenu_MusicMenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
754 {
755 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
756 let __vi = *__vt.get(4usize).unwrap_or_else(|| {
757 panic!(
758 "unity: virtual slot {}
759 out of range (vtable len {}
760) on the runtime class behind {}
761 (method `{}
762`)",
763 4usize,
764 __vt.len(),
765 <MyRoomRecallMenu_MusicMenuItem as ::unity::ClassIdentity>::NAME,
766 "GetName",
767 )
768 });
769 let __inner: extern "C" fn(MyRoomRecallMenu_MusicMenuItem, ::unity::OptionalMethod) -> ::unity::Il2CppString =
770 ::core::mem::transmute(__vi.method_ptr);
771 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
772 __inner(__receiver, __mi)
773 }
774 }
775 }
776 #[doc = "`BuildAttribute()` overload"]
777 fn build_attribute(self) -> crate::app::basicmenuitem::BasicMenuItem_Attribute {
778 unsafe {
779 let __receiver =
780 <MyRoomRecallMenu_MusicMenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
781 {
782 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
783 let __vi = *__vt.get(8usize).unwrap_or_else(|| {
784 panic!(
785 "unity: virtual slot {}
786 out of range (vtable len {}
787) on the runtime class behind {}
788 (method `{}
789`)",
790 8usize,
791 __vt.len(),
792 <MyRoomRecallMenu_MusicMenuItem as ::unity::ClassIdentity>::NAME,
793 "BuildAttribute",
794 )
795 });
796 let __inner: extern "C" fn(
797 MyRoomRecallMenu_MusicMenuItem,
798 ::unity::OptionalMethod,
799 ) -> crate::app::basicmenuitem::BasicMenuItem_Attribute = ::core::mem::transmute(__vi.method_ptr);
800 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
801 __inner(__receiver, __mi)
802 }
803 }
804 }
805 #[doc = "`ACall()` overload"]
806 fn a_call(self) -> crate::app::basicmenu::BasicMenu_Result {
807 unsafe {
808 let __receiver =
809 <MyRoomRecallMenu_MusicMenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
810 {
811 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
812 let __vi = *__vt.get(18usize).unwrap_or_else(|| {
813 panic!(
814 "unity: virtual slot {}
815 out of range (vtable len {}
816) on the runtime class behind {}
817 (method `{}
818`)",
819 18usize,
820 __vt.len(),
821 <MyRoomRecallMenu_MusicMenuItem as ::unity::ClassIdentity>::NAME,
822 "ACall",
823 )
824 });
825 let __inner: extern "C" fn(MyRoomRecallMenu_MusicMenuItem, ::unity::OptionalMethod) -> crate::app::basicmenu::BasicMenu_Result =
826 ::core::mem::transmute(__vi.method_ptr);
827 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
828 __inner(__receiver, __mi)
829 }
830 }
831 }
832 #[doc = "`BCall()` overload"]
833 fn b_call(self) -> crate::app::basicmenu::BasicMenu_Result {
834 unsafe {
835 let __receiver =
836 <MyRoomRecallMenu_MusicMenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
837 {
838 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
839 let __vi = *__vt.get(19usize).unwrap_or_else(|| {
840 panic!(
841 "unity: virtual slot {}
842 out of range (vtable len {}
843) on the runtime class behind {}
844 (method `{}
845`)",
846 19usize,
847 __vt.len(),
848 <MyRoomRecallMenu_MusicMenuItem as ::unity::ClassIdentity>::NAME,
849 "BCall",
850 )
851 });
852 let __inner: extern "C" fn(MyRoomRecallMenu_MusicMenuItem, ::unity::OptionalMethod) -> crate::app::basicmenu::BasicMenu_Result =
853 ::core::mem::transmute(__vi.method_ptr);
854 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
855 __inner(__receiver, __mi)
856 }
857 }
858 }
859}
860
861#[cfg(feature = "app-myroomrecallmenu")]
862impl<__T: IMyRoomRecallMenu_MusicMenuItem> IMyRoomRecallMenu_MusicMenuItemMethods for __T {}
863
864#[cfg(feature = "app-myroomrecallmenu")]
865impl MyRoomRecallMenu_MusicMenuItem {
866 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
867 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
868 }
869
870 pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
871 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
872 }
873
874 pub fn build_attribute_method_info() -> &'static ::unity::il2cpp::MethodInfo {
875 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
876 }
877
878 pub fn a_call_method_info() -> &'static ::unity::il2cpp::MethodInfo {
879 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
880 }
881
882 pub fn b_call_method_info() -> &'static ::unity::il2cpp::MethodInfo {
883 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
884 }
885}
886
887#[cfg(feature = "app-myroomrecallmenu")]
888impl MyRoomRecallMenu_MusicMenuItem {
889 #[doc = "Direct (non-virtual) call to `MyRoomRecallMenu_MusicMenuItem`'s own `GetName`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
890 pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
891 let __mi = Self::get_name_method_info();
892 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
893 __inner(this.into(), ::core::option::Option::None)
894 }
895
896 #[doc = "Direct (non-virtual) call to `MyRoomRecallMenu_MusicMenuItem`'s own `BuildAttribute`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
897 pub unsafe fn build_attribute(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::basicmenuitem::BasicMenuItem_Attribute {
898 let __mi = Self::build_attribute_method_info();
899 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::basicmenuitem::BasicMenuItem_Attribute =
900 ::core::mem::transmute(__mi.method_ptr);
901 __inner(this.into(), ::core::option::Option::None)
902 }
903
904 #[doc = "Direct (non-virtual) call to `MyRoomRecallMenu_MusicMenuItem`'s own `ACall`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
905 pub unsafe fn a_call(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::basicmenu::BasicMenu_Result {
906 let __mi = Self::a_call_method_info();
907 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::basicmenu::BasicMenu_Result =
908 ::core::mem::transmute(__mi.method_ptr);
909 __inner(this.into(), ::core::option::Option::None)
910 }
911
912 #[doc = "Direct (non-virtual) call to `MyRoomRecallMenu_MusicMenuItem`'s own `BCall`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
913 pub unsafe fn b_call(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::basicmenu::BasicMenu_Result {
914 let __mi = Self::b_call_method_info();
915 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::basicmenu::BasicMenu_Result =
916 ::core::mem::transmute(__mi.method_ptr);
917 __inner(this.into(), ::core::option::Option::None)
918 }
919}
920
921#[cfg(feature = "app-myroomrecallmenu")]
922impl MyRoomRecallMenu_MusicMenuItem {
923 #[doc = "`.ctor(crate::app::myroomrecallmenu::MyRoomRecallMenu_DecideEventHandler)` — overload selector"]
924 pub fn new(event_handler: crate::app::myroomrecallmenu::MyRoomRecallMenu_DecideEventHandler) -> Self {
925 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
926 panic!(
927 "{}
928::{}
929 failed to instantiate",
930 ::core::stringify!(MyRoomRecallMenu_MusicMenuItem),
931 ::core::stringify!(new),
932 )
933 });
934 <Self as IMyRoomRecallMenu_MusicMenuItemMethods>::ctor(this, event_handler);
935 this
936 }
937}
938
939#[cfg(feature = "app-myroomrecallmenu")]
940pub trait IMyRoomRecallMenu_MovieMenuItemMethods: IMyRoomRecallMenu_MovieMenuItem {
941 #[doc = "`.ctor(crate::app::myroomrecallmenu::MyRoomRecallMenu_DecideEventHandler)` overload"]
942 fn ctor(self, event_handler: impl ::core::convert::Into<crate::app::myroomrecallmenu::MyRoomRecallMenu_DecideEventHandler>) -> () {
943 unsafe {
944 let __receiver =
945 <MyRoomRecallMenu_MovieMenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
946 ::unity::il2cpp_call!((::unity::module_base()+0x2094760usize)as*mut u8,();
947(MyRoomRecallMenu_MovieMenuItem)__receiver,(crate::app::myroomrecallmenu::MyRoomRecallMenu_DecideEventHandler)::core::convert::Into::into(event_handler))
948 }
949 }
950 #[doc = "`GetName()` overload"]
951 fn get_name(self) -> ::unity::Il2CppString {
952 unsafe {
953 let __receiver =
954 <MyRoomRecallMenu_MovieMenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
955 {
956 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
957 let __vi = *__vt.get(4usize).unwrap_or_else(|| {
958 panic!(
959 "unity: virtual slot {}
960 out of range (vtable len {}
961) on the runtime class behind {}
962 (method `{}
963`)",
964 4usize,
965 __vt.len(),
966 <MyRoomRecallMenu_MovieMenuItem as ::unity::ClassIdentity>::NAME,
967 "GetName",
968 )
969 });
970 let __inner: extern "C" fn(MyRoomRecallMenu_MovieMenuItem, ::unity::OptionalMethod) -> ::unity::Il2CppString =
971 ::core::mem::transmute(__vi.method_ptr);
972 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
973 __inner(__receiver, __mi)
974 }
975 }
976 }
977 #[doc = "`BuildAttribute()` overload"]
978 fn build_attribute(self) -> crate::app::basicmenuitem::BasicMenuItem_Attribute {
979 unsafe {
980 let __receiver =
981 <MyRoomRecallMenu_MovieMenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
982 {
983 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
984 let __vi = *__vt.get(8usize).unwrap_or_else(|| {
985 panic!(
986 "unity: virtual slot {}
987 out of range (vtable len {}
988) on the runtime class behind {}
989 (method `{}
990`)",
991 8usize,
992 __vt.len(),
993 <MyRoomRecallMenu_MovieMenuItem as ::unity::ClassIdentity>::NAME,
994 "BuildAttribute",
995 )
996 });
997 let __inner: extern "C" fn(
998 MyRoomRecallMenu_MovieMenuItem,
999 ::unity::OptionalMethod,
1000 ) -> crate::app::basicmenuitem::BasicMenuItem_Attribute = ::core::mem::transmute(__vi.method_ptr);
1001 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1002 __inner(__receiver, __mi)
1003 }
1004 }
1005 }
1006 #[doc = "`ACall()` overload"]
1007 fn a_call(self) -> crate::app::basicmenu::BasicMenu_Result {
1008 unsafe {
1009 let __receiver =
1010 <MyRoomRecallMenu_MovieMenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1011 {
1012 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1013 let __vi = *__vt.get(18usize).unwrap_or_else(|| {
1014 panic!(
1015 "unity: virtual slot {}
1016 out of range (vtable len {}
1017) on the runtime class behind {}
1018 (method `{}
1019`)",
1020 18usize,
1021 __vt.len(),
1022 <MyRoomRecallMenu_MovieMenuItem as ::unity::ClassIdentity>::NAME,
1023 "ACall",
1024 )
1025 });
1026 let __inner: extern "C" fn(MyRoomRecallMenu_MovieMenuItem, ::unity::OptionalMethod) -> crate::app::basicmenu::BasicMenu_Result =
1027 ::core::mem::transmute(__vi.method_ptr);
1028 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1029 __inner(__receiver, __mi)
1030 }
1031 }
1032 }
1033 #[doc = "`BCall()` overload"]
1034 fn b_call(self) -> crate::app::basicmenu::BasicMenu_Result {
1035 unsafe {
1036 let __receiver =
1037 <MyRoomRecallMenu_MovieMenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1038 {
1039 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1040 let __vi = *__vt.get(19usize).unwrap_or_else(|| {
1041 panic!(
1042 "unity: virtual slot {}
1043 out of range (vtable len {}
1044) on the runtime class behind {}
1045 (method `{}
1046`)",
1047 19usize,
1048 __vt.len(),
1049 <MyRoomRecallMenu_MovieMenuItem as ::unity::ClassIdentity>::NAME,
1050 "BCall",
1051 )
1052 });
1053 let __inner: extern "C" fn(MyRoomRecallMenu_MovieMenuItem, ::unity::OptionalMethod) -> crate::app::basicmenu::BasicMenu_Result =
1054 ::core::mem::transmute(__vi.method_ptr);
1055 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1056 __inner(__receiver, __mi)
1057 }
1058 }
1059 }
1060}
1061
1062#[cfg(feature = "app-myroomrecallmenu")]
1063impl<__T: IMyRoomRecallMenu_MovieMenuItem> IMyRoomRecallMenu_MovieMenuItemMethods for __T {}
1064
1065#[cfg(feature = "app-myroomrecallmenu")]
1066impl MyRoomRecallMenu_MovieMenuItem {
1067 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1068 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
1069 }
1070
1071 pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1072 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
1073 }
1074
1075 pub fn build_attribute_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1076 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
1077 }
1078
1079 pub fn a_call_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1080 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
1081 }
1082
1083 pub fn b_call_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1084 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
1085 }
1086}
1087
1088#[cfg(feature = "app-myroomrecallmenu")]
1089impl MyRoomRecallMenu_MovieMenuItem {
1090 #[doc = "Direct (non-virtual) call to `MyRoomRecallMenu_MovieMenuItem`'s own `GetName`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1091 pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
1092 let __mi = Self::get_name_method_info();
1093 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
1094 __inner(this.into(), ::core::option::Option::None)
1095 }
1096
1097 #[doc = "Direct (non-virtual) call to `MyRoomRecallMenu_MovieMenuItem`'s own `BuildAttribute`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1098 pub unsafe fn build_attribute(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::basicmenuitem::BasicMenuItem_Attribute {
1099 let __mi = Self::build_attribute_method_info();
1100 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::basicmenuitem::BasicMenuItem_Attribute =
1101 ::core::mem::transmute(__mi.method_ptr);
1102 __inner(this.into(), ::core::option::Option::None)
1103 }
1104
1105 #[doc = "Direct (non-virtual) call to `MyRoomRecallMenu_MovieMenuItem`'s own `ACall`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1106 pub unsafe fn a_call(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::basicmenu::BasicMenu_Result {
1107 let __mi = Self::a_call_method_info();
1108 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::basicmenu::BasicMenu_Result =
1109 ::core::mem::transmute(__mi.method_ptr);
1110 __inner(this.into(), ::core::option::Option::None)
1111 }
1112
1113 #[doc = "Direct (non-virtual) call to `MyRoomRecallMenu_MovieMenuItem`'s own `BCall`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1114 pub unsafe fn b_call(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::basicmenu::BasicMenu_Result {
1115 let __mi = Self::b_call_method_info();
1116 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::basicmenu::BasicMenu_Result =
1117 ::core::mem::transmute(__mi.method_ptr);
1118 __inner(this.into(), ::core::option::Option::None)
1119 }
1120}
1121
1122#[cfg(feature = "app-myroomrecallmenu")]
1123impl MyRoomRecallMenu_MovieMenuItem {
1124 #[doc = "`.ctor(crate::app::myroomrecallmenu::MyRoomRecallMenu_DecideEventHandler)` — overload selector"]
1125 pub fn new(event_handler: crate::app::myroomrecallmenu::MyRoomRecallMenu_DecideEventHandler) -> Self {
1126 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
1127 panic!(
1128 "{}
1129::{}
1130 failed to instantiate",
1131 ::core::stringify!(MyRoomRecallMenu_MovieMenuItem),
1132 ::core::stringify!(new),
1133 )
1134 });
1135 <Self as IMyRoomRecallMenu_MovieMenuItemMethods>::ctor(this, event_handler);
1136 this
1137 }
1138}
1139
1140#[cfg(feature = "app-myroomrecallmenu")]
1141pub trait IMyRoomRecallMenu_GodRelianceMenuItemMethods: IMyRoomRecallMenu_GodRelianceMenuItem {
1142 #[doc = "`.ctor(crate::app::myroomrecallmenu::MyRoomRecallMenu_DecideEventHandler)` overload"]
1143 fn ctor(self, event_handler: impl ::core::convert::Into<crate::app::myroomrecallmenu::MyRoomRecallMenu_DecideEventHandler>) -> () {
1144 unsafe {
1145 let __receiver = <MyRoomRecallMenu_GodRelianceMenuItem as ::unity::FromIlInstance>::from_il_instance(
1146 <Self as ::unity::SystemObject>::as_instance(self),
1147 );
1148 ::unity::il2cpp_call!((::unity::module_base()+0x2094530usize)as*mut u8,();
1149(MyRoomRecallMenu_GodRelianceMenuItem)__receiver,(crate::app::myroomrecallmenu::MyRoomRecallMenu_DecideEventHandler)::core::convert::Into::into(event_handler))
1150 }
1151 }
1152 #[doc = "`GetName()` overload"]
1153 fn get_name(self) -> ::unity::Il2CppString {
1154 unsafe {
1155 let __receiver = <MyRoomRecallMenu_GodRelianceMenuItem as ::unity::FromIlInstance>::from_il_instance(
1156 <Self as ::unity::SystemObject>::as_instance(self),
1157 );
1158 {
1159 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1160 let __vi = *__vt.get(4usize).unwrap_or_else(|| {
1161 panic!(
1162 "unity: virtual slot {}
1163 out of range (vtable len {}
1164) on the runtime class behind {}
1165 (method `{}
1166`)",
1167 4usize,
1168 __vt.len(),
1169 <MyRoomRecallMenu_GodRelianceMenuItem as ::unity::ClassIdentity>::NAME,
1170 "GetName",
1171 )
1172 });
1173 let __inner: extern "C" fn(MyRoomRecallMenu_GodRelianceMenuItem, ::unity::OptionalMethod) -> ::unity::Il2CppString =
1174 ::core::mem::transmute(__vi.method_ptr);
1175 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1176 __inner(__receiver, __mi)
1177 }
1178 }
1179 }
1180 #[doc = "`BuildAttribute()` overload"]
1181 fn build_attribute(self) -> crate::app::basicmenuitem::BasicMenuItem_Attribute {
1182 unsafe {
1183 let __receiver = <MyRoomRecallMenu_GodRelianceMenuItem as ::unity::FromIlInstance>::from_il_instance(
1184 <Self as ::unity::SystemObject>::as_instance(self),
1185 );
1186 {
1187 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1188 let __vi = *__vt.get(8usize).unwrap_or_else(|| {
1189 panic!(
1190 "unity: virtual slot {}
1191 out of range (vtable len {}
1192) on the runtime class behind {}
1193 (method `{}
1194`)",
1195 8usize,
1196 __vt.len(),
1197 <MyRoomRecallMenu_GodRelianceMenuItem as ::unity::ClassIdentity>::NAME,
1198 "BuildAttribute",
1199 )
1200 });
1201 let __inner: extern "C" fn(
1202 MyRoomRecallMenu_GodRelianceMenuItem,
1203 ::unity::OptionalMethod,
1204 ) -> crate::app::basicmenuitem::BasicMenuItem_Attribute = ::core::mem::transmute(__vi.method_ptr);
1205 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1206 __inner(__receiver, __mi)
1207 }
1208 }
1209 }
1210 #[doc = "`ACall()` overload"]
1211 fn a_call(self) -> crate::app::basicmenu::BasicMenu_Result {
1212 unsafe {
1213 let __receiver = <MyRoomRecallMenu_GodRelianceMenuItem as ::unity::FromIlInstance>::from_il_instance(
1214 <Self as ::unity::SystemObject>::as_instance(self),
1215 );
1216 {
1217 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1218 let __vi = *__vt.get(18usize).unwrap_or_else(|| {
1219 panic!(
1220 "unity: virtual slot {}
1221 out of range (vtable len {}
1222) on the runtime class behind {}
1223 (method `{}
1224`)",
1225 18usize,
1226 __vt.len(),
1227 <MyRoomRecallMenu_GodRelianceMenuItem as ::unity::ClassIdentity>::NAME,
1228 "ACall",
1229 )
1230 });
1231 let __inner: extern "C" fn(MyRoomRecallMenu_GodRelianceMenuItem, ::unity::OptionalMethod) -> crate::app::basicmenu::BasicMenu_Result =
1232 ::core::mem::transmute(__vi.method_ptr);
1233 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1234 __inner(__receiver, __mi)
1235 }
1236 }
1237 }
1238 #[doc = "`BCall()` overload"]
1239 fn b_call(self) -> crate::app::basicmenu::BasicMenu_Result {
1240 unsafe {
1241 let __receiver = <MyRoomRecallMenu_GodRelianceMenuItem as ::unity::FromIlInstance>::from_il_instance(
1242 <Self as ::unity::SystemObject>::as_instance(self),
1243 );
1244 {
1245 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1246 let __vi = *__vt.get(19usize).unwrap_or_else(|| {
1247 panic!(
1248 "unity: virtual slot {}
1249 out of range (vtable len {}
1250) on the runtime class behind {}
1251 (method `{}
1252`)",
1253 19usize,
1254 __vt.len(),
1255 <MyRoomRecallMenu_GodRelianceMenuItem as ::unity::ClassIdentity>::NAME,
1256 "BCall",
1257 )
1258 });
1259 let __inner: extern "C" fn(MyRoomRecallMenu_GodRelianceMenuItem, ::unity::OptionalMethod) -> crate::app::basicmenu::BasicMenu_Result =
1260 ::core::mem::transmute(__vi.method_ptr);
1261 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1262 __inner(__receiver, __mi)
1263 }
1264 }
1265 }
1266}
1267
1268#[cfg(feature = "app-myroomrecallmenu")]
1269impl<__T: IMyRoomRecallMenu_GodRelianceMenuItem> IMyRoomRecallMenu_GodRelianceMenuItemMethods for __T {}
1270
1271#[cfg(feature = "app-myroomrecallmenu")]
1272impl MyRoomRecallMenu_GodRelianceMenuItem {
1273 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1274 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
1275 }
1276
1277 pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1278 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
1279 }
1280
1281 pub fn build_attribute_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1282 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
1283 }
1284
1285 pub fn a_call_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1286 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
1287 }
1288
1289 pub fn b_call_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1290 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
1291 }
1292}
1293
1294#[cfg(feature = "app-myroomrecallmenu")]
1295impl MyRoomRecallMenu_GodRelianceMenuItem {
1296 #[doc = "Direct (non-virtual) call to `MyRoomRecallMenu_GodRelianceMenuItem`'s own `GetName`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1297 pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
1298 let __mi = Self::get_name_method_info();
1299 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
1300 __inner(this.into(), ::core::option::Option::None)
1301 }
1302
1303 #[doc = "Direct (non-virtual) call to `MyRoomRecallMenu_GodRelianceMenuItem`'s own `BuildAttribute`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1304 pub unsafe fn build_attribute(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::basicmenuitem::BasicMenuItem_Attribute {
1305 let __mi = Self::build_attribute_method_info();
1306 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::basicmenuitem::BasicMenuItem_Attribute =
1307 ::core::mem::transmute(__mi.method_ptr);
1308 __inner(this.into(), ::core::option::Option::None)
1309 }
1310
1311 #[doc = "Direct (non-virtual) call to `MyRoomRecallMenu_GodRelianceMenuItem`'s own `ACall`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1312 pub unsafe fn a_call(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::basicmenu::BasicMenu_Result {
1313 let __mi = Self::a_call_method_info();
1314 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::basicmenu::BasicMenu_Result =
1315 ::core::mem::transmute(__mi.method_ptr);
1316 __inner(this.into(), ::core::option::Option::None)
1317 }
1318
1319 #[doc = "Direct (non-virtual) call to `MyRoomRecallMenu_GodRelianceMenuItem`'s own `BCall`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1320 pub unsafe fn b_call(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::basicmenu::BasicMenu_Result {
1321 let __mi = Self::b_call_method_info();
1322 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::basicmenu::BasicMenu_Result =
1323 ::core::mem::transmute(__mi.method_ptr);
1324 __inner(this.into(), ::core::option::Option::None)
1325 }
1326}
1327
1328#[cfg(feature = "app-myroomrecallmenu")]
1329impl MyRoomRecallMenu_GodRelianceMenuItem {
1330 #[doc = "`.ctor(crate::app::myroomrecallmenu::MyRoomRecallMenu_DecideEventHandler)` — overload selector"]
1331 pub fn new(event_handler: crate::app::myroomrecallmenu::MyRoomRecallMenu_DecideEventHandler) -> Self {
1332 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
1333 panic!(
1334 "{}
1335::{}
1336 failed to instantiate",
1337 ::core::stringify!(MyRoomRecallMenu_GodRelianceMenuItem),
1338 ::core::stringify!(new),
1339 )
1340 });
1341 <Self as IMyRoomRecallMenu_GodRelianceMenuItemMethods>::ctor(this, event_handler);
1342 this
1343 }
1344}
1345
1346#[cfg(feature = "app-myroomrecallmenu")]
1347pub trait IMyRoomRecallMenu_DecideEventHandlerMethods: IMyRoomRecallMenu_DecideEventHandler {
1348 #[doc = "`.ctor(crate::system::object::Object, ::unity::IntPtr)` overload"]
1349 fn ctor(self, object: impl ::core::convert::Into<crate::system::object::Object>, method: impl ::core::convert::Into<::unity::IntPtr>) -> () {
1350 unsafe {
1351 let __receiver = <MyRoomRecallMenu_DecideEventHandler as ::unity::FromIlInstance>::from_il_instance(
1352 <Self as ::unity::SystemObject>::as_instance(self),
1353 );
1354 ::unity::il2cpp_call!((::unity::module_base()+0x2094210usize)as*mut u8,();
1355(MyRoomRecallMenu_DecideEventHandler)__receiver,(crate::system::object::Object)::core::convert::Into::into(object),(::unity::IntPtr)::core::convert::Into::into(method))
1356 }
1357 }
1358 #[doc = "`Invoke(crate::app::myroomrecallmenu::MyRoomRecallMenu_MenuResult)` overload"]
1359 fn invoke(self, result: impl ::core::convert::Into<crate::app::myroomrecallmenu::MyRoomRecallMenu_MenuResult>) -> () {
1360 unsafe {
1361 let __receiver = <MyRoomRecallMenu_DecideEventHandler as ::unity::FromIlInstance>::from_il_instance(
1362 <Self as ::unity::SystemObject>::as_instance(self),
1363 );
1364 {
1365 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1366 let __vi = *__vt.get(13usize).unwrap_or_else(|| {
1367 panic!(
1368 "unity: virtual slot {}
1369 out of range (vtable len {}
1370) on the runtime class behind {}
1371 (method `{}
1372`)",
1373 13usize,
1374 __vt.len(),
1375 <MyRoomRecallMenu_DecideEventHandler as ::unity::ClassIdentity>::NAME,
1376 "Invoke",
1377 )
1378 });
1379 let __inner: extern "C" fn(
1380 MyRoomRecallMenu_DecideEventHandler,
1381 crate::app::myroomrecallmenu::MyRoomRecallMenu_MenuResult,
1382 ::unity::OptionalMethod,
1383 ) -> () = ::core::mem::transmute(__vi.method_ptr);
1384 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1385 __inner(__receiver, ::core::convert::Into::into(result), __mi)
1386 }
1387 }
1388 }
1389}
1390
1391#[cfg(feature = "app-myroomrecallmenu")]
1392impl<__T: IMyRoomRecallMenu_DecideEventHandler> IMyRoomRecallMenu_DecideEventHandlerMethods for __T {}
1393
1394#[cfg(feature = "app-myroomrecallmenu")]
1395impl MyRoomRecallMenu_DecideEventHandler {
1396 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1397 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
1398 }
1399
1400 pub fn invoke_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1401 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
1402 }
1403}
1404
1405#[cfg(feature = "app-myroomrecallmenu")]
1406impl MyRoomRecallMenu_DecideEventHandler {
1407 #[doc = "Direct (non-virtual) call to `MyRoomRecallMenu_DecideEventHandler`'s own `Invoke`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1408 pub unsafe fn invoke(
1409 this: impl ::core::convert::Into<::unity::IlInstance>,
1410 result: crate::app::myroomrecallmenu::MyRoomRecallMenu_MenuResult,
1411 ) -> () {
1412 let __mi = Self::invoke_method_info();
1413 let __inner: extern "C" fn(::unity::IlInstance, crate::app::myroomrecallmenu::MyRoomRecallMenu_MenuResult, ::unity::OptionalMethod) -> () =
1414 ::core::mem::transmute(__mi.method_ptr);
1415 __inner(this.into(), result, ::core::option::Option::None)
1416 }
1417}
1418
1419#[cfg(feature = "app-myroomrecallmenu")]
1420impl MyRoomRecallMenu_DecideEventHandler {
1421 #[doc = "`.ctor(crate::system::object::Object, ::unity::IntPtr)` — overload selector"]
1422 pub fn new(object: crate::system::object::Object, method: ::unity::IntPtr) -> Self {
1423 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
1424 panic!(
1425 "{}
1426::{}
1427 failed to instantiate",
1428 ::core::stringify!(MyRoomRecallMenu_DecideEventHandler),
1429 ::core::stringify!(new),
1430 )
1431 });
1432 <Self as IMyRoomRecallMenu_DecideEventHandlerMethods>::ctor(this, object, method);
1433 this
1434 }
1435}
1436
1437#[cfg(feature = "app-myroomrecallmenu")]
1438#[doc(hidden)]
1439pub mod prelude {
1440 pub use super::{
1441 IMyRoomRecallMenu, IMyRoomRecallMenuMethods, IMyRoomRecallMenu_DecideEventHandler, IMyRoomRecallMenu_DecideEventHandlerMethods,
1442 IMyRoomRecallMenu_GodRelianceMenuItem, IMyRoomRecallMenu_GodRelianceMenuItemMethods, IMyRoomRecallMenu_MovieMenuItem,
1443 IMyRoomRecallMenu_MovieMenuItemMethods, IMyRoomRecallMenu_MusicMenuItem, IMyRoomRecallMenu_MusicMenuItemMethods,
1444 IMyRoomRecallMenu_RelianceMenuItem, IMyRoomRecallMenu_RelianceMenuItemMethods, IMyRoomRecallMenu_WakeupMenuItem,
1445 IMyRoomRecallMenu_WakeupMenuItemMethods, MyRoomRecallMenu, MyRoomRecallMenu_DecideEventHandler, MyRoomRecallMenu_GodRelianceMenuItem,
1446 MyRoomRecallMenu_MenuResult, MyRoomRecallMenu_MovieMenuItem, MyRoomRecallMenu_MusicMenuItem, MyRoomRecallMenu_RelianceMenuItem,
1447 MyRoomRecallMenu_WakeupMenuItem,
1448 };
1449 #[cfg(feature = "app-basicmenu")]
1450 pub use crate::app::basicmenu::IBasicMenuMethods;
1451 #[cfg(feature = "app-basicmenuitem")]
1452 pub use crate::app::basicmenuitem::IBasicMenuItemMethods;
1453 #[cfg(feature = "app-procinst")]
1454 pub use crate::app::procinst::IProcInstMethods;
1455 #[cfg(feature = "system-delegate")]
1456 pub use crate::system::delegate::IDelegateMethods;
1457 #[cfg(feature = "system-multicastdelegate")]
1458 pub use crate::system::multicastdelegate::IMulticastDelegateMethods;
1459 #[cfg(feature = "system-object")]
1460 pub use crate::system::object::IObjectMethods;
1461 #[cfg(feature = "system-enum")]
1462 pub use crate::system::r#enum::IEnumMethods;
1463 #[cfg(feature = "system-valuetype")]
1464 pub use crate::system::valuetype::IValueTypeMethods;
1465 pub use crate::{
1466 app::{basicmenu::IBasicMenu, basicmenuitem::IBasicMenuItem, procinst::IProcInst},
1467 system::{delegate::IDelegate, multicastdelegate::IMulticastDelegate, object::IObject, r#enum::IEnum, valuetype::IValueType},
1468 };
1469}