1#[cfg(feature = "unity_engine-ui-layoutelement-types")]
4mod __types {
5 #[allow(unused_imports)] use ::unity::prelude::*;
6
7 use super::*;
8 use crate::{
9 system::object::{IObject, Object},
10 unity_engine::{
11 behaviour::{Behaviour, IBehaviour},
12 component::{Component, IComponent},
13 event_systems::uibehaviour::{IUIBehaviour, UIBehaviour},
14 monobehaviour::{IMonoBehaviour, MonoBehaviour},
15 object_2::{IObject_2, Object_2},
16 },
17 };
18
19 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/unity_engine/ui/layoutelement/LayoutElement.md"))]
20 #[::unity::class(namespace = "UnityEngine.UI", name = "LayoutElement")]
21 #[parent(crate::unity_engine::event_systems::uibehaviour::UIBehaviour)]
22 pub struct LayoutElement {
23 #[offset(24)]
24 #[rename(name = "m_IgnoreLayout")]
25 pub m_ignore_layout: bool,
26 #[offset(28)]
27 #[rename(name = "m_MinWidth")]
28 pub m_min_width: f32,
29 #[offset(32)]
30 #[rename(name = "m_MinHeight")]
31 pub m_min_height: f32,
32 #[offset(36)]
33 #[rename(name = "m_PreferredWidth")]
34 pub m_preferred_width: f32,
35 #[offset(40)]
36 #[rename(name = "m_PreferredHeight")]
37 pub m_preferred_height: f32,
38 #[offset(44)]
39 #[rename(name = "m_FlexibleWidth")]
40 pub m_flexible_width: f32,
41 #[offset(48)]
42 #[rename(name = "m_FlexibleHeight")]
43 pub m_flexible_height: f32,
44 #[offset(52)]
45 #[rename(name = "m_LayoutPriority")]
46 pub m_layout_priority: i32,
47 }
48}
49
50#[cfg(feature = "unity_engine-ui-layoutelement-types")]
51pub use __types::*;
52
53#[cfg(feature = "unity_engine-ui-layoutelement")]
54pub trait ILayoutElementMethods: ILayoutElement {
55 #[doc = "`get_ignoreLayout()` overload"]
56 fn get_ignore_layout(self) -> bool {
57 unsafe {
58 let __receiver = <LayoutElement as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
59 {
60 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
61 let __vi = *__vt.get(27usize).unwrap_or_else(|| {
62 panic!(
63 "unity: virtual slot {}
64 out of range (vtable len {}
65) on the runtime class behind {}
66 (method `{}
67`)",
68 27usize,
69 __vt.len(),
70 <LayoutElement as ::unity::ClassIdentity>::NAME,
71 "get_ignoreLayout",
72 )
73 });
74 let __inner: extern "C" fn(LayoutElement, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__vi.method_ptr);
75 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
76 __inner(__receiver, __mi)
77 }
78 }
79 }
80 #[doc = "`set_ignoreLayout(bool)` overload"]
81 fn set_ignore_layout(self, value: impl ::core::convert::Into<bool>) -> () {
82 unsafe {
83 let __receiver = <LayoutElement as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
84 {
85 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
86 let __vi = *__vt.get(28usize).unwrap_or_else(|| {
87 panic!(
88 "unity: virtual slot {}
89 out of range (vtable len {}
90) on the runtime class behind {}
91 (method `{}
92`)",
93 28usize,
94 __vt.len(),
95 <LayoutElement as ::unity::ClassIdentity>::NAME,
96 "set_ignoreLayout",
97 )
98 });
99 let __inner: extern "C" fn(LayoutElement, bool, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__vi.method_ptr);
100 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
101 __inner(__receiver, ::core::convert::Into::into(value), __mi)
102 }
103 }
104 }
105 #[doc = "`CalculateLayoutInputHorizontal()` overload"]
106 fn calculate_layout_input_horizontal(self) -> () {
107 unsafe {
108 let __receiver = <LayoutElement as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
109 {
110 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
111 let __vi = *__vt.get(29usize).unwrap_or_else(|| {
112 panic!(
113 "unity: virtual slot {}
114 out of range (vtable len {}
115) on the runtime class behind {}
116 (method `{}
117`)",
118 29usize,
119 __vt.len(),
120 <LayoutElement as ::unity::ClassIdentity>::NAME,
121 "CalculateLayoutInputHorizontal",
122 )
123 });
124 let __inner: extern "C" fn(LayoutElement, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__vi.method_ptr);
125 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
126 __inner(__receiver, __mi)
127 }
128 }
129 }
130 #[doc = "`CalculateLayoutInputVertical()` overload"]
131 fn calculate_layout_input_vertical(self) -> () {
132 unsafe {
133 let __receiver = <LayoutElement as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
134 {
135 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
136 let __vi = *__vt.get(30usize).unwrap_or_else(|| {
137 panic!(
138 "unity: virtual slot {}
139 out of range (vtable len {}
140) on the runtime class behind {}
141 (method `{}
142`)",
143 30usize,
144 __vt.len(),
145 <LayoutElement as ::unity::ClassIdentity>::NAME,
146 "CalculateLayoutInputVertical",
147 )
148 });
149 let __inner: extern "C" fn(LayoutElement, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__vi.method_ptr);
150 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
151 __inner(__receiver, __mi)
152 }
153 }
154 }
155 #[doc = "`get_minWidth()` overload"]
156 fn get_min_width(self) -> f32 {
157 unsafe {
158 let __receiver = <LayoutElement as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
159 {
160 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
161 let __vi = *__vt.get(31usize).unwrap_or_else(|| {
162 panic!(
163 "unity: virtual slot {}
164 out of range (vtable len {}
165) on the runtime class behind {}
166 (method `{}
167`)",
168 31usize,
169 __vt.len(),
170 <LayoutElement as ::unity::ClassIdentity>::NAME,
171 "get_minWidth",
172 )
173 });
174 let __inner: extern "C" fn(LayoutElement, ::unity::OptionalMethod) -> f32 = ::core::mem::transmute(__vi.method_ptr);
175 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
176 __inner(__receiver, __mi)
177 }
178 }
179 }
180 #[doc = "`set_minWidth(f32)` overload"]
181 fn set_min_width(self, value: impl ::core::convert::Into<f32>) -> () {
182 unsafe {
183 let __receiver = <LayoutElement as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
184 {
185 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
186 let __vi = *__vt.get(32usize).unwrap_or_else(|| {
187 panic!(
188 "unity: virtual slot {}
189 out of range (vtable len {}
190) on the runtime class behind {}
191 (method `{}
192`)",
193 32usize,
194 __vt.len(),
195 <LayoutElement as ::unity::ClassIdentity>::NAME,
196 "set_minWidth",
197 )
198 });
199 let __inner: extern "C" fn(LayoutElement, f32, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__vi.method_ptr);
200 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
201 __inner(__receiver, ::core::convert::Into::into(value), __mi)
202 }
203 }
204 }
205 #[doc = "`get_minHeight()` overload"]
206 fn get_min_height(self) -> f32 {
207 unsafe {
208 let __receiver = <LayoutElement as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
209 {
210 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
211 let __vi = *__vt.get(33usize).unwrap_or_else(|| {
212 panic!(
213 "unity: virtual slot {}
214 out of range (vtable len {}
215) on the runtime class behind {}
216 (method `{}
217`)",
218 33usize,
219 __vt.len(),
220 <LayoutElement as ::unity::ClassIdentity>::NAME,
221 "get_minHeight",
222 )
223 });
224 let __inner: extern "C" fn(LayoutElement, ::unity::OptionalMethod) -> f32 = ::core::mem::transmute(__vi.method_ptr);
225 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
226 __inner(__receiver, __mi)
227 }
228 }
229 }
230 #[doc = "`set_minHeight(f32)` overload"]
231 fn set_min_height(self, value: impl ::core::convert::Into<f32>) -> () {
232 unsafe {
233 let __receiver = <LayoutElement as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
234 {
235 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
236 let __vi = *__vt.get(34usize).unwrap_or_else(|| {
237 panic!(
238 "unity: virtual slot {}
239 out of range (vtable len {}
240) on the runtime class behind {}
241 (method `{}
242`)",
243 34usize,
244 __vt.len(),
245 <LayoutElement as ::unity::ClassIdentity>::NAME,
246 "set_minHeight",
247 )
248 });
249 let __inner: extern "C" fn(LayoutElement, f32, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__vi.method_ptr);
250 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
251 __inner(__receiver, ::core::convert::Into::into(value), __mi)
252 }
253 }
254 }
255 #[doc = "`get_preferredWidth()` overload"]
256 fn get_preferred_width(self) -> f32 {
257 unsafe {
258 let __receiver = <LayoutElement as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
259 {
260 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
261 let __vi = *__vt.get(35usize).unwrap_or_else(|| {
262 panic!(
263 "unity: virtual slot {}
264 out of range (vtable len {}
265) on the runtime class behind {}
266 (method `{}
267`)",
268 35usize,
269 __vt.len(),
270 <LayoutElement as ::unity::ClassIdentity>::NAME,
271 "get_preferredWidth",
272 )
273 });
274 let __inner: extern "C" fn(LayoutElement, ::unity::OptionalMethod) -> f32 = ::core::mem::transmute(__vi.method_ptr);
275 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
276 __inner(__receiver, __mi)
277 }
278 }
279 }
280 #[doc = "`set_preferredWidth(f32)` overload"]
281 fn set_preferred_width(self, value: impl ::core::convert::Into<f32>) -> () {
282 unsafe {
283 let __receiver = <LayoutElement as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
284 {
285 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
286 let __vi = *__vt.get(36usize).unwrap_or_else(|| {
287 panic!(
288 "unity: virtual slot {}
289 out of range (vtable len {}
290) on the runtime class behind {}
291 (method `{}
292`)",
293 36usize,
294 __vt.len(),
295 <LayoutElement as ::unity::ClassIdentity>::NAME,
296 "set_preferredWidth",
297 )
298 });
299 let __inner: extern "C" fn(LayoutElement, f32, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__vi.method_ptr);
300 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
301 __inner(__receiver, ::core::convert::Into::into(value), __mi)
302 }
303 }
304 }
305 #[doc = "`get_preferredHeight()` overload"]
306 fn get_preferred_height(self) -> f32 {
307 unsafe {
308 let __receiver = <LayoutElement as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
309 {
310 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
311 let __vi = *__vt.get(37usize).unwrap_or_else(|| {
312 panic!(
313 "unity: virtual slot {}
314 out of range (vtable len {}
315) on the runtime class behind {}
316 (method `{}
317`)",
318 37usize,
319 __vt.len(),
320 <LayoutElement as ::unity::ClassIdentity>::NAME,
321 "get_preferredHeight",
322 )
323 });
324 let __inner: extern "C" fn(LayoutElement, ::unity::OptionalMethod) -> f32 = ::core::mem::transmute(__vi.method_ptr);
325 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
326 __inner(__receiver, __mi)
327 }
328 }
329 }
330 #[doc = "`set_preferredHeight(f32)` overload"]
331 fn set_preferred_height(self, value: impl ::core::convert::Into<f32>) -> () {
332 unsafe {
333 let __receiver = <LayoutElement as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
334 {
335 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
336 let __vi = *__vt.get(38usize).unwrap_or_else(|| {
337 panic!(
338 "unity: virtual slot {}
339 out of range (vtable len {}
340) on the runtime class behind {}
341 (method `{}
342`)",
343 38usize,
344 __vt.len(),
345 <LayoutElement as ::unity::ClassIdentity>::NAME,
346 "set_preferredHeight",
347 )
348 });
349 let __inner: extern "C" fn(LayoutElement, f32, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__vi.method_ptr);
350 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
351 __inner(__receiver, ::core::convert::Into::into(value), __mi)
352 }
353 }
354 }
355 #[doc = "`get_flexibleWidth()` overload"]
356 fn get_flexible_width(self) -> f32 {
357 unsafe {
358 let __receiver = <LayoutElement as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
359 {
360 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
361 let __vi = *__vt.get(39usize).unwrap_or_else(|| {
362 panic!(
363 "unity: virtual slot {}
364 out of range (vtable len {}
365) on the runtime class behind {}
366 (method `{}
367`)",
368 39usize,
369 __vt.len(),
370 <LayoutElement as ::unity::ClassIdentity>::NAME,
371 "get_flexibleWidth",
372 )
373 });
374 let __inner: extern "C" fn(LayoutElement, ::unity::OptionalMethod) -> f32 = ::core::mem::transmute(__vi.method_ptr);
375 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
376 __inner(__receiver, __mi)
377 }
378 }
379 }
380 #[doc = "`set_flexibleWidth(f32)` overload"]
381 fn set_flexible_width(self, value: impl ::core::convert::Into<f32>) -> () {
382 unsafe {
383 let __receiver = <LayoutElement as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
384 {
385 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
386 let __vi = *__vt.get(40usize).unwrap_or_else(|| {
387 panic!(
388 "unity: virtual slot {}
389 out of range (vtable len {}
390) on the runtime class behind {}
391 (method `{}
392`)",
393 40usize,
394 __vt.len(),
395 <LayoutElement as ::unity::ClassIdentity>::NAME,
396 "set_flexibleWidth",
397 )
398 });
399 let __inner: extern "C" fn(LayoutElement, f32, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__vi.method_ptr);
400 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
401 __inner(__receiver, ::core::convert::Into::into(value), __mi)
402 }
403 }
404 }
405 #[doc = "`get_flexibleHeight()` overload"]
406 fn get_flexible_height(self) -> f32 {
407 unsafe {
408 let __receiver = <LayoutElement as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
409 {
410 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
411 let __vi = *__vt.get(41usize).unwrap_or_else(|| {
412 panic!(
413 "unity: virtual slot {}
414 out of range (vtable len {}
415) on the runtime class behind {}
416 (method `{}
417`)",
418 41usize,
419 __vt.len(),
420 <LayoutElement as ::unity::ClassIdentity>::NAME,
421 "get_flexibleHeight",
422 )
423 });
424 let __inner: extern "C" fn(LayoutElement, ::unity::OptionalMethod) -> f32 = ::core::mem::transmute(__vi.method_ptr);
425 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
426 __inner(__receiver, __mi)
427 }
428 }
429 }
430 #[doc = "`set_flexibleHeight(f32)` overload"]
431 fn set_flexible_height(self, value: impl ::core::convert::Into<f32>) -> () {
432 unsafe {
433 let __receiver = <LayoutElement as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
434 {
435 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
436 let __vi = *__vt.get(42usize).unwrap_or_else(|| {
437 panic!(
438 "unity: virtual slot {}
439 out of range (vtable len {}
440) on the runtime class behind {}
441 (method `{}
442`)",
443 42usize,
444 __vt.len(),
445 <LayoutElement as ::unity::ClassIdentity>::NAME,
446 "set_flexibleHeight",
447 )
448 });
449 let __inner: extern "C" fn(LayoutElement, f32, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__vi.method_ptr);
450 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
451 __inner(__receiver, ::core::convert::Into::into(value), __mi)
452 }
453 }
454 }
455 #[doc = "`get_layoutPriority()` overload"]
456 fn get_layout_priority(self) -> i32 {
457 unsafe {
458 let __receiver = <LayoutElement as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
459 {
460 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
461 let __vi = *__vt.get(43usize).unwrap_or_else(|| {
462 panic!(
463 "unity: virtual slot {}
464 out of range (vtable len {}
465) on the runtime class behind {}
466 (method `{}
467`)",
468 43usize,
469 __vt.len(),
470 <LayoutElement as ::unity::ClassIdentity>::NAME,
471 "get_layoutPriority",
472 )
473 });
474 let __inner: extern "C" fn(LayoutElement, ::unity::OptionalMethod) -> i32 = ::core::mem::transmute(__vi.method_ptr);
475 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
476 __inner(__receiver, __mi)
477 }
478 }
479 }
480 #[doc = "`set_layoutPriority(i32)` overload"]
481 fn set_layout_priority(self, value: impl ::core::convert::Into<i32>) -> () {
482 unsafe {
483 let __receiver = <LayoutElement as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
484 {
485 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
486 let __vi = *__vt.get(44usize).unwrap_or_else(|| {
487 panic!(
488 "unity: virtual slot {}
489 out of range (vtable len {}
490) on the runtime class behind {}
491 (method `{}
492`)",
493 44usize,
494 __vt.len(),
495 <LayoutElement as ::unity::ClassIdentity>::NAME,
496 "set_layoutPriority",
497 )
498 });
499 let __inner: extern "C" fn(LayoutElement, i32, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__vi.method_ptr);
500 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
501 __inner(__receiver, ::core::convert::Into::into(value), __mi)
502 }
503 }
504 }
505 #[doc = "`.ctor()` overload"]
506 fn ctor(self) -> () {
507 unsafe {
508 let __receiver = <LayoutElement as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
509 ::unity::il2cpp_call!((::unity::module_base()+0x3bffb00usize)as*mut u8,();
510(LayoutElement)__receiver)
511 }
512 }
513 #[doc = "`OnEnable()` overload"]
514 fn on_enable(self) -> () {
515 unsafe {
516 let __receiver = <LayoutElement as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
517 {
518 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
519 let __vi = *__vt.get(5usize).unwrap_or_else(|| {
520 panic!(
521 "unity: virtual slot {}
522 out of range (vtable len {}
523) on the runtime class behind {}
524 (method `{}
525`)",
526 5usize,
527 __vt.len(),
528 <LayoutElement as ::unity::ClassIdentity>::NAME,
529 "OnEnable",
530 )
531 });
532 let __inner: extern "C" fn(LayoutElement, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__vi.method_ptr);
533 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
534 __inner(__receiver, __mi)
535 }
536 }
537 }
538 #[doc = "`OnTransformParentChanged()` overload"]
539 fn on_transform_parent_changed(self) -> () {
540 unsafe {
541 let __receiver = <LayoutElement as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
542 {
543 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
544 let __vi = *__vt.get(12usize).unwrap_or_else(|| {
545 panic!(
546 "unity: virtual slot {}
547 out of range (vtable len {}
548) on the runtime class behind {}
549 (method `{}
550`)",
551 12usize,
552 __vt.len(),
553 <LayoutElement as ::unity::ClassIdentity>::NAME,
554 "OnTransformParentChanged",
555 )
556 });
557 let __inner: extern "C" fn(LayoutElement, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__vi.method_ptr);
558 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
559 __inner(__receiver, __mi)
560 }
561 }
562 }
563 #[doc = "`OnDisable()` overload"]
564 fn on_disable(self) -> () {
565 unsafe {
566 let __receiver = <LayoutElement as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
567 {
568 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
569 let __vi = *__vt.get(7usize).unwrap_or_else(|| {
570 panic!(
571 "unity: virtual slot {}
572 out of range (vtable len {}
573) on the runtime class behind {}
574 (method `{}
575`)",
576 7usize,
577 __vt.len(),
578 <LayoutElement as ::unity::ClassIdentity>::NAME,
579 "OnDisable",
580 )
581 });
582 let __inner: extern "C" fn(LayoutElement, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__vi.method_ptr);
583 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
584 __inner(__receiver, __mi)
585 }
586 }
587 }
588 #[doc = "`OnDidApplyAnimationProperties()` overload"]
589 fn on_did_apply_animation_properties(self) -> () {
590 unsafe {
591 let __receiver = <LayoutElement as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
592 {
593 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
594 let __vi = *__vt.get(13usize).unwrap_or_else(|| {
595 panic!(
596 "unity: virtual slot {}
597 out of range (vtable len {}
598) on the runtime class behind {}
599 (method `{}
600`)",
601 13usize,
602 __vt.len(),
603 <LayoutElement as ::unity::ClassIdentity>::NAME,
604 "OnDidApplyAnimationProperties",
605 )
606 });
607 let __inner: extern "C" fn(LayoutElement, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__vi.method_ptr);
608 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
609 __inner(__receiver, __mi)
610 }
611 }
612 }
613 #[doc = "`OnBeforeTransformParentChanged()` overload"]
614 fn on_before_transform_parent_changed(self) -> () {
615 unsafe {
616 let __receiver = <LayoutElement as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
617 {
618 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
619 let __vi = *__vt.get(11usize).unwrap_or_else(|| {
620 panic!(
621 "unity: virtual slot {}
622 out of range (vtable len {}
623) on the runtime class behind {}
624 (method `{}
625`)",
626 11usize,
627 __vt.len(),
628 <LayoutElement as ::unity::ClassIdentity>::NAME,
629 "OnBeforeTransformParentChanged",
630 )
631 });
632 let __inner: extern "C" fn(LayoutElement, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__vi.method_ptr);
633 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
634 __inner(__receiver, __mi)
635 }
636 }
637 }
638 #[doc = "`SetDirty()` overload"]
639 fn set_dirty(self) -> () {
640 unsafe {
641 let __receiver = <LayoutElement as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
642 ::unity::il2cpp_call!((::unity::module_base()+0x3bff5c0usize)as*mut u8,();
643(LayoutElement)__receiver)
644 }
645 }
646}
647
648#[cfg(feature = "unity_engine-ui-layoutelement")]
649impl<__T: ILayoutElement> ILayoutElementMethods for __T {}
650
651#[cfg(feature = "unity_engine-ui-layoutelement")]
652impl LayoutElement {
653 pub fn get_ignore_layout_method_info() -> &'static ::unity::il2cpp::MethodInfo {
654 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
655 }
656
657 pub fn set_ignore_layout_method_info() -> &'static ::unity::il2cpp::MethodInfo {
658 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
659 }
660
661 pub fn calculate_layout_input_horizontal_method_info() -> &'static ::unity::il2cpp::MethodInfo {
662 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
663 }
664
665 pub fn calculate_layout_input_vertical_method_info() -> &'static ::unity::il2cpp::MethodInfo {
666 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
667 }
668
669 pub fn get_min_width_method_info() -> &'static ::unity::il2cpp::MethodInfo {
670 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
671 }
672
673 pub fn set_min_width_method_info() -> &'static ::unity::il2cpp::MethodInfo {
674 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[5]
675 }
676
677 pub fn get_min_height_method_info() -> &'static ::unity::il2cpp::MethodInfo {
678 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[6]
679 }
680
681 pub fn set_min_height_method_info() -> &'static ::unity::il2cpp::MethodInfo {
682 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[7]
683 }
684
685 pub fn get_preferred_width_method_info() -> &'static ::unity::il2cpp::MethodInfo {
686 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[8]
687 }
688
689 pub fn set_preferred_width_method_info() -> &'static ::unity::il2cpp::MethodInfo {
690 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[9]
691 }
692
693 pub fn get_preferred_height_method_info() -> &'static ::unity::il2cpp::MethodInfo {
694 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[10]
695 }
696
697 pub fn set_preferred_height_method_info() -> &'static ::unity::il2cpp::MethodInfo {
698 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[11]
699 }
700
701 pub fn get_flexible_width_method_info() -> &'static ::unity::il2cpp::MethodInfo {
702 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[12]
703 }
704
705 pub fn set_flexible_width_method_info() -> &'static ::unity::il2cpp::MethodInfo {
706 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[13]
707 }
708
709 pub fn get_flexible_height_method_info() -> &'static ::unity::il2cpp::MethodInfo {
710 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[14]
711 }
712
713 pub fn set_flexible_height_method_info() -> &'static ::unity::il2cpp::MethodInfo {
714 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[15]
715 }
716
717 pub fn get_layout_priority_method_info() -> &'static ::unity::il2cpp::MethodInfo {
718 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[16]
719 }
720
721 pub fn set_layout_priority_method_info() -> &'static ::unity::il2cpp::MethodInfo {
722 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[17]
723 }
724
725 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
726 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[18]
727 }
728
729 pub fn on_enable_method_info() -> &'static ::unity::il2cpp::MethodInfo {
730 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[19]
731 }
732
733 pub fn on_transform_parent_changed_method_info() -> &'static ::unity::il2cpp::MethodInfo {
734 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[20]
735 }
736
737 pub fn on_disable_method_info() -> &'static ::unity::il2cpp::MethodInfo {
738 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[21]
739 }
740
741 pub fn on_did_apply_animation_properties_method_info() -> &'static ::unity::il2cpp::MethodInfo {
742 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[22]
743 }
744
745 pub fn on_before_transform_parent_changed_method_info() -> &'static ::unity::il2cpp::MethodInfo {
746 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[23]
747 }
748
749 pub fn set_dirty_method_info() -> &'static ::unity::il2cpp::MethodInfo {
750 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[24]
751 }
752}
753
754#[cfg(feature = "unity_engine-ui-layoutelement")]
755impl LayoutElement {
756 #[doc = "Direct (non-virtual) call to `LayoutElement`'s own `get_ignoreLayout`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
757 pub unsafe fn get_ignore_layout(this: impl ::core::convert::Into<::unity::IlInstance>) -> bool {
758 let __mi = Self::get_ignore_layout_method_info();
759 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__mi.method_ptr);
760 __inner(this.into(), ::core::option::Option::None)
761 }
762
763 #[doc = "Direct (non-virtual) call to `LayoutElement`'s own `set_ignoreLayout`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
764 pub unsafe fn set_ignore_layout(this: impl ::core::convert::Into<::unity::IlInstance>, value: bool) -> () {
765 let __mi = Self::set_ignore_layout_method_info();
766 let __inner: extern "C" fn(::unity::IlInstance, bool, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
767 __inner(this.into(), value, ::core::option::Option::None)
768 }
769
770 #[doc = "Direct (non-virtual) call to `LayoutElement`'s own `CalculateLayoutInputHorizontal`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
771 pub unsafe fn calculate_layout_input_horizontal(this: impl ::core::convert::Into<::unity::IlInstance>) -> () {
772 let __mi = Self::calculate_layout_input_horizontal_method_info();
773 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
774 __inner(this.into(), ::core::option::Option::None)
775 }
776
777 #[doc = "Direct (non-virtual) call to `LayoutElement`'s own `CalculateLayoutInputVertical`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
778 pub unsafe fn calculate_layout_input_vertical(this: impl ::core::convert::Into<::unity::IlInstance>) -> () {
779 let __mi = Self::calculate_layout_input_vertical_method_info();
780 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
781 __inner(this.into(), ::core::option::Option::None)
782 }
783
784 #[doc = "Direct (non-virtual) call to `LayoutElement`'s own `get_minWidth`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
785 pub unsafe fn get_min_width(this: impl ::core::convert::Into<::unity::IlInstance>) -> f32 {
786 let __mi = Self::get_min_width_method_info();
787 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> f32 = ::core::mem::transmute(__mi.method_ptr);
788 __inner(this.into(), ::core::option::Option::None)
789 }
790
791 #[doc = "Direct (non-virtual) call to `LayoutElement`'s own `set_minWidth`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
792 pub unsafe fn set_min_width(this: impl ::core::convert::Into<::unity::IlInstance>, value: f32) -> () {
793 let __mi = Self::set_min_width_method_info();
794 let __inner: extern "C" fn(::unity::IlInstance, f32, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
795 __inner(this.into(), value, ::core::option::Option::None)
796 }
797
798 #[doc = "Direct (non-virtual) call to `LayoutElement`'s own `get_minHeight`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
799 pub unsafe fn get_min_height(this: impl ::core::convert::Into<::unity::IlInstance>) -> f32 {
800 let __mi = Self::get_min_height_method_info();
801 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> f32 = ::core::mem::transmute(__mi.method_ptr);
802 __inner(this.into(), ::core::option::Option::None)
803 }
804
805 #[doc = "Direct (non-virtual) call to `LayoutElement`'s own `set_minHeight`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
806 pub unsafe fn set_min_height(this: impl ::core::convert::Into<::unity::IlInstance>, value: f32) -> () {
807 let __mi = Self::set_min_height_method_info();
808 let __inner: extern "C" fn(::unity::IlInstance, f32, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
809 __inner(this.into(), value, ::core::option::Option::None)
810 }
811
812 #[doc = "Direct (non-virtual) call to `LayoutElement`'s own `get_preferredWidth`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
813 pub unsafe fn get_preferred_width(this: impl ::core::convert::Into<::unity::IlInstance>) -> f32 {
814 let __mi = Self::get_preferred_width_method_info();
815 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> f32 = ::core::mem::transmute(__mi.method_ptr);
816 __inner(this.into(), ::core::option::Option::None)
817 }
818
819 #[doc = "Direct (non-virtual) call to `LayoutElement`'s own `set_preferredWidth`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
820 pub unsafe fn set_preferred_width(this: impl ::core::convert::Into<::unity::IlInstance>, value: f32) -> () {
821 let __mi = Self::set_preferred_width_method_info();
822 let __inner: extern "C" fn(::unity::IlInstance, f32, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
823 __inner(this.into(), value, ::core::option::Option::None)
824 }
825
826 #[doc = "Direct (non-virtual) call to `LayoutElement`'s own `get_preferredHeight`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
827 pub unsafe fn get_preferred_height(this: impl ::core::convert::Into<::unity::IlInstance>) -> f32 {
828 let __mi = Self::get_preferred_height_method_info();
829 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> f32 = ::core::mem::transmute(__mi.method_ptr);
830 __inner(this.into(), ::core::option::Option::None)
831 }
832
833 #[doc = "Direct (non-virtual) call to `LayoutElement`'s own `set_preferredHeight`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
834 pub unsafe fn set_preferred_height(this: impl ::core::convert::Into<::unity::IlInstance>, value: f32) -> () {
835 let __mi = Self::set_preferred_height_method_info();
836 let __inner: extern "C" fn(::unity::IlInstance, f32, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
837 __inner(this.into(), value, ::core::option::Option::None)
838 }
839
840 #[doc = "Direct (non-virtual) call to `LayoutElement`'s own `get_flexibleWidth`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
841 pub unsafe fn get_flexible_width(this: impl ::core::convert::Into<::unity::IlInstance>) -> f32 {
842 let __mi = Self::get_flexible_width_method_info();
843 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> f32 = ::core::mem::transmute(__mi.method_ptr);
844 __inner(this.into(), ::core::option::Option::None)
845 }
846
847 #[doc = "Direct (non-virtual) call to `LayoutElement`'s own `set_flexibleWidth`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
848 pub unsafe fn set_flexible_width(this: impl ::core::convert::Into<::unity::IlInstance>, value: f32) -> () {
849 let __mi = Self::set_flexible_width_method_info();
850 let __inner: extern "C" fn(::unity::IlInstance, f32, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
851 __inner(this.into(), value, ::core::option::Option::None)
852 }
853
854 #[doc = "Direct (non-virtual) call to `LayoutElement`'s own `get_flexibleHeight`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
855 pub unsafe fn get_flexible_height(this: impl ::core::convert::Into<::unity::IlInstance>) -> f32 {
856 let __mi = Self::get_flexible_height_method_info();
857 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> f32 = ::core::mem::transmute(__mi.method_ptr);
858 __inner(this.into(), ::core::option::Option::None)
859 }
860
861 #[doc = "Direct (non-virtual) call to `LayoutElement`'s own `set_flexibleHeight`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
862 pub unsafe fn set_flexible_height(this: impl ::core::convert::Into<::unity::IlInstance>, value: f32) -> () {
863 let __mi = Self::set_flexible_height_method_info();
864 let __inner: extern "C" fn(::unity::IlInstance, f32, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
865 __inner(this.into(), value, ::core::option::Option::None)
866 }
867
868 #[doc = "Direct (non-virtual) call to `LayoutElement`'s own `get_layoutPriority`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
869 pub unsafe fn get_layout_priority(this: impl ::core::convert::Into<::unity::IlInstance>) -> i32 {
870 let __mi = Self::get_layout_priority_method_info();
871 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> i32 = ::core::mem::transmute(__mi.method_ptr);
872 __inner(this.into(), ::core::option::Option::None)
873 }
874
875 #[doc = "Direct (non-virtual) call to `LayoutElement`'s own `set_layoutPriority`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
876 pub unsafe fn set_layout_priority(this: impl ::core::convert::Into<::unity::IlInstance>, value: i32) -> () {
877 let __mi = Self::set_layout_priority_method_info();
878 let __inner: extern "C" fn(::unity::IlInstance, i32, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
879 __inner(this.into(), value, ::core::option::Option::None)
880 }
881
882 #[doc = "Direct (non-virtual) call to `LayoutElement`'s own `OnEnable`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
883 pub unsafe fn on_enable(this: impl ::core::convert::Into<::unity::IlInstance>) -> () {
884 let __mi = Self::on_enable_method_info();
885 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
886 __inner(this.into(), ::core::option::Option::None)
887 }
888
889 #[doc = "Direct (non-virtual) call to `LayoutElement`'s own `OnTransformParentChanged`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
890 pub unsafe fn on_transform_parent_changed(this: impl ::core::convert::Into<::unity::IlInstance>) -> () {
891 let __mi = Self::on_transform_parent_changed_method_info();
892 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
893 __inner(this.into(), ::core::option::Option::None)
894 }
895
896 #[doc = "Direct (non-virtual) call to `LayoutElement`'s own `OnDisable`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
897 pub unsafe fn on_disable(this: impl ::core::convert::Into<::unity::IlInstance>) -> () {
898 let __mi = Self::on_disable_method_info();
899 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
900 __inner(this.into(), ::core::option::Option::None)
901 }
902
903 #[doc = "Direct (non-virtual) call to `LayoutElement`'s own `OnDidApplyAnimationProperties`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
904 pub unsafe fn on_did_apply_animation_properties(this: impl ::core::convert::Into<::unity::IlInstance>) -> () {
905 let __mi = Self::on_did_apply_animation_properties_method_info();
906 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
907 __inner(this.into(), ::core::option::Option::None)
908 }
909
910 #[doc = "Direct (non-virtual) call to `LayoutElement`'s own `OnBeforeTransformParentChanged`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
911 pub unsafe fn on_before_transform_parent_changed(this: impl ::core::convert::Into<::unity::IlInstance>) -> () {
912 let __mi = Self::on_before_transform_parent_changed_method_info();
913 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
914 __inner(this.into(), ::core::option::Option::None)
915 }
916}
917
918#[cfg(feature = "unity_engine-ui-layoutelement")]
919impl LayoutElement {
920 #[doc = "`.ctor()` — no args"]
921 pub fn new() -> Self {
922 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
923 panic!(
924 "{}
925::{}
926 failed to instantiate",
927 ::core::stringify!(LayoutElement),
928 ::core::stringify!(new),
929 )
930 });
931 <Self as ILayoutElementMethods>::ctor(this);
932 this
933 }
934}
935
936#[cfg(feature = "unity_engine-ui-layoutelement")]
937#[doc(hidden)]
938pub mod prelude {
939 pub use super::{ILayoutElement, ILayoutElementMethods, LayoutElement};
940 #[cfg(feature = "system-object")]
941 pub use crate::system::object::IObjectMethods;
942 #[cfg(feature = "unity_engine-behaviour")]
943 pub use crate::unity_engine::behaviour::IBehaviourMethods;
944 #[cfg(feature = "unity_engine-component")]
945 pub use crate::unity_engine::component::IComponentMethods;
946 #[cfg(feature = "unity_engine-event_systems-uibehaviour")]
947 pub use crate::unity_engine::event_systems::uibehaviour::IUIBehaviourMethods;
948 #[cfg(feature = "unity_engine-monobehaviour")]
949 pub use crate::unity_engine::monobehaviour::IMonoBehaviourMethods;
950 #[cfg(feature = "unity_engine-object_2")]
951 pub use crate::unity_engine::object_2::IObject_2Methods;
952 pub use crate::{
953 system::object::IObject,
954 unity_engine::{
955 behaviour::IBehaviour, component::IComponent, event_systems::uibehaviour::IUIBehaviour, monobehaviour::IMonoBehaviour,
956 object_2::IObject_2,
957 },
958 };
959}