1#[cfg(feature = "app-rewindmenucontent-types")]
4mod __types {
5 #[allow(unused_imports)] use ::unity::prelude::*;
6
7 use super::*;
8 use crate::{
9 app::basicmenucontent::{BasicMenuContent, IBasicMenuContent},
10 system::object::{IObject, Object},
11 unity_engine::{
12 behaviour::{Behaviour, IBehaviour},
13 component::{Component, IComponent},
14 monobehaviour::{IMonoBehaviour, MonoBehaviour},
15 object_2::{IObject_2, Object_2},
16 },
17 };
18
19 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/rewindmenucontent/RewindMenuContent_ScrollArrow.md"))]
20 #[::unity::class(namespace = "App", name = "RewindMenuContent.ScrollArrow")]
21 #[parent(crate::system::object::Object)]
22 pub struct RewindMenuContent_ScrollArrow {
23 #[offset(16)]
24 #[rename(name = "m_RootObject")]
25 pub m_root_object: crate::unity_engine::gameobject::GameObject,
26 }
27
28 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/rewindmenucontent/RewindMenuContent_Phase.md"))]
29 #[::unity::class(namespace = "App", name = "RewindMenuContent.Phase")]
30 #[parent(crate::system::object::Object)]
31 pub struct RewindMenuContent_Phase {
32 #[offset(16)]
33 #[rename(name = "m_RootObject")]
34 pub m_root_object: crate::unity_engine::gameobject::GameObject,
35 #[offset(24)]
36 #[rename(name = "m_TurnName")]
37 pub m_turn_name: crate::tm_pro::textmeshprougui::TextMeshProUGUI,
38 #[offset(32)]
39 #[rename(name = "m_Turn")]
40 pub m_turn: crate::tm_pro::textmeshprougui::TextMeshProUGUI,
41 #[offset(40)]
42 #[rename(name = "m_RestName")]
43 pub m_rest_name: crate::tm_pro::textmeshprougui::TextMeshProUGUI,
44 #[offset(48)]
45 #[rename(name = "m_Rest")]
46 pub m_rest: crate::tm_pro::textmeshprougui::TextMeshProUGUI,
47 }
48
49 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/rewindmenucontent/RewindMenuContent_KeyHelp.md"))]
50 #[::unity::class(namespace = "App", name = "RewindMenuContent.KeyHelp")]
51 #[parent(crate::system::object::Object)]
52 pub struct RewindMenuContent_KeyHelp {
53 #[offset(16)]
54 #[rename(name = "m_RootObject")]
55 pub m_root_object: crate::unity_engine::gameobject::GameObject,
56 }
57
58 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/rewindmenucontent/RewindMenuContent.md"))]
59 #[::unity::class(namespace = "App", name = "RewindMenuContent")]
60 #[parent(crate::app::basicmenucontent::BasicMenuContent)]
61 pub struct RewindMenuContent {
62 #[static_field]
63 #[rename(name = "PrefabPath")]
64 pub prefab_path: ::unity::Il2CppString,
65 #[static_field]
66 #[rename(name = "ShowRowMax")]
67 pub show_row_max: i32,
68 #[offset(232)]
69 #[rename(name = "m_PlayerPhaseObj")]
70 pub m_player_phase_obj: crate::unity_engine::gameobject::GameObject,
71 #[offset(240)]
72 #[rename(name = "m_EnemyPhaseObj")]
73 pub m_enemy_phase_obj: crate::unity_engine::gameobject::GameObject,
74 #[offset(248)]
75 #[rename(name = "m_AllyPhaseObj")]
76 pub m_ally_phase_obj: crate::unity_engine::gameobject::GameObject,
77 #[offset(256)]
78 #[rename(name = "m_Enemy2PhaseObj")]
79 pub m_enemy2_phase_obj: crate::unity_engine::gameobject::GameObject,
80 #[offset(264)]
81 #[rename(name = "m_ScrollArrowUpObj")]
82 pub m_scroll_arrow_up_obj: crate::unity_engine::gameobject::GameObject,
83 #[offset(272)]
84 #[rename(name = "m_ScrollArrowDownObj")]
85 pub m_scroll_arrow_down_obj: crate::unity_engine::gameobject::GameObject,
86 #[offset(280)]
87 #[rename(name = "m_RestRewindTimesObj")]
88 pub m_rest_rewind_times_obj: crate::unity_engine::gameobject::GameObject,
89 #[offset(288)]
90 #[rename(name = "m_KeyHelpObj")]
91 pub m_key_help_obj: crate::unity_engine::gameobject::GameObject,
92 #[offset(296)]
93 #[rename(name = "m_ForcePlayerColor")]
94 pub m_force_player_color: crate::unity_engine::color::Color,
95 #[offset(312)]
96 #[rename(name = "m_ForceEnemyColor")]
97 pub m_force_enemy_color: crate::unity_engine::color::Color,
98 #[offset(328)]
99 #[rename(name = "m_ForceAllyColor")]
100 pub m_force_ally_color: crate::unity_engine::color::Color,
101 #[offset(344)]
102 #[rename(name = "m_ForceEnemy2Color")]
103 pub m_force_enemy2_color: crate::unity_engine::color::Color,
104 #[offset(360)]
105 #[rename(name = "m_RootAnimator")]
106 pub m_root_animator: crate::unity_engine::animator::Animator,
107 #[offset(368)]
108 #[rename(name = "m_PlayerPhase")]
109 pub m_player_phase: crate::app::rewindmenucontent::RewindMenuContent_Phase,
110 #[offset(376)]
111 #[rename(name = "m_EnemyPhase")]
112 pub m_enemy_phase: crate::app::rewindmenucontent::RewindMenuContent_Phase,
113 #[offset(384)]
114 #[rename(name = "m_AllyPhase")]
115 pub m_ally_phase: crate::app::rewindmenucontent::RewindMenuContent_Phase,
116 #[offset(392)]
117 #[rename(name = "m_Enemy2Phase")]
118 pub m_enemy2_phase: crate::app::rewindmenucontent::RewindMenuContent_Phase,
119 #[offset(400)]
120 #[rename(name = "m_ScrollArrowUp")]
121 pub m_scroll_arrow_up: crate::app::rewindmenucontent::RewindMenuContent_ScrollArrow,
122 #[offset(408)]
123 #[rename(name = "m_ScrollArrowDown")]
124 pub m_scroll_arrow_down: crate::app::rewindmenucontent::RewindMenuContent_ScrollArrow,
125 #[offset(416)]
126 #[rename(name = "m_RestRewindTimes")]
127 pub m_rest_rewind_times: crate::app::rewindmenucontent::RewindMenuContent_RestRewindTimes,
128 #[offset(424)]
129 #[rename(name = "m_KeyHelp")]
130 pub m_key_help: crate::app::rewindmenucontent::RewindMenuContent_KeyHelp,
131 }
132
133 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/rewindmenucontent/RewindMenuContent_RestRewindTimes.md"))]
134 #[::unity::class(namespace = "App", name = "RewindMenuContent.RestRewindTimes")]
135 #[parent(crate::system::object::Object)]
136 pub struct RewindMenuContent_RestRewindTimes {
137 #[offset(16)]
138 #[rename(name = "m_RootObject")]
139 pub m_root_object: crate::unity_engine::gameobject::GameObject,
140 #[offset(24)]
141 #[rename(name = "m_Name")]
142 pub m_name: crate::tm_pro::textmeshprougui::TextMeshProUGUI,
143 #[offset(32)]
144 #[rename(name = "m_Times")]
145 pub m_times: crate::tm_pro::textmeshprougui::TextMeshProUGUI,
146 }
147}
148
149#[cfg(feature = "app-rewindmenucontent-types")]
150pub use __types::*;
151
152#[cfg(feature = "app-rewindmenucontent")]
153pub trait IRewindMenuContent_ScrollArrowMethods: IRewindMenuContent_ScrollArrow {
154 #[doc = "`.ctor(crate::unity_engine::gameobject::GameObject)` overload"]
155 fn ctor(self, root_object: impl ::core::convert::Into<crate::unity_engine::gameobject::GameObject>) -> () {
156 unsafe {
157 let __receiver =
158 <RewindMenuContent_ScrollArrow as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
159 ::unity::il2cpp_call!((::unity::module_base()+0x1b0fde0usize)as*mut u8,();
160(RewindMenuContent_ScrollArrow)__receiver,(crate::unity_engine::gameobject::GameObject)::core::convert::Into::into(root_object))
161 }
162 }
163 #[doc = "`Show()` overload"]
164 fn show(self) -> () {
165 unsafe {
166 let __receiver =
167 <RewindMenuContent_ScrollArrow as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
168 ::unity::il2cpp_call!((::unity::module_base()+0x1b0fe20usize)as*mut u8,();
169(RewindMenuContent_ScrollArrow)__receiver)
170 }
171 }
172 #[doc = "`Hide()` overload"]
173 fn hide(self) -> () {
174 unsafe {
175 let __receiver =
176 <RewindMenuContent_ScrollArrow as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
177 ::unity::il2cpp_call!((::unity::module_base()+0x1b0fe30usize)as*mut u8,();
178(RewindMenuContent_ScrollArrow)__receiver)
179 }
180 }
181}
182
183#[cfg(feature = "app-rewindmenucontent")]
184impl<__T: IRewindMenuContent_ScrollArrow> IRewindMenuContent_ScrollArrowMethods for __T {}
185
186#[cfg(feature = "app-rewindmenucontent")]
187impl RewindMenuContent_ScrollArrow {
188 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
189 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
190 }
191
192 pub fn show_method_info() -> &'static ::unity::il2cpp::MethodInfo {
193 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
194 }
195
196 pub fn hide_method_info() -> &'static ::unity::il2cpp::MethodInfo {
197 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
198 }
199}
200
201#[cfg(feature = "app-rewindmenucontent")]
202impl RewindMenuContent_ScrollArrow {
203 #[doc = "`.ctor(crate::unity_engine::gameobject::GameObject)` — overload selector"]
204 pub fn new(root_object: crate::unity_engine::gameobject::GameObject) -> Self {
205 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
206 panic!(
207 "{}
208::{}
209 failed to instantiate",
210 ::core::stringify!(RewindMenuContent_ScrollArrow),
211 ::core::stringify!(new),
212 )
213 });
214 <Self as IRewindMenuContent_ScrollArrowMethods>::ctor(this, root_object);
215 this
216 }
217}
218
219#[cfg(feature = "app-rewindmenucontent")]
220pub trait IRewindMenuContent_PhaseMethods: IRewindMenuContent_Phase {
221 #[doc = "`.ctor(crate::unity_engine::gameobject::GameObject)` overload"]
222 fn ctor(self, root_object: impl ::core::convert::Into<crate::unity_engine::gameobject::GameObject>) -> () {
223 unsafe {
224 let __receiver =
225 <RewindMenuContent_Phase as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
226 ::unity::il2cpp_call!((::unity::module_base()+0x1b0f5b0usize)as*mut u8,();
227(RewindMenuContent_Phase)__receiver,(crate::unity_engine::gameobject::GameObject)::core::convert::Into::into(root_object))
228 }
229 }
230 #[doc = "`Show()` overload"]
231 fn show(self) -> () {
232 unsafe {
233 let __receiver =
234 <RewindMenuContent_Phase as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
235 ::unity::il2cpp_call!((::unity::module_base()+0x1b0fa80usize)as*mut u8,();
236(RewindMenuContent_Phase)__receiver)
237 }
238 }
239 #[doc = "`Hide()` overload"]
240 fn hide(self) -> () {
241 unsafe {
242 let __receiver =
243 <RewindMenuContent_Phase as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
244 ::unity::il2cpp_call!((::unity::module_base()+0x1b0fa90usize)as*mut u8,();
245(RewindMenuContent_Phase)__receiver)
246 }
247 }
248 #[doc = "`SetTurn(i32)` overload"]
249 fn set_turn(self, turn: impl ::core::convert::Into<i32>) -> () {
250 unsafe {
251 let __receiver =
252 <RewindMenuContent_Phase as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
253 ::unity::il2cpp_call!((::unity::module_base()+0x1b0f920usize)as*mut u8,();
254(RewindMenuContent_Phase)__receiver,(i32)::core::convert::Into::into(turn))
255 }
256 }
257 #[doc = "`SetRestUnitNum(i32)` overload"]
258 fn set_rest_unit_num(self, rest_unit_num: impl ::core::convert::Into<i32>) -> () {
259 unsafe {
260 let __receiver =
261 <RewindMenuContent_Phase as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
262 ::unity::il2cpp_call!((::unity::module_base()+0x1b0f9d0usize)as*mut u8,();
263(RewindMenuContent_Phase)__receiver,(i32)::core::convert::Into::into(rest_unit_num))
264 }
265 }
266}
267
268#[cfg(feature = "app-rewindmenucontent")]
269impl<__T: IRewindMenuContent_Phase> IRewindMenuContent_PhaseMethods for __T {}
270
271#[cfg(feature = "app-rewindmenucontent")]
272impl RewindMenuContent_Phase {
273 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
274 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
275 }
276
277 pub fn show_method_info() -> &'static ::unity::il2cpp::MethodInfo {
278 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
279 }
280
281 pub fn hide_method_info() -> &'static ::unity::il2cpp::MethodInfo {
282 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
283 }
284
285 pub fn set_turn_method_info() -> &'static ::unity::il2cpp::MethodInfo {
286 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
287 }
288
289 pub fn set_rest_unit_num_method_info() -> &'static ::unity::il2cpp::MethodInfo {
290 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
291 }
292}
293
294#[cfg(feature = "app-rewindmenucontent")]
295impl RewindMenuContent_Phase {
296 #[doc = "`.ctor(crate::unity_engine::gameobject::GameObject)` — overload selector"]
297 pub fn new(root_object: crate::unity_engine::gameobject::GameObject) -> Self {
298 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
299 panic!(
300 "{}
301::{}
302 failed to instantiate",
303 ::core::stringify!(RewindMenuContent_Phase),
304 ::core::stringify!(new),
305 )
306 });
307 <Self as IRewindMenuContent_PhaseMethods>::ctor(this, root_object);
308 this
309 }
310}
311
312#[cfg(feature = "app-rewindmenucontent")]
313pub trait IRewindMenuContent_KeyHelpMethods: IRewindMenuContent_KeyHelp {
314 #[doc = "`.ctor(crate::unity_engine::gameobject::GameObject)` overload"]
315 fn ctor(self, root_object: impl ::core::convert::Into<crate::unity_engine::gameobject::GameObject>) -> () {
316 unsafe {
317 let __receiver =
318 <RewindMenuContent_KeyHelp as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
319 ::unity::il2cpp_call!((::unity::module_base()+0x1b0f380usize)as*mut u8,();
320(RewindMenuContent_KeyHelp)__receiver,(crate::unity_engine::gameobject::GameObject)::core::convert::Into::into(root_object))
321 }
322 }
323 #[doc = "`Reset()` overload"]
324 fn reset(self) -> () {
325 unsafe {
326 let __receiver =
327 <RewindMenuContent_KeyHelp as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
328 ::unity::il2cpp_call!((::unity::module_base()+0x1b0f3d0usize)as*mut u8,();
329(RewindMenuContent_KeyHelp)__receiver)
330 }
331 }
332 #[doc = "`Set()` overload"]
333 fn set(self) -> () {
334 unsafe {
335 let __receiver =
336 <RewindMenuContent_KeyHelp as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
337 ::unity::il2cpp_call!((::unity::module_base()+0x1b0f4b0usize)as*mut u8,();
338(RewindMenuContent_KeyHelp)__receiver)
339 }
340 }
341}
342
343#[cfg(feature = "app-rewindmenucontent")]
344impl<__T: IRewindMenuContent_KeyHelp> IRewindMenuContent_KeyHelpMethods for __T {}
345
346#[cfg(feature = "app-rewindmenucontent")]
347impl RewindMenuContent_KeyHelp {
348 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
349 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
350 }
351
352 pub fn reset_method_info() -> &'static ::unity::il2cpp::MethodInfo {
353 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
354 }
355
356 pub fn set_method_info() -> &'static ::unity::il2cpp::MethodInfo {
357 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
358 }
359}
360
361#[cfg(feature = "app-rewindmenucontent")]
362impl RewindMenuContent_KeyHelp {
363 #[doc = "`.ctor(crate::unity_engine::gameobject::GameObject)` — overload selector"]
364 pub fn new(root_object: crate::unity_engine::gameobject::GameObject) -> Self {
365 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
366 panic!(
367 "{}
368::{}
369 failed to instantiate",
370 ::core::stringify!(RewindMenuContent_KeyHelp),
371 ::core::stringify!(new),
372 )
373 });
374 <Self as IRewindMenuContent_KeyHelpMethods>::ctor(this, root_object);
375 this
376 }
377}
378
379#[cfg(feature = "app-rewindmenucontent")]
380impl RewindMenuContent {
381 #[doc = "`LoadAsync()` overload"]
382 pub fn load_async() -> () {
383 unsafe {
384 ::unity::il2cpp_call!((::unity::module_base()+0x201bd90usize)as*mut u8,();
385 )
386 }
387 }
388
389 #[doc = "`Unload()` overload"]
390 pub fn unload() -> () {
391 unsafe {
392 ::unity::il2cpp_call!((::unity::module_base()+0x201be10usize)as*mut u8,();
393 )
394 }
395 }
396
397 #[doc = "`IsLoading()` overload"]
398 pub fn is_loading() -> bool {
399 unsafe {
400 ::unity::il2cpp_call!((::unity::module_base()+0x201be90usize)as*mut u8,bool;
401 )
402 }
403 }
404
405 #[doc = "`CreateContent()` overload"]
406 pub fn create_content() -> crate::app::rewindmenucontent::RewindMenuContent {
407 unsafe {
408 ::unity::il2cpp_call!((::unity::module_base()+0x201b2f0usize)as*mut u8,crate::app::rewindmenucontent::RewindMenuContent;
409 )
410 }
411 }
412}
413
414#[cfg(feature = "app-rewindmenucontent")]
415pub trait IRewindMenuContentMethods: IRewindMenuContent {
416 #[doc = "`.ctor()` overload"]
417 fn ctor(self) -> () {
418 unsafe {
419 let __receiver = <RewindMenuContent as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
420 ::unity::il2cpp_call!((::unity::module_base()+0x201b3a0usize)as*mut u8,();
421(RewindMenuContent)__receiver)
422 }
423 }
424 #[doc = "`IsOpening()` overload"]
425 fn is_opening(self) -> bool {
426 unsafe {
427 let __receiver = <RewindMenuContent 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(6usize).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 6usize,
438 __vt.len(),
439 <RewindMenuContent as ::unity::ClassIdentity>::NAME,
440 "IsOpening",
441 )
442 });
443 let __inner: extern "C" fn(RewindMenuContent, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__vi.method_ptr);
444 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
445 __inner(__receiver, __mi)
446 }
447 }
448 }
449 #[doc = "`IsClosing()` overload"]
450 fn is_closing(self) -> bool {
451 unsafe {
452 let __receiver = <RewindMenuContent as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
453 {
454 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
455 let __vi = *__vt.get(7usize).unwrap_or_else(|| {
456 panic!(
457 "unity: virtual slot {}
458 out of range (vtable len {}
459) on the runtime class behind {}
460 (method `{}
461`)",
462 7usize,
463 __vt.len(),
464 <RewindMenuContent as ::unity::ClassIdentity>::NAME,
465 "IsClosing",
466 )
467 });
468 let __inner: extern "C" fn(RewindMenuContent, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__vi.method_ptr);
469 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
470 __inner(__receiver, __mi)
471 }
472 }
473 }
474 #[doc = "`IsClosed()` overload"]
475 fn is_closed(self) -> bool {
476 unsafe {
477 let __receiver = <RewindMenuContent as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
478 {
479 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
480 let __vi = *__vt.get(8usize).unwrap_or_else(|| {
481 panic!(
482 "unity: virtual slot {}
483 out of range (vtable len {}
484) on the runtime class behind {}
485 (method `{}
486`)",
487 8usize,
488 __vt.len(),
489 <RewindMenuContent as ::unity::ClassIdentity>::NAME,
490 "IsClosed",
491 )
492 });
493 let __inner: extern "C" fn(RewindMenuContent, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__vi.method_ptr);
494 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
495 __inner(__receiver, __mi)
496 }
497 }
498 }
499 #[doc = "`GetMenuItemContentMax()` overload"]
500 fn get_menu_item_content_max(self) -> i32 {
501 unsafe {
502 let __receiver = <RewindMenuContent as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
503 {
504 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
505 let __vi = *__vt.get(4usize).unwrap_or_else(|| {
506 panic!(
507 "unity: virtual slot {}
508 out of range (vtable len {}
509) on the runtime class behind {}
510 (method `{}
511`)",
512 4usize,
513 __vt.len(),
514 <RewindMenuContent as ::unity::ClassIdentity>::NAME,
515 "GetMenuItemContentMax",
516 )
517 });
518 let __inner: extern "C" fn(RewindMenuContent, ::unity::OptionalMethod) -> i32 = ::core::mem::transmute(__vi.method_ptr);
519 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
520 __inner(__receiver, __mi)
521 }
522 }
523 }
524 #[doc = "`GetRewindMenuItemContent(i32)` overload"]
525 fn get_rewind_menu_item_content(self, item_index: impl ::core::convert::Into<i32>) -> crate::app::rewindmenuitemcontent::RewindMenuItemContent {
526 unsafe {
527 let __receiver = <RewindMenuContent as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
528 ::unity::il2cpp_call!((::unity::module_base()+0x201b630usize)as*mut u8,crate::app::rewindmenuitemcontent::RewindMenuItemContent;
529(RewindMenuContent)__receiver,(i32)::core::convert::Into::into(item_index))
530 }
531 }
532 #[doc = "`InitObjReference()` overload"]
533 fn init_obj_reference(self) -> () {
534 unsafe {
535 let __receiver = <RewindMenuContent as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
536 {
537 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
538 let __vi = *__vt.get(13usize).unwrap_or_else(|| {
539 panic!(
540 "unity: virtual slot {}
541 out of range (vtable len {}
542) on the runtime class behind {}
543 (method `{}
544`)",
545 13usize,
546 __vt.len(),
547 <RewindMenuContent as ::unity::ClassIdentity>::NAME,
548 "InitObjReference",
549 )
550 });
551 let __inner: extern "C" fn(RewindMenuContent, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__vi.method_ptr);
552 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
553 __inner(__receiver, __mi)
554 }
555 }
556 }
557 #[doc = "`BuildMenuItemContent()` overload"]
558 fn build_menu_item_content(self) -> () {
559 unsafe {
560 let __receiver = <RewindMenuContent as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
561 {
562 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
563 let __vi = *__vt.get(18usize).unwrap_or_else(|| {
564 panic!(
565 "unity: virtual slot {}
566 out of range (vtable len {}
567) on the runtime class behind {}
568 (method `{}
569`)",
570 18usize,
571 __vt.len(),
572 <RewindMenuContent as ::unity::ClassIdentity>::NAME,
573 "BuildMenuItemContent",
574 )
575 });
576 let __inner: extern "C" fn(RewindMenuContent, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__vi.method_ptr);
577 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
578 __inner(__receiver, __mi)
579 }
580 }
581 }
582 #[doc = "`BuildWH()` overload"]
583 fn build_wh(self) -> () {
584 unsafe {
585 let __receiver = <RewindMenuContent as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
586 {
587 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
588 let __vi = *__vt.get(20usize).unwrap_or_else(|| {
589 panic!(
590 "unity: virtual slot {}
591 out of range (vtable len {}
592) on the runtime class behind {}
593 (method `{}
594`)",
595 20usize,
596 __vt.len(),
597 <RewindMenuContent as ::unity::ClassIdentity>::NAME,
598 "BuildWH",
599 )
600 });
601 let __inner: extern "C" fn(RewindMenuContent, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__vi.method_ptr);
602 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
603 __inner(__receiver, __mi)
604 }
605 }
606 }
607 #[doc = "`CalcW()` overload"]
608 fn calc_w(self) -> f32 {
609 unsafe {
610 let __receiver = <RewindMenuContent as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
611 {
612 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
613 let __vi = *__vt.get(21usize).unwrap_or_else(|| {
614 panic!(
615 "unity: virtual slot {}
616 out of range (vtable len {}
617) on the runtime class behind {}
618 (method `{}
619`)",
620 21usize,
621 __vt.len(),
622 <RewindMenuContent as ::unity::ClassIdentity>::NAME,
623 "CalcW",
624 )
625 });
626 let __inner: extern "C" fn(RewindMenuContent, ::unity::OptionalMethod) -> f32 = ::core::mem::transmute(__vi.method_ptr);
627 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
628 __inner(__receiver, __mi)
629 }
630 }
631 }
632 #[doc = "`CalcH()` overload"]
633 fn calc_h(self) -> f32 {
634 unsafe {
635 let __receiver = <RewindMenuContent as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
636 {
637 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
638 let __vi = *__vt.get(22usize).unwrap_or_else(|| {
639 panic!(
640 "unity: virtual slot {}
641 out of range (vtable len {}
642) on the runtime class behind {}
643 (method `{}
644`)",
645 22usize,
646 __vt.len(),
647 <RewindMenuContent as ::unity::ClassIdentity>::NAME,
648 "CalcH",
649 )
650 });
651 let __inner: extern "C" fn(RewindMenuContent, ::unity::OptionalMethod) -> f32 = ::core::mem::transmute(__vi.method_ptr);
652 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
653 __inner(__receiver, __mi)
654 }
655 }
656 }
657 #[doc = "`CycleMenuItemContent(bool, i32)` overload"]
658 fn cycle_menu_item_content(self, is_forward: impl ::core::convert::Into<bool>, cycle_count: impl ::core::convert::Into<i32>) -> () {
659 unsafe {
660 let __receiver = <RewindMenuContent as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
661 {
662 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
663 let __vi = *__vt.get(28usize).unwrap_or_else(|| {
664 panic!(
665 "unity: virtual slot {}
666 out of range (vtable len {}
667) on the runtime class behind {}
668 (method `{}
669`)",
670 28usize,
671 __vt.len(),
672 <RewindMenuContent as ::unity::ClassIdentity>::NAME,
673 "CycleMenuItemContent",
674 )
675 });
676 let __inner: extern "C" fn(RewindMenuContent, bool, i32, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__vi.method_ptr);
677 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
678 __inner(
679 __receiver,
680 ::core::convert::Into::into(is_forward),
681 ::core::convert::Into::into(cycle_count),
682 __mi,
683 )
684 }
685 }
686 }
687 #[doc = "`GetLineHeightForScroll()` overload"]
688 fn get_line_height_for_scroll(self) -> f32 {
689 unsafe {
690 let __receiver = <RewindMenuContent as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
691 {
692 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
693 let __vi = *__vt.get(29usize).unwrap_or_else(|| {
694 panic!(
695 "unity: virtual slot {}
696 out of range (vtable len {}
697) on the runtime class behind {}
698 (method `{}
699`)",
700 29usize,
701 __vt.len(),
702 <RewindMenuContent as ::unity::ClassIdentity>::NAME,
703 "GetLineHeightForScroll",
704 )
705 });
706 let __inner: extern "C" fn(RewindMenuContent, ::unity::OptionalMethod) -> f32 = ::core::mem::transmute(__vi.method_ptr);
707 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
708 __inner(__receiver, __mi)
709 }
710 }
711 }
712 #[doc = "`Awake()` overload"]
713 fn awake(self) -> () {
714 unsafe {
715 let __receiver = <RewindMenuContent as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
716 {
717 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
718 let __vi = *__vt.get(30usize).unwrap_or_else(|| {
719 panic!(
720 "unity: virtual slot {}
721 out of range (vtable len {}
722) on the runtime class behind {}
723 (method `{}
724`)",
725 30usize,
726 __vt.len(),
727 <RewindMenuContent as ::unity::ClassIdentity>::NAME,
728 "Awake",
729 )
730 });
731 let __inner: extern "C" fn(RewindMenuContent, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__vi.method_ptr);
732 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
733 __inner(__receiver, __mi)
734 }
735 }
736 }
737 #[doc = "`Start()` overload"]
738 fn start(self) -> () {
739 unsafe {
740 let __receiver = <RewindMenuContent as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
741 {
742 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
743 let __vi = *__vt.get(31usize).unwrap_or_else(|| {
744 panic!(
745 "unity: virtual slot {}
746 out of range (vtable len {}
747) on the runtime class behind {}
748 (method `{}
749`)",
750 31usize,
751 __vt.len(),
752 <RewindMenuContent as ::unity::ClassIdentity>::NAME,
753 "Start",
754 )
755 });
756 let __inner: extern "C" fn(RewindMenuContent, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__vi.method_ptr);
757 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
758 __inner(__receiver, __mi)
759 }
760 }
761 }
762 #[doc = "`Update()` overload"]
763 fn update(self) -> () {
764 unsafe {
765 let __receiver = <RewindMenuContent as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
766 {
767 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
768 let __vi = *__vt.get(32usize).unwrap_or_else(|| {
769 panic!(
770 "unity: virtual slot {}
771 out of range (vtable len {}
772) on the runtime class behind {}
773 (method `{}
774`)",
775 32usize,
776 __vt.len(),
777 <RewindMenuContent as ::unity::ClassIdentity>::NAME,
778 "Update",
779 )
780 });
781 let __inner: extern "C" fn(RewindMenuContent, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__vi.method_ptr);
782 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
783 __inner(__receiver, __mi)
784 }
785 }
786 }
787 #[doc = "`AfterBuild()` overload"]
788 fn after_build(self) -> () {
789 unsafe {
790 let __receiver = <RewindMenuContent as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
791 {
792 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
793 let __vi = *__vt.get(27usize).unwrap_or_else(|| {
794 panic!(
795 "unity: virtual slot {}
796 out of range (vtable len {}
797) on the runtime class behind {}
798 (method `{}
799`)",
800 27usize,
801 __vt.len(),
802 <RewindMenuContent as ::unity::ClassIdentity>::NAME,
803 "AfterBuild",
804 )
805 });
806 let __inner: extern "C" fn(RewindMenuContent, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__vi.method_ptr);
807 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
808 __inner(__receiver, __mi)
809 }
810 }
811 }
812 #[doc = "`Suspend()` overload"]
813 fn suspend(self) -> () {
814 unsafe {
815 let __receiver = <RewindMenuContent as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
816 {
817 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
818 let __vi = *__vt.get(15usize).unwrap_or_else(|| {
819 panic!(
820 "unity: virtual slot {}
821 out of range (vtable len {}
822) on the runtime class behind {}
823 (method `{}
824`)",
825 15usize,
826 __vt.len(),
827 <RewindMenuContent as ::unity::ClassIdentity>::NAME,
828 "Suspend",
829 )
830 });
831 let __inner: extern "C" fn(RewindMenuContent, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__vi.method_ptr);
832 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
833 __inner(__receiver, __mi)
834 }
835 }
836 }
837 #[doc = "`UnSuspend()` overload"]
838 fn un_suspend(self) -> () {
839 unsafe {
840 let __receiver = <RewindMenuContent as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
841 {
842 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
843 let __vi = *__vt.get(16usize).unwrap_or_else(|| {
844 panic!(
845 "unity: virtual slot {}
846 out of range (vtable len {}
847) on the runtime class behind {}
848 (method `{}
849`)",
850 16usize,
851 __vt.len(),
852 <RewindMenuContent as ::unity::ClassIdentity>::NAME,
853 "UnSuspend",
854 )
855 });
856 let __inner: extern "C" fn(RewindMenuContent, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__vi.method_ptr);
857 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
858 __inner(__receiver, __mi)
859 }
860 }
861 }
862 #[doc = "`UpdateParts(crate::app::force::Force_Type, i32, i32)` overload"]
863 fn update_parts(
864 self,
865 current_force_type: impl ::core::convert::Into<crate::app::force::Force_Type>,
866 turn: impl ::core::convert::Into<i32>,
867 rest_unit_num: impl ::core::convert::Into<i32>,
868 ) -> () {
869 unsafe {
870 let __receiver = <RewindMenuContent as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
871 ::unity::il2cpp_call!((::unity::module_base()+0x201a4c0usize)as*mut u8,();
872(RewindMenuContent)__receiver,(crate::app::force::Force_Type)::core::convert::Into::into(current_force_type),(i32)::core::convert::Into::into(turn),(i32)::core::convert::Into::into(rest_unit_num))
873 }
874 }
875 #[doc = "`IsMenuItemMoving()` overload"]
876 fn is_menu_item_moving(self) -> bool {
877 unsafe {
878 let __receiver = <RewindMenuContent as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
879 ::unity::il2cpp_call!((::unity::module_base()+0x2019d30usize)as*mut u8,bool;
880(RewindMenuContent)__receiver)
881 }
882 }
883 #[doc = "`MoveUp(i32)` overload"]
884 fn move_up(self, scroll_count: impl ::core::convert::Into<i32>) -> () {
885 unsafe {
886 let __receiver = <RewindMenuContent as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
887 ::unity::il2cpp_call!((::unity::module_base()+0x201a130usize)as*mut u8,();
888(RewindMenuContent)__receiver,(i32)::core::convert::Into::into(scroll_count))
889 }
890 }
891 #[doc = "`MoveDown(i32)` overload"]
892 fn move_down(self, scroll_count: impl ::core::convert::Into<i32>) -> () {
893 unsafe {
894 let __receiver = <RewindMenuContent as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
895 ::unity::il2cpp_call!((::unity::module_base()+0x2019e60usize)as*mut u8,();
896(RewindMenuContent)__receiver,(i32)::core::convert::Into::into(scroll_count))
897 }
898 }
899}
900
901#[cfg(feature = "app-rewindmenucontent")]
902impl<__T: IRewindMenuContent> IRewindMenuContentMethods for __T {}
903
904#[cfg(feature = "app-rewindmenucontent")]
905impl RewindMenuContent {
906 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
907 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
908 }
909
910 pub fn is_opening_method_info() -> &'static ::unity::il2cpp::MethodInfo {
911 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
912 }
913
914 pub fn is_closing_method_info() -> &'static ::unity::il2cpp::MethodInfo {
915 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
916 }
917
918 pub fn is_closed_method_info() -> &'static ::unity::il2cpp::MethodInfo {
919 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
920 }
921
922 pub fn get_menu_item_content_max_method_info() -> &'static ::unity::il2cpp::MethodInfo {
923 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
924 }
925
926 pub fn get_rewind_menu_item_content_method_info() -> &'static ::unity::il2cpp::MethodInfo {
927 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[5]
928 }
929
930 pub fn init_obj_reference_method_info() -> &'static ::unity::il2cpp::MethodInfo {
931 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[6]
932 }
933
934 pub fn build_menu_item_content_method_info() -> &'static ::unity::il2cpp::MethodInfo {
935 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[7]
936 }
937
938 pub fn build_wh_method_info() -> &'static ::unity::il2cpp::MethodInfo {
939 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[8]
940 }
941
942 pub fn calc_w_method_info() -> &'static ::unity::il2cpp::MethodInfo {
943 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[9]
944 }
945
946 pub fn calc_h_method_info() -> &'static ::unity::il2cpp::MethodInfo {
947 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[10]
948 }
949
950 pub fn cycle_menu_item_content_method_info() -> &'static ::unity::il2cpp::MethodInfo {
951 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[11]
952 }
953
954 pub fn get_line_height_for_scroll_method_info() -> &'static ::unity::il2cpp::MethodInfo {
955 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[12]
956 }
957
958 pub fn awake_method_info() -> &'static ::unity::il2cpp::MethodInfo {
959 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[13]
960 }
961
962 pub fn start_method_info() -> &'static ::unity::il2cpp::MethodInfo {
963 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[14]
964 }
965
966 pub fn update_method_info() -> &'static ::unity::il2cpp::MethodInfo {
967 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[15]
968 }
969
970 pub fn after_build_method_info() -> &'static ::unity::il2cpp::MethodInfo {
971 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[16]
972 }
973
974 pub fn suspend_method_info() -> &'static ::unity::il2cpp::MethodInfo {
975 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[17]
976 }
977
978 pub fn un_suspend_method_info() -> &'static ::unity::il2cpp::MethodInfo {
979 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[18]
980 }
981
982 pub fn update_parts_method_info() -> &'static ::unity::il2cpp::MethodInfo {
983 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[19]
984 }
985
986 pub fn is_menu_item_moving_method_info() -> &'static ::unity::il2cpp::MethodInfo {
987 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[20]
988 }
989
990 pub fn move_up_method_info() -> &'static ::unity::il2cpp::MethodInfo {
991 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[21]
992 }
993
994 pub fn move_down_method_info() -> &'static ::unity::il2cpp::MethodInfo {
995 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[22]
996 }
997
998 pub fn load_async_method_info() -> &'static ::unity::il2cpp::MethodInfo {
999 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[23]
1000 }
1001
1002 pub fn unload_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1003 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[24]
1004 }
1005
1006 pub fn is_loading_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1007 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[25]
1008 }
1009
1010 pub fn create_content_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1011 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[26]
1012 }
1013}
1014
1015#[cfg(feature = "app-rewindmenucontent")]
1016impl RewindMenuContent {
1017 #[doc = "Direct (non-virtual) call to `RewindMenuContent`'s own `IsOpening`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1018 pub unsafe fn is_opening(this: impl ::core::convert::Into<::unity::IlInstance>) -> bool {
1019 let __mi = Self::is_opening_method_info();
1020 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__mi.method_ptr);
1021 __inner(this.into(), ::core::option::Option::None)
1022 }
1023
1024 #[doc = "Direct (non-virtual) call to `RewindMenuContent`'s own `IsClosing`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1025 pub unsafe fn is_closing(this: impl ::core::convert::Into<::unity::IlInstance>) -> bool {
1026 let __mi = Self::is_closing_method_info();
1027 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__mi.method_ptr);
1028 __inner(this.into(), ::core::option::Option::None)
1029 }
1030
1031 #[doc = "Direct (non-virtual) call to `RewindMenuContent`'s own `IsClosed`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1032 pub unsafe fn is_closed(this: impl ::core::convert::Into<::unity::IlInstance>) -> bool {
1033 let __mi = Self::is_closed_method_info();
1034 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__mi.method_ptr);
1035 __inner(this.into(), ::core::option::Option::None)
1036 }
1037
1038 #[doc = "Direct (non-virtual) call to `RewindMenuContent`'s own `GetMenuItemContentMax`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1039 pub unsafe fn get_menu_item_content_max(this: impl ::core::convert::Into<::unity::IlInstance>) -> i32 {
1040 let __mi = Self::get_menu_item_content_max_method_info();
1041 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> i32 = ::core::mem::transmute(__mi.method_ptr);
1042 __inner(this.into(), ::core::option::Option::None)
1043 }
1044
1045 #[doc = "Direct (non-virtual) call to `RewindMenuContent`'s own `InitObjReference`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1046 pub unsafe fn init_obj_reference(this: impl ::core::convert::Into<::unity::IlInstance>) -> () {
1047 let __mi = Self::init_obj_reference_method_info();
1048 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
1049 __inner(this.into(), ::core::option::Option::None)
1050 }
1051
1052 #[doc = "Direct (non-virtual) call to `RewindMenuContent`'s own `BuildMenuItemContent`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1053 pub unsafe fn build_menu_item_content(this: impl ::core::convert::Into<::unity::IlInstance>) -> () {
1054 let __mi = Self::build_menu_item_content_method_info();
1055 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
1056 __inner(this.into(), ::core::option::Option::None)
1057 }
1058
1059 #[doc = "Direct (non-virtual) call to `RewindMenuContent`'s own `BuildWH`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1060 pub unsafe fn build_wh(this: impl ::core::convert::Into<::unity::IlInstance>) -> () {
1061 let __mi = Self::build_wh_method_info();
1062 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
1063 __inner(this.into(), ::core::option::Option::None)
1064 }
1065
1066 #[doc = "Direct (non-virtual) call to `RewindMenuContent`'s own `CalcW`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1067 pub unsafe fn calc_w(this: impl ::core::convert::Into<::unity::IlInstance>) -> f32 {
1068 let __mi = Self::calc_w_method_info();
1069 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> f32 = ::core::mem::transmute(__mi.method_ptr);
1070 __inner(this.into(), ::core::option::Option::None)
1071 }
1072
1073 #[doc = "Direct (non-virtual) call to `RewindMenuContent`'s own `CalcH`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1074 pub unsafe fn calc_h(this: impl ::core::convert::Into<::unity::IlInstance>) -> f32 {
1075 let __mi = Self::calc_h_method_info();
1076 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> f32 = ::core::mem::transmute(__mi.method_ptr);
1077 __inner(this.into(), ::core::option::Option::None)
1078 }
1079
1080 #[doc = "Direct (non-virtual) call to `RewindMenuContent`'s own `CycleMenuItemContent`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1081 pub unsafe fn cycle_menu_item_content(this: impl ::core::convert::Into<::unity::IlInstance>, is_forward: bool, cycle_count: i32) -> () {
1082 let __mi = Self::cycle_menu_item_content_method_info();
1083 let __inner: extern "C" fn(::unity::IlInstance, bool, i32, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
1084 __inner(this.into(), is_forward, cycle_count, ::core::option::Option::None)
1085 }
1086
1087 #[doc = "Direct (non-virtual) call to `RewindMenuContent`'s own `GetLineHeightForScroll`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1088 pub unsafe fn get_line_height_for_scroll(this: impl ::core::convert::Into<::unity::IlInstance>) -> f32 {
1089 let __mi = Self::get_line_height_for_scroll_method_info();
1090 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> f32 = ::core::mem::transmute(__mi.method_ptr);
1091 __inner(this.into(), ::core::option::Option::None)
1092 }
1093
1094 #[doc = "Direct (non-virtual) call to `RewindMenuContent`'s own `Awake`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1095 pub unsafe fn awake(this: impl ::core::convert::Into<::unity::IlInstance>) -> () {
1096 let __mi = Self::awake_method_info();
1097 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
1098 __inner(this.into(), ::core::option::Option::None)
1099 }
1100
1101 #[doc = "Direct (non-virtual) call to `RewindMenuContent`'s own `Start`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1102 pub unsafe fn start(this: impl ::core::convert::Into<::unity::IlInstance>) -> () {
1103 let __mi = Self::start_method_info();
1104 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
1105 __inner(this.into(), ::core::option::Option::None)
1106 }
1107
1108 #[doc = "Direct (non-virtual) call to `RewindMenuContent`'s own `Update`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1109 pub unsafe fn update(this: impl ::core::convert::Into<::unity::IlInstance>) -> () {
1110 let __mi = Self::update_method_info();
1111 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
1112 __inner(this.into(), ::core::option::Option::None)
1113 }
1114
1115 #[doc = "Direct (non-virtual) call to `RewindMenuContent`'s own `AfterBuild`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1116 pub unsafe fn after_build(this: impl ::core::convert::Into<::unity::IlInstance>) -> () {
1117 let __mi = Self::after_build_method_info();
1118 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
1119 __inner(this.into(), ::core::option::Option::None)
1120 }
1121
1122 #[doc = "Direct (non-virtual) call to `RewindMenuContent`'s own `Suspend`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1123 pub unsafe fn suspend(this: impl ::core::convert::Into<::unity::IlInstance>) -> () {
1124 let __mi = Self::suspend_method_info();
1125 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
1126 __inner(this.into(), ::core::option::Option::None)
1127 }
1128
1129 #[doc = "Direct (non-virtual) call to `RewindMenuContent`'s own `UnSuspend`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1130 pub unsafe fn un_suspend(this: impl ::core::convert::Into<::unity::IlInstance>) -> () {
1131 let __mi = Self::un_suspend_method_info();
1132 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
1133 __inner(this.into(), ::core::option::Option::None)
1134 }
1135}
1136
1137#[cfg(feature = "app-rewindmenucontent")]
1138impl RewindMenuContent {
1139 #[doc = "`.ctor()` — no args"]
1140 pub fn new() -> Self {
1141 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
1142 panic!(
1143 "{}
1144::{}
1145 failed to instantiate",
1146 ::core::stringify!(RewindMenuContent),
1147 ::core::stringify!(new),
1148 )
1149 });
1150 <Self as IRewindMenuContentMethods>::ctor(this);
1151 this
1152 }
1153}
1154
1155#[cfg(feature = "app-rewindmenucontent")]
1156pub trait IRewindMenuContent_RestRewindTimesMethods: IRewindMenuContent_RestRewindTimes {
1157 #[doc = "`.ctor(crate::unity_engine::gameobject::GameObject)` overload"]
1158 fn ctor(self, root_object: impl ::core::convert::Into<crate::unity_engine::gameobject::GameObject>) -> () {
1159 unsafe {
1160 let __receiver =
1161 <RewindMenuContent_RestRewindTimes as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1162 ::unity::il2cpp_call!((::unity::module_base()+0x1b0faa0usize)as*mut u8,();
1163(RewindMenuContent_RestRewindTimes)__receiver,(crate::unity_engine::gameobject::GameObject)::core::convert::Into::into(root_object))
1164 }
1165 }
1166 #[doc = "`SetTimes(i32)` overload"]
1167 fn set_times(self, times: impl ::core::convert::Into<i32>) -> () {
1168 unsafe {
1169 let __receiver =
1170 <RewindMenuContent_RestRewindTimes as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1171 ::unity::il2cpp_call!((::unity::module_base()+0x1b0fcc0usize)as*mut u8,();
1172(RewindMenuContent_RestRewindTimes)__receiver,(i32)::core::convert::Into::into(times))
1173 }
1174 }
1175}
1176
1177#[cfg(feature = "app-rewindmenucontent")]
1178impl<__T: IRewindMenuContent_RestRewindTimes> IRewindMenuContent_RestRewindTimesMethods for __T {}
1179
1180#[cfg(feature = "app-rewindmenucontent")]
1181impl RewindMenuContent_RestRewindTimes {
1182 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1183 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
1184 }
1185
1186 pub fn set_times_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1187 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
1188 }
1189}
1190
1191#[cfg(feature = "app-rewindmenucontent")]
1192impl RewindMenuContent_RestRewindTimes {
1193 #[doc = "`.ctor(crate::unity_engine::gameobject::GameObject)` — overload selector"]
1194 pub fn new(root_object: crate::unity_engine::gameobject::GameObject) -> Self {
1195 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
1196 panic!(
1197 "{}
1198::{}
1199 failed to instantiate",
1200 ::core::stringify!(RewindMenuContent_RestRewindTimes),
1201 ::core::stringify!(new),
1202 )
1203 });
1204 <Self as IRewindMenuContent_RestRewindTimesMethods>::ctor(this, root_object);
1205 this
1206 }
1207}
1208
1209#[cfg(feature = "app-rewindmenucontent")]
1210#[doc(hidden)]
1211pub mod prelude {
1212 pub use super::{
1213 IRewindMenuContent, IRewindMenuContentMethods, IRewindMenuContent_KeyHelp, IRewindMenuContent_KeyHelpMethods, IRewindMenuContent_Phase,
1214 IRewindMenuContent_PhaseMethods, IRewindMenuContent_RestRewindTimes, IRewindMenuContent_RestRewindTimesMethods,
1215 IRewindMenuContent_ScrollArrow, IRewindMenuContent_ScrollArrowMethods, RewindMenuContent, RewindMenuContent_KeyHelp, RewindMenuContent_Phase,
1216 RewindMenuContent_RestRewindTimes, RewindMenuContent_ScrollArrow,
1217 };
1218 #[cfg(feature = "app-basicmenucontent")]
1219 pub use crate::app::basicmenucontent::IBasicMenuContentMethods;
1220 #[cfg(feature = "system-object")]
1221 pub use crate::system::object::IObjectMethods;
1222 #[cfg(feature = "unity_engine-behaviour")]
1223 pub use crate::unity_engine::behaviour::IBehaviourMethods;
1224 #[cfg(feature = "unity_engine-component")]
1225 pub use crate::unity_engine::component::IComponentMethods;
1226 #[cfg(feature = "unity_engine-monobehaviour")]
1227 pub use crate::unity_engine::monobehaviour::IMonoBehaviourMethods;
1228 #[cfg(feature = "unity_engine-object_2")]
1229 pub use crate::unity_engine::object_2::IObject_2Methods;
1230 pub use crate::{
1231 app::basicmenucontent::IBasicMenuContent,
1232 system::object::IObject,
1233 unity_engine::{behaviour::IBehaviour, component::IComponent, monobehaviour::IMonoBehaviour, object_2::IObject_2},
1234 };
1235}