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