1#[cfg(feature = "unity_engine-resource_management-util-delayedactionmanager-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::{
14 behaviour::{Behaviour, IBehaviour},
15 component::{Component, IComponent},
16 monobehaviour::{IMonoBehaviour, MonoBehaviour},
17 object_2::{IObject_2, Object_2},
18 resource_management::util::componentsingleton_1_2::{ComponentSingleton_1_2, IComponentSingleton_1_2},
19 },
20 };
21
22 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/unity_engine/resource_management/util/delayedactionmanager/DelayedActionManager_DelegateInfo.md"))]
23 #[repr(C)]
24 #[derive(::core::clone::Clone, ::core::marker::Copy)]
25 pub struct DelayedActionManager_DelegateInfo {
26 pub m_id: i32,
27 pub m_delegate: crate::system::delegate::Delegate,
28 pub m_target: ::unity::Array<crate::system::object::Object>,
29 }
30 impl ::unity::ClassIdentity for DelayedActionManager_DelegateInfo {
31 const NAME: &'static str = "DelayedActionManager.DelegateInfo";
32 const NAMESPACE: &'static str = "UnityEngine.ResourceManagement.Util";
33
34 fn class() -> ::unity::Class {
35 static CACHE: ::std::sync::OnceLock<::unity::Class> = ::std::sync::OnceLock::new();
36 *CACHE.get_or_init(|| ::unity::Class::lookup(Self::NAMESPACE, Self::NAME))
37 }
38 }
39 impl ::unity::IlType for DelayedActionManager_DelegateInfo {
40 fn il_type() -> &'static ::unity::il2cpp::Il2CppType {
41 &<Self as ::unity::ClassIdentity>::class().raw()._1.byval_arg
42 }
43 }
44 impl DelayedActionManager_DelegateInfo {
45 #[inline]
46 pub fn s_id() -> i32 {
47 static OFFSET: ::std::sync::OnceLock<usize> = ::std::sync::OnceLock::new();
48 let __offset = ::unity::cached_field_offset_static::<Self>(&OFFSET, "s_Id");
49 ::unity::static_field_get_value_at_offset(<Self as ::unity::ClassIdentity>::class(), __offset)
50 }
51
52 #[inline]
53 pub fn set_s_id(value: i32) {
54 static OFFSET: ::std::sync::OnceLock<usize> = ::std::sync::OnceLock::new();
55 let __offset = ::unity::cached_field_offset_static::<Self>(&OFFSET, "s_Id");
56 ::unity::static_field_set_value_at_offset(<Self as ::unity::ClassIdentity>::class(), __offset, value);
57 }
58 }
59
60 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/unity_engine/resource_management/util/delayedactionmanager/DelayedActionManager.md"))]
61 #[::unity::class(namespace = "UnityEngine.ResourceManagement.Util", name = "DelayedActionManager")]
62 #[parent(crate::unity_engine::resource_management::util::componentsingleton_1_2::ComponentSingleton_1_2<crate::unity_engine::resource_management::util::delayedactionmanager::DelayedActionManager>)]
63 pub struct DelayedActionManager {
64 #[offset(24)]
65 #[rename(name = "m_Actions")]
66 pub m_actions: ::unity::Array<
67 crate::system::collections::generic::list_1::List_1<
68 crate::unity_engine::resource_management::util::delayedactionmanager::DelayedActionManager_DelegateInfo,
69 >,
70 >,
71 #[offset(32)]
72 #[rename(name = "m_DelayedActions")]
73 pub m_delayed_actions: crate::system::collections::generic::linkedlist_1::LinkedList_1<
74 crate::unity_engine::resource_management::util::delayedactionmanager::DelayedActionManager_DelegateInfo,
75 >,
76 #[offset(40)]
77 #[rename(name = "m_NodeCache")]
78 pub m_node_cache: crate::system::collections::generic::stack_1::Stack_1<
79 crate::system::collections::generic::linkedlistnode_1::LinkedListNode_1<
80 crate::unity_engine::resource_management::util::delayedactionmanager::DelayedActionManager_DelegateInfo,
81 >,
82 >,
83 #[offset(48)]
84 #[rename(name = "m_CollectionIndex")]
85 pub m_collection_index: i32,
86 #[offset(52)]
87 #[rename(name = "m_DestroyOnCompletion")]
88 pub m_destroy_on_completion: bool,
89 }
90}
91
92#[cfg(feature = "unity_engine-resource_management-util-delayedactionmanager-types")]
93pub use __types::*;
94
95#[cfg(feature = "unity_engine-resource_management-util-delayedactionmanager")]
96#[doc(hidden)]
97#[allow(non_snake_case, non_camel_case_types, clippy::too_many_arguments)]
98mod __DelayedActionManager_DelegateInfo_unity_raw {
99 use super::*;
100 #[doc(hidden)]
101 #[allow(non_snake_case)]
102 pub mod __lookup_ctor {
103 use super::*;
104 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
105 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[
106 <crate::system::delegate::Delegate as ::unity::IlType>::il_type(),
107 <f32 as ::unity::IlType>::il_type(),
108 <::unity::Array<crate::system::object::Object> as ::unity::IlType>::il_type(),
109 ];
110 ::unity::lookup::method_info_on_class_with_signature(
111 <DelayedActionManager_DelegateInfo as ::unity::ClassIdentity>::class(),
112 ".ctor",
113 3,
114 param_types,
115 false,
116 )
117 });
118 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
119 match &*METHOD {
120 ::core::result::Result::Ok(mi) => *mi,
121 ::core::result::Result::Err(e) => {
122 panic!(
123 "method lookup failed: {}
124::{}
125: {}
126",
127 <DelayedActionManager_DelegateInfo as ::unity::ClassIdentity>::NAME,
128 ".ctor",
129 e
130 )
131 },
132 }
133 }
134 }
135 #[doc(hidden)]
136 #[allow(non_snake_case)]
137 pub mod __lookup_get_invocation_time {
138 use super::*;
139 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
140 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[];
141 ::unity::lookup::method_info_on_class_with_signature(
142 <DelayedActionManager_DelegateInfo as ::unity::ClassIdentity>::class(),
143 "get_InvocationTime",
144 0,
145 param_types,
146 false,
147 )
148 });
149 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
150 match &*METHOD {
151 ::core::result::Result::Ok(mi) => *mi,
152 ::core::result::Result::Err(e) => {
153 panic!(
154 "method lookup failed: {}
155::{}
156: {}
157",
158 <DelayedActionManager_DelegateInfo as ::unity::ClassIdentity>::NAME,
159 "get_InvocationTime",
160 e
161 )
162 },
163 }
164 }
165 }
166 #[doc(hidden)]
167 #[allow(non_snake_case)]
168 pub mod __lookup_set_invocation_time {
169 use super::*;
170 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
171 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[<f32 as ::unity::IlType>::il_type()];
172 ::unity::lookup::method_info_on_class_with_signature(
173 <DelayedActionManager_DelegateInfo as ::unity::ClassIdentity>::class(),
174 "set_InvocationTime",
175 1,
176 param_types,
177 false,
178 )
179 });
180 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
181 match &*METHOD {
182 ::core::result::Result::Ok(mi) => *mi,
183 ::core::result::Result::Err(e) => {
184 panic!(
185 "method lookup failed: {}
186::{}
187: {}
188",
189 <DelayedActionManager_DelegateInfo as ::unity::ClassIdentity>::NAME,
190 "set_InvocationTime",
191 e
192 )
193 },
194 }
195 }
196 }
197 #[doc(hidden)]
198 #[allow(non_snake_case)]
199 pub mod __lookup_to_string {
200 use super::*;
201 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
202 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[];
203 ::unity::lookup::method_info_on_class_with_signature(
204 <DelayedActionManager_DelegateInfo as ::unity::ClassIdentity>::class(),
205 "ToString",
206 0,
207 param_types,
208 false,
209 )
210 });
211 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
212 match &*METHOD {
213 ::core::result::Result::Ok(mi) => *mi,
214 ::core::result::Result::Err(e) => {
215 panic!(
216 "method lookup failed: {}
217::{}
218: {}
219",
220 <DelayedActionManager_DelegateInfo as ::unity::ClassIdentity>::NAME,
221 "ToString",
222 e
223 )
224 },
225 }
226 }
227 }
228 #[doc(hidden)]
229 #[allow(non_snake_case)]
230 pub mod __lookup_invoke {
231 use super::*;
232 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
233 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[];
234 ::unity::lookup::method_info_on_class_with_signature(
235 <DelayedActionManager_DelegateInfo as ::unity::ClassIdentity>::class(),
236 "Invoke",
237 0,
238 param_types,
239 false,
240 )
241 });
242 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
243 match &*METHOD {
244 ::core::result::Result::Ok(mi) => *mi,
245 ::core::result::Result::Err(e) => {
246 panic!(
247 "method lookup failed: {}
248::{}
249: {}
250",
251 <DelayedActionManager_DelegateInfo as ::unity::ClassIdentity>::NAME,
252 "Invoke",
253 e
254 )
255 },
256 }
257 }
258 }
259}
260
261#[cfg(feature = "unity_engine-resource_management-util-delayedactionmanager")]
262impl DelayedActionManager_DelegateInfo {
263 #[doc = "`.ctor(crate::system::delegate::Delegate, f32, ::unity::Array<crate::system::object::Object>)` overload"]
264 pub fn ctor(
265 &mut self,
266 d: impl ::core::convert::Into<crate::system::delegate::Delegate>,
267 invocation_time: impl ::core::convert::Into<f32>,
268 p: impl ::core::convert::Into<::unity::Array<crate::system::object::Object>>,
269 ) -> () {
270 unsafe {
271 ::unity::il2cpp_call!(::unity::callable_ptr(__DelayedActionManager_DelegateInfo_unity_raw::__lookup_ctor::get_method_info().method_ptr),();
272(*mut DelayedActionManager_DelegateInfo)self as*mut DelayedActionManager_DelegateInfo,(crate::system::delegate::Delegate)::core::convert::Into::into(d),(f32)::core::convert::Into::into(invocation_time),(::unity::Array<crate::system::object::Object>)::core::convert::Into::into(p))
273 }
274 }
275
276 #[doc = "`get_InvocationTime()` overload"]
277 pub fn get_invocation_time(&mut self) -> f32 {
278 unsafe {
279 ::unity::il2cpp_call!(::unity::callable_ptr(__DelayedActionManager_DelegateInfo_unity_raw::__lookup_get_invocation_time::get_method_info().method_ptr),f32;
280(*mut DelayedActionManager_DelegateInfo)self as*mut DelayedActionManager_DelegateInfo)
281 }
282 }
283
284 #[doc = "`set_InvocationTime(f32)` overload"]
285 pub fn set_invocation_time(&mut self, value: impl ::core::convert::Into<f32>) -> () {
286 unsafe {
287 ::unity::il2cpp_call!(::unity::callable_ptr(__DelayedActionManager_DelegateInfo_unity_raw::__lookup_set_invocation_time::get_method_info().method_ptr),();
288(*mut DelayedActionManager_DelegateInfo)self as*mut DelayedActionManager_DelegateInfo,(f32)::core::convert::Into::into(value))
289 }
290 }
291
292 #[doc = "`ToString()` overload"]
293 pub fn to_string(&mut self) -> ::unity::Il2CppString {
294 unsafe {
295 ::unity::il2cpp_call!(::unity::callable_ptr(__DelayedActionManager_DelegateInfo_unity_raw::__lookup_to_string::get_method_info().method_ptr), ::unity::Il2CppString;
296(*mut DelayedActionManager_DelegateInfo)self as*mut DelayedActionManager_DelegateInfo)
297 }
298 }
299
300 #[doc = "`Invoke()` overload"]
301 pub fn invoke(&mut self) -> () {
302 unsafe {
303 ::unity::il2cpp_call!(::unity::callable_ptr(__DelayedActionManager_DelegateInfo_unity_raw::__lookup_invoke::get_method_info().method_ptr),();
304(*mut DelayedActionManager_DelegateInfo)self as*mut DelayedActionManager_DelegateInfo)
305 }
306 }
307}
308
309#[cfg(feature = "unity_engine-resource_management-util-delayedactionmanager")]
310impl DelayedActionManager_DelegateInfo {
311 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
312 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
313 }
314
315 pub fn get_invocation_time_method_info() -> &'static ::unity::il2cpp::MethodInfo {
316 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
317 }
318
319 pub fn set_invocation_time_method_info() -> &'static ::unity::il2cpp::MethodInfo {
320 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
321 }
322
323 pub fn to_string_method_info() -> &'static ::unity::il2cpp::MethodInfo {
324 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
325 }
326
327 pub fn invoke_method_info() -> &'static ::unity::il2cpp::MethodInfo {
328 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
329 }
330}
331
332#[cfg(feature = "unity_engine-resource_management-util-delayedactionmanager")]
333#[doc(hidden)]
334#[allow(non_snake_case, non_camel_case_types, clippy::too_many_arguments)]
335mod __DelayedActionManager_unity_raw {
336 use super::*;
337 #[doc(hidden)]
338 #[allow(non_snake_case)]
339 pub mod __lookup_get_node {
340 use super::*;
341 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
342 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[
343 <crate::unity_engine::resource_management::util::delayedactionmanager::DelayedActionManager_DelegateInfo as ::unity::IlType>::il_type(
344 ),
345 ];
346 ::unity::lookup::method_info_on_class_with_signature(
347 <DelayedActionManager as ::unity::ClassIdentity>::class(),
348 "GetNode",
349 1,
350 param_types,
351 false,
352 )
353 });
354 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
355 match &*METHOD {
356 ::core::result::Result::Ok(mi) => *mi,
357 ::core::result::Result::Err(e) => {
358 panic!(
359 "method lookup failed: {}
360::{}
361: {}
362",
363 <DelayedActionManager as ::unity::ClassIdentity>::NAME,
364 "GetNode",
365 e
366 )
367 },
368 }
369 }
370 }
371 #[doc(hidden)]
372 #[allow(non_snake_case)]
373 pub mod __lookup_clear {
374 use super::*;
375 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
376 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[];
377 ::unity::lookup::method_info_on_class_with_signature(
378 <DelayedActionManager as ::unity::ClassIdentity>::class(),
379 "Clear",
380 0,
381 param_types,
382 true,
383 )
384 });
385 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
386 match &*METHOD {
387 ::core::result::Result::Ok(mi) => *mi,
388 ::core::result::Result::Err(e) => {
389 panic!(
390 "method lookup failed: {}
391::{}
392: {}
393",
394 <DelayedActionManager as ::unity::ClassIdentity>::NAME,
395 "Clear",
396 e
397 )
398 },
399 }
400 }
401 }
402 #[doc(hidden)]
403 #[allow(non_snake_case)]
404 pub mod __lookup_destroy_when_complete {
405 use super::*;
406 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
407 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[];
408 ::unity::lookup::method_info_on_class_with_signature(
409 <DelayedActionManager as ::unity::ClassIdentity>::class(),
410 "DestroyWhenComplete",
411 0,
412 param_types,
413 false,
414 )
415 });
416 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
417 match &*METHOD {
418 ::core::result::Result::Ok(mi) => *mi,
419 ::core::result::Result::Err(e) => {
420 panic!(
421 "method lookup failed: {}
422::{}
423: {}
424",
425 <DelayedActionManager as ::unity::ClassIdentity>::NAME,
426 "DestroyWhenComplete",
427 e
428 )
429 },
430 }
431 }
432 }
433 #[doc(hidden)]
434 #[allow(non_snake_case)]
435 pub mod __lookup_add_action {
436 use super::*;
437 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
438 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[
439 <crate::system::delegate::Delegate as ::unity::IlType>::il_type(),
440 <f32 as ::unity::IlType>::il_type(),
441 <::unity::Array<crate::system::object::Object> as ::unity::IlType>::il_type(),
442 ];
443 ::unity::lookup::method_info_on_class_with_signature(
444 <DelayedActionManager as ::unity::ClassIdentity>::class(),
445 "AddAction",
446 3,
447 param_types,
448 true,
449 )
450 });
451 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
452 match &*METHOD {
453 ::core::result::Result::Ok(mi) => *mi,
454 ::core::result::Result::Err(e) => {
455 panic!(
456 "method lookup failed: {}
457::{}
458: {}
459",
460 <DelayedActionManager as ::unity::ClassIdentity>::NAME,
461 "AddAction",
462 e
463 )
464 },
465 }
466 }
467 }
468 #[doc(hidden)]
469 #[allow(non_snake_case)]
470 pub mod __lookup_add_action_internal {
471 use super::*;
472 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
473 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[
474 <crate::system::delegate::Delegate as ::unity::IlType>::il_type(),
475 <f32 as ::unity::IlType>::il_type(),
476 <::unity::Array<crate::system::object::Object> as ::unity::IlType>::il_type(),
477 ];
478 ::unity::lookup::method_info_on_class_with_signature(
479 <DelayedActionManager as ::unity::ClassIdentity>::class(),
480 "AddActionInternal",
481 3,
482 param_types,
483 false,
484 )
485 });
486 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
487 match &*METHOD {
488 ::core::result::Result::Ok(mi) => *mi,
489 ::core::result::Result::Err(e) => {
490 panic!(
491 "method lookup failed: {}
492::{}
493: {}
494",
495 <DelayedActionManager as ::unity::ClassIdentity>::NAME,
496 "AddActionInternal",
497 e
498 )
499 },
500 }
501 }
502 }
503 #[doc(hidden)]
504 #[allow(non_snake_case)]
505 pub mod __lookup_get_is_active {
506 use super::*;
507 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
508 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[];
509 ::unity::lookup::method_info_on_class_with_signature(
510 <DelayedActionManager as ::unity::ClassIdentity>::class(),
511 "get_IsActive",
512 0,
513 param_types,
514 true,
515 )
516 });
517 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
518 match &*METHOD {
519 ::core::result::Result::Ok(mi) => *mi,
520 ::core::result::Result::Err(e) => {
521 panic!(
522 "method lookup failed: {}
523::{}
524: {}
525",
526 <DelayedActionManager as ::unity::ClassIdentity>::NAME,
527 "get_IsActive",
528 e
529 )
530 },
531 }
532 }
533 }
534 #[doc(hidden)]
535 #[allow(non_snake_case)]
536 pub mod __lookup_wait {
537 use super::*;
538 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
539 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[<f32 as ::unity::IlType>::il_type(), <f32 as ::unity::IlType>::il_type()];
540 ::unity::lookup::method_info_on_class_with_signature(
541 <DelayedActionManager as ::unity::ClassIdentity>::class(),
542 "Wait",
543 2,
544 param_types,
545 true,
546 )
547 });
548 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
549 match &*METHOD {
550 ::core::result::Result::Ok(mi) => *mi,
551 ::core::result::Result::Err(e) => {
552 panic!(
553 "method lookup failed: {}
554::{}
555: {}
556",
557 <DelayedActionManager as ::unity::ClassIdentity>::NAME,
558 "Wait",
559 e
560 )
561 },
562 }
563 }
564 }
565 #[doc(hidden)]
566 #[allow(non_snake_case)]
567 pub mod __lookup_late_update {
568 use super::*;
569 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
570 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[];
571 ::unity::lookup::method_info_on_class_with_signature(
572 <DelayedActionManager as ::unity::ClassIdentity>::class(),
573 "LateUpdate",
574 0,
575 param_types,
576 false,
577 )
578 });
579 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
580 match &*METHOD {
581 ::core::result::Result::Ok(mi) => *mi,
582 ::core::result::Result::Err(e) => {
583 panic!(
584 "method lookup failed: {}
585::{}
586: {}
587",
588 <DelayedActionManager as ::unity::ClassIdentity>::NAME,
589 "LateUpdate",
590 e
591 )
592 },
593 }
594 }
595 }
596 #[doc(hidden)]
597 #[allow(non_snake_case)]
598 pub mod __lookup_internal_late_update {
599 use super::*;
600 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
601 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[<f32 as ::unity::IlType>::il_type()];
602 ::unity::lookup::method_info_on_class_with_signature(
603 <DelayedActionManager as ::unity::ClassIdentity>::class(),
604 "InternalLateUpdate",
605 1,
606 param_types,
607 false,
608 )
609 });
610 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
611 match &*METHOD {
612 ::core::result::Result::Ok(mi) => *mi,
613 ::core::result::Result::Err(e) => {
614 panic!(
615 "method lookup failed: {}
616::{}
617: {}
618",
619 <DelayedActionManager as ::unity::ClassIdentity>::NAME,
620 "InternalLateUpdate",
621 e
622 )
623 },
624 }
625 }
626 }
627 #[doc(hidden)]
628 #[allow(non_snake_case)]
629 pub mod __lookup_on_application_quit {
630 use super::*;
631 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
632 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[];
633 ::unity::lookup::method_info_on_class_with_signature(
634 <DelayedActionManager as ::unity::ClassIdentity>::class(),
635 "OnApplicationQuit",
636 0,
637 param_types,
638 false,
639 )
640 });
641 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
642 match &*METHOD {
643 ::core::result::Result::Ok(mi) => *mi,
644 ::core::result::Result::Err(e) => {
645 panic!(
646 "method lookup failed: {}
647::{}
648: {}
649",
650 <DelayedActionManager as ::unity::ClassIdentity>::NAME,
651 "OnApplicationQuit",
652 e
653 )
654 },
655 }
656 }
657 }
658 #[doc(hidden)]
659 #[allow(non_snake_case)]
660 pub mod __lookup_ctor {
661 use super::*;
662 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
663 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[];
664 ::unity::lookup::method_info_on_class_with_signature(
665 <DelayedActionManager as ::unity::ClassIdentity>::class(),
666 ".ctor",
667 0,
668 param_types,
669 false,
670 )
671 });
672 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
673 match &*METHOD {
674 ::core::result::Result::Ok(mi) => *mi,
675 ::core::result::Result::Err(e) => {
676 panic!(
677 "method lookup failed: {}
678::{}
679: {}
680",
681 <DelayedActionManager as ::unity::ClassIdentity>::NAME,
682 ".ctor",
683 e
684 )
685 },
686 }
687 }
688 }
689}
690
691#[cfg(feature = "unity_engine-resource_management-util-delayedactionmanager")]
692impl DelayedActionManager {
693 #[doc = "`Clear()` overload"]
694 pub fn clear() -> () {
695 unsafe {
696 ::unity::il2cpp_call!(__DelayedActionManager_unity_raw::__lookup_clear::get_method_info().method_ptr,();
697 )
698 }
699 }
700
701 #[doc = "`AddAction(crate::system::delegate::Delegate, f32, ::unity::Array<crate::system::object::Object>)` overload"]
702 pub fn add_action(
703 action: impl ::core::convert::Into<crate::system::delegate::Delegate>,
704 delay: impl ::core::convert::Into<f32>,
705 parameters: impl ::core::convert::Into<::unity::Array<crate::system::object::Object>>,
706 ) -> () {
707 unsafe {
708 ::unity::il2cpp_call!(__DelayedActionManager_unity_raw::__lookup_add_action::get_method_info().method_ptr,();
709(crate::system::delegate::Delegate)::core::convert::Into::into(action),(f32)::core::convert::Into::into(delay),(::unity::Array<crate::system::object::Object>)::core::convert::Into::into(parameters))
710 }
711 }
712
713 #[doc = "`get_IsActive()` overload"]
714 pub fn get_is_active() -> bool {
715 unsafe {
716 ::unity::il2cpp_call!(__DelayedActionManager_unity_raw::__lookup_get_is_active::get_method_info().method_ptr,bool;
717 )
718 }
719 }
720
721 #[doc = "`Wait(f32, f32)` overload"]
722 pub fn wait(timeout: impl ::core::convert::Into<f32>, time_advance_amount: impl ::core::convert::Into<f32>) -> bool {
723 unsafe {
724 ::unity::il2cpp_call!(__DelayedActionManager_unity_raw::__lookup_wait::get_method_info().method_ptr,bool;
725(f32)::core::convert::Into::into(timeout),(f32)::core::convert::Into::into(time_advance_amount))
726 }
727 }
728}
729
730#[cfg(feature = "unity_engine-resource_management-util-delayedactionmanager")]
731pub trait IDelayedActionManagerMethods: IDelayedActionManager {
732 #[doc = "`GetNode(*mutcrate::unity_engine::resource_management::util::delayedactionmanager::DelayedActionManager_DelegateInfo)` overload"]
733 fn get_node(
734 self,
735 ) -> (
736 crate::system::collections::generic::linkedlistnode_1::LinkedListNode_1<
737 crate::unity_engine::resource_management::util::delayedactionmanager::DelayedActionManager_DelegateInfo,
738 >,
739 crate::unity_engine::resource_management::util::delayedactionmanager::DelayedActionManager_DelegateInfo,
740 ) {
741 unsafe {
742 let __receiver = <DelayedActionManager as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
743 let mut __out_0 = ::core::mem::MaybeUninit::<
744 crate::unity_engine::resource_management::util::delayedactionmanager::DelayedActionManager_DelegateInfo,
745 >::uninit();
746 let __ret = {
747 ::unity::il2cpp_call!(__DelayedActionManager_unity_raw::__lookup_get_node::get_method_info().method_ptr,crate::system::collections::generic::linkedlistnode_1::LinkedListNode_1<crate::unity_engine::resource_management::util::delayedactionmanager::DelayedActionManager_DelegateInfo> ;
748(DelayedActionManager)__receiver,(*mut crate::unity_engine::resource_management::util::delayedactionmanager::DelayedActionManager_DelegateInfo)__out_0.as_mut_ptr())
749 };
750 (__ret, __out_0.assume_init())
751 }
752 }
753 #[doc = "`DestroyWhenComplete()` overload"]
754 fn destroy_when_complete(self) -> () {
755 unsafe {
756 let __receiver = <DelayedActionManager as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
757 ::unity::il2cpp_call!(__DelayedActionManager_unity_raw::__lookup_destroy_when_complete::get_method_info().method_ptr,();
758(DelayedActionManager)__receiver)
759 }
760 }
761 #[doc = "`AddActionInternal(crate::system::delegate::Delegate, f32, ::unity::Array<crate::system::object::Object>)` overload"]
762 fn add_action_internal(
763 self,
764 action: impl ::core::convert::Into<crate::system::delegate::Delegate>,
765 delay: impl ::core::convert::Into<f32>,
766 parameters: impl ::core::convert::Into<::unity::Array<crate::system::object::Object>>,
767 ) -> () {
768 unsafe {
769 let __receiver = <DelayedActionManager as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
770 ::unity::il2cpp_call!(__DelayedActionManager_unity_raw::__lookup_add_action_internal::get_method_info().method_ptr,();
771(DelayedActionManager)__receiver,(crate::system::delegate::Delegate)::core::convert::Into::into(action),(f32)::core::convert::Into::into(delay),(::unity::Array<crate::system::object::Object>)::core::convert::Into::into(parameters))
772 }
773 }
774 #[doc = "`LateUpdate()` overload"]
775 fn late_update(self) -> () {
776 unsafe {
777 let __receiver = <DelayedActionManager as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
778 ::unity::il2cpp_call!(__DelayedActionManager_unity_raw::__lookup_late_update::get_method_info().method_ptr,();
779(DelayedActionManager)__receiver)
780 }
781 }
782 #[doc = "`InternalLateUpdate(f32)` overload"]
783 fn internal_late_update(self, t: impl ::core::convert::Into<f32>) -> () {
784 unsafe {
785 let __receiver = <DelayedActionManager as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
786 ::unity::il2cpp_call!(__DelayedActionManager_unity_raw::__lookup_internal_late_update::get_method_info().method_ptr,();
787(DelayedActionManager)__receiver,(f32)::core::convert::Into::into(t))
788 }
789 }
790 #[doc = "`OnApplicationQuit()` overload"]
791 fn on_application_quit(self) -> () {
792 unsafe {
793 let __receiver = <DelayedActionManager as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
794 ::unity::il2cpp_call!(__DelayedActionManager_unity_raw::__lookup_on_application_quit::get_method_info().method_ptr,();
795(DelayedActionManager)__receiver)
796 }
797 }
798 #[doc = "`.ctor()` overload"]
799 fn ctor(self) -> () {
800 unsafe {
801 let __receiver = <DelayedActionManager as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
802 ::unity::il2cpp_call!(__DelayedActionManager_unity_raw::__lookup_ctor::get_method_info().method_ptr,();
803(DelayedActionManager)__receiver)
804 }
805 }
806}
807
808#[cfg(feature = "unity_engine-resource_management-util-delayedactionmanager")]
809impl<__T: IDelayedActionManager> IDelayedActionManagerMethods for __T {}
810
811#[cfg(feature = "unity_engine-resource_management-util-delayedactionmanager")]
812impl DelayedActionManager {
813 pub fn get_node_method_info() -> &'static ::unity::il2cpp::MethodInfo {
814 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
815 }
816
817 pub fn clear_method_info() -> &'static ::unity::il2cpp::MethodInfo {
818 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
819 }
820
821 pub fn destroy_when_complete_method_info() -> &'static ::unity::il2cpp::MethodInfo {
822 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
823 }
824
825 pub fn add_action_method_info() -> &'static ::unity::il2cpp::MethodInfo {
826 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
827 }
828
829 pub fn add_action_internal_method_info() -> &'static ::unity::il2cpp::MethodInfo {
830 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
831 }
832
833 pub fn get_is_active_method_info() -> &'static ::unity::il2cpp::MethodInfo {
834 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[5]
835 }
836
837 pub fn wait_method_info() -> &'static ::unity::il2cpp::MethodInfo {
838 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[6]
839 }
840
841 pub fn late_update_method_info() -> &'static ::unity::il2cpp::MethodInfo {
842 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[7]
843 }
844
845 pub fn internal_late_update_method_info() -> &'static ::unity::il2cpp::MethodInfo {
846 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[8]
847 }
848
849 pub fn on_application_quit_method_info() -> &'static ::unity::il2cpp::MethodInfo {
850 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[9]
851 }
852
853 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
854 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[10]
855 }
856}
857
858#[cfg(feature = "unity_engine-resource_management-util-delayedactionmanager")]
859impl DelayedActionManager {
860 #[doc = "`.ctor()` — no args"]
861 pub fn new() -> Self {
862 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
863 panic!(
864 "{}
865::{}
866 failed to instantiate",
867 ::core::stringify!(DelayedActionManager),
868 ::core::stringify!(new),
869 )
870 });
871 <Self as IDelayedActionManagerMethods>::ctor(this);
872 this
873 }
874}
875
876#[cfg(feature = "unity_engine-resource_management-util-delayedactionmanager")]
877#[doc(hidden)]
878pub mod prelude {
879 pub use super::{DelayedActionManager, DelayedActionManager_DelegateInfo, IDelayedActionManager, IDelayedActionManagerMethods};
880 #[cfg(feature = "system-object")]
881 pub use crate::system::object::IObjectMethods;
882 #[cfg(feature = "system-valuetype")]
883 pub use crate::system::valuetype::IValueTypeMethods;
884 #[cfg(feature = "unity_engine-behaviour")]
885 pub use crate::unity_engine::behaviour::IBehaviourMethods;
886 #[cfg(feature = "unity_engine-component")]
887 pub use crate::unity_engine::component::IComponentMethods;
888 #[cfg(feature = "unity_engine-monobehaviour")]
889 pub use crate::unity_engine::monobehaviour::IMonoBehaviourMethods;
890 #[cfg(feature = "unity_engine-object_2")]
891 pub use crate::unity_engine::object_2::IObject_2Methods;
892 #[cfg(feature = "unity_engine-resource_management-util-componentsingleton_1_2")]
893 pub use crate::unity_engine::resource_management::util::componentsingleton_1_2::IComponentSingleton_1_2Methods;
894 pub use crate::{
895 system::{object::IObject, valuetype::IValueType},
896 unity_engine::{
897 behaviour::IBehaviour, component::IComponent, monobehaviour::IMonoBehaviour, object_2::IObject_2,
898 resource_management::util::componentsingleton_1_2::IComponentSingleton_1_2,
899 },
900 };
901}