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