engage/generated/root/
simpleanimationplayable.rs

1// @generated by il2cpp-bindgen — do not edit by hand.
2
3#[cfg(feature = "root-simpleanimationplayable-types")]
4mod __types {
5    #[allow(unused_imports)] use ::unity::prelude::*;
6
7    use super::*;
8    use crate::{
9        system::{
10            object::{IObject, Object},
11            valuetype::{IValueType, ValueType},
12        },
13        unity_engine::playables::playablebehaviour::{IPlayableBehaviour, PlayableBehaviour},
14    };
15
16    #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/root/simpleanimationplayable/SimpleAnimationPlayable_StateHandle.md"))]
17    #[::unity::class(namespace = "", name = "SimpleAnimationPlayable.StateHandle")]
18    #[parent(crate::system::object::Object)]
19    pub struct SimpleAnimationPlayable_StateHandle {
20        #[offset(16)]
21        #[rename(name = "m_Parent")]
22        pub m_parent: crate::root::simpleanimationplayable::SimpleAnimationPlayable,
23        #[offset(24)]
24        #[rename(name = "m_Index")]
25        pub m_index: i32,
26        #[offset(32)]
27        #[rename(name = "m_Target")]
28        pub m_target: crate::unity_engine::playables::playable::Playable,
29    }
30
31    #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/root/simpleanimationplayable/SimpleAnimationPlayable_StateManagement.md"))]
32    #[::unity::class(namespace = "", name = "SimpleAnimationPlayable.StateManagement")]
33    #[parent(crate::system::object::Object)]
34    pub struct SimpleAnimationPlayable_StateManagement {
35        #[offset(16)]
36        #[rename(name = "m_States")]
37        pub m_states: crate::system::collections::generic::list_1::List_1<crate::root::simpleanimationplayable::SimpleAnimationPlayable_StateInfo>,
38        #[offset(24)]
39        #[rename(name = "m_Count")]
40        pub m_count: i32,
41    }
42
43    #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/root/simpleanimationplayable/SimpleAnimationPlayable_StateInfo.md"))]
44    #[::unity::class(namespace = "", name = "SimpleAnimationPlayable.StateInfo")]
45    #[parent(crate::system::object::Object)]
46    pub struct SimpleAnimationPlayable_StateInfo {
47        #[offset(16)]
48        #[rename(name = "m_Enabled")]
49        pub m_enabled: bool,
50        #[offset(20)]
51        #[rename(name = "m_Index")]
52        pub m_index: i32,
53        #[offset(24)]
54        #[rename(name = "m_StateName")]
55        pub m_state_name: ::unity::Il2CppString,
56        #[offset(32)]
57        #[rename(name = "m_Fading")]
58        pub m_fading: bool,
59        #[offset(36)]
60        #[rename(name = "m_Time")]
61        pub m_time: f32,
62        #[offset(40)]
63        #[rename(name = "m_TargetWeight")]
64        pub m_target_weight: f32,
65        #[offset(44)]
66        #[rename(name = "m_Weight")]
67        pub m_weight: f32,
68        #[offset(48)]
69        #[rename(name = "m_FadeSpeed")]
70        pub m_fade_speed: f32,
71        #[offset(56)]
72        #[rename(name = "m_Clip")]
73        pub m_clip: crate::unity_engine::animationclip::AnimationClip,
74        #[offset(64)]
75        #[rename(name = "m_Playable")]
76        pub m_playable: crate::unity_engine::playables::playable::Playable,
77        #[offset(80)]
78        #[rename(name = "m_WrapMode")]
79        pub m_wrap_mode: crate::unity_engine::wrapmode::WrapMode,
80        #[offset(84)]
81        #[rename(name = "m_IsClone")]
82        pub m_is_clone: bool,
83        #[offset(85)]
84        #[rename(name = "m_ReadyForCleanup")]
85        pub m_ready_for_cleanup: bool,
86        #[offset(88)]
87        #[rename(name = "m_ParentState")]
88        pub m_parent_state: crate::root::simpleanimationplayable::SimpleAnimationPlayable_StateHandle,
89        #[offset(96)]
90        #[rename(name = "m_WeightDirty")]
91        pub m_weight_dirty: bool,
92        #[offset(97)]
93        #[rename(name = "m_EnabledDirty")]
94        pub m_enabled_dirty: bool,
95        #[offset(98)]
96        #[rename(name = "m_TimeIsUpToDate")]
97        pub m_time_is_up_to_date: bool,
98    }
99
100    #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/root/simpleanimationplayable/SimpleAnimationPlayable_IState.md"))]
101    #[::unity::class(namespace = "", name = "SimpleAnimationPlayable.IState")]
102    pub struct SimpleAnimationPlayable_IState {}
103
104    #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/root/simpleanimationplayable/SimpleAnimationPlayable_StateEnumerable_StateEnumerator.md"))]
105    #[::unity::class(namespace = "", name = "SimpleAnimationPlayable.StateEnumerable.StateEnumerator")]
106    #[parent(crate::system::object::Object)]
107    pub struct SimpleAnimationPlayable_StateEnumerable_StateEnumerator {
108        #[offset(16)]
109        #[rename(name = "m_Index")]
110        pub m_index: i32,
111        #[offset(20)]
112        #[rename(name = "m_Version")]
113        pub m_version: i32,
114        #[offset(24)]
115        #[rename(name = "m_Owner")]
116        pub m_owner: crate::root::simpleanimationplayable::SimpleAnimationPlayable,
117    }
118
119    #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/root/simpleanimationplayable/SimpleAnimationPlayable_StateEnumerable.md"))]
120    #[::unity::class(namespace = "", name = "SimpleAnimationPlayable.StateEnumerable")]
121    #[parent(crate::system::object::Object)]
122    pub struct SimpleAnimationPlayable_StateEnumerable {
123        #[offset(16)]
124        #[rename(name = "m_Owner")]
125        pub m_owner: crate::root::simpleanimationplayable::SimpleAnimationPlayable,
126    }
127
128    #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/root/simpleanimationplayable/SimpleAnimationPlayable_QueuedState.md"))]
129    #[repr(C)]
130    #[derive(::core::clone::Clone, ::core::marker::Copy)]
131    pub struct SimpleAnimationPlayable_QueuedState {
132        pub state: crate::root::simpleanimationplayable::SimpleAnimationPlayable_StateHandle,
133        pub fade_time: f32,
134    }
135    impl ::unity::ClassIdentity for SimpleAnimationPlayable_QueuedState {
136        const NAME: &'static str = "SimpleAnimationPlayable.QueuedState";
137        const NAMESPACE: &'static str = "";
138
139        fn class() -> ::unity::Class {
140            static CACHE: ::std::sync::OnceLock<::unity::Class> = ::std::sync::OnceLock::new();
141            *CACHE.get_or_init(|| ::unity::Class::lookup(Self::NAMESPACE, Self::NAME))
142        }
143    }
144    impl ::unity::IlType for SimpleAnimationPlayable_QueuedState {
145        fn il_type() -> &'static ::unity::il2cpp::Il2CppType {
146            &<Self as ::unity::ClassIdentity>::class().raw()._1.byval_arg
147        }
148    }
149
150    #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/root/simpleanimationplayable/SimpleAnimationPlayable.md"))]
151    #[::unity::class(namespace = "", name = "SimpleAnimationPlayable")]
152    #[parent(crate::unity_engine::playables::playablebehaviour::PlayableBehaviour)]
153    pub struct SimpleAnimationPlayable {
154        #[offset(16)]
155        #[rename(name = "m_StateQueue")]
156        pub m_state_queue: crate::system::collections::generic::linkedlist_1::LinkedList_1<
157            crate::root::simpleanimationplayable::SimpleAnimationPlayable_QueuedState,
158        >,
159        #[offset(24)]
160        #[rename(name = "m_States")]
161        pub m_states: crate::root::simpleanimationplayable::SimpleAnimationPlayable_StateManagement,
162        #[offset(32)]
163        #[rename(name = "m_Initialized")]
164        pub m_initialized: bool,
165        #[offset(33)]
166        #[rename(name = "m_KeepStoppedPlayablesConnected")]
167        pub m_keep_stopped_playables_connected: bool,
168        #[offset(40)]
169        #[rename(name = "m_ActualPlayable")]
170        pub m_actual_playable: crate::unity_engine::playables::playable::Playable,
171        #[offset(56)]
172        #[rename(name = "m_Mixer")]
173        pub m_mixer: crate::unity_engine::animations::animationmixerplayable::AnimationMixerPlayable,
174        #[offset(72)]
175        #[rename(name = "onDone")]
176        pub on_done: crate::system::action::Action,
177        #[offset(80)]
178        #[rename(name = "m_StatesVersion")]
179        pub m_states_version: i32,
180    }
181}
182
183#[cfg(feature = "root-simpleanimationplayable-types")]
184pub use __types::*;
185
186#[cfg(feature = "root-simpleanimationplayable")]
187pub trait ISimpleAnimationPlayable_StateHandleMethods: ISimpleAnimationPlayable_StateHandle {
188    #[doc = "`.ctor(crate::root::simpleanimationplayable::SimpleAnimationPlayable, i32, crate::unity_engine::playables::playable::Playable)` overload"]
189    fn ctor(
190        self,
191        s: impl ::core::convert::Into<crate::root::simpleanimationplayable::SimpleAnimationPlayable>,
192        index: impl ::core::convert::Into<i32>,
193        target: impl ::core::convert::Into<crate::unity_engine::playables::playable::Playable>,
194    ) -> () {
195        unsafe {
196            let __receiver = <SimpleAnimationPlayable_StateHandle as ::unity::FromIlInstance>::from_il_instance(
197                <Self as ::unity::SystemObject>::as_instance(self),
198            );
199            ::unity::il2cpp_call!((::unity::module_base()+0x3eee0d0usize)as*mut u8,();
200(SimpleAnimationPlayable_StateHandle)__receiver,(crate::root::simpleanimationplayable::SimpleAnimationPlayable)::core::convert::Into::into(s),(i32)::core::convert::Into::into(index),(crate::unity_engine::playables::playable::Playable)::core::convert::Into::into(target))
201        }
202    }
203    #[doc = "`IsValid()` overload"]
204    fn is_valid(self) -> bool {
205        unsafe {
206            let __receiver = <SimpleAnimationPlayable_StateHandle as ::unity::FromIlInstance>::from_il_instance(
207                <Self as ::unity::SystemObject>::as_instance(self),
208            );
209            {
210                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
211                let __vi = *__vt.get(4usize).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                        4usize,
219                        __vt.len(),
220                        <SimpleAnimationPlayable_StateHandle as ::unity::ClassIdentity>::NAME,
221                        "IsValid",
222                    )
223                });
224                let __inner: extern "C" fn(SimpleAnimationPlayable_StateHandle, ::unity::OptionalMethod) -> bool =
225                    ::core::mem::transmute(__vi.method_ptr);
226                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
227                __inner(__receiver, __mi)
228            }
229        }
230    }
231    #[doc = "`get_enabled()` overload"]
232    fn get_enabled(self) -> bool {
233        unsafe {
234            let __receiver = <SimpleAnimationPlayable_StateHandle as ::unity::FromIlInstance>::from_il_instance(
235                <Self as ::unity::SystemObject>::as_instance(self),
236            );
237            {
238                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
239                let __vi = *__vt.get(5usize).unwrap_or_else(|| {
240                    panic!(
241                        "unity: virtual slot {}
242 out of range (vtable len {}
243) on the runtime class behind {}
244 (method `{}
245`)",
246                        5usize,
247                        __vt.len(),
248                        <SimpleAnimationPlayable_StateHandle as ::unity::ClassIdentity>::NAME,
249                        "get_enabled",
250                    )
251                });
252                let __inner: extern "C" fn(SimpleAnimationPlayable_StateHandle, ::unity::OptionalMethod) -> bool =
253                    ::core::mem::transmute(__vi.method_ptr);
254                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
255                __inner(__receiver, __mi)
256            }
257        }
258    }
259    #[doc = "`set_enabled(bool)` overload"]
260    fn set_enabled(self, value: impl ::core::convert::Into<bool>) -> () {
261        unsafe {
262            let __receiver = <SimpleAnimationPlayable_StateHandle as ::unity::FromIlInstance>::from_il_instance(
263                <Self as ::unity::SystemObject>::as_instance(self),
264            );
265            {
266                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
267                let __vi = *__vt.get(6usize).unwrap_or_else(|| {
268                    panic!(
269                        "unity: virtual slot {}
270 out of range (vtable len {}
271) on the runtime class behind {}
272 (method `{}
273`)",
274                        6usize,
275                        __vt.len(),
276                        <SimpleAnimationPlayable_StateHandle as ::unity::ClassIdentity>::NAME,
277                        "set_enabled",
278                    )
279                });
280                let __inner: extern "C" fn(SimpleAnimationPlayable_StateHandle, bool, ::unity::OptionalMethod) -> () =
281                    ::core::mem::transmute(__vi.method_ptr);
282                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
283                __inner(__receiver, ::core::convert::Into::into(value), __mi)
284            }
285        }
286    }
287    #[doc = "`get_time()` overload"]
288    fn get_time(self) -> f32 {
289        unsafe {
290            let __receiver = <SimpleAnimationPlayable_StateHandle as ::unity::FromIlInstance>::from_il_instance(
291                <Self as ::unity::SystemObject>::as_instance(self),
292            );
293            {
294                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
295                let __vi = *__vt.get(7usize).unwrap_or_else(|| {
296                    panic!(
297                        "unity: virtual slot {}
298 out of range (vtable len {}
299) on the runtime class behind {}
300 (method `{}
301`)",
302                        7usize,
303                        __vt.len(),
304                        <SimpleAnimationPlayable_StateHandle as ::unity::ClassIdentity>::NAME,
305                        "get_time",
306                    )
307                });
308                let __inner: extern "C" fn(SimpleAnimationPlayable_StateHandle, ::unity::OptionalMethod) -> f32 =
309                    ::core::mem::transmute(__vi.method_ptr);
310                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
311                __inner(__receiver, __mi)
312            }
313        }
314    }
315    #[doc = "`set_time(f32)` overload"]
316    fn set_time(self, value: impl ::core::convert::Into<f32>) -> () {
317        unsafe {
318            let __receiver = <SimpleAnimationPlayable_StateHandle as ::unity::FromIlInstance>::from_il_instance(
319                <Self as ::unity::SystemObject>::as_instance(self),
320            );
321            {
322                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
323                let __vi = *__vt.get(8usize).unwrap_or_else(|| {
324                    panic!(
325                        "unity: virtual slot {}
326 out of range (vtable len {}
327) on the runtime class behind {}
328 (method `{}
329`)",
330                        8usize,
331                        __vt.len(),
332                        <SimpleAnimationPlayable_StateHandle as ::unity::ClassIdentity>::NAME,
333                        "set_time",
334                    )
335                });
336                let __inner: extern "C" fn(SimpleAnimationPlayable_StateHandle, f32, ::unity::OptionalMethod) -> () =
337                    ::core::mem::transmute(__vi.method_ptr);
338                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
339                __inner(__receiver, ::core::convert::Into::into(value), __mi)
340            }
341        }
342    }
343    #[doc = "`get_normalizedTime()` overload"]
344    fn get_normalized_time(self) -> f32 {
345        unsafe {
346            let __receiver = <SimpleAnimationPlayable_StateHandle as ::unity::FromIlInstance>::from_il_instance(
347                <Self as ::unity::SystemObject>::as_instance(self),
348            );
349            {
350                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
351                let __vi = *__vt.get(9usize).unwrap_or_else(|| {
352                    panic!(
353                        "unity: virtual slot {}
354 out of range (vtable len {}
355) on the runtime class behind {}
356 (method `{}
357`)",
358                        9usize,
359                        __vt.len(),
360                        <SimpleAnimationPlayable_StateHandle as ::unity::ClassIdentity>::NAME,
361                        "get_normalizedTime",
362                    )
363                });
364                let __inner: extern "C" fn(SimpleAnimationPlayable_StateHandle, ::unity::OptionalMethod) -> f32 =
365                    ::core::mem::transmute(__vi.method_ptr);
366                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
367                __inner(__receiver, __mi)
368            }
369        }
370    }
371    #[doc = "`set_normalizedTime(f32)` overload"]
372    fn set_normalized_time(self, value: impl ::core::convert::Into<f32>) -> () {
373        unsafe {
374            let __receiver = <SimpleAnimationPlayable_StateHandle as ::unity::FromIlInstance>::from_il_instance(
375                <Self as ::unity::SystemObject>::as_instance(self),
376            );
377            {
378                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
379                let __vi = *__vt.get(10usize).unwrap_or_else(|| {
380                    panic!(
381                        "unity: virtual slot {}
382 out of range (vtable len {}
383) on the runtime class behind {}
384 (method `{}
385`)",
386                        10usize,
387                        __vt.len(),
388                        <SimpleAnimationPlayable_StateHandle as ::unity::ClassIdentity>::NAME,
389                        "set_normalizedTime",
390                    )
391                });
392                let __inner: extern "C" fn(SimpleAnimationPlayable_StateHandle, f32, ::unity::OptionalMethod) -> () =
393                    ::core::mem::transmute(__vi.method_ptr);
394                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
395                __inner(__receiver, ::core::convert::Into::into(value), __mi)
396            }
397        }
398    }
399    #[doc = "`get_speed()` overload"]
400    fn get_speed(self) -> f32 {
401        unsafe {
402            let __receiver = <SimpleAnimationPlayable_StateHandle as ::unity::FromIlInstance>::from_il_instance(
403                <Self as ::unity::SystemObject>::as_instance(self),
404            );
405            {
406                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
407                let __vi = *__vt.get(11usize).unwrap_or_else(|| {
408                    panic!(
409                        "unity: virtual slot {}
410 out of range (vtable len {}
411) on the runtime class behind {}
412 (method `{}
413`)",
414                        11usize,
415                        __vt.len(),
416                        <SimpleAnimationPlayable_StateHandle as ::unity::ClassIdentity>::NAME,
417                        "get_speed",
418                    )
419                });
420                let __inner: extern "C" fn(SimpleAnimationPlayable_StateHandle, ::unity::OptionalMethod) -> f32 =
421                    ::core::mem::transmute(__vi.method_ptr);
422                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
423                __inner(__receiver, __mi)
424            }
425        }
426    }
427    #[doc = "`set_speed(f32)` overload"]
428    fn set_speed(self, value: impl ::core::convert::Into<f32>) -> () {
429        unsafe {
430            let __receiver = <SimpleAnimationPlayable_StateHandle as ::unity::FromIlInstance>::from_il_instance(
431                <Self as ::unity::SystemObject>::as_instance(self),
432            );
433            {
434                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
435                let __vi = *__vt.get(12usize).unwrap_or_else(|| {
436                    panic!(
437                        "unity: virtual slot {}
438 out of range (vtable len {}
439) on the runtime class behind {}
440 (method `{}
441`)",
442                        12usize,
443                        __vt.len(),
444                        <SimpleAnimationPlayable_StateHandle as ::unity::ClassIdentity>::NAME,
445                        "set_speed",
446                    )
447                });
448                let __inner: extern "C" fn(SimpleAnimationPlayable_StateHandle, f32, ::unity::OptionalMethod) -> () =
449                    ::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_name()` overload"]
456    fn get_name(self) -> ::unity::Il2CppString {
457        unsafe {
458            let __receiver = <SimpleAnimationPlayable_StateHandle as ::unity::FromIlInstance>::from_il_instance(
459                <Self as ::unity::SystemObject>::as_instance(self),
460            );
461            {
462                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
463                let __vi = *__vt.get(13usize).unwrap_or_else(|| {
464                    panic!(
465                        "unity: virtual slot {}
466 out of range (vtable len {}
467) on the runtime class behind {}
468 (method `{}
469`)",
470                        13usize,
471                        __vt.len(),
472                        <SimpleAnimationPlayable_StateHandle as ::unity::ClassIdentity>::NAME,
473                        "get_name",
474                    )
475                });
476                let __inner: extern "C" fn(SimpleAnimationPlayable_StateHandle, ::unity::OptionalMethod) -> ::unity::Il2CppString =
477                    ::core::mem::transmute(__vi.method_ptr);
478                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
479                __inner(__receiver, __mi)
480            }
481        }
482    }
483    #[doc = "`set_name(::unity::Il2CppString)` overload"]
484    fn set_name(self, value: impl ::core::convert::Into<::unity::Il2CppString>) -> () {
485        unsafe {
486            let __receiver = <SimpleAnimationPlayable_StateHandle as ::unity::FromIlInstance>::from_il_instance(
487                <Self as ::unity::SystemObject>::as_instance(self),
488            );
489            {
490                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
491                let __vi = *__vt.get(14usize).unwrap_or_else(|| {
492                    panic!(
493                        "unity: virtual slot {}
494 out of range (vtable len {}
495) on the runtime class behind {}
496 (method `{}
497`)",
498                        14usize,
499                        __vt.len(),
500                        <SimpleAnimationPlayable_StateHandle as ::unity::ClassIdentity>::NAME,
501                        "set_name",
502                    )
503                });
504                let __inner: extern "C" fn(SimpleAnimationPlayable_StateHandle, ::unity::Il2CppString, ::unity::OptionalMethod) -> () =
505                    ::core::mem::transmute(__vi.method_ptr);
506                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
507                __inner(__receiver, ::core::convert::Into::into(value), __mi)
508            }
509        }
510    }
511    #[doc = "`get_weight()` overload"]
512    fn get_weight(self) -> f32 {
513        unsafe {
514            let __receiver = <SimpleAnimationPlayable_StateHandle as ::unity::FromIlInstance>::from_il_instance(
515                <Self as ::unity::SystemObject>::as_instance(self),
516            );
517            {
518                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
519                let __vi = *__vt.get(15usize).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                        15usize,
527                        __vt.len(),
528                        <SimpleAnimationPlayable_StateHandle as ::unity::ClassIdentity>::NAME,
529                        "get_weight",
530                    )
531                });
532                let __inner: extern "C" fn(SimpleAnimationPlayable_StateHandle, ::unity::OptionalMethod) -> f32 =
533                    ::core::mem::transmute(__vi.method_ptr);
534                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
535                __inner(__receiver, __mi)
536            }
537        }
538    }
539    #[doc = "`set_weight(f32)` overload"]
540    fn set_weight(self, value: impl ::core::convert::Into<f32>) -> () {
541        unsafe {
542            let __receiver = <SimpleAnimationPlayable_StateHandle as ::unity::FromIlInstance>::from_il_instance(
543                <Self as ::unity::SystemObject>::as_instance(self),
544            );
545            {
546                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
547                let __vi = *__vt.get(16usize).unwrap_or_else(|| {
548                    panic!(
549                        "unity: virtual slot {}
550 out of range (vtable len {}
551) on the runtime class behind {}
552 (method `{}
553`)",
554                        16usize,
555                        __vt.len(),
556                        <SimpleAnimationPlayable_StateHandle as ::unity::ClassIdentity>::NAME,
557                        "set_weight",
558                    )
559                });
560                let __inner: extern "C" fn(SimpleAnimationPlayable_StateHandle, f32, ::unity::OptionalMethod) -> () =
561                    ::core::mem::transmute(__vi.method_ptr);
562                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
563                __inner(__receiver, ::core::convert::Into::into(value), __mi)
564            }
565        }
566    }
567    #[doc = "`get_length()` overload"]
568    fn get_length(self) -> f32 {
569        unsafe {
570            let __receiver = <SimpleAnimationPlayable_StateHandle as ::unity::FromIlInstance>::from_il_instance(
571                <Self as ::unity::SystemObject>::as_instance(self),
572            );
573            {
574                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
575                let __vi = *__vt.get(17usize).unwrap_or_else(|| {
576                    panic!(
577                        "unity: virtual slot {}
578 out of range (vtable len {}
579) on the runtime class behind {}
580 (method `{}
581`)",
582                        17usize,
583                        __vt.len(),
584                        <SimpleAnimationPlayable_StateHandle as ::unity::ClassIdentity>::NAME,
585                        "get_length",
586                    )
587                });
588                let __inner: extern "C" fn(SimpleAnimationPlayable_StateHandle, ::unity::OptionalMethod) -> f32 =
589                    ::core::mem::transmute(__vi.method_ptr);
590                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
591                __inner(__receiver, __mi)
592            }
593        }
594    }
595    #[doc = "`get_clip()` overload"]
596    fn get_clip(self) -> crate::unity_engine::animationclip::AnimationClip {
597        unsafe {
598            let __receiver = <SimpleAnimationPlayable_StateHandle as ::unity::FromIlInstance>::from_il_instance(
599                <Self as ::unity::SystemObject>::as_instance(self),
600            );
601            {
602                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
603                let __vi = *__vt.get(18usize).unwrap_or_else(|| {
604                    panic!(
605                        "unity: virtual slot {}
606 out of range (vtable len {}
607) on the runtime class behind {}
608 (method `{}
609`)",
610                        18usize,
611                        __vt.len(),
612                        <SimpleAnimationPlayable_StateHandle as ::unity::ClassIdentity>::NAME,
613                        "get_clip",
614                    )
615                });
616                let __inner: extern "C" fn(
617                    SimpleAnimationPlayable_StateHandle,
618                    ::unity::OptionalMethod,
619                ) -> crate::unity_engine::animationclip::AnimationClip = ::core::mem::transmute(__vi.method_ptr);
620                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
621                __inner(__receiver, __mi)
622            }
623        }
624    }
625    #[doc = "`get_wrapMode()` overload"]
626    fn get_wrap_mode(self) -> crate::unity_engine::wrapmode::WrapMode {
627        unsafe {
628            let __receiver = <SimpleAnimationPlayable_StateHandle as ::unity::FromIlInstance>::from_il_instance(
629                <Self as ::unity::SystemObject>::as_instance(self),
630            );
631            {
632                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
633                let __vi = *__vt.get(19usize).unwrap_or_else(|| {
634                    panic!(
635                        "unity: virtual slot {}
636 out of range (vtable len {}
637) on the runtime class behind {}
638 (method `{}
639`)",
640                        19usize,
641                        __vt.len(),
642                        <SimpleAnimationPlayable_StateHandle as ::unity::ClassIdentity>::NAME,
643                        "get_wrapMode",
644                    )
645                });
646                let __inner: extern "C" fn(SimpleAnimationPlayable_StateHandle, ::unity::OptionalMethod) -> crate::unity_engine::wrapmode::WrapMode =
647                    ::core::mem::transmute(__vi.method_ptr);
648                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
649                __inner(__receiver, __mi)
650            }
651        }
652    }
653    #[doc = "`get_index()` overload"]
654    fn get_index(self) -> i32 {
655        unsafe {
656            let __receiver = <SimpleAnimationPlayable_StateHandle as ::unity::FromIlInstance>::from_il_instance(
657                <Self as ::unity::SystemObject>::as_instance(self),
658            );
659            ::unity::il2cpp_call!((::unity::module_base()+0x3ef3810usize)as*mut u8,i32;
660(SimpleAnimationPlayable_StateHandle)__receiver)
661        }
662    }
663}
664
665#[cfg(feature = "root-simpleanimationplayable")]
666impl<__T: ISimpleAnimationPlayable_StateHandle> ISimpleAnimationPlayable_StateHandleMethods for __T {}
667
668#[cfg(feature = "root-simpleanimationplayable")]
669impl SimpleAnimationPlayable_StateHandle {
670    pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
671        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
672    }
673
674    pub fn is_valid_method_info() -> &'static ::unity::il2cpp::MethodInfo {
675        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
676    }
677
678    pub fn get_enabled_method_info() -> &'static ::unity::il2cpp::MethodInfo {
679        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
680    }
681
682    pub fn set_enabled_method_info() -> &'static ::unity::il2cpp::MethodInfo {
683        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
684    }
685
686    pub fn get_time_method_info() -> &'static ::unity::il2cpp::MethodInfo {
687        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
688    }
689
690    pub fn set_time_method_info() -> &'static ::unity::il2cpp::MethodInfo {
691        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[5]
692    }
693
694    pub fn get_normalized_time_method_info() -> &'static ::unity::il2cpp::MethodInfo {
695        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[6]
696    }
697
698    pub fn set_normalized_time_method_info() -> &'static ::unity::il2cpp::MethodInfo {
699        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[7]
700    }
701
702    pub fn get_speed_method_info() -> &'static ::unity::il2cpp::MethodInfo {
703        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[8]
704    }
705
706    pub fn set_speed_method_info() -> &'static ::unity::il2cpp::MethodInfo {
707        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[9]
708    }
709
710    pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
711        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[10]
712    }
713
714    pub fn set_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
715        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[11]
716    }
717
718    pub fn get_weight_method_info() -> &'static ::unity::il2cpp::MethodInfo {
719        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[12]
720    }
721
722    pub fn set_weight_method_info() -> &'static ::unity::il2cpp::MethodInfo {
723        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[13]
724    }
725
726    pub fn get_length_method_info() -> &'static ::unity::il2cpp::MethodInfo {
727        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[14]
728    }
729
730    pub fn get_clip_method_info() -> &'static ::unity::il2cpp::MethodInfo {
731        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[15]
732    }
733
734    pub fn get_wrap_mode_method_info() -> &'static ::unity::il2cpp::MethodInfo {
735        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[16]
736    }
737
738    pub fn get_index_method_info() -> &'static ::unity::il2cpp::MethodInfo {
739        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[17]
740    }
741}
742
743#[cfg(feature = "root-simpleanimationplayable")]
744impl SimpleAnimationPlayable_StateHandle {
745    #[doc = "Direct (non-virtual) call to `SimpleAnimationPlayable_StateHandle`'s own `IsValid`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
746    pub unsafe fn is_valid(this: impl ::core::convert::Into<::unity::IlInstance>) -> bool {
747        let __mi = Self::is_valid_method_info();
748        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__mi.method_ptr);
749        __inner(this.into(), ::core::option::Option::None)
750    }
751
752    #[doc = "Direct (non-virtual) call to `SimpleAnimationPlayable_StateHandle`'s own `get_enabled`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
753    pub unsafe fn get_enabled(this: impl ::core::convert::Into<::unity::IlInstance>) -> bool {
754        let __mi = Self::get_enabled_method_info();
755        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__mi.method_ptr);
756        __inner(this.into(), ::core::option::Option::None)
757    }
758
759    #[doc = "Direct (non-virtual) call to `SimpleAnimationPlayable_StateHandle`'s own `set_enabled`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
760    pub unsafe fn set_enabled(this: impl ::core::convert::Into<::unity::IlInstance>, value: bool) -> () {
761        let __mi = Self::set_enabled_method_info();
762        let __inner: extern "C" fn(::unity::IlInstance, bool, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
763        __inner(this.into(), value, ::core::option::Option::None)
764    }
765
766    #[doc = "Direct (non-virtual) call to `SimpleAnimationPlayable_StateHandle`'s own `get_time`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
767    pub unsafe fn get_time(this: impl ::core::convert::Into<::unity::IlInstance>) -> f32 {
768        let __mi = Self::get_time_method_info();
769        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> f32 = ::core::mem::transmute(__mi.method_ptr);
770        __inner(this.into(), ::core::option::Option::None)
771    }
772
773    #[doc = "Direct (non-virtual) call to `SimpleAnimationPlayable_StateHandle`'s own `set_time`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
774    pub unsafe fn set_time(this: impl ::core::convert::Into<::unity::IlInstance>, value: f32) -> () {
775        let __mi = Self::set_time_method_info();
776        let __inner: extern "C" fn(::unity::IlInstance, f32, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
777        __inner(this.into(), value, ::core::option::Option::None)
778    }
779
780    #[doc = "Direct (non-virtual) call to `SimpleAnimationPlayable_StateHandle`'s own `get_normalizedTime`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
781    pub unsafe fn get_normalized_time(this: impl ::core::convert::Into<::unity::IlInstance>) -> f32 {
782        let __mi = Self::get_normalized_time_method_info();
783        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> f32 = ::core::mem::transmute(__mi.method_ptr);
784        __inner(this.into(), ::core::option::Option::None)
785    }
786
787    #[doc = "Direct (non-virtual) call to `SimpleAnimationPlayable_StateHandle`'s own `set_normalizedTime`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
788    pub unsafe fn set_normalized_time(this: impl ::core::convert::Into<::unity::IlInstance>, value: f32) -> () {
789        let __mi = Self::set_normalized_time_method_info();
790        let __inner: extern "C" fn(::unity::IlInstance, f32, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
791        __inner(this.into(), value, ::core::option::Option::None)
792    }
793
794    #[doc = "Direct (non-virtual) call to `SimpleAnimationPlayable_StateHandle`'s own `get_speed`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
795    pub unsafe fn get_speed(this: impl ::core::convert::Into<::unity::IlInstance>) -> f32 {
796        let __mi = Self::get_speed_method_info();
797        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> f32 = ::core::mem::transmute(__mi.method_ptr);
798        __inner(this.into(), ::core::option::Option::None)
799    }
800
801    #[doc = "Direct (non-virtual) call to `SimpleAnimationPlayable_StateHandle`'s own `set_speed`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
802    pub unsafe fn set_speed(this: impl ::core::convert::Into<::unity::IlInstance>, value: f32) -> () {
803        let __mi = Self::set_speed_method_info();
804        let __inner: extern "C" fn(::unity::IlInstance, f32, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
805        __inner(this.into(), value, ::core::option::Option::None)
806    }
807
808    #[doc = "Direct (non-virtual) call to `SimpleAnimationPlayable_StateHandle`'s own `get_name`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
809    pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
810        let __mi = Self::get_name_method_info();
811        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
812        __inner(this.into(), ::core::option::Option::None)
813    }
814
815    #[doc = "Direct (non-virtual) call to `SimpleAnimationPlayable_StateHandle`'s own `set_name`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
816    pub unsafe fn set_name(this: impl ::core::convert::Into<::unity::IlInstance>, value: ::unity::Il2CppString) -> () {
817        let __mi = Self::set_name_method_info();
818        let __inner: extern "C" fn(::unity::IlInstance, ::unity::Il2CppString, ::unity::OptionalMethod) -> () =
819            ::core::mem::transmute(__mi.method_ptr);
820        __inner(this.into(), value, ::core::option::Option::None)
821    }
822
823    #[doc = "Direct (non-virtual) call to `SimpleAnimationPlayable_StateHandle`'s own `get_weight`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
824    pub unsafe fn get_weight(this: impl ::core::convert::Into<::unity::IlInstance>) -> f32 {
825        let __mi = Self::get_weight_method_info();
826        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> f32 = ::core::mem::transmute(__mi.method_ptr);
827        __inner(this.into(), ::core::option::Option::None)
828    }
829
830    #[doc = "Direct (non-virtual) call to `SimpleAnimationPlayable_StateHandle`'s own `set_weight`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
831    pub unsafe fn set_weight(this: impl ::core::convert::Into<::unity::IlInstance>, value: f32) -> () {
832        let __mi = Self::set_weight_method_info();
833        let __inner: extern "C" fn(::unity::IlInstance, f32, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
834        __inner(this.into(), value, ::core::option::Option::None)
835    }
836
837    #[doc = "Direct (non-virtual) call to `SimpleAnimationPlayable_StateHandle`'s own `get_length`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
838    pub unsafe fn get_length(this: impl ::core::convert::Into<::unity::IlInstance>) -> f32 {
839        let __mi = Self::get_length_method_info();
840        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> f32 = ::core::mem::transmute(__mi.method_ptr);
841        __inner(this.into(), ::core::option::Option::None)
842    }
843
844    #[doc = "Direct (non-virtual) call to `SimpleAnimationPlayable_StateHandle`'s own `get_clip`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
845    pub unsafe fn get_clip(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::unity_engine::animationclip::AnimationClip {
846        let __mi = Self::get_clip_method_info();
847        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::unity_engine::animationclip::AnimationClip =
848            ::core::mem::transmute(__mi.method_ptr);
849        __inner(this.into(), ::core::option::Option::None)
850    }
851
852    #[doc = "Direct (non-virtual) call to `SimpleAnimationPlayable_StateHandle`'s own `get_wrapMode`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
853    pub unsafe fn get_wrap_mode(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::unity_engine::wrapmode::WrapMode {
854        let __mi = Self::get_wrap_mode_method_info();
855        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::unity_engine::wrapmode::WrapMode =
856            ::core::mem::transmute(__mi.method_ptr);
857        __inner(this.into(), ::core::option::Option::None)
858    }
859}
860
861#[cfg(feature = "root-simpleanimationplayable")]
862impl SimpleAnimationPlayable_StateHandle {
863    #[doc = "`.ctor(crate::root::simpleanimationplayable::SimpleAnimationPlayable, i32, crate::unity_engine::playables::playable::Playable)` — overload selector"]
864    pub fn new(
865        s: crate::root::simpleanimationplayable::SimpleAnimationPlayable,
866        index: i32,
867        target: crate::unity_engine::playables::playable::Playable,
868    ) -> Self {
869        let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
870            panic!(
871                "{}
872::{}
873 failed to instantiate",
874                ::core::stringify!(SimpleAnimationPlayable_StateHandle),
875                ::core::stringify!(new),
876            )
877        });
878        <Self as ISimpleAnimationPlayable_StateHandleMethods>::ctor(this, s, index, target);
879        this
880    }
881}
882
883#[cfg(feature = "root-simpleanimationplayable")]
884pub trait ISimpleAnimationPlayable_StateManagementMethods: ISimpleAnimationPlayable_StateManagement {
885    #[doc = "`get_Count()` overload"]
886    fn get_count(self) -> i32 {
887        unsafe {
888            let __receiver = <SimpleAnimationPlayable_StateManagement as ::unity::FromIlInstance>::from_il_instance(
889                <Self as ::unity::SystemObject>::as_instance(self),
890            );
891            ::unity::il2cpp_call!((::unity::module_base()+0x3ef3b10usize)as*mut u8,i32;
892(SimpleAnimationPlayable_StateManagement)__receiver)
893        }
894    }
895    #[doc = "`get_Item(i32)` overload"]
896    fn get_item(self, i: impl ::core::convert::Into<i32>) -> crate::root::simpleanimationplayable::SimpleAnimationPlayable_StateInfo {
897        unsafe {
898            let __receiver = <SimpleAnimationPlayable_StateManagement as ::unity::FromIlInstance>::from_il_instance(
899                <Self as ::unity::SystemObject>::as_instance(self),
900            );
901            ::unity::il2cpp_call!((::unity::module_base()+0x3eed8a0usize)as*mut u8,crate::root::simpleanimationplayable::SimpleAnimationPlayable_StateInfo;
902(SimpleAnimationPlayable_StateManagement)__receiver,(i32)::core::convert::Into::into(i))
903        }
904    }
905    #[doc = "`.ctor()` overload"]
906    fn ctor(self) -> () {
907        unsafe {
908            let __receiver = <SimpleAnimationPlayable_StateManagement as ::unity::FromIlInstance>::from_il_instance(
909                <Self as ::unity::SystemObject>::as_instance(self),
910            );
911            ::unity::il2cpp_call!((::unity::module_base()+0x3eedbc0usize)as*mut u8,();
912(SimpleAnimationPlayable_StateManagement)__receiver)
913        }
914    }
915    #[doc = "`InsertState()` overload"]
916    fn insert_state(self) -> crate::root::simpleanimationplayable::SimpleAnimationPlayable_StateInfo {
917        unsafe {
918            let __receiver = <SimpleAnimationPlayable_StateManagement as ::unity::FromIlInstance>::from_il_instance(
919                <Self as ::unity::SystemObject>::as_instance(self),
920            );
921            ::unity::il2cpp_call!((::unity::module_base()+0x3eee330usize)as*mut u8,crate::root::simpleanimationplayable::SimpleAnimationPlayable_StateInfo;
922(SimpleAnimationPlayable_StateManagement)__receiver)
923        }
924    }
925    #[doc = "`AnyStatePlaying()` overload"]
926    fn any_state_playing(self) -> bool {
927        unsafe {
928            let __receiver = <SimpleAnimationPlayable_StateManagement as ::unity::FromIlInstance>::from_il_instance(
929                <Self as ::unity::SystemObject>::as_instance(self),
930            );
931            ::unity::il2cpp_call!((::unity::module_base()+0x3eef1b0usize)as*mut u8,bool;
932(SimpleAnimationPlayable_StateManagement)__receiver)
933        }
934    }
935    #[doc = "`RemoveState(i32)` overload"]
936    fn remove_state(self, index: impl ::core::convert::Into<i32>) -> () {
937        unsafe {
938            let __receiver = <SimpleAnimationPlayable_StateManagement as ::unity::FromIlInstance>::from_il_instance(
939                <Self as ::unity::SystemObject>::as_instance(self),
940            );
941            ::unity::il2cpp_call!((::unity::module_base()+0x3eee840usize)as*mut u8,();
942(SimpleAnimationPlayable_StateManagement)__receiver,(i32)::core::convert::Into::into(index))
943        }
944    }
945    #[doc = "`RemoveClip(crate::unity_engine::animationclip::AnimationClip)` overload"]
946    fn remove_clip(self, clip: impl ::core::convert::Into<crate::unity_engine::animationclip::AnimationClip>) -> bool {
947        unsafe {
948            let __receiver = <SimpleAnimationPlayable_StateManagement as ::unity::FromIlInstance>::from_il_instance(
949                <Self as ::unity::SystemObject>::as_instance(self),
950            );
951            ::unity::il2cpp_call!((::unity::module_base()+0x3eee900usize)as*mut u8,bool;
952(SimpleAnimationPlayable_StateManagement)__receiver,(crate::unity_engine::animationclip::AnimationClip)::core::convert::Into::into(clip))
953        }
954    }
955    #[doc = "`FindState(::unity::Il2CppString)` overload"]
956    fn find_state(
957        self,
958        name: impl ::core::convert::Into<::unity::Il2CppString>,
959    ) -> crate::root::simpleanimationplayable::SimpleAnimationPlayable_StateInfo {
960        unsafe {
961            let __receiver = <SimpleAnimationPlayable_StateManagement as ::unity::FromIlInstance>::from_il_instance(
962                <Self as ::unity::SystemObject>::as_instance(self),
963            );
964            ::unity::il2cpp_call!((::unity::module_base()+0x3eedf80usize)as*mut u8,crate::root::simpleanimationplayable::SimpleAnimationPlayable_StateInfo;
965(SimpleAnimationPlayable_StateManagement)__receiver,(::unity::Il2CppString)::core::convert::Into::into(name))
966        }
967    }
968    #[doc = "`EnableState(i32)` overload"]
969    fn enable_state(self, index: impl ::core::convert::Into<i32>) -> () {
970        unsafe {
971            let __receiver = <SimpleAnimationPlayable_StateManagement as ::unity::FromIlInstance>::from_il_instance(
972                <Self as ::unity::SystemObject>::as_instance(self),
973            );
974            ::unity::il2cpp_call!((::unity::module_base()+0x3eef720usize)as*mut u8,();
975(SimpleAnimationPlayable_StateManagement)__receiver,(i32)::core::convert::Into::into(index))
976        }
977    }
978    #[doc = "`DisableState(i32)` overload"]
979    fn disable_state(self, index: impl ::core::convert::Into<i32>) -> () {
980        unsafe {
981            let __receiver = <SimpleAnimationPlayable_StateManagement as ::unity::FromIlInstance>::from_il_instance(
982                <Self as ::unity::SystemObject>::as_instance(self),
983            );
984            ::unity::il2cpp_call!((::unity::module_base()+0x3ef24d0usize)as*mut u8,();
985(SimpleAnimationPlayable_StateManagement)__receiver,(i32)::core::convert::Into::into(index))
986        }
987    }
988    #[doc = "`SetInputWeight(i32, f32)` overload"]
989    fn set_input_weight(self, index: impl ::core::convert::Into<i32>, weight: impl ::core::convert::Into<f32>) -> () {
990        unsafe {
991            let __receiver = <SimpleAnimationPlayable_StateManagement as ::unity::FromIlInstance>::from_il_instance(
992                <Self as ::unity::SystemObject>::as_instance(self),
993            );
994            ::unity::il2cpp_call!((::unity::module_base()+0x3ef3300usize)as*mut u8,();
995(SimpleAnimationPlayable_StateManagement)__receiver,(i32)::core::convert::Into::into(index),(f32)::core::convert::Into::into(weight))
996        }
997    }
998    #[doc = "`SetStateTime(i32, f32)` overload"]
999    fn set_state_time(self, index: impl ::core::convert::Into<i32>, time: impl ::core::convert::Into<f32>) -> () {
1000        unsafe {
1001            let __receiver = <SimpleAnimationPlayable_StateManagement as ::unity::FromIlInstance>::from_il_instance(
1002                <Self as ::unity::SystemObject>::as_instance(self),
1003            );
1004            ::unity::il2cpp_call!((::unity::module_base()+0x3eef020usize)as*mut u8,();
1005(SimpleAnimationPlayable_StateManagement)__receiver,(i32)::core::convert::Into::into(index),(f32)::core::convert::Into::into(time))
1006        }
1007    }
1008    #[doc = "`GetStateTime(i32)` overload"]
1009    fn get_state_time(self, index: impl ::core::convert::Into<i32>) -> f32 {
1010        unsafe {
1011            let __receiver = <SimpleAnimationPlayable_StateManagement as ::unity::FromIlInstance>::from_il_instance(
1012                <Self as ::unity::SystemObject>::as_instance(self),
1013            );
1014            ::unity::il2cpp_call!((::unity::module_base()+0x3ef0a30usize)as*mut u8,f32;
1015(SimpleAnimationPlayable_StateManagement)__receiver,(i32)::core::convert::Into::into(index))
1016        }
1017    }
1018    #[doc = "`IsCloneOf(i32, i32)` overload"]
1019    fn is_clone_of(self, potential_clone_index: impl ::core::convert::Into<i32>, original_index: impl ::core::convert::Into<i32>) -> bool {
1020        unsafe {
1021            let __receiver = <SimpleAnimationPlayable_StateManagement as ::unity::FromIlInstance>::from_il_instance(
1022                <Self as ::unity::SystemObject>::as_instance(self),
1023            );
1024            ::unity::il2cpp_call!((::unity::module_base()+0x3ef3b30usize)as*mut u8,bool;
1025(SimpleAnimationPlayable_StateManagement)__receiver,(i32)::core::convert::Into::into(potential_clone_index),(i32)::core::convert::Into::into(original_index))
1026        }
1027    }
1028    #[doc = "`GetStateSpeed(i32)` overload"]
1029    fn get_state_speed(self, index: impl ::core::convert::Into<i32>) -> f32 {
1030        unsafe {
1031            let __receiver = <SimpleAnimationPlayable_StateManagement as ::unity::FromIlInstance>::from_il_instance(
1032                <Self as ::unity::SystemObject>::as_instance(self),
1033            );
1034            ::unity::il2cpp_call!((::unity::module_base()+0x3ef2b90usize)as*mut u8,f32;
1035(SimpleAnimationPlayable_StateManagement)__receiver,(i32)::core::convert::Into::into(index))
1036        }
1037    }
1038    #[doc = "`SetStateSpeed(i32, f32)` overload"]
1039    fn set_state_speed(self, index: impl ::core::convert::Into<i32>, value: impl ::core::convert::Into<f32>) -> () {
1040        unsafe {
1041            let __receiver = <SimpleAnimationPlayable_StateManagement as ::unity::FromIlInstance>::from_il_instance(
1042                <Self as ::unity::SystemObject>::as_instance(self),
1043            );
1044            ::unity::il2cpp_call!((::unity::module_base()+0x3ef2d50usize)as*mut u8,();
1045(SimpleAnimationPlayable_StateManagement)__receiver,(i32)::core::convert::Into::into(index),(f32)::core::convert::Into::into(value))
1046        }
1047    }
1048    #[doc = "`GetInputWeight(i32)` overload"]
1049    fn get_input_weight(self, index: impl ::core::convert::Into<i32>) -> f32 {
1050        unsafe {
1051            let __receiver = <SimpleAnimationPlayable_StateManagement as ::unity::FromIlInstance>::from_il_instance(
1052                <Self as ::unity::SystemObject>::as_instance(self),
1053            );
1054            ::unity::il2cpp_call!((::unity::module_base()+0x3ef3bd0usize)as*mut u8,f32;
1055(SimpleAnimationPlayable_StateManagement)__receiver,(i32)::core::convert::Into::into(index))
1056        }
1057    }
1058    #[doc = "`GetStateLength(i32)` overload"]
1059    fn get_state_length(self, index: impl ::core::convert::Into<i32>) -> f32 {
1060        unsafe {
1061            let __receiver = <SimpleAnimationPlayable_StateManagement as ::unity::FromIlInstance>::from_il_instance(
1062                <Self as ::unity::SystemObject>::as_instance(self),
1063            );
1064            ::unity::il2cpp_call!((::unity::module_base()+0x3ef3420usize)as*mut u8,f32;
1065(SimpleAnimationPlayable_StateManagement)__receiver,(i32)::core::convert::Into::into(index))
1066        }
1067    }
1068    #[doc = "`GetClipLength(i32)` overload"]
1069    fn get_clip_length(self, index: impl ::core::convert::Into<i32>) -> f32 {
1070        unsafe {
1071            let __receiver = <SimpleAnimationPlayable_StateManagement as ::unity::FromIlInstance>::from_il_instance(
1072                <Self as ::unity::SystemObject>::as_instance(self),
1073            );
1074            ::unity::il2cpp_call!((::unity::module_base()+0x3ef28b0usize)as*mut u8,f32;
1075(SimpleAnimationPlayable_StateManagement)__receiver,(i32)::core::convert::Into::into(index))
1076        }
1077    }
1078    #[doc = "`GetStatePlayableDuration(i32)` overload"]
1079    fn get_state_playable_duration(self, index: impl ::core::convert::Into<i32>) -> f32 {
1080        unsafe {
1081            let __receiver = <SimpleAnimationPlayable_StateManagement as ::unity::FromIlInstance>::from_il_instance(
1082                <Self as ::unity::SystemObject>::as_instance(self),
1083            );
1084            ::unity::il2cpp_call!((::unity::module_base()+0x3ef3c40usize)as*mut u8,f32;
1085(SimpleAnimationPlayable_StateManagement)__receiver,(i32)::core::convert::Into::into(index))
1086        }
1087    }
1088    #[doc = "`GetStateClip(i32)` overload"]
1089    fn get_state_clip(self, index: impl ::core::convert::Into<i32>) -> crate::unity_engine::animationclip::AnimationClip {
1090        unsafe {
1091            let __receiver = <SimpleAnimationPlayable_StateManagement as ::unity::FromIlInstance>::from_il_instance(
1092                <Self as ::unity::SystemObject>::as_instance(self),
1093            );
1094            ::unity::il2cpp_call!((::unity::module_base()+0x3ef3650usize)as*mut u8,crate::unity_engine::animationclip::AnimationClip;
1095(SimpleAnimationPlayable_StateManagement)__receiver,(i32)::core::convert::Into::into(index))
1096        }
1097    }
1098    #[doc = "`GetStateWrapMode(i32)` overload"]
1099    fn get_state_wrap_mode(self, index: impl ::core::convert::Into<i32>) -> crate::unity_engine::wrapmode::WrapMode {
1100        unsafe {
1101            let __receiver = <SimpleAnimationPlayable_StateManagement as ::unity::FromIlInstance>::from_il_instance(
1102                <Self as ::unity::SystemObject>::as_instance(self),
1103            );
1104            ::unity::il2cpp_call!((::unity::module_base()+0x3ef37a0usize)as*mut u8,crate::unity_engine::wrapmode::WrapMode;
1105(SimpleAnimationPlayable_StateManagement)__receiver,(i32)::core::convert::Into::into(index))
1106        }
1107    }
1108    #[doc = "`GetStateName(i32)` overload"]
1109    fn get_state_name(self, index: impl ::core::convert::Into<i32>) -> ::unity::Il2CppString {
1110        unsafe {
1111            let __receiver = <SimpleAnimationPlayable_StateManagement as ::unity::FromIlInstance>::from_il_instance(
1112                <Self as ::unity::SystemObject>::as_instance(self),
1113            );
1114            ::unity::il2cpp_call!((::unity::module_base()+0x3ef2ee0usize)as*mut u8, ::unity::Il2CppString;
1115(SimpleAnimationPlayable_StateManagement)__receiver,(i32)::core::convert::Into::into(index))
1116        }
1117    }
1118    #[doc = "`SetStateName(i32, ::unity::Il2CppString)` overload"]
1119    fn set_state_name(self, index: impl ::core::convert::Into<i32>, name: impl ::core::convert::Into<::unity::Il2CppString>) -> () {
1120        unsafe {
1121            let __receiver = <SimpleAnimationPlayable_StateManagement as ::unity::FromIlInstance>::from_il_instance(
1122                <Self as ::unity::SystemObject>::as_instance(self),
1123            );
1124            ::unity::il2cpp_call!((::unity::module_base()+0x3ef3070usize)as*mut u8,();
1125(SimpleAnimationPlayable_StateManagement)__receiver,(i32)::core::convert::Into::into(index),(::unity::Il2CppString)::core::convert::Into::into(name))
1126        }
1127    }
1128    #[doc = "`StopState(i32, bool)` overload"]
1129    fn stop_state(self, index: impl ::core::convert::Into<i32>, cleanup: impl ::core::convert::Into<bool>) -> () {
1130        unsafe {
1131            let __receiver = <SimpleAnimationPlayable_StateManagement as ::unity::FromIlInstance>::from_il_instance(
1132                <Self as ::unity::SystemObject>::as_instance(self),
1133            );
1134            ::unity::il2cpp_call!((::unity::module_base()+0x3eef0a0usize)as*mut u8,();
1135(SimpleAnimationPlayable_StateManagement)__receiver,(i32)::core::convert::Into::into(index),(bool)::core::convert::Into::into(cleanup))
1136        }
1137    }
1138}
1139
1140#[cfg(feature = "root-simpleanimationplayable")]
1141impl<__T: ISimpleAnimationPlayable_StateManagement> ISimpleAnimationPlayable_StateManagementMethods for __T {}
1142
1143#[cfg(feature = "root-simpleanimationplayable")]
1144impl SimpleAnimationPlayable_StateManagement {
1145    pub fn get_count_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1146        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
1147    }
1148
1149    pub fn get_item_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1150        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
1151    }
1152
1153    pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1154        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
1155    }
1156
1157    pub fn insert_state_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1158        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
1159    }
1160
1161    pub fn any_state_playing_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1162        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
1163    }
1164
1165    pub fn remove_state_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1166        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[5]
1167    }
1168
1169    pub fn remove_clip_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1170        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[6]
1171    }
1172
1173    pub fn find_state_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1174        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[7]
1175    }
1176
1177    pub fn enable_state_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1178        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[8]
1179    }
1180
1181    pub fn disable_state_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1182        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[9]
1183    }
1184
1185    pub fn set_input_weight_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1186        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[10]
1187    }
1188
1189    pub fn set_state_time_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1190        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[11]
1191    }
1192
1193    pub fn get_state_time_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1194        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[12]
1195    }
1196
1197    pub fn is_clone_of_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1198        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[13]
1199    }
1200
1201    pub fn get_state_speed_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1202        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[14]
1203    }
1204
1205    pub fn set_state_speed_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1206        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[15]
1207    }
1208
1209    pub fn get_input_weight_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1210        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[16]
1211    }
1212
1213    pub fn get_state_length_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1214        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[17]
1215    }
1216
1217    pub fn get_clip_length_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1218        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[18]
1219    }
1220
1221    pub fn get_state_playable_duration_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1222        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[19]
1223    }
1224
1225    pub fn get_state_clip_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1226        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[20]
1227    }
1228
1229    pub fn get_state_wrap_mode_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1230        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[21]
1231    }
1232
1233    pub fn get_state_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1234        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[22]
1235    }
1236
1237    pub fn set_state_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1238        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[23]
1239    }
1240
1241    pub fn stop_state_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1242        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[24]
1243    }
1244}
1245
1246#[cfg(feature = "root-simpleanimationplayable")]
1247impl SimpleAnimationPlayable_StateManagement {
1248    #[doc = "`.ctor()` — no args"]
1249    pub fn new() -> Self {
1250        let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
1251            panic!(
1252                "{}
1253::{}
1254 failed to instantiate",
1255                ::core::stringify!(SimpleAnimationPlayable_StateManagement),
1256                ::core::stringify!(new),
1257            )
1258        });
1259        <Self as ISimpleAnimationPlayable_StateManagementMethods>::ctor(this);
1260        this
1261    }
1262}
1263
1264#[cfg(feature = "root-simpleanimationplayable")]
1265pub trait ISimpleAnimationPlayable_StateInfoMethods: ISimpleAnimationPlayable_StateInfo {
1266    #[doc = "`Initialize(::unity::Il2CppString, crate::unity_engine::animationclip::AnimationClip, crate::unity_engine::wrapmode::WrapMode)` overload"]
1267    fn initialize(
1268        self,
1269        name: impl ::core::convert::Into<::unity::Il2CppString>,
1270        clip: impl ::core::convert::Into<crate::unity_engine::animationclip::AnimationClip>,
1271        wrap_mode: impl ::core::convert::Into<crate::unity_engine::wrapmode::WrapMode>,
1272    ) -> () {
1273        unsafe {
1274            let __receiver =
1275                <SimpleAnimationPlayable_StateInfo as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1276            ::unity::il2cpp_call!((::unity::module_base()+0x3eee510usize)as*mut u8,();
1277(SimpleAnimationPlayable_StateInfo)__receiver,(::unity::Il2CppString)::core::convert::Into::into(name),(crate::unity_engine::animationclip::AnimationClip)::core::convert::Into::into(clip),(crate::unity_engine::wrapmode::WrapMode)::core::convert::Into::into(wrap_mode))
1278        }
1279    }
1280    #[doc = "`GetTime()` overload"]
1281    fn get_time(self) -> f32 {
1282        unsafe {
1283            let __receiver =
1284                <SimpleAnimationPlayable_StateInfo as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1285            ::unity::il2cpp_call!((::unity::module_base()+0x3ef06a0usize)as*mut u8,f32;
1286(SimpleAnimationPlayable_StateInfo)__receiver)
1287        }
1288    }
1289    #[doc = "`SetTime(f32)` overload"]
1290    fn set_time(self, new_time: impl ::core::convert::Into<f32>) -> () {
1291        unsafe {
1292            let __receiver =
1293                <SimpleAnimationPlayable_StateInfo as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1294            ::unity::il2cpp_call!((::unity::module_base()+0x3ef3820usize)as*mut u8,();
1295(SimpleAnimationPlayable_StateInfo)__receiver,(f32)::core::convert::Into::into(new_time))
1296        }
1297    }
1298    #[doc = "`Enable()` overload"]
1299    fn enable(self) -> () {
1300        unsafe {
1301            let __receiver =
1302                <SimpleAnimationPlayable_StateInfo as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1303            ::unity::il2cpp_call!((::unity::module_base()+0x3eeeb80usize)as*mut u8,();
1304(SimpleAnimationPlayable_StateInfo)__receiver)
1305        }
1306    }
1307    #[doc = "`Disable()` overload"]
1308    fn disable(self) -> () {
1309        unsafe {
1310            let __receiver =
1311                <SimpleAnimationPlayable_StateInfo as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1312            ::unity::il2cpp_call!((::unity::module_base()+0x3ef0780usize)as*mut u8,();
1313(SimpleAnimationPlayable_StateInfo)__receiver)
1314        }
1315    }
1316    #[doc = "`Pause()` overload"]
1317    fn pause(self) -> () {
1318        unsafe {
1319            let __receiver =
1320                <SimpleAnimationPlayable_StateInfo as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1321            ::unity::il2cpp_call!((::unity::module_base()+0x3eee560usize)as*mut u8,();
1322(SimpleAnimationPlayable_StateInfo)__receiver)
1323        }
1324    }
1325    #[doc = "`Play()` overload"]
1326    fn play(self) -> () {
1327        unsafe {
1328            let __receiver =
1329                <SimpleAnimationPlayable_StateInfo as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1330            ::unity::il2cpp_call!((::unity::module_base()+0x3ef0580usize)as*mut u8,();
1331(SimpleAnimationPlayable_StateInfo)__receiver)
1332        }
1333    }
1334    #[doc = "`Stop()` overload"]
1335    fn stop(self) -> () {
1336        unsafe {
1337            let __receiver =
1338                <SimpleAnimationPlayable_StateInfo as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1339            ::unity::il2cpp_call!((::unity::module_base()+0x3ef04e0usize)as*mut u8,();
1340(SimpleAnimationPlayable_StateInfo)__receiver)
1341        }
1342    }
1343    #[doc = "`ForceWeight(f32)` overload"]
1344    fn force_weight(self, weight: impl ::core::convert::Into<f32>) -> () {
1345        unsafe {
1346            let __receiver =
1347                <SimpleAnimationPlayable_StateInfo as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1348            ::unity::il2cpp_call!((::unity::module_base()+0x3eeeba0usize)as*mut u8,();
1349(SimpleAnimationPlayable_StateInfo)__receiver,(f32)::core::convert::Into::into(weight))
1350        }
1351    }
1352    #[doc = "`SetWeight(f32)` overload"]
1353    fn set_weight(self, weight: impl ::core::convert::Into<f32>) -> () {
1354        unsafe {
1355            let __receiver =
1356                <SimpleAnimationPlayable_StateInfo as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1357            ::unity::il2cpp_call!((::unity::module_base()+0x3ef04d0usize)as*mut u8,();
1358(SimpleAnimationPlayable_StateInfo)__receiver,(f32)::core::convert::Into::into(weight))
1359        }
1360    }
1361    #[doc = "`FadeTo(f32, f32)` overload"]
1362    fn fade_to(self, weight: impl ::core::convert::Into<f32>, speed: impl ::core::convert::Into<f32>) -> () {
1363        unsafe {
1364            let __receiver =
1365                <SimpleAnimationPlayable_StateInfo as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1366            ::unity::il2cpp_call!((::unity::module_base()+0x3eef490usize)as*mut u8,();
1367(SimpleAnimationPlayable_StateInfo)__receiver,(f32)::core::convert::Into::into(weight),(f32)::core::convert::Into::into(speed))
1368        }
1369    }
1370    #[doc = "`DestroyPlayable()` overload"]
1371    fn destroy_playable(self) -> () {
1372        unsafe {
1373            let __receiver =
1374                <SimpleAnimationPlayable_StateInfo as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1375            ::unity::il2cpp_call!((::unity::module_base()+0x3ef3930usize)as*mut u8,();
1376(SimpleAnimationPlayable_StateInfo)__receiver)
1377        }
1378    }
1379    #[doc = "`SetAsCloneOf(crate::root::simpleanimationplayable::SimpleAnimationPlayable_StateHandle)` overload"]
1380    fn set_as_clone_of(self, handle: impl ::core::convert::Into<crate::root::simpleanimationplayable::SimpleAnimationPlayable_StateHandle>) -> () {
1381        unsafe {
1382            let __receiver =
1383                <SimpleAnimationPlayable_StateInfo as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1384            ::unity::il2cpp_call!((::unity::module_base()+0x3eef7b0usize)as*mut u8,();
1385(SimpleAnimationPlayable_StateInfo)__receiver,(crate::root::simpleanimationplayable::SimpleAnimationPlayable_StateHandle)::core::convert::Into::into(handle))
1386        }
1387    }
1388    #[doc = "`get_enabled()` overload"]
1389    fn get_enabled(self) -> bool {
1390        unsafe {
1391            let __receiver =
1392                <SimpleAnimationPlayable_StateInfo as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1393            ::unity::il2cpp_call!((::unity::module_base()+0x3ef39e0usize)as*mut u8,bool;
1394(SimpleAnimationPlayable_StateInfo)__receiver)
1395        }
1396    }
1397    #[doc = "`get_index()` overload"]
1398    fn get_index(self) -> i32 {
1399        unsafe {
1400            let __receiver =
1401                <SimpleAnimationPlayable_StateInfo as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1402            ::unity::il2cpp_call!((::unity::module_base()+0x3ef39f0usize)as*mut u8,i32;
1403(SimpleAnimationPlayable_StateInfo)__receiver)
1404        }
1405    }
1406    #[doc = "`set_index(i32)` overload"]
1407    fn set_index(self, value: impl ::core::convert::Into<i32>) -> () {
1408        unsafe {
1409            let __receiver =
1410                <SimpleAnimationPlayable_StateInfo as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1411            ::unity::il2cpp_call!((::unity::module_base()+0x3ef3a00usize)as*mut u8,();
1412(SimpleAnimationPlayable_StateInfo)__receiver,(i32)::core::convert::Into::into(value))
1413        }
1414    }
1415    #[doc = "`get_stateName()` overload"]
1416    fn get_state_name(self) -> ::unity::Il2CppString {
1417        unsafe {
1418            let __receiver =
1419                <SimpleAnimationPlayable_StateInfo as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1420            ::unity::il2cpp_call!((::unity::module_base()+0x3ef3a10usize)as*mut u8, ::unity::Il2CppString;
1421(SimpleAnimationPlayable_StateInfo)__receiver)
1422        }
1423    }
1424    #[doc = "`set_stateName(::unity::Il2CppString)` overload"]
1425    fn set_state_name(self, value: impl ::core::convert::Into<::unity::Il2CppString>) -> () {
1426        unsafe {
1427            let __receiver =
1428                <SimpleAnimationPlayable_StateInfo as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1429            ::unity::il2cpp_call!((::unity::module_base()+0x3ef3a20usize)as*mut u8,();
1430(SimpleAnimationPlayable_StateInfo)__receiver,(::unity::Il2CppString)::core::convert::Into::into(value))
1431        }
1432    }
1433    #[doc = "`get_fading()` overload"]
1434    fn get_fading(self) -> bool {
1435        unsafe {
1436            let __receiver =
1437                <SimpleAnimationPlayable_StateInfo as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1438            ::unity::il2cpp_call!((::unity::module_base()+0x3ef3a30usize)as*mut u8,bool;
1439(SimpleAnimationPlayable_StateInfo)__receiver)
1440        }
1441    }
1442    #[doc = "`get_targetWeight()` overload"]
1443    fn get_target_weight(self) -> f32 {
1444        unsafe {
1445            let __receiver =
1446                <SimpleAnimationPlayable_StateInfo as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1447            ::unity::il2cpp_call!((::unity::module_base()+0x3ef3a40usize)as*mut u8,f32;
1448(SimpleAnimationPlayable_StateInfo)__receiver)
1449        }
1450    }
1451    #[doc = "`get_weight()` overload"]
1452    fn get_weight(self) -> f32 {
1453        unsafe {
1454            let __receiver =
1455                <SimpleAnimationPlayable_StateInfo as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1456            ::unity::il2cpp_call!((::unity::module_base()+0x3ef3a50usize)as*mut u8,f32;
1457(SimpleAnimationPlayable_StateInfo)__receiver)
1458        }
1459    }
1460    #[doc = "`get_fadeSpeed()` overload"]
1461    fn get_fade_speed(self) -> f32 {
1462        unsafe {
1463            let __receiver =
1464                <SimpleAnimationPlayable_StateInfo as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1465            ::unity::il2cpp_call!((::unity::module_base()+0x3ef3a60usize)as*mut u8,f32;
1466(SimpleAnimationPlayable_StateInfo)__receiver)
1467        }
1468    }
1469    #[doc = "`get_speed()` overload"]
1470    fn get_speed(self) -> f32 {
1471        unsafe {
1472            let __receiver =
1473                <SimpleAnimationPlayable_StateInfo as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1474            ::unity::il2cpp_call!((::unity::module_base()+0x3ef0640usize)as*mut u8,f32;
1475(SimpleAnimationPlayable_StateInfo)__receiver)
1476        }
1477    }
1478    #[doc = "`set_speed(f32)` overload"]
1479    fn set_speed(self, value: impl ::core::convert::Into<f32>) -> () {
1480        unsafe {
1481            let __receiver =
1482                <SimpleAnimationPlayable_StateInfo as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1483            ::unity::il2cpp_call!((::unity::module_base()+0x3ef1130usize)as*mut u8,();
1484(SimpleAnimationPlayable_StateInfo)__receiver,(f32)::core::convert::Into::into(value))
1485        }
1486    }
1487    #[doc = "`get_playableDuration()` overload"]
1488    fn get_playable_duration(self) -> f32 {
1489        unsafe {
1490            let __receiver =
1491                <SimpleAnimationPlayable_StateInfo as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1492            ::unity::il2cpp_call!((::unity::module_base()+0x3ef0720usize)as*mut u8,f32;
1493(SimpleAnimationPlayable_StateInfo)__receiver)
1494        }
1495    }
1496    #[doc = "`get_clip()` overload"]
1497    fn get_clip(self) -> crate::unity_engine::animationclip::AnimationClip {
1498        unsafe {
1499            let __receiver =
1500                <SimpleAnimationPlayable_StateInfo as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1501            ::unity::il2cpp_call!((::unity::module_base()+0x3ef3a70usize)as*mut u8,crate::unity_engine::animationclip::AnimationClip;
1502(SimpleAnimationPlayable_StateInfo)__receiver)
1503        }
1504    }
1505    #[doc = "`SetPlayable(crate::unity_engine::playables::playable::Playable)` overload"]
1506    fn set_playable(self, playable: impl ::core::convert::Into<crate::unity_engine::playables::playable::Playable>) -> () {
1507        unsafe {
1508            let __receiver =
1509                <SimpleAnimationPlayable_StateInfo as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1510            ::unity::il2cpp_call!((::unity::module_base()+0x3ef3a80usize)as*mut u8,();
1511(SimpleAnimationPlayable_StateInfo)__receiver,(crate::unity_engine::playables::playable::Playable)::core::convert::Into::into(playable))
1512        }
1513    }
1514    #[doc = "`get_isDone()` overload"]
1515    fn get_is_done(self) -> bool {
1516        unsafe {
1517            let __receiver =
1518                <SimpleAnimationPlayable_StateInfo as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1519            ::unity::il2cpp_call!((::unity::module_base()+0x3ef05e0usize)as*mut u8,bool;
1520(SimpleAnimationPlayable_StateInfo)__receiver)
1521        }
1522    }
1523    #[doc = "`get_playable()` overload"]
1524    fn get_playable(self) -> crate::unity_engine::playables::playable::Playable {
1525        unsafe {
1526            let __receiver =
1527                <SimpleAnimationPlayable_StateInfo as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1528            ::unity::il2cpp_call!((::unity::module_base()+0x3ef3a90usize)as*mut u8,crate::unity_engine::playables::playable::Playable;
1529(SimpleAnimationPlayable_StateInfo)__receiver)
1530        }
1531    }
1532    #[doc = "`get_wrapMode()` overload"]
1533    fn get_wrap_mode(self) -> crate::unity_engine::wrapmode::WrapMode {
1534        unsafe {
1535            let __receiver =
1536                <SimpleAnimationPlayable_StateInfo as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1537            ::unity::il2cpp_call!((::unity::module_base()+0x3ef3aa0usize)as*mut u8,crate::unity_engine::wrapmode::WrapMode;
1538(SimpleAnimationPlayable_StateInfo)__receiver)
1539        }
1540    }
1541    #[doc = "`get_isClone()` overload"]
1542    fn get_is_clone(self) -> bool {
1543        unsafe {
1544            let __receiver =
1545                <SimpleAnimationPlayable_StateInfo as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1546            ::unity::il2cpp_call!((::unity::module_base()+0x3ef3ab0usize)as*mut u8,bool;
1547(SimpleAnimationPlayable_StateInfo)__receiver)
1548        }
1549    }
1550    #[doc = "`get_isReadyForCleanup()` overload"]
1551    fn get_is_ready_for_cleanup(self) -> bool {
1552        unsafe {
1553            let __receiver =
1554                <SimpleAnimationPlayable_StateInfo as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1555            ::unity::il2cpp_call!((::unity::module_base()+0x3ef3ac0usize)as*mut u8,bool;
1556(SimpleAnimationPlayable_StateInfo)__receiver)
1557        }
1558    }
1559    #[doc = "`get_parentState()` overload"]
1560    fn get_parent_state(self) -> crate::root::simpleanimationplayable::SimpleAnimationPlayable_StateHandle {
1561        unsafe {
1562            let __receiver =
1563                <SimpleAnimationPlayable_StateInfo as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1564            ::unity::il2cpp_call!((::unity::module_base()+0x3ef3ad0usize)as*mut u8,crate::root::simpleanimationplayable::SimpleAnimationPlayable_StateHandle;
1565(SimpleAnimationPlayable_StateInfo)__receiver)
1566        }
1567    }
1568    #[doc = "`get_enabledDirty()` overload"]
1569    fn get_enabled_dirty(self) -> bool {
1570        unsafe {
1571            let __receiver =
1572                <SimpleAnimationPlayable_StateInfo as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1573            ::unity::il2cpp_call!((::unity::module_base()+0x3ef3ae0usize)as*mut u8,bool;
1574(SimpleAnimationPlayable_StateInfo)__receiver)
1575        }
1576    }
1577    #[doc = "`get_weightDirty()` overload"]
1578    fn get_weight_dirty(self) -> bool {
1579        unsafe {
1580            let __receiver =
1581                <SimpleAnimationPlayable_StateInfo as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1582            ::unity::il2cpp_call!((::unity::module_base()+0x3ef3af0usize)as*mut u8,bool;
1583(SimpleAnimationPlayable_StateInfo)__receiver)
1584        }
1585    }
1586    #[doc = "`ResetDirtyFlags()` overload"]
1587    fn reset_dirty_flags(self) -> () {
1588        unsafe {
1589            let __receiver =
1590                <SimpleAnimationPlayable_StateInfo as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1591            ::unity::il2cpp_call!((::unity::module_base()+0x3ef07a0usize)as*mut u8,();
1592(SimpleAnimationPlayable_StateInfo)__receiver)
1593        }
1594    }
1595    #[doc = "`InvalidateTime()` overload"]
1596    fn invalidate_time(self) -> () {
1597        unsafe {
1598            let __receiver =
1599                <SimpleAnimationPlayable_StateInfo as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1600            ::unity::il2cpp_call!((::unity::module_base()+0x3ef0e70usize)as*mut u8,();
1601(SimpleAnimationPlayable_StateInfo)__receiver)
1602        }
1603    }
1604    #[doc = "`.ctor()` overload"]
1605    fn ctor(self) -> () {
1606        unsafe {
1607            let __receiver =
1608                <SimpleAnimationPlayable_StateInfo as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1609            ::unity::il2cpp_call!((::unity::module_base()+0x3ef3b00usize)as*mut u8,();
1610(SimpleAnimationPlayable_StateInfo)__receiver)
1611        }
1612    }
1613}
1614
1615#[cfg(feature = "root-simpleanimationplayable")]
1616impl<__T: ISimpleAnimationPlayable_StateInfo> ISimpleAnimationPlayable_StateInfoMethods for __T {}
1617
1618#[cfg(feature = "root-simpleanimationplayable")]
1619impl SimpleAnimationPlayable_StateInfo {
1620    pub fn initialize_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1621        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
1622    }
1623
1624    pub fn get_time_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1625        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
1626    }
1627
1628    pub fn set_time_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1629        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
1630    }
1631
1632    pub fn enable_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1633        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
1634    }
1635
1636    pub fn disable_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1637        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
1638    }
1639
1640    pub fn pause_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1641        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[5]
1642    }
1643
1644    pub fn play_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1645        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[6]
1646    }
1647
1648    pub fn stop_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1649        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[7]
1650    }
1651
1652    pub fn force_weight_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1653        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[8]
1654    }
1655
1656    pub fn set_weight_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1657        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[9]
1658    }
1659
1660    pub fn fade_to_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1661        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[10]
1662    }
1663
1664    pub fn destroy_playable_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1665        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[11]
1666    }
1667
1668    pub fn set_as_clone_of_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1669        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[12]
1670    }
1671
1672    pub fn get_enabled_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1673        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[13]
1674    }
1675
1676    pub fn get_index_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1677        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[14]
1678    }
1679
1680    pub fn set_index_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1681        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[15]
1682    }
1683
1684    pub fn get_state_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1685        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[16]
1686    }
1687
1688    pub fn set_state_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1689        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[17]
1690    }
1691
1692    pub fn get_fading_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1693        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[18]
1694    }
1695
1696    pub fn get_target_weight_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1697        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[19]
1698    }
1699
1700    pub fn get_weight_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1701        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[20]
1702    }
1703
1704    pub fn get_fade_speed_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1705        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[21]
1706    }
1707
1708    pub fn get_speed_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1709        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[22]
1710    }
1711
1712    pub fn set_speed_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1713        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[23]
1714    }
1715
1716    pub fn get_playable_duration_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1717        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[24]
1718    }
1719
1720    pub fn get_clip_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1721        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[25]
1722    }
1723
1724    pub fn set_playable_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1725        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[26]
1726    }
1727
1728    pub fn get_is_done_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1729        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[27]
1730    }
1731
1732    pub fn get_playable_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1733        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[28]
1734    }
1735
1736    pub fn get_wrap_mode_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1737        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[29]
1738    }
1739
1740    pub fn get_is_clone_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1741        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[30]
1742    }
1743
1744    pub fn get_is_ready_for_cleanup_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1745        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[31]
1746    }
1747
1748    pub fn get_parent_state_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1749        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[32]
1750    }
1751
1752    pub fn get_enabled_dirty_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1753        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[33]
1754    }
1755
1756    pub fn get_weight_dirty_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1757        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[34]
1758    }
1759
1760    pub fn reset_dirty_flags_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1761        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[35]
1762    }
1763
1764    pub fn invalidate_time_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1765        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[36]
1766    }
1767
1768    pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1769        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[37]
1770    }
1771}
1772
1773#[cfg(feature = "root-simpleanimationplayable")]
1774impl SimpleAnimationPlayable_StateInfo {
1775    #[doc = "`.ctor()` — no args"]
1776    pub fn new() -> Self {
1777        let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
1778            panic!(
1779                "{}
1780::{}
1781 failed to instantiate",
1782                ::core::stringify!(SimpleAnimationPlayable_StateInfo),
1783                ::core::stringify!(new),
1784            )
1785        });
1786        <Self as ISimpleAnimationPlayable_StateInfoMethods>::ctor(this);
1787        this
1788    }
1789}
1790
1791#[cfg(feature = "root-simpleanimationplayable")]
1792pub trait ISimpleAnimationPlayable_IStateMethods: ISimpleAnimationPlayable_IState {
1793    #[doc = "`IsValid()` overload"]
1794    fn is_valid(self) -> bool {
1795        unsafe {
1796            let __receiver =
1797                <SimpleAnimationPlayable_IState as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1798            {
1799                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1800                let __vi = *__vt.get(0usize).unwrap_or_else(|| {
1801                    panic!(
1802                        "unity: virtual slot {}
1803 out of range (vtable len {}
1804) on the runtime class behind {}
1805 (method `{}
1806`)",
1807                        0usize,
1808                        __vt.len(),
1809                        <SimpleAnimationPlayable_IState as ::unity::ClassIdentity>::NAME,
1810                        "IsValid",
1811                    )
1812                });
1813                let __inner: extern "C" fn(SimpleAnimationPlayable_IState, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__vi.method_ptr);
1814                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1815                __inner(__receiver, __mi)
1816            }
1817        }
1818    }
1819    #[doc = "`get_enabled()` overload"]
1820    fn get_enabled(self) -> bool {
1821        unsafe {
1822            let __receiver =
1823                <SimpleAnimationPlayable_IState as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1824            {
1825                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1826                let __vi = *__vt.get(1usize).unwrap_or_else(|| {
1827                    panic!(
1828                        "unity: virtual slot {}
1829 out of range (vtable len {}
1830) on the runtime class behind {}
1831 (method `{}
1832`)",
1833                        1usize,
1834                        __vt.len(),
1835                        <SimpleAnimationPlayable_IState as ::unity::ClassIdentity>::NAME,
1836                        "get_enabled",
1837                    )
1838                });
1839                let __inner: extern "C" fn(SimpleAnimationPlayable_IState, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__vi.method_ptr);
1840                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1841                __inner(__receiver, __mi)
1842            }
1843        }
1844    }
1845    #[doc = "`set_enabled(bool)` overload"]
1846    fn set_enabled(self, value: impl ::core::convert::Into<bool>) -> () {
1847        unsafe {
1848            let __receiver =
1849                <SimpleAnimationPlayable_IState as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1850            {
1851                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1852                let __vi = *__vt.get(2usize).unwrap_or_else(|| {
1853                    panic!(
1854                        "unity: virtual slot {}
1855 out of range (vtable len {}
1856) on the runtime class behind {}
1857 (method `{}
1858`)",
1859                        2usize,
1860                        __vt.len(),
1861                        <SimpleAnimationPlayable_IState as ::unity::ClassIdentity>::NAME,
1862                        "set_enabled",
1863                    )
1864                });
1865                let __inner: extern "C" fn(SimpleAnimationPlayable_IState, bool, ::unity::OptionalMethod) -> () =
1866                    ::core::mem::transmute(__vi.method_ptr);
1867                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1868                __inner(__receiver, ::core::convert::Into::into(value), __mi)
1869            }
1870        }
1871    }
1872    #[doc = "`get_time()` overload"]
1873    fn get_time(self) -> f32 {
1874        unsafe {
1875            let __receiver =
1876                <SimpleAnimationPlayable_IState as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1877            {
1878                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1879                let __vi = *__vt.get(3usize).unwrap_or_else(|| {
1880                    panic!(
1881                        "unity: virtual slot {}
1882 out of range (vtable len {}
1883) on the runtime class behind {}
1884 (method `{}
1885`)",
1886                        3usize,
1887                        __vt.len(),
1888                        <SimpleAnimationPlayable_IState as ::unity::ClassIdentity>::NAME,
1889                        "get_time",
1890                    )
1891                });
1892                let __inner: extern "C" fn(SimpleAnimationPlayable_IState, ::unity::OptionalMethod) -> f32 = ::core::mem::transmute(__vi.method_ptr);
1893                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1894                __inner(__receiver, __mi)
1895            }
1896        }
1897    }
1898    #[doc = "`set_time(f32)` overload"]
1899    fn set_time(self, value: impl ::core::convert::Into<f32>) -> () {
1900        unsafe {
1901            let __receiver =
1902                <SimpleAnimationPlayable_IState as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1903            {
1904                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1905                let __vi = *__vt.get(4usize).unwrap_or_else(|| {
1906                    panic!(
1907                        "unity: virtual slot {}
1908 out of range (vtable len {}
1909) on the runtime class behind {}
1910 (method `{}
1911`)",
1912                        4usize,
1913                        __vt.len(),
1914                        <SimpleAnimationPlayable_IState as ::unity::ClassIdentity>::NAME,
1915                        "set_time",
1916                    )
1917                });
1918                let __inner: extern "C" fn(SimpleAnimationPlayable_IState, f32, ::unity::OptionalMethod) -> () =
1919                    ::core::mem::transmute(__vi.method_ptr);
1920                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1921                __inner(__receiver, ::core::convert::Into::into(value), __mi)
1922            }
1923        }
1924    }
1925    #[doc = "`get_normalizedTime()` overload"]
1926    fn get_normalized_time(self) -> f32 {
1927        unsafe {
1928            let __receiver =
1929                <SimpleAnimationPlayable_IState as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1930            {
1931                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1932                let __vi = *__vt.get(5usize).unwrap_or_else(|| {
1933                    panic!(
1934                        "unity: virtual slot {}
1935 out of range (vtable len {}
1936) on the runtime class behind {}
1937 (method `{}
1938`)",
1939                        5usize,
1940                        __vt.len(),
1941                        <SimpleAnimationPlayable_IState as ::unity::ClassIdentity>::NAME,
1942                        "get_normalizedTime",
1943                    )
1944                });
1945                let __inner: extern "C" fn(SimpleAnimationPlayable_IState, ::unity::OptionalMethod) -> f32 = ::core::mem::transmute(__vi.method_ptr);
1946                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1947                __inner(__receiver, __mi)
1948            }
1949        }
1950    }
1951    #[doc = "`set_normalizedTime(f32)` overload"]
1952    fn set_normalized_time(self, value: impl ::core::convert::Into<f32>) -> () {
1953        unsafe {
1954            let __receiver =
1955                <SimpleAnimationPlayable_IState as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1956            {
1957                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1958                let __vi = *__vt.get(6usize).unwrap_or_else(|| {
1959                    panic!(
1960                        "unity: virtual slot {}
1961 out of range (vtable len {}
1962) on the runtime class behind {}
1963 (method `{}
1964`)",
1965                        6usize,
1966                        __vt.len(),
1967                        <SimpleAnimationPlayable_IState as ::unity::ClassIdentity>::NAME,
1968                        "set_normalizedTime",
1969                    )
1970                });
1971                let __inner: extern "C" fn(SimpleAnimationPlayable_IState, f32, ::unity::OptionalMethod) -> () =
1972                    ::core::mem::transmute(__vi.method_ptr);
1973                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1974                __inner(__receiver, ::core::convert::Into::into(value), __mi)
1975            }
1976        }
1977    }
1978    #[doc = "`get_speed()` overload"]
1979    fn get_speed(self) -> f32 {
1980        unsafe {
1981            let __receiver =
1982                <SimpleAnimationPlayable_IState as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1983            {
1984                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1985                let __vi = *__vt.get(7usize).unwrap_or_else(|| {
1986                    panic!(
1987                        "unity: virtual slot {}
1988 out of range (vtable len {}
1989) on the runtime class behind {}
1990 (method `{}
1991`)",
1992                        7usize,
1993                        __vt.len(),
1994                        <SimpleAnimationPlayable_IState as ::unity::ClassIdentity>::NAME,
1995                        "get_speed",
1996                    )
1997                });
1998                let __inner: extern "C" fn(SimpleAnimationPlayable_IState, ::unity::OptionalMethod) -> f32 = ::core::mem::transmute(__vi.method_ptr);
1999                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2000                __inner(__receiver, __mi)
2001            }
2002        }
2003    }
2004    #[doc = "`set_speed(f32)` overload"]
2005    fn set_speed(self, value: impl ::core::convert::Into<f32>) -> () {
2006        unsafe {
2007            let __receiver =
2008                <SimpleAnimationPlayable_IState as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2009            {
2010                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2011                let __vi = *__vt.get(8usize).unwrap_or_else(|| {
2012                    panic!(
2013                        "unity: virtual slot {}
2014 out of range (vtable len {}
2015) on the runtime class behind {}
2016 (method `{}
2017`)",
2018                        8usize,
2019                        __vt.len(),
2020                        <SimpleAnimationPlayable_IState as ::unity::ClassIdentity>::NAME,
2021                        "set_speed",
2022                    )
2023                });
2024                let __inner: extern "C" fn(SimpleAnimationPlayable_IState, f32, ::unity::OptionalMethod) -> () =
2025                    ::core::mem::transmute(__vi.method_ptr);
2026                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2027                __inner(__receiver, ::core::convert::Into::into(value), __mi)
2028            }
2029        }
2030    }
2031    #[doc = "`get_name()` overload"]
2032    fn get_name(self) -> ::unity::Il2CppString {
2033        unsafe {
2034            let __receiver =
2035                <SimpleAnimationPlayable_IState as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2036            {
2037                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2038                let __vi = *__vt.get(9usize).unwrap_or_else(|| {
2039                    panic!(
2040                        "unity: virtual slot {}
2041 out of range (vtable len {}
2042) on the runtime class behind {}
2043 (method `{}
2044`)",
2045                        9usize,
2046                        __vt.len(),
2047                        <SimpleAnimationPlayable_IState as ::unity::ClassIdentity>::NAME,
2048                        "get_name",
2049                    )
2050                });
2051                let __inner: extern "C" fn(SimpleAnimationPlayable_IState, ::unity::OptionalMethod) -> ::unity::Il2CppString =
2052                    ::core::mem::transmute(__vi.method_ptr);
2053                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2054                __inner(__receiver, __mi)
2055            }
2056        }
2057    }
2058    #[doc = "`set_name(::unity::Il2CppString)` overload"]
2059    fn set_name(self, value: impl ::core::convert::Into<::unity::Il2CppString>) -> () {
2060        unsafe {
2061            let __receiver =
2062                <SimpleAnimationPlayable_IState as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2063            {
2064                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2065                let __vi = *__vt.get(10usize).unwrap_or_else(|| {
2066                    panic!(
2067                        "unity: virtual slot {}
2068 out of range (vtable len {}
2069) on the runtime class behind {}
2070 (method `{}
2071`)",
2072                        10usize,
2073                        __vt.len(),
2074                        <SimpleAnimationPlayable_IState as ::unity::ClassIdentity>::NAME,
2075                        "set_name",
2076                    )
2077                });
2078                let __inner: extern "C" fn(SimpleAnimationPlayable_IState, ::unity::Il2CppString, ::unity::OptionalMethod) -> () =
2079                    ::core::mem::transmute(__vi.method_ptr);
2080                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2081                __inner(__receiver, ::core::convert::Into::into(value), __mi)
2082            }
2083        }
2084    }
2085    #[doc = "`get_weight()` overload"]
2086    fn get_weight(self) -> f32 {
2087        unsafe {
2088            let __receiver =
2089                <SimpleAnimationPlayable_IState as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2090            {
2091                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2092                let __vi = *__vt.get(11usize).unwrap_or_else(|| {
2093                    panic!(
2094                        "unity: virtual slot {}
2095 out of range (vtable len {}
2096) on the runtime class behind {}
2097 (method `{}
2098`)",
2099                        11usize,
2100                        __vt.len(),
2101                        <SimpleAnimationPlayable_IState as ::unity::ClassIdentity>::NAME,
2102                        "get_weight",
2103                    )
2104                });
2105                let __inner: extern "C" fn(SimpleAnimationPlayable_IState, ::unity::OptionalMethod) -> f32 = ::core::mem::transmute(__vi.method_ptr);
2106                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2107                __inner(__receiver, __mi)
2108            }
2109        }
2110    }
2111    #[doc = "`set_weight(f32)` overload"]
2112    fn set_weight(self, value: impl ::core::convert::Into<f32>) -> () {
2113        unsafe {
2114            let __receiver =
2115                <SimpleAnimationPlayable_IState as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2116            {
2117                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2118                let __vi = *__vt.get(12usize).unwrap_or_else(|| {
2119                    panic!(
2120                        "unity: virtual slot {}
2121 out of range (vtable len {}
2122) on the runtime class behind {}
2123 (method `{}
2124`)",
2125                        12usize,
2126                        __vt.len(),
2127                        <SimpleAnimationPlayable_IState as ::unity::ClassIdentity>::NAME,
2128                        "set_weight",
2129                    )
2130                });
2131                let __inner: extern "C" fn(SimpleAnimationPlayable_IState, f32, ::unity::OptionalMethod) -> () =
2132                    ::core::mem::transmute(__vi.method_ptr);
2133                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2134                __inner(__receiver, ::core::convert::Into::into(value), __mi)
2135            }
2136        }
2137    }
2138    #[doc = "`get_length()` overload"]
2139    fn get_length(self) -> f32 {
2140        unsafe {
2141            let __receiver =
2142                <SimpleAnimationPlayable_IState as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2143            {
2144                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2145                let __vi = *__vt.get(13usize).unwrap_or_else(|| {
2146                    panic!(
2147                        "unity: virtual slot {}
2148 out of range (vtable len {}
2149) on the runtime class behind {}
2150 (method `{}
2151`)",
2152                        13usize,
2153                        __vt.len(),
2154                        <SimpleAnimationPlayable_IState as ::unity::ClassIdentity>::NAME,
2155                        "get_length",
2156                    )
2157                });
2158                let __inner: extern "C" fn(SimpleAnimationPlayable_IState, ::unity::OptionalMethod) -> f32 = ::core::mem::transmute(__vi.method_ptr);
2159                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2160                __inner(__receiver, __mi)
2161            }
2162        }
2163    }
2164    #[doc = "`get_clip()` overload"]
2165    fn get_clip(self) -> crate::unity_engine::animationclip::AnimationClip {
2166        unsafe {
2167            let __receiver =
2168                <SimpleAnimationPlayable_IState as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2169            {
2170                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2171                let __vi = *__vt.get(14usize).unwrap_or_else(|| {
2172                    panic!(
2173                        "unity: virtual slot {}
2174 out of range (vtable len {}
2175) on the runtime class behind {}
2176 (method `{}
2177`)",
2178                        14usize,
2179                        __vt.len(),
2180                        <SimpleAnimationPlayable_IState as ::unity::ClassIdentity>::NAME,
2181                        "get_clip",
2182                    )
2183                });
2184                let __inner: extern "C" fn(
2185                    SimpleAnimationPlayable_IState,
2186                    ::unity::OptionalMethod,
2187                ) -> crate::unity_engine::animationclip::AnimationClip = ::core::mem::transmute(__vi.method_ptr);
2188                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2189                __inner(__receiver, __mi)
2190            }
2191        }
2192    }
2193    #[doc = "`get_wrapMode()` overload"]
2194    fn get_wrap_mode(self) -> crate::unity_engine::wrapmode::WrapMode {
2195        unsafe {
2196            let __receiver =
2197                <SimpleAnimationPlayable_IState as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2198            {
2199                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2200                let __vi = *__vt.get(15usize).unwrap_or_else(|| {
2201                    panic!(
2202                        "unity: virtual slot {}
2203 out of range (vtable len {}
2204) on the runtime class behind {}
2205 (method `{}
2206`)",
2207                        15usize,
2208                        __vt.len(),
2209                        <SimpleAnimationPlayable_IState as ::unity::ClassIdentity>::NAME,
2210                        "get_wrapMode",
2211                    )
2212                });
2213                let __inner: extern "C" fn(SimpleAnimationPlayable_IState, ::unity::OptionalMethod) -> crate::unity_engine::wrapmode::WrapMode =
2214                    ::core::mem::transmute(__vi.method_ptr);
2215                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2216                __inner(__receiver, __mi)
2217            }
2218        }
2219    }
2220}
2221
2222#[cfg(feature = "root-simpleanimationplayable")]
2223impl<__T: ISimpleAnimationPlayable_IState> ISimpleAnimationPlayable_IStateMethods for __T {}
2224
2225#[cfg(feature = "root-simpleanimationplayable")]
2226impl SimpleAnimationPlayable_IState {
2227    pub fn is_valid_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2228        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
2229    }
2230
2231    pub fn get_enabled_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2232        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
2233    }
2234
2235    pub fn set_enabled_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2236        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
2237    }
2238
2239    pub fn get_time_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2240        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
2241    }
2242
2243    pub fn set_time_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2244        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
2245    }
2246
2247    pub fn get_normalized_time_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2248        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[5]
2249    }
2250
2251    pub fn set_normalized_time_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2252        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[6]
2253    }
2254
2255    pub fn get_speed_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2256        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[7]
2257    }
2258
2259    pub fn set_speed_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2260        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[8]
2261    }
2262
2263    pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2264        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[9]
2265    }
2266
2267    pub fn set_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2268        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[10]
2269    }
2270
2271    pub fn get_weight_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2272        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[11]
2273    }
2274
2275    pub fn set_weight_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2276        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[12]
2277    }
2278
2279    pub fn get_length_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2280        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[13]
2281    }
2282
2283    pub fn get_clip_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2284        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[14]
2285    }
2286
2287    pub fn get_wrap_mode_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2288        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[15]
2289    }
2290}
2291
2292#[cfg(feature = "root-simpleanimationplayable")]
2293impl SimpleAnimationPlayable_IState {
2294    #[doc = "Direct (non-virtual) call to `SimpleAnimationPlayable_IState`'s own `IsValid`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2295    pub unsafe fn is_valid(this: impl ::core::convert::Into<::unity::IlInstance>) -> bool {
2296        let __mi = Self::is_valid_method_info();
2297        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__mi.method_ptr);
2298        __inner(this.into(), ::core::option::Option::None)
2299    }
2300
2301    #[doc = "Direct (non-virtual) call to `SimpleAnimationPlayable_IState`'s own `get_enabled`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2302    pub unsafe fn get_enabled(this: impl ::core::convert::Into<::unity::IlInstance>) -> bool {
2303        let __mi = Self::get_enabled_method_info();
2304        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__mi.method_ptr);
2305        __inner(this.into(), ::core::option::Option::None)
2306    }
2307
2308    #[doc = "Direct (non-virtual) call to `SimpleAnimationPlayable_IState`'s own `set_enabled`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2309    pub unsafe fn set_enabled(this: impl ::core::convert::Into<::unity::IlInstance>, value: bool) -> () {
2310        let __mi = Self::set_enabled_method_info();
2311        let __inner: extern "C" fn(::unity::IlInstance, bool, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
2312        __inner(this.into(), value, ::core::option::Option::None)
2313    }
2314
2315    #[doc = "Direct (non-virtual) call to `SimpleAnimationPlayable_IState`'s own `get_time`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2316    pub unsafe fn get_time(this: impl ::core::convert::Into<::unity::IlInstance>) -> f32 {
2317        let __mi = Self::get_time_method_info();
2318        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> f32 = ::core::mem::transmute(__mi.method_ptr);
2319        __inner(this.into(), ::core::option::Option::None)
2320    }
2321
2322    #[doc = "Direct (non-virtual) call to `SimpleAnimationPlayable_IState`'s own `set_time`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2323    pub unsafe fn set_time(this: impl ::core::convert::Into<::unity::IlInstance>, value: f32) -> () {
2324        let __mi = Self::set_time_method_info();
2325        let __inner: extern "C" fn(::unity::IlInstance, f32, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
2326        __inner(this.into(), value, ::core::option::Option::None)
2327    }
2328
2329    #[doc = "Direct (non-virtual) call to `SimpleAnimationPlayable_IState`'s own `get_normalizedTime`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2330    pub unsafe fn get_normalized_time(this: impl ::core::convert::Into<::unity::IlInstance>) -> f32 {
2331        let __mi = Self::get_normalized_time_method_info();
2332        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> f32 = ::core::mem::transmute(__mi.method_ptr);
2333        __inner(this.into(), ::core::option::Option::None)
2334    }
2335
2336    #[doc = "Direct (non-virtual) call to `SimpleAnimationPlayable_IState`'s own `set_normalizedTime`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2337    pub unsafe fn set_normalized_time(this: impl ::core::convert::Into<::unity::IlInstance>, value: f32) -> () {
2338        let __mi = Self::set_normalized_time_method_info();
2339        let __inner: extern "C" fn(::unity::IlInstance, f32, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
2340        __inner(this.into(), value, ::core::option::Option::None)
2341    }
2342
2343    #[doc = "Direct (non-virtual) call to `SimpleAnimationPlayable_IState`'s own `get_speed`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2344    pub unsafe fn get_speed(this: impl ::core::convert::Into<::unity::IlInstance>) -> f32 {
2345        let __mi = Self::get_speed_method_info();
2346        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> f32 = ::core::mem::transmute(__mi.method_ptr);
2347        __inner(this.into(), ::core::option::Option::None)
2348    }
2349
2350    #[doc = "Direct (non-virtual) call to `SimpleAnimationPlayable_IState`'s own `set_speed`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2351    pub unsafe fn set_speed(this: impl ::core::convert::Into<::unity::IlInstance>, value: f32) -> () {
2352        let __mi = Self::set_speed_method_info();
2353        let __inner: extern "C" fn(::unity::IlInstance, f32, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
2354        __inner(this.into(), value, ::core::option::Option::None)
2355    }
2356
2357    #[doc = "Direct (non-virtual) call to `SimpleAnimationPlayable_IState`'s own `get_name`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2358    pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
2359        let __mi = Self::get_name_method_info();
2360        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
2361        __inner(this.into(), ::core::option::Option::None)
2362    }
2363
2364    #[doc = "Direct (non-virtual) call to `SimpleAnimationPlayable_IState`'s own `set_name`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2365    pub unsafe fn set_name(this: impl ::core::convert::Into<::unity::IlInstance>, value: ::unity::Il2CppString) -> () {
2366        let __mi = Self::set_name_method_info();
2367        let __inner: extern "C" fn(::unity::IlInstance, ::unity::Il2CppString, ::unity::OptionalMethod) -> () =
2368            ::core::mem::transmute(__mi.method_ptr);
2369        __inner(this.into(), value, ::core::option::Option::None)
2370    }
2371
2372    #[doc = "Direct (non-virtual) call to `SimpleAnimationPlayable_IState`'s own `get_weight`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2373    pub unsafe fn get_weight(this: impl ::core::convert::Into<::unity::IlInstance>) -> f32 {
2374        let __mi = Self::get_weight_method_info();
2375        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> f32 = ::core::mem::transmute(__mi.method_ptr);
2376        __inner(this.into(), ::core::option::Option::None)
2377    }
2378
2379    #[doc = "Direct (non-virtual) call to `SimpleAnimationPlayable_IState`'s own `set_weight`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2380    pub unsafe fn set_weight(this: impl ::core::convert::Into<::unity::IlInstance>, value: f32) -> () {
2381        let __mi = Self::set_weight_method_info();
2382        let __inner: extern "C" fn(::unity::IlInstance, f32, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
2383        __inner(this.into(), value, ::core::option::Option::None)
2384    }
2385
2386    #[doc = "Direct (non-virtual) call to `SimpleAnimationPlayable_IState`'s own `get_length`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2387    pub unsafe fn get_length(this: impl ::core::convert::Into<::unity::IlInstance>) -> f32 {
2388        let __mi = Self::get_length_method_info();
2389        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> f32 = ::core::mem::transmute(__mi.method_ptr);
2390        __inner(this.into(), ::core::option::Option::None)
2391    }
2392
2393    #[doc = "Direct (non-virtual) call to `SimpleAnimationPlayable_IState`'s own `get_clip`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2394    pub unsafe fn get_clip(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::unity_engine::animationclip::AnimationClip {
2395        let __mi = Self::get_clip_method_info();
2396        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::unity_engine::animationclip::AnimationClip =
2397            ::core::mem::transmute(__mi.method_ptr);
2398        __inner(this.into(), ::core::option::Option::None)
2399    }
2400
2401    #[doc = "Direct (non-virtual) call to `SimpleAnimationPlayable_IState`'s own `get_wrapMode`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2402    pub unsafe fn get_wrap_mode(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::unity_engine::wrapmode::WrapMode {
2403        let __mi = Self::get_wrap_mode_method_info();
2404        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::unity_engine::wrapmode::WrapMode =
2405            ::core::mem::transmute(__mi.method_ptr);
2406        __inner(this.into(), ::core::option::Option::None)
2407    }
2408}
2409
2410#[cfg(feature = "root-simpleanimationplayable")]
2411pub trait ISimpleAnimationPlayable_StateEnumerable_StateEnumeratorMethods: ISimpleAnimationPlayable_StateEnumerable_StateEnumerator {
2412    #[doc = "`.ctor(crate::root::simpleanimationplayable::SimpleAnimationPlayable)` overload"]
2413    fn ctor(self, owner: impl ::core::convert::Into<crate::root::simpleanimationplayable::SimpleAnimationPlayable>) -> () {
2414        unsafe {
2415            let __receiver = <SimpleAnimationPlayable_StateEnumerable_StateEnumerator as ::unity::FromIlInstance>::from_il_instance(
2416                <Self as ::unity::SystemObject>::as_instance(self),
2417            );
2418            ::unity::il2cpp_call!((::unity::module_base()+0x3ef2130usize)as*mut u8,();
2419(SimpleAnimationPlayable_StateEnumerable_StateEnumerator)__receiver,(crate::root::simpleanimationplayable::SimpleAnimationPlayable)::core::convert::Into::into(owner))
2420        }
2421    }
2422    #[doc = "`IsValid()` overload"]
2423    fn is_valid(self) -> bool {
2424        unsafe {
2425            let __receiver = <SimpleAnimationPlayable_StateEnumerable_StateEnumerator as ::unity::FromIlInstance>::from_il_instance(
2426                <Self as ::unity::SystemObject>::as_instance(self),
2427            );
2428            ::unity::il2cpp_call!((::unity::module_base()+0x3ef4000usize)as*mut u8,bool;
2429(SimpleAnimationPlayable_StateEnumerable_StateEnumerator)__receiver)
2430        }
2431    }
2432    #[doc = "`GetCurrentHandle(i32)` overload"]
2433    fn get_current_handle(self, index: impl ::core::convert::Into<i32>) -> crate::root::simpleanimationplayable::SimpleAnimationPlayable_IState {
2434        unsafe {
2435            let __receiver = <SimpleAnimationPlayable_StateEnumerable_StateEnumerator as ::unity::FromIlInstance>::from_il_instance(
2436                <Self as ::unity::SystemObject>::as_instance(self),
2437            );
2438            ::unity::il2cpp_call!((::unity::module_base()+0x3ef4030usize)as*mut u8,crate::root::simpleanimationplayable::SimpleAnimationPlayable_IState;
2439(SimpleAnimationPlayable_StateEnumerable_StateEnumerator)__receiver,(i32)::core::convert::Into::into(index))
2440        }
2441    }
2442    #[doc = "`System.Collections.IEnumerator.get_Current()` overload"]
2443    fn system_collections_i_enumerator_get_current(self) -> crate::system::object::Object {
2444        unsafe {
2445            let __receiver = <SimpleAnimationPlayable_StateEnumerable_StateEnumerator as ::unity::FromIlInstance>::from_il_instance(
2446                <Self as ::unity::SystemObject>::as_instance(self),
2447            );
2448            {
2449                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2450                let __vi = *__vt.get(7usize).unwrap_or_else(|| {
2451                    panic!(
2452                        "unity: virtual slot {}
2453 out of range (vtable len {}
2454) on the runtime class behind {}
2455 (method `{}
2456`)",
2457                        7usize,
2458                        __vt.len(),
2459                        <SimpleAnimationPlayable_StateEnumerable_StateEnumerator as ::unity::ClassIdentity>::NAME,
2460                        "System.Collections.IEnumerator.get_Current",
2461                    )
2462                });
2463                let __inner: extern "C" fn(
2464                    SimpleAnimationPlayable_StateEnumerable_StateEnumerator,
2465                    ::unity::OptionalMethod,
2466                ) -> crate::system::object::Object = ::core::mem::transmute(__vi.method_ptr);
2467                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2468                __inner(__receiver, __mi)
2469            }
2470        }
2471    }
2472    #[doc = "`Dispose()` overload"]
2473    fn dispose(self) -> () {
2474        unsafe {
2475            let __receiver = <SimpleAnimationPlayable_StateEnumerable_StateEnumerator as ::unity::FromIlInstance>::from_il_instance(
2476                <Self as ::unity::SystemObject>::as_instance(self),
2477            );
2478            {
2479                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2480                let __vi = *__vt.get(5usize).unwrap_or_else(|| {
2481                    panic!(
2482                        "unity: virtual slot {}
2483 out of range (vtable len {}
2484) on the runtime class behind {}
2485 (method `{}
2486`)",
2487                        5usize,
2488                        __vt.len(),
2489                        <SimpleAnimationPlayable_StateEnumerable_StateEnumerator as ::unity::ClassIdentity>::NAME,
2490                        "Dispose",
2491                    )
2492                });
2493                let __inner: extern "C" fn(SimpleAnimationPlayable_StateEnumerable_StateEnumerator, ::unity::OptionalMethod) -> () =
2494                    ::core::mem::transmute(__vi.method_ptr);
2495                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2496                __inner(__receiver, __mi)
2497            }
2498        }
2499    }
2500    #[doc = "`MoveNext()` overload"]
2501    fn move_next(self) -> bool {
2502        unsafe {
2503            let __receiver = <SimpleAnimationPlayable_StateEnumerable_StateEnumerator as ::unity::FromIlInstance>::from_il_instance(
2504                <Self as ::unity::SystemObject>::as_instance(self),
2505            );
2506            {
2507                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2508                let __vi = *__vt.get(6usize).unwrap_or_else(|| {
2509                    panic!(
2510                        "unity: virtual slot {}
2511 out of range (vtable len {}
2512) on the runtime class behind {}
2513 (method `{}
2514`)",
2515                        6usize,
2516                        __vt.len(),
2517                        <SimpleAnimationPlayable_StateEnumerable_StateEnumerator as ::unity::ClassIdentity>::NAME,
2518                        "MoveNext",
2519                    )
2520                });
2521                let __inner: extern "C" fn(SimpleAnimationPlayable_StateEnumerable_StateEnumerator, ::unity::OptionalMethod) -> bool =
2522                    ::core::mem::transmute(__vi.method_ptr);
2523                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2524                __inner(__receiver, __mi)
2525            }
2526        }
2527    }
2528    #[doc = "`Reset()` overload"]
2529    fn reset(self) -> () {
2530        unsafe {
2531            let __receiver = <SimpleAnimationPlayable_StateEnumerable_StateEnumerator as ::unity::FromIlInstance>::from_il_instance(
2532                <Self as ::unity::SystemObject>::as_instance(self),
2533            );
2534            {
2535                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2536                let __vi = *__vt.get(8usize).unwrap_or_else(|| {
2537                    panic!(
2538                        "unity: virtual slot {}
2539 out of range (vtable len {}
2540) on the runtime class behind {}
2541 (method `{}
2542`)",
2543                        8usize,
2544                        __vt.len(),
2545                        <SimpleAnimationPlayable_StateEnumerable_StateEnumerator as ::unity::ClassIdentity>::NAME,
2546                        "Reset",
2547                    )
2548                });
2549                let __inner: extern "C" fn(SimpleAnimationPlayable_StateEnumerable_StateEnumerator, ::unity::OptionalMethod) -> () =
2550                    ::core::mem::transmute(__vi.method_ptr);
2551                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2552                __inner(__receiver, __mi)
2553            }
2554        }
2555    }
2556}
2557
2558#[cfg(feature = "root-simpleanimationplayable")]
2559impl<__T: ISimpleAnimationPlayable_StateEnumerable_StateEnumerator> ISimpleAnimationPlayable_StateEnumerable_StateEnumeratorMethods for __T {}
2560
2561#[cfg(feature = "root-simpleanimationplayable")]
2562impl SimpleAnimationPlayable_StateEnumerable_StateEnumerator {
2563    pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2564        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
2565    }
2566
2567    pub fn is_valid_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2568        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
2569    }
2570
2571    pub fn get_current_handle_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2572        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
2573    }
2574
2575    pub fn system_collections_i_enumerator_get_current_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2576        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
2577    }
2578
2579    pub fn dispose_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2580        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[5]
2581    }
2582
2583    pub fn move_next_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2584        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[6]
2585    }
2586
2587    pub fn reset_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2588        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[7]
2589    }
2590}
2591
2592#[cfg(feature = "root-simpleanimationplayable")]
2593impl SimpleAnimationPlayable_StateEnumerable_StateEnumerator {
2594    #[doc = "Direct (non-virtual) call to `SimpleAnimationPlayable_StateEnumerable_StateEnumerator`'s own `System.Collections.IEnumerator.get_Current`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2595    pub unsafe fn system_collections_i_enumerator_get_current(
2596        this: impl ::core::convert::Into<::unity::IlInstance>,
2597    ) -> crate::system::object::Object {
2598        let __mi = Self::system_collections_i_enumerator_get_current_method_info();
2599        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::system::object::Object =
2600            ::core::mem::transmute(__mi.method_ptr);
2601        __inner(this.into(), ::core::option::Option::None)
2602    }
2603
2604    #[doc = "Direct (non-virtual) call to `SimpleAnimationPlayable_StateEnumerable_StateEnumerator`'s own `Dispose`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2605    pub unsafe fn dispose(this: impl ::core::convert::Into<::unity::IlInstance>) -> () {
2606        let __mi = Self::dispose_method_info();
2607        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
2608        __inner(this.into(), ::core::option::Option::None)
2609    }
2610
2611    #[doc = "Direct (non-virtual) call to `SimpleAnimationPlayable_StateEnumerable_StateEnumerator`'s own `MoveNext`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2612    pub unsafe fn move_next(this: impl ::core::convert::Into<::unity::IlInstance>) -> bool {
2613        let __mi = Self::move_next_method_info();
2614        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__mi.method_ptr);
2615        __inner(this.into(), ::core::option::Option::None)
2616    }
2617
2618    #[doc = "Direct (non-virtual) call to `SimpleAnimationPlayable_StateEnumerable_StateEnumerator`'s own `Reset`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2619    pub unsafe fn reset(this: impl ::core::convert::Into<::unity::IlInstance>) -> () {
2620        let __mi = Self::reset_method_info();
2621        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
2622        __inner(this.into(), ::core::option::Option::None)
2623    }
2624}
2625
2626#[cfg(feature = "root-simpleanimationplayable")]
2627impl SimpleAnimationPlayable_StateEnumerable_StateEnumerator {
2628    #[doc = "`.ctor(crate::root::simpleanimationplayable::SimpleAnimationPlayable)` — overload selector"]
2629    pub fn new(owner: crate::root::simpleanimationplayable::SimpleAnimationPlayable) -> Self {
2630        let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
2631            panic!(
2632                "{}
2633::{}
2634 failed to instantiate",
2635                ::core::stringify!(SimpleAnimationPlayable_StateEnumerable_StateEnumerator),
2636                ::core::stringify!(new),
2637            )
2638        });
2639        <Self as ISimpleAnimationPlayable_StateEnumerable_StateEnumeratorMethods>::ctor(this, owner);
2640        this
2641    }
2642}
2643
2644#[cfg(feature = "root-simpleanimationplayable")]
2645pub trait ISimpleAnimationPlayable_StateEnumerableMethods: ISimpleAnimationPlayable_StateEnumerable {
2646    #[doc = "`.ctor(crate::root::simpleanimationplayable::SimpleAnimationPlayable)` overload"]
2647    fn ctor(self, owner: impl ::core::convert::Into<crate::root::simpleanimationplayable::SimpleAnimationPlayable>) -> () {
2648        unsafe {
2649            let __receiver = <SimpleAnimationPlayable_StateEnumerable as ::unity::FromIlInstance>::from_il_instance(
2650                <Self as ::unity::SystemObject>::as_instance(self),
2651            );
2652            ::unity::il2cpp_call!((::unity::module_base()+0x3eedf40usize)as*mut u8,();
2653(SimpleAnimationPlayable_StateEnumerable)__receiver,(crate::root::simpleanimationplayable::SimpleAnimationPlayable)::core::convert::Into::into(owner))
2654        }
2655    }
2656    #[doc = "`GetEnumerator()` overload"]
2657    fn get_enumerator(
2658        self,
2659    ) -> crate::system::collections::generic::ienumerator_1::IEnumerator_1<crate::root::simpleanimationplayable::SimpleAnimationPlayable_IState> {
2660        unsafe {
2661            let __receiver = <SimpleAnimationPlayable_StateEnumerable as ::unity::FromIlInstance>::from_il_instance(
2662                <Self as ::unity::SystemObject>::as_instance(self),
2663            );
2664            {
2665                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2666                let __vi = *__vt.get(4usize).unwrap_or_else(|| {
2667                    panic!(
2668                        "unity: virtual slot {}
2669 out of range (vtable len {}
2670) on the runtime class behind {}
2671 (method `{}
2672`)",
2673                        4usize,
2674                        __vt.len(),
2675                        <SimpleAnimationPlayable_StateEnumerable as ::unity::ClassIdentity>::NAME,
2676                        "GetEnumerator",
2677                    )
2678                });
2679                let __inner: extern "C" fn(
2680                    SimpleAnimationPlayable_StateEnumerable,
2681                    ::unity::OptionalMethod,
2682                ) -> crate::system::collections::generic::ienumerator_1::IEnumerator_1<
2683                    crate::root::simpleanimationplayable::SimpleAnimationPlayable_IState,
2684                > = ::core::mem::transmute(__vi.method_ptr);
2685                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2686                __inner(__receiver, __mi)
2687            }
2688        }
2689    }
2690    #[doc = "`System.Collections.IEnumerable.GetEnumerator()` overload"]
2691    fn system_collections_i_enumerable_get_enumerator(self) -> crate::system::collections::ienumerator::IEnumerator {
2692        unsafe {
2693            let __receiver = <SimpleAnimationPlayable_StateEnumerable as ::unity::FromIlInstance>::from_il_instance(
2694                <Self as ::unity::SystemObject>::as_instance(self),
2695            );
2696            {
2697                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2698                let __vi = *__vt.get(5usize).unwrap_or_else(|| {
2699                    panic!(
2700                        "unity: virtual slot {}
2701 out of range (vtable len {}
2702) on the runtime class behind {}
2703 (method `{}
2704`)",
2705                        5usize,
2706                        __vt.len(),
2707                        <SimpleAnimationPlayable_StateEnumerable as ::unity::ClassIdentity>::NAME,
2708                        "System.Collections.IEnumerable.GetEnumerator",
2709                    )
2710                });
2711                let __inner: extern "C" fn(
2712                    SimpleAnimationPlayable_StateEnumerable,
2713                    ::unity::OptionalMethod,
2714                ) -> crate::system::collections::ienumerator::IEnumerator = ::core::mem::transmute(__vi.method_ptr);
2715                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2716                __inner(__receiver, __mi)
2717            }
2718        }
2719    }
2720}
2721
2722#[cfg(feature = "root-simpleanimationplayable")]
2723impl<__T: ISimpleAnimationPlayable_StateEnumerable> ISimpleAnimationPlayable_StateEnumerableMethods for __T {}
2724
2725#[cfg(feature = "root-simpleanimationplayable")]
2726impl SimpleAnimationPlayable_StateEnumerable {
2727    pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2728        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
2729    }
2730
2731    pub fn get_enumerator_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2732        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
2733    }
2734
2735    pub fn system_collections_i_enumerable_get_enumerator_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2736        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
2737    }
2738}
2739
2740#[cfg(feature = "root-simpleanimationplayable")]
2741impl SimpleAnimationPlayable_StateEnumerable {
2742    #[doc = "Direct (non-virtual) call to `SimpleAnimationPlayable_StateEnumerable`'s own `GetEnumerator`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2743    pub unsafe fn get_enumerator(
2744        this: impl ::core::convert::Into<::unity::IlInstance>,
2745    ) -> crate::system::collections::generic::ienumerator_1::IEnumerator_1<crate::root::simpleanimationplayable::SimpleAnimationPlayable_IState> {
2746        let __mi = Self::get_enumerator_method_info();
2747        let __inner: extern "C" fn(
2748            ::unity::IlInstance,
2749            ::unity::OptionalMethod,
2750        ) -> crate::system::collections::generic::ienumerator_1::IEnumerator_1<
2751            crate::root::simpleanimationplayable::SimpleAnimationPlayable_IState,
2752        > = ::core::mem::transmute(__mi.method_ptr);
2753        __inner(this.into(), ::core::option::Option::None)
2754    }
2755
2756    #[doc = "Direct (non-virtual) call to `SimpleAnimationPlayable_StateEnumerable`'s own `System.Collections.IEnumerable.GetEnumerator`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2757    pub unsafe fn system_collections_i_enumerable_get_enumerator(
2758        this: impl ::core::convert::Into<::unity::IlInstance>,
2759    ) -> crate::system::collections::ienumerator::IEnumerator {
2760        let __mi = Self::system_collections_i_enumerable_get_enumerator_method_info();
2761        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::system::collections::ienumerator::IEnumerator =
2762            ::core::mem::transmute(__mi.method_ptr);
2763        __inner(this.into(), ::core::option::Option::None)
2764    }
2765}
2766
2767#[cfg(feature = "root-simpleanimationplayable")]
2768impl SimpleAnimationPlayable_StateEnumerable {
2769    #[doc = "`.ctor(crate::root::simpleanimationplayable::SimpleAnimationPlayable)` — overload selector"]
2770    pub fn new(owner: crate::root::simpleanimationplayable::SimpleAnimationPlayable) -> Self {
2771        let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
2772            panic!(
2773                "{}
2774::{}
2775 failed to instantiate",
2776                ::core::stringify!(SimpleAnimationPlayable_StateEnumerable),
2777                ::core::stringify!(new),
2778            )
2779        });
2780        <Self as ISimpleAnimationPlayable_StateEnumerableMethods>::ctor(this, owner);
2781        this
2782    }
2783}
2784
2785#[cfg(feature = "root-simpleanimationplayable")]
2786impl SimpleAnimationPlayable_QueuedState {
2787    #[doc = "`.ctor(crate::root::simpleanimationplayable::SimpleAnimationPlayable_StateHandle, f32)` overload"]
2788    pub fn ctor(
2789        &mut self,
2790        s: impl ::core::convert::Into<crate::root::simpleanimationplayable::SimpleAnimationPlayable_StateHandle>,
2791        t: impl ::core::convert::Into<f32>,
2792    ) -> () {
2793        unsafe {
2794            ::unity::il2cpp_call!((::unity::module_base()+0x3eeef70usize)as*mut u8,();
2795(*mut SimpleAnimationPlayable_QueuedState)self as*mut SimpleAnimationPlayable_QueuedState,(crate::root::simpleanimationplayable::SimpleAnimationPlayable_StateHandle)::core::convert::Into::into(s),(f32)::core::convert::Into::into(t))
2796        }
2797    }
2798}
2799
2800#[cfg(feature = "root-simpleanimationplayable")]
2801impl SimpleAnimationPlayable_QueuedState {
2802    pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2803        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
2804    }
2805}
2806
2807#[cfg(feature = "root-simpleanimationplayable")]
2808pub trait ISimpleAnimationPlayableMethods: ISimpleAnimationPlayable {
2809    #[doc = "`get_keepStoppedPlayablesConnected()` overload"]
2810    fn get_keep_stopped_playables_connected(self) -> bool {
2811        unsafe {
2812            let __receiver =
2813                <SimpleAnimationPlayable as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2814            ::unity::il2cpp_call!((::unity::module_base()+0x3eed780usize)as*mut u8,bool;
2815(SimpleAnimationPlayable)__receiver)
2816        }
2817    }
2818    #[doc = "`set_keepStoppedPlayablesConnected(bool)` overload"]
2819    fn set_keep_stopped_playables_connected(self, value: impl ::core::convert::Into<bool>) -> () {
2820        unsafe {
2821            let __receiver =
2822                <SimpleAnimationPlayable as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2823            ::unity::il2cpp_call!((::unity::module_base()+0x3eed790usize)as*mut u8,();
2824(SimpleAnimationPlayable)__receiver,(bool)::core::convert::Into::into(value))
2825        }
2826    }
2827    #[doc = "`UpdateStoppedPlayablesConnections()` overload"]
2828    fn update_stopped_playables_connections(self) -> () {
2829        unsafe {
2830            let __receiver =
2831                <SimpleAnimationPlayable as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2832            ::unity::il2cpp_call!((::unity::module_base()+0x3eed7b0usize)as*mut u8,();
2833(SimpleAnimationPlayable)__receiver)
2834        }
2835    }
2836    #[doc = "`get_self()` overload"]
2837    fn get_self(self) -> crate::unity_engine::playables::playable::Playable {
2838        unsafe {
2839            let __receiver =
2840                <SimpleAnimationPlayable as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2841            ::unity::il2cpp_call!((::unity::module_base()+0x3eedb50usize)as*mut u8,crate::unity_engine::playables::playable::Playable;
2842(SimpleAnimationPlayable)__receiver)
2843        }
2844    }
2845    #[doc = "`get_playable()` overload"]
2846    fn get_playable(self) -> crate::unity_engine::playables::playable::Playable {
2847        unsafe {
2848            let __receiver =
2849                <SimpleAnimationPlayable as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2850            ::unity::il2cpp_call!((::unity::module_base()+0x3eeccc0usize)as*mut u8,crate::unity_engine::playables::playable::Playable;
2851(SimpleAnimationPlayable)__receiver)
2852        }
2853    }
2854    #[doc = "`get_graph()` overload"]
2855    fn get_graph(self) -> crate::unity_engine::playables::playablegraph::PlayableGraph {
2856        unsafe {
2857            let __receiver =
2858                <SimpleAnimationPlayable as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2859            ::unity::il2cpp_call!((::unity::module_base()+0x3eedb60usize)as*mut u8,crate::unity_engine::playables::playablegraph::PlayableGraph;
2860(SimpleAnimationPlayable)__receiver)
2861        }
2862    }
2863    #[doc = "`.ctor()` overload"]
2864    fn ctor(self) -> () {
2865        unsafe {
2866            let __receiver =
2867                <SimpleAnimationPlayable as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2868            ::unity::il2cpp_call!((::unity::module_base()+0x3eeca20usize)as*mut u8,();
2869(SimpleAnimationPlayable)__receiver)
2870        }
2871    }
2872    #[doc = "`GetInput(i32)` overload"]
2873    fn get_input(self, index: impl ::core::convert::Into<i32>) -> crate::unity_engine::playables::playable::Playable {
2874        unsafe {
2875            let __receiver =
2876                <SimpleAnimationPlayable as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2877            ::unity::il2cpp_call!((::unity::module_base()+0x3eedc50usize)as*mut u8,crate::unity_engine::playables::playable::Playable;
2878(SimpleAnimationPlayable)__receiver,(i32)::core::convert::Into::into(index))
2879        }
2880    }
2881    #[doc = "`OnPlayableCreate(crate::unity_engine::playables::playable::Playable)` overload"]
2882    fn on_playable_create(self, playable: impl ::core::convert::Into<crate::unity_engine::playables::playable::Playable>) -> () {
2883        unsafe {
2884            let __receiver =
2885                <SimpleAnimationPlayable as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2886            {
2887                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2888                let __vi = *__vt.get(15usize).unwrap_or_else(|| {
2889                    panic!(
2890                        "unity: virtual slot {}
2891 out of range (vtable len {}
2892) on the runtime class behind {}
2893 (method `{}
2894`)",
2895                        15usize,
2896                        __vt.len(),
2897                        <SimpleAnimationPlayable as ::unity::ClassIdentity>::NAME,
2898                        "OnPlayableCreate",
2899                    )
2900                });
2901                let __inner: extern "C" fn(
2902                    SimpleAnimationPlayable,
2903                    crate::unity_engine::playables::playable::Playable,
2904                    ::unity::OptionalMethod,
2905                ) -> () = ::core::mem::transmute(__vi.method_ptr);
2906                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2907                __inner(__receiver, ::core::convert::Into::into(playable), __mi)
2908            }
2909        }
2910    }
2911    #[doc = "`GetStates()` overload"]
2912    fn get_states(
2913        self,
2914    ) -> crate::system::collections::generic::ienumerable_1::IEnumerable_1<crate::root::simpleanimationplayable::SimpleAnimationPlayable_IState> {
2915        unsafe {
2916            let __receiver =
2917                <SimpleAnimationPlayable as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2918            ::unity::il2cpp_call!((::unity::module_base()+0x3eedec0usize)as*mut u8,crate::system::collections::generic::ienumerable_1::IEnumerable_1<crate::root::simpleanimationplayable::SimpleAnimationPlayable_IState> ;
2919(SimpleAnimationPlayable)__receiver)
2920        }
2921    }
2922    #[doc = "`GetState(::unity::Il2CppString)` overload"]
2923    fn get_state(
2924        self,
2925        name: impl ::core::convert::Into<::unity::Il2CppString>,
2926    ) -> crate::root::simpleanimationplayable::SimpleAnimationPlayable_IState {
2927        unsafe {
2928            let __receiver =
2929                <SimpleAnimationPlayable as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2930            ::unity::il2cpp_call!((::unity::module_base()+0x3eebfe0usize)as*mut u8,crate::root::simpleanimationplayable::SimpleAnimationPlayable_IState;
2931(SimpleAnimationPlayable)__receiver,(::unity::Il2CppString)::core::convert::Into::into(name))
2932        }
2933    }
2934    #[doc = "`DoAddClip(::unity::Il2CppString, crate::unity_engine::animationclip::AnimationClip)` overload"]
2935    fn do_add_clip(
2936        self,
2937        name: impl ::core::convert::Into<::unity::Il2CppString>,
2938        clip: impl ::core::convert::Into<crate::unity_engine::animationclip::AnimationClip>,
2939    ) -> crate::root::simpleanimationplayable::SimpleAnimationPlayable_StateInfo {
2940        unsafe {
2941            let __receiver =
2942                <SimpleAnimationPlayable as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2943            ::unity::il2cpp_call!((::unity::module_base()+0x3eee130usize)as*mut u8,crate::root::simpleanimationplayable::SimpleAnimationPlayable_StateInfo;
2944(SimpleAnimationPlayable)__receiver,(::unity::Il2CppString)::core::convert::Into::into(name),(crate::unity_engine::animationclip::AnimationClip)::core::convert::Into::into(clip))
2945        }
2946    }
2947    #[doc = "`AddClip(crate::unity_engine::animationclip::AnimationClip, ::unity::Il2CppString)` overload"]
2948    fn add_clip(
2949        self,
2950        clip: impl ::core::convert::Into<crate::unity_engine::animationclip::AnimationClip>,
2951        name: impl ::core::convert::Into<::unity::Il2CppString>,
2952    ) -> bool {
2953        unsafe {
2954            let __receiver =
2955                <SimpleAnimationPlayable as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2956            ::unity::il2cpp_call!((::unity::module_base()+0x3eeb240usize)as*mut u8,bool;
2957(SimpleAnimationPlayable)__receiver,(crate::unity_engine::animationclip::AnimationClip)::core::convert::Into::into(clip),(::unity::Il2CppString)::core::convert::Into::into(name))
2958        }
2959    }
2960    #[doc = "`RemoveClip(::unity::Il2CppString)` overload"]
2961    fn remove_clip(self, name: impl ::core::convert::Into<::unity::Il2CppString>) -> bool {
2962        unsafe {
2963            let __receiver =
2964                <SimpleAnimationPlayable as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2965            ::unity::il2cpp_call!((::unity::module_base()+0x3eeb810usize)as*mut u8,bool;
2966(SimpleAnimationPlayable)__receiver,(::unity::Il2CppString)::core::convert::Into::into(name))
2967        }
2968    }
2969    #[doc = "`RemoveClip(crate::unity_engine::animationclip::AnimationClip)` overload"]
2970    fn remove_clip_2(self, clip: impl ::core::convert::Into<crate::unity_engine::animationclip::AnimationClip>) -> bool {
2971        unsafe {
2972            let __receiver =
2973                <SimpleAnimationPlayable as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2974            ::unity::il2cpp_call!((::unity::module_base()+0x3eebbb0usize)as*mut u8,bool;
2975(SimpleAnimationPlayable)__receiver,(crate::unity_engine::animationclip::AnimationClip)::core::convert::Into::into(clip))
2976        }
2977    }
2978    #[doc = "`Play(::unity::Il2CppString)` overload"]
2979    fn play(self, name: impl ::core::convert::Into<::unity::Il2CppString>) -> bool {
2980        unsafe {
2981            let __receiver =
2982                <SimpleAnimationPlayable as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2983            ::unity::il2cpp_call!((::unity::module_base()+0x3eeb170usize)as*mut u8,bool;
2984(SimpleAnimationPlayable)__receiver,(::unity::Il2CppString)::core::convert::Into::into(name))
2985        }
2986    }
2987    #[doc = "`Play(i32)` overload"]
2988    fn play_2(self, index: impl ::core::convert::Into<i32>) -> bool {
2989        unsafe {
2990            let __receiver =
2991                <SimpleAnimationPlayable as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2992            ::unity::il2cpp_call!((::unity::module_base()+0x3eeea10usize)as*mut u8,bool;
2993(SimpleAnimationPlayable)__receiver,(i32)::core::convert::Into::into(index))
2994        }
2995    }
2996    #[doc = "`PlayQueued(::unity::Il2CppString, crate::unity_engine::queuemode::QueueMode)` overload"]
2997    fn play_queued(
2998        self,
2999        name: impl ::core::convert::Into<::unity::Il2CppString>,
3000        queue_mode: impl ::core::convert::Into<crate::unity_engine::queuemode::QueueMode>,
3001    ) -> bool {
3002        unsafe {
3003            let __receiver =
3004                <SimpleAnimationPlayable as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3005            ::unity::il2cpp_call!((::unity::module_base()+0x3eeb9d0usize)as*mut u8,bool;
3006(SimpleAnimationPlayable)__receiver,(::unity::Il2CppString)::core::convert::Into::into(name),(crate::unity_engine::queuemode::QueueMode)::core::convert::Into::into(queue_mode))
3007        }
3008    }
3009    #[doc = "`PlayQueued(i32, crate::unity_engine::queuemode::QueueMode)` overload"]
3010    fn play_queued_2(
3011        self,
3012        index: impl ::core::convert::Into<i32>,
3013        queue_mode: impl ::core::convert::Into<crate::unity_engine::queuemode::QueueMode>,
3014    ) -> bool {
3015        unsafe {
3016            let __receiver =
3017                <SimpleAnimationPlayable as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3018            ::unity::il2cpp_call!((::unity::module_base()+0x3eeec90usize)as*mut u8,bool;
3019(SimpleAnimationPlayable)__receiver,(i32)::core::convert::Into::into(index),(crate::unity_engine::queuemode::QueueMode)::core::convert::Into::into(queue_mode))
3020        }
3021    }
3022    #[doc = "`Rewind(::unity::Il2CppString)` overload"]
3023    fn rewind(self, name: impl ::core::convert::Into<::unity::Il2CppString>) -> () {
3024        unsafe {
3025            let __receiver =
3026                <SimpleAnimationPlayable as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3027            ::unity::il2cpp_call!((::unity::module_base()+0x3eebda0usize)as*mut u8,();
3028(SimpleAnimationPlayable)__receiver,(::unity::Il2CppString)::core::convert::Into::into(name))
3029        }
3030    }
3031    #[doc = "`Rewind(i32)` overload"]
3032    fn rewind_2(self, index: impl ::core::convert::Into<i32>) -> () {
3033        unsafe {
3034            let __receiver =
3035                <SimpleAnimationPlayable as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3036            ::unity::il2cpp_call!((::unity::module_base()+0x3eeefb0usize)as*mut u8,();
3037(SimpleAnimationPlayable)__receiver,(i32)::core::convert::Into::into(index))
3038        }
3039    }
3040    #[doc = "`Rewind()` overload"]
3041    fn rewind_3(self) -> () {
3042        unsafe {
3043            let __receiver =
3044                <SimpleAnimationPlayable as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3045            ::unity::il2cpp_call!((::unity::module_base()+0x3eebc20usize)as*mut u8,();
3046(SimpleAnimationPlayable)__receiver)
3047        }
3048    }
3049    #[doc = "`RemoveClones(crate::root::simpleanimationplayable::SimpleAnimationPlayable_StateInfo)` overload"]
3050    fn remove_clones(self, state: impl ::core::convert::Into<crate::root::simpleanimationplayable::SimpleAnimationPlayable_StateInfo>) -> () {
3051        unsafe {
3052            let __receiver =
3053                <SimpleAnimationPlayable as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3054            ::unity::il2cpp_call!((::unity::module_base()+0x3eee670usize)as*mut u8,();
3055(SimpleAnimationPlayable)__receiver,(crate::root::simpleanimationplayable::SimpleAnimationPlayable_StateInfo)::core::convert::Into::into(state))
3056        }
3057    }
3058    #[doc = "`Stop(::unity::Il2CppString)` overload"]
3059    fn stop(self, name: impl ::core::convert::Into<::unity::Il2CppString>) -> bool {
3060        unsafe {
3061            let __receiver =
3062                <SimpleAnimationPlayable as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3063            ::unity::il2cpp_call!((::unity::module_base()+0x3eeaf00usize)as*mut u8,bool;
3064(SimpleAnimationPlayable)__receiver,(::unity::Il2CppString)::core::convert::Into::into(name))
3065        }
3066    }
3067    #[doc = "`DoStop(i32)` overload"]
3068    fn do_stop(self, index: impl ::core::convert::Into<i32>) -> () {
3069        unsafe {
3070            let __receiver =
3071                <SimpleAnimationPlayable as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3072            ::unity::il2cpp_call!((::unity::module_base()+0x3eeebc0usize)as*mut u8,();
3073(SimpleAnimationPlayable)__receiver,(i32)::core::convert::Into::into(index))
3074        }
3075    }
3076    #[doc = "`StopAll()` overload"]
3077    fn stop_all(self) -> bool {
3078        unsafe {
3079            let __receiver =
3080                <SimpleAnimationPlayable as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3081            ::unity::il2cpp_call!((::unity::module_base()+0x3eeadb0usize)as*mut u8,bool;
3082(SimpleAnimationPlayable)__receiver)
3083        }
3084    }
3085    #[doc = "`IsPlaying()` overload"]
3086    fn is_playing(self) -> bool {
3087        unsafe {
3088            let __receiver =
3089                <SimpleAnimationPlayable as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3090            ::unity::il2cpp_call!((::unity::module_base()+0x3eea3f0usize)as*mut u8,bool;
3091(SimpleAnimationPlayable)__receiver)
3092        }
3093    }
3094    #[doc = "`IsPlaying(::unity::Il2CppString)` overload"]
3095    fn is_playing_2(self, state_name: impl ::core::convert::Into<::unity::Il2CppString>) -> bool {
3096        unsafe {
3097            let __receiver =
3098                <SimpleAnimationPlayable as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3099            ::unity::il2cpp_call!((::unity::module_base()+0x3eeac80usize)as*mut u8,bool;
3100(SimpleAnimationPlayable)__receiver,(::unity::Il2CppString)::core::convert::Into::into(state_name))
3101        }
3102    }
3103    #[doc = "`IsClonePlaying(crate::root::simpleanimationplayable::SimpleAnimationPlayable_StateInfo)` overload"]
3104    fn is_clone_playing(self, state: impl ::core::convert::Into<crate::root::simpleanimationplayable::SimpleAnimationPlayable_StateInfo>) -> bool {
3105        unsafe {
3106            let __receiver =
3107                <SimpleAnimationPlayable as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3108            ::unity::il2cpp_call!((::unity::module_base()+0x3eef2f0usize)as*mut u8,bool;
3109(SimpleAnimationPlayable)__receiver,(crate::root::simpleanimationplayable::SimpleAnimationPlayable_StateInfo)::core::convert::Into::into(state))
3110        }
3111    }
3112    #[doc = "`GetClipCount()` overload"]
3113    fn get_clip_count(self) -> i32 {
3114        unsafe {
3115            let __receiver =
3116                <SimpleAnimationPlayable as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3117            ::unity::il2cpp_call!((::unity::module_base()+0x3eeabb0usize)as*mut u8,i32;
3118(SimpleAnimationPlayable)__receiver)
3119        }
3120    }
3121    #[doc = "`SetupLerp(crate::root::simpleanimationplayable::SimpleAnimationPlayable_StateInfo, f32, f32)` overload"]
3122    fn setup_lerp(
3123        self,
3124        state: impl ::core::convert::Into<crate::root::simpleanimationplayable::SimpleAnimationPlayable_StateInfo>,
3125        target_weight: impl ::core::convert::Into<f32>,
3126        time: impl ::core::convert::Into<f32>,
3127    ) -> () {
3128        unsafe {
3129            let __receiver =
3130                <SimpleAnimationPlayable as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3131            ::unity::il2cpp_call!((::unity::module_base()+0x3eef400usize)as*mut u8,();
3132(SimpleAnimationPlayable)__receiver,(crate::root::simpleanimationplayable::SimpleAnimationPlayable_StateInfo)::core::convert::Into::into(state),(f32)::core::convert::Into::into(target_weight),(f32)::core::convert::Into::into(time))
3133        }
3134    }
3135    #[doc = "`Crossfade(i32, f32)` overload"]
3136    fn crossfade(self, index: impl ::core::convert::Into<i32>, time: impl ::core::convert::Into<f32>) -> bool {
3137        unsafe {
3138            let __receiver =
3139                <SimpleAnimationPlayable as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3140            ::unity::il2cpp_call!((::unity::module_base()+0x3eef4b0usize)as*mut u8,bool;
3141(SimpleAnimationPlayable)__receiver,(i32)::core::convert::Into::into(index),(f32)::core::convert::Into::into(time))
3142        }
3143    }
3144    #[doc = "`CloneState(i32)` overload"]
3145    fn clone_state(self, index: impl ::core::convert::Into<i32>) -> crate::root::simpleanimationplayable::SimpleAnimationPlayable_StateInfo {
3146        unsafe {
3147            let __receiver =
3148                <SimpleAnimationPlayable as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3149            ::unity::il2cpp_call!((::unity::module_base()+0x3eeedb0usize)as*mut u8,crate::root::simpleanimationplayable::SimpleAnimationPlayable_StateInfo;
3150(SimpleAnimationPlayable)__receiver,(i32)::core::convert::Into::into(index))
3151        }
3152    }
3153    #[doc = "`Crossfade(::unity::Il2CppString, f32)` overload"]
3154    fn crossfade_2(self, name: impl ::core::convert::Into<::unity::Il2CppString>, time: impl ::core::convert::Into<f32>) -> bool {
3155        unsafe {
3156            let __receiver =
3157                <SimpleAnimationPlayable as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3158            ::unity::il2cpp_call!((::unity::module_base()+0x3eea8a0usize)as*mut u8,bool;
3159(SimpleAnimationPlayable)__receiver,(::unity::Il2CppString)::core::convert::Into::into(name),(f32)::core::convert::Into::into(time))
3160        }
3161    }
3162    #[doc = "`CrossfadeQueued(::unity::Il2CppString, f32, crate::unity_engine::queuemode::QueueMode)` overload"]
3163    fn crossfade_queued(
3164        self,
3165        name: impl ::core::convert::Into<::unity::Il2CppString>,
3166        time: impl ::core::convert::Into<f32>,
3167        queue_mode: impl ::core::convert::Into<crate::unity_engine::queuemode::QueueMode>,
3168    ) -> bool {
3169        unsafe {
3170            let __receiver =
3171                <SimpleAnimationPlayable as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3172            ::unity::il2cpp_call!((::unity::module_base()+0x3eeaa10usize)as*mut u8,bool;
3173(SimpleAnimationPlayable)__receiver,(::unity::Il2CppString)::core::convert::Into::into(name),(f32)::core::convert::Into::into(time),(crate::unity_engine::queuemode::QueueMode)::core::convert::Into::into(queue_mode))
3174        }
3175    }
3176    #[doc = "`CrossfadeQueued(i32, f32, crate::unity_engine::queuemode::QueueMode)` overload"]
3177    fn crossfade_queued_2(
3178        self,
3179        index: impl ::core::convert::Into<i32>,
3180        time: impl ::core::convert::Into<f32>,
3181        queue_mode: impl ::core::convert::Into<crate::unity_engine::queuemode::QueueMode>,
3182    ) -> bool {
3183        unsafe {
3184            let __receiver =
3185                <SimpleAnimationPlayable as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3186            ::unity::il2cpp_call!((::unity::module_base()+0x3eef7e0usize)as*mut u8,bool;
3187(SimpleAnimationPlayable)__receiver,(i32)::core::convert::Into::into(index),(f32)::core::convert::Into::into(time),(crate::unity_engine::queuemode::QueueMode)::core::convert::Into::into(queue_mode))
3188        }
3189    }
3190    #[doc = "`Blend(i32, f32, f32)` overload"]
3191    fn blend(
3192        self,
3193        index: impl ::core::convert::Into<i32>,
3194        target_weight: impl ::core::convert::Into<f32>,
3195        time: impl ::core::convert::Into<f32>,
3196    ) -> bool {
3197        unsafe {
3198            let __receiver =
3199                <SimpleAnimationPlayable as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3200            ::unity::il2cpp_call!((::unity::module_base()+0x3eef910usize)as*mut u8,bool;
3201(SimpleAnimationPlayable)__receiver,(i32)::core::convert::Into::into(index),(f32)::core::convert::Into::into(target_weight),(f32)::core::convert::Into::into(time))
3202        }
3203    }
3204    #[doc = "`Blend(::unity::Il2CppString, f32, f32)` overload"]
3205    fn blend_2(
3206        self,
3207        name: impl ::core::convert::Into<::unity::Il2CppString>,
3208        target_weight: impl ::core::convert::Into<f32>,
3209        time: impl ::core::convert::Into<f32>,
3210    ) -> bool {
3211        unsafe {
3212            let __receiver =
3213                <SimpleAnimationPlayable as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3214            ::unity::il2cpp_call!((::unity::module_base()+0x3eea750usize)as*mut u8,bool;
3215(SimpleAnimationPlayable)__receiver,(::unity::Il2CppString)::core::convert::Into::into(name),(f32)::core::convert::Into::into(target_weight),(f32)::core::convert::Into::into(time))
3216        }
3217    }
3218    #[doc = "`OnGraphStop(crate::unity_engine::playables::playable::Playable)` overload"]
3219    fn on_graph_stop(self, playable: impl ::core::convert::Into<crate::unity_engine::playables::playable::Playable>) -> () {
3220        unsafe {
3221            let __receiver =
3222                <SimpleAnimationPlayable as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3223            {
3224                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
3225                let __vi = *__vt.get(14usize).unwrap_or_else(|| {
3226                    panic!(
3227                        "unity: virtual slot {}
3228 out of range (vtable len {}
3229) on the runtime class behind {}
3230 (method `{}
3231`)",
3232                        14usize,
3233                        __vt.len(),
3234                        <SimpleAnimationPlayable as ::unity::ClassIdentity>::NAME,
3235                        "OnGraphStop",
3236                    )
3237                });
3238                let __inner: extern "C" fn(
3239                    SimpleAnimationPlayable,
3240                    crate::unity_engine::playables::playable::Playable,
3241                    ::unity::OptionalMethod,
3242                ) -> () = ::core::mem::transmute(__vi.method_ptr);
3243                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
3244                __inner(__receiver, ::core::convert::Into::into(playable), __mi)
3245            }
3246        }
3247    }
3248    #[doc = "`UpdateDoneStatus()` overload"]
3249    fn update_done_status(self) -> () {
3250        unsafe {
3251            let __receiver =
3252                <SimpleAnimationPlayable as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3253            ::unity::il2cpp_call!((::unity::module_base()+0x3eee5c0usize)as*mut u8,();
3254(SimpleAnimationPlayable)__receiver)
3255        }
3256    }
3257    #[doc = "`CleanClonedStates()` overload"]
3258    fn clean_cloned_states(self) -> () {
3259        unsafe {
3260            let __receiver =
3261                <SimpleAnimationPlayable as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3262            ::unity::il2cpp_call!((::unity::module_base()+0x3eefc80usize)as*mut u8,();
3263(SimpleAnimationPlayable)__receiver)
3264        }
3265    }
3266    #[doc = "`DisconnectInput(i32)` overload"]
3267    fn disconnect_input(self, index: impl ::core::convert::Into<i32>) -> () {
3268        unsafe {
3269            let __receiver =
3270                <SimpleAnimationPlayable as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3271            ::unity::il2cpp_call!((::unity::module_base()+0x3eeda10usize)as*mut u8,();
3272(SimpleAnimationPlayable)__receiver,(i32)::core::convert::Into::into(index))
3273        }
3274    }
3275    #[doc = "`ConnectInput(i32)` overload"]
3276    fn connect_input(self, index: impl ::core::convert::Into<i32>) -> () {
3277        unsafe {
3278            let __receiver =
3279                <SimpleAnimationPlayable as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3280            ::unity::il2cpp_call!((::unity::module_base()+0x3eed910usize)as*mut u8,();
3281(SimpleAnimationPlayable)__receiver,(i32)::core::convert::Into::into(index))
3282        }
3283    }
3284    #[doc = "`UpdateStates(f32)` overload"]
3285    fn update_states(self, delta_time: impl ::core::convert::Into<f32>) -> () {
3286        unsafe {
3287            let __receiver =
3288                <SimpleAnimationPlayable as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3289            ::unity::il2cpp_call!((::unity::module_base()+0x3eefe60usize)as*mut u8,();
3290(SimpleAnimationPlayable)__receiver,(f32)::core::convert::Into::into(delta_time))
3291        }
3292    }
3293    #[doc = "`CalculateQueueTimes()` overload"]
3294    fn calculate_queue_times(self) -> f32 {
3295        unsafe {
3296            let __receiver =
3297                <SimpleAnimationPlayable as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3298            ::unity::il2cpp_call!((::unity::module_base()+0x3ef07b0usize)as*mut u8,f32;
3299(SimpleAnimationPlayable)__receiver)
3300        }
3301    }
3302    #[doc = "`ClearQueuedStates()` overload"]
3303    fn clear_queued_states(self) -> () {
3304        unsafe {
3305            let __receiver =
3306                <SimpleAnimationPlayable as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3307            ::unity::il2cpp_call!((::unity::module_base()+0x3ef0b00usize)as*mut u8,();
3308(SimpleAnimationPlayable)__receiver)
3309        }
3310    }
3311    #[doc = "`UpdateQueuedStates()` overload"]
3312    fn update_queued_states(self) -> () {
3313        unsafe {
3314            let __receiver =
3315                <SimpleAnimationPlayable as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3316            ::unity::il2cpp_call!((::unity::module_base()+0x3ef0c90usize)as*mut u8,();
3317(SimpleAnimationPlayable)__receiver)
3318        }
3319    }
3320    #[doc = "`InvalidateStateTimes()` overload"]
3321    fn invalidate_state_times(self) -> () {
3322        unsafe {
3323            let __receiver =
3324                <SimpleAnimationPlayable as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3325            ::unity::il2cpp_call!((::unity::module_base()+0x3ef0d90usize)as*mut u8,();
3326(SimpleAnimationPlayable)__receiver)
3327        }
3328    }
3329    #[doc = "`PrepareFrame(crate::unity_engine::playables::playable::Playable, crate::unity_engine::playables::framedata::FrameData)` overload"]
3330    fn prepare_frame(
3331        self,
3332        owner: impl ::core::convert::Into<crate::unity_engine::playables::playable::Playable>,
3333        data: impl ::core::convert::Into<crate::unity_engine::playables::framedata::FrameData>,
3334    ) -> () {
3335        unsafe {
3336            let __receiver =
3337                <SimpleAnimationPlayable as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3338            {
3339                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
3340                let __vi = *__vt.get(19usize).unwrap_or_else(|| {
3341                    panic!(
3342                        "unity: virtual slot {}
3343 out of range (vtable len {}
3344) on the runtime class behind {}
3345 (method `{}
3346`)",
3347                        19usize,
3348                        __vt.len(),
3349                        <SimpleAnimationPlayable as ::unity::ClassIdentity>::NAME,
3350                        "PrepareFrame",
3351                    )
3352                });
3353                let __inner: extern "C" fn(
3354                    SimpleAnimationPlayable,
3355                    crate::unity_engine::playables::playable::Playable,
3356                    crate::unity_engine::playables::framedata::FrameData,
3357                    ::unity::OptionalMethod,
3358                ) -> () = ::core::mem::transmute(__vi.method_ptr);
3359                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
3360                __inner(__receiver, ::core::convert::Into::into(owner), ::core::convert::Into::into(data), __mi)
3361            }
3362        }
3363    }
3364    #[doc = "`ValidateInput(i32, crate::unity_engine::playables::playable::Playable)` overload"]
3365    fn validate_input(
3366        self,
3367        index: impl ::core::convert::Into<i32>,
3368        input: impl ::core::convert::Into<crate::unity_engine::playables::playable::Playable>,
3369    ) -> bool {
3370        unsafe {
3371            let __receiver =
3372                <SimpleAnimationPlayable as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3373            ::unity::il2cpp_call!((::unity::module_base()+0x3ef0f90usize)as*mut u8,bool;
3374(SimpleAnimationPlayable)__receiver,(i32)::core::convert::Into::into(index),(crate::unity_engine::playables::playable::Playable)::core::convert::Into::into(input))
3375        }
3376    }
3377    #[doc = "`ValidateIndex(i32)` overload"]
3378    fn validate_index(self, index: impl ::core::convert::Into<i32>) -> bool {
3379        unsafe {
3380            let __receiver =
3381                <SimpleAnimationPlayable as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3382            ::unity::il2cpp_call!((::unity::module_base()+0x3ef1110usize)as*mut u8,bool;
3383(SimpleAnimationPlayable)__receiver,(i32)::core::convert::Into::into(index))
3384        }
3385    }
3386    #[doc = "`IsFinished(f32)` overload"]
3387    fn is_finished(self, rest_time: impl ::core::convert::Into<f32>) -> bool {
3388        unsafe {
3389            let __receiver =
3390                <SimpleAnimationPlayable as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3391            ::unity::il2cpp_call!((::unity::module_base()+0x3eec1c0usize)as*mut u8,bool;
3392(SimpleAnimationPlayable)__receiver,(f32)::core::convert::Into::into(rest_time))
3393        }
3394    }
3395    #[doc = "`SetSpeed(f32)` overload"]
3396    fn set_speed(self, speed: impl ::core::convert::Into<f32>) -> () {
3397        unsafe {
3398            let __receiver =
3399                <SimpleAnimationPlayable as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3400            ::unity::il2cpp_call!((::unity::module_base()+0x3eec450usize)as*mut u8,();
3401(SimpleAnimationPlayable)__receiver,(f32)::core::convert::Into::into(speed))
3402        }
3403    }
3404    #[doc = "`InvalidateStates()` overload"]
3405    fn invalidate_states(self) -> () {
3406        unsafe {
3407            let __receiver =
3408                <SimpleAnimationPlayable as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3409            ::unity::il2cpp_call!((::unity::module_base()+0x3eee660usize)as*mut u8,();
3410(SimpleAnimationPlayable)__receiver)
3411        }
3412    }
3413    #[doc = "`StateInfoToHandle(crate::root::simpleanimationplayable::SimpleAnimationPlayable_StateInfo)` overload"]
3414    fn state_info_to_handle(
3415        self,
3416        info: impl ::core::convert::Into<crate::root::simpleanimationplayable::SimpleAnimationPlayable_StateInfo>,
3417    ) -> crate::root::simpleanimationplayable::SimpleAnimationPlayable_StateHandle {
3418        unsafe {
3419            let __receiver =
3420                <SimpleAnimationPlayable as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3421            ::unity::il2cpp_call!((::unity::module_base()+0x3eeeee0usize)as*mut u8,crate::root::simpleanimationplayable::SimpleAnimationPlayable_StateHandle;
3422(SimpleAnimationPlayable)__receiver,(crate::root::simpleanimationplayable::SimpleAnimationPlayable_StateInfo)::core::convert::Into::into(info))
3423        }
3424    }
3425}
3426
3427#[cfg(feature = "root-simpleanimationplayable")]
3428impl<__T: ISimpleAnimationPlayable> ISimpleAnimationPlayableMethods for __T {}
3429
3430#[cfg(feature = "root-simpleanimationplayable")]
3431impl SimpleAnimationPlayable {
3432    pub fn get_keep_stopped_playables_connected_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3433        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
3434    }
3435
3436    pub fn set_keep_stopped_playables_connected_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3437        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
3438    }
3439
3440    pub fn update_stopped_playables_connections_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3441        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
3442    }
3443
3444    pub fn get_self_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3445        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
3446    }
3447
3448    pub fn get_playable_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3449        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
3450    }
3451
3452    pub fn get_graph_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3453        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[5]
3454    }
3455
3456    pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3457        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[6]
3458    }
3459
3460    pub fn get_input_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3461        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[7]
3462    }
3463
3464    pub fn on_playable_create_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3465        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[8]
3466    }
3467
3468    pub fn get_states_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3469        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[9]
3470    }
3471
3472    pub fn get_state_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3473        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[10]
3474    }
3475
3476    pub fn do_add_clip_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3477        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[11]
3478    }
3479
3480    pub fn add_clip_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3481        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[12]
3482    }
3483
3484    pub fn remove_clip_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3485        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[13]
3486    }
3487
3488    pub fn remove_clip_2_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3489        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[14]
3490    }
3491
3492    pub fn play_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3493        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[15]
3494    }
3495
3496    pub fn play_2_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3497        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[16]
3498    }
3499
3500    pub fn play_queued_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3501        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[17]
3502    }
3503
3504    pub fn play_queued_2_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3505        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[18]
3506    }
3507
3508    pub fn rewind_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3509        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[19]
3510    }
3511
3512    pub fn rewind_2_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3513        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[20]
3514    }
3515
3516    pub fn rewind_3_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3517        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[21]
3518    }
3519
3520    pub fn remove_clones_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3521        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[22]
3522    }
3523
3524    pub fn stop_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3525        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[23]
3526    }
3527
3528    pub fn do_stop_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3529        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[24]
3530    }
3531
3532    pub fn stop_all_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3533        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[25]
3534    }
3535
3536    pub fn is_playing_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3537        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[26]
3538    }
3539
3540    pub fn is_playing_2_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3541        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[27]
3542    }
3543
3544    pub fn is_clone_playing_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3545        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[28]
3546    }
3547
3548    pub fn get_clip_count_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3549        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[29]
3550    }
3551
3552    pub fn setup_lerp_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3553        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[30]
3554    }
3555
3556    pub fn crossfade_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3557        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[31]
3558    }
3559
3560    pub fn clone_state_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3561        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[32]
3562    }
3563
3564    pub fn crossfade_2_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3565        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[33]
3566    }
3567
3568    pub fn crossfade_queued_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3569        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[34]
3570    }
3571
3572    pub fn crossfade_queued_2_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3573        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[35]
3574    }
3575
3576    pub fn blend_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3577        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[36]
3578    }
3579
3580    pub fn blend_2_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3581        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[37]
3582    }
3583
3584    pub fn on_graph_stop_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3585        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[38]
3586    }
3587
3588    pub fn update_done_status_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3589        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[39]
3590    }
3591
3592    pub fn clean_cloned_states_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3593        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[40]
3594    }
3595
3596    pub fn disconnect_input_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3597        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[41]
3598    }
3599
3600    pub fn connect_input_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3601        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[42]
3602    }
3603
3604    pub fn update_states_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3605        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[43]
3606    }
3607
3608    pub fn calculate_queue_times_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3609        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[44]
3610    }
3611
3612    pub fn clear_queued_states_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3613        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[45]
3614    }
3615
3616    pub fn update_queued_states_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3617        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[46]
3618    }
3619
3620    pub fn invalidate_state_times_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3621        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[47]
3622    }
3623
3624    pub fn prepare_frame_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3625        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[48]
3626    }
3627
3628    pub fn validate_input_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3629        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[49]
3630    }
3631
3632    pub fn validate_index_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3633        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[50]
3634    }
3635
3636    pub fn is_finished_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3637        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[51]
3638    }
3639
3640    pub fn set_speed_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3641        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[52]
3642    }
3643
3644    pub fn invalidate_states_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3645        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[53]
3646    }
3647
3648    pub fn state_info_to_handle_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3649        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[54]
3650    }
3651}
3652
3653#[cfg(feature = "root-simpleanimationplayable")]
3654impl SimpleAnimationPlayable {
3655    #[doc = "Direct (non-virtual) call to `SimpleAnimationPlayable`'s own `OnPlayableCreate`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3656    pub unsafe fn on_playable_create(
3657        this: impl ::core::convert::Into<::unity::IlInstance>,
3658        playable: crate::unity_engine::playables::playable::Playable,
3659    ) -> () {
3660        let __mi = Self::on_playable_create_method_info();
3661        let __inner: extern "C" fn(::unity::IlInstance, crate::unity_engine::playables::playable::Playable, ::unity::OptionalMethod) -> () =
3662            ::core::mem::transmute(__mi.method_ptr);
3663        __inner(this.into(), playable, ::core::option::Option::None)
3664    }
3665
3666    #[doc = "Direct (non-virtual) call to `SimpleAnimationPlayable`'s own `OnGraphStop`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3667    pub unsafe fn on_graph_stop(
3668        this: impl ::core::convert::Into<::unity::IlInstance>,
3669        playable: crate::unity_engine::playables::playable::Playable,
3670    ) -> () {
3671        let __mi = Self::on_graph_stop_method_info();
3672        let __inner: extern "C" fn(::unity::IlInstance, crate::unity_engine::playables::playable::Playable, ::unity::OptionalMethod) -> () =
3673            ::core::mem::transmute(__mi.method_ptr);
3674        __inner(this.into(), playable, ::core::option::Option::None)
3675    }
3676
3677    #[doc = "Direct (non-virtual) call to `SimpleAnimationPlayable`'s own `PrepareFrame`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3678    pub unsafe fn prepare_frame(
3679        this: impl ::core::convert::Into<::unity::IlInstance>,
3680        owner: crate::unity_engine::playables::playable::Playable,
3681        data: crate::unity_engine::playables::framedata::FrameData,
3682    ) -> () {
3683        let __mi = Self::prepare_frame_method_info();
3684        let __inner: extern "C" fn(
3685            ::unity::IlInstance,
3686            crate::unity_engine::playables::playable::Playable,
3687            crate::unity_engine::playables::framedata::FrameData,
3688            ::unity::OptionalMethod,
3689        ) -> () = ::core::mem::transmute(__mi.method_ptr);
3690        __inner(this.into(), owner, data, ::core::option::Option::None)
3691    }
3692}
3693
3694#[cfg(feature = "root-simpleanimationplayable")]
3695impl SimpleAnimationPlayable {
3696    #[doc = "`.ctor()` — no args"]
3697    pub fn new() -> Self {
3698        let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
3699            panic!(
3700                "{}
3701::{}
3702 failed to instantiate",
3703                ::core::stringify!(SimpleAnimationPlayable),
3704                ::core::stringify!(new),
3705            )
3706        });
3707        <Self as ISimpleAnimationPlayableMethods>::ctor(this);
3708        this
3709    }
3710}
3711
3712#[cfg(feature = "root-simpleanimationplayable")]
3713#[doc(hidden)]
3714pub mod prelude {
3715    pub use super::{
3716        ISimpleAnimationPlayable, ISimpleAnimationPlayableMethods, ISimpleAnimationPlayable_IState, ISimpleAnimationPlayable_IStateMethods,
3717        ISimpleAnimationPlayable_StateEnumerable, ISimpleAnimationPlayable_StateEnumerableMethods,
3718        ISimpleAnimationPlayable_StateEnumerable_StateEnumerator, ISimpleAnimationPlayable_StateEnumerable_StateEnumeratorMethods,
3719        ISimpleAnimationPlayable_StateHandle, ISimpleAnimationPlayable_StateHandleMethods, ISimpleAnimationPlayable_StateInfo,
3720        ISimpleAnimationPlayable_StateInfoMethods, ISimpleAnimationPlayable_StateManagement, ISimpleAnimationPlayable_StateManagementMethods,
3721        SimpleAnimationPlayable, SimpleAnimationPlayable_IState, SimpleAnimationPlayable_QueuedState, SimpleAnimationPlayable_StateEnumerable,
3722        SimpleAnimationPlayable_StateEnumerable_StateEnumerator, SimpleAnimationPlayable_StateHandle, SimpleAnimationPlayable_StateInfo,
3723        SimpleAnimationPlayable_StateManagement,
3724    };
3725    #[cfg(feature = "system-object")]
3726    pub use crate::system::object::IObjectMethods;
3727    #[cfg(feature = "system-valuetype")]
3728    pub use crate::system::valuetype::IValueTypeMethods;
3729    #[cfg(feature = "unity_engine-playables-playablebehaviour")]
3730    pub use crate::unity_engine::playables::playablebehaviour::IPlayableBehaviourMethods;
3731    pub use crate::{
3732        system::{object::IObject, valuetype::IValueType},
3733        unity_engine::playables::playablebehaviour::IPlayableBehaviour,
3734    };
3735}
engage/generated/root/simpleanimationplayable.rs

engage/generated/root/
simpleanimationplayable.rs
