1#[cfg(feature = "unity_engine-resource_management-resourcemanager-types")]
4mod __types {
5 #[allow(unused_imports)] use ::unity::prelude::*;
6
7 use super::*;
8 use crate::{
9 system::{
10 object::{IObject, Object},
11 r#enum::{Enum, IEnum},
12 valuetype::{IValueType, ValueType},
13 },
14 unity_engine::resource_management::async_operations::asyncoperationbase_1::{AsyncOperationBase_1, IAsyncOperationBase_1},
15 };
16
17 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/unity_engine/resource_management/resourcemanager/ResourceManager_CompletedOperation_1.md"))]
18 #[::unity::class(namespace = "UnityEngine.ResourceManagement", name = "ResourceManager.CompletedOperation`1")]
19 #[parent(crate::unity_engine::resource_management::async_operations::asyncoperationbase_1::AsyncOperationBase_1<T0>)]
20 #[parent(crate::system::object::Object)]
21 pub struct ResourceManager_CompletedOperation_1<T0: ::unity::ClassIdentity> {
22 #[rename(name = "m_Success")]
23 pub m_success: bool,
24 #[rename(name = "m_ReleaseDependenciesOnFailure")]
25 pub m_release_dependencies_on_failure: bool,
26 }
27
28 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/unity_engine/resource_management/resourcemanager/ResourceManager.md"))]
29 #[::unity::class(namespace = "UnityEngine.ResourceManagement", name = "ResourceManager")]
30 #[parent(crate::system::object::Object)]
31 pub struct ResourceManager {
32 #[offset(16)]
33 #[rename(name = "postProfilerEvents")]
34 pub post_profiler_events: bool,
35 #[offset(40)]
36 #[rename(name = "CallbackHooksEnabled")]
37 pub callback_hooks_enabled: bool,
38 #[offset(48)]
39 #[rename(name = "m_ResourceProviders")]
40 pub m_resource_providers: crate::root::listwithevents_1::ListWithEvents_1<
41 crate::unity_engine::resource_management::resource_providers::iresourceprovider::IResourceProvider,
42 >,
43 #[offset(56)]
44 #[rename(name = "m_allocator")]
45 pub m_allocator: crate::unity_engine::resource_management::util::iallocationstrategy::IAllocationStrategy,
46 #[offset(64)]
47 #[rename(name = "m_UpdateReceivers")]
48 pub m_update_receivers:
49 crate::root::listwithevents_1::ListWithEvents_1<crate::unity_engine::resource_management::iupdatereceiver::IUpdateReceiver>,
50 #[offset(72)]
51 #[rename(name = "m_UpdateReceiversToRemove")]
52 pub m_update_receivers_to_remove:
53 crate::system::collections::generic::list_1::List_1<crate::unity_engine::resource_management::iupdatereceiver::IUpdateReceiver>,
54 #[offset(80)]
55 #[rename(name = "m_UpdatingReceivers")]
56 pub m_updating_receivers: bool,
57 #[offset(81)]
58 #[rename(name = "m_InsideUpdateMethod")]
59 pub m_inside_update_method: bool,
60 #[offset(88)]
61 #[rename(name = "m_providerMap")]
62 pub m_provider_map: crate::system::collections::generic::dictionary_2::Dictionary_2<
63 i32,
64 crate::unity_engine::resource_management::resource_providers::iresourceprovider::IResourceProvider,
65 >,
66 #[offset(96)]
67 #[rename(name = "m_AssetOperationCache")]
68 pub m_asset_operation_cache: crate::system::collections::generic::dictionary_2::Dictionary_2<
69 crate::unity_engine::resource_management::util::ioperationcachekey::IOperationCacheKey,
70 crate::unity_engine::resource_management::async_operations::iasyncoperation::IAsyncOperation,
71 >,
72 #[offset(104)]
73 #[rename(name = "m_TrackedInstanceOperations")]
74 pub m_tracked_instance_operations: crate::system::collections::generic::hashset_1::HashSet_1<
75 crate::unity_engine::resource_management::resourcemanager::ResourceManager_InstanceOperation,
76 >,
77 #[offset(112)]
78 #[rename(name = "m_UpdateCallbacks")]
79 pub m_update_callbacks: crate::root::delegatelist_1::DelegateList_1<f32>,
80 #[offset(120)]
81 #[rename(name = "m_DeferredCompleteCallbacks")]
82 pub m_deferred_complete_callbacks: crate::system::collections::generic::list_1::List_1<
83 crate::unity_engine::resource_management::async_operations::iasyncoperation::IAsyncOperation,
84 >,
85 #[offset(128)]
86 #[rename(name = "m_obsoleteDiagnosticsHandler")]
87 pub m_obsolete_diagnostics_handler: crate::system::action_4::Action_4<
88 crate::unity_engine::resource_management::async_operations::asyncoperationhandle::AsyncOperationHandle,
89 crate::unity_engine::resource_management::resourcemanager::ResourceManager_DiagnosticEventType,
90 i32,
91 crate::system::object::Object,
92 >,
93 #[offset(136)]
94 #[rename(name = "m_diagnosticsHandler")]
95 pub m_diagnostics_handler:
96 crate::system::action_1::Action_1<crate::unity_engine::resource_management::resourcemanager::ResourceManager_DiagnosticEventContext>,
97 #[offset(144)]
98 #[rename(name = "m_ReleaseOpNonCached")]
99 pub m_release_op_non_cached:
100 crate::system::action_1::Action_1<crate::unity_engine::resource_management::async_operations::iasyncoperation::IAsyncOperation>,
101 #[offset(152)]
102 #[rename(name = "m_ReleaseOpCached")]
103 pub m_release_op_cached:
104 crate::system::action_1::Action_1<crate::unity_engine::resource_management::async_operations::iasyncoperation::IAsyncOperation>,
105 #[offset(160)]
106 #[rename(name = "m_ReleaseInstanceOp")]
107 pub m_release_instance_op:
108 crate::system::action_1::Action_1<crate::unity_engine::resource_management::async_operations::iasyncoperation::IAsyncOperation>,
109 #[static_field]
110 #[rename(name = "s_GroupOperationTypeHash")]
111 pub s_group_operation_type_hash: i32,
112 #[static_field]
113 #[rename(name = "s_InstanceOperationTypeHash")]
114 pub s_instance_operation_type_hash: i32,
115 #[offset(176)]
116 #[rename(name = "m_RegisteredForCallbacks")]
117 pub m_registered_for_callbacks: bool,
118 #[offset(184)]
119 #[rename(name = "m_ProviderOperationTypeCache")]
120 pub m_provider_operation_type_cache:
121 crate::system::collections::generic::dictionary_2::Dictionary_2<::unity::SystemType, ::unity::SystemType>,
122 }
123
124 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/unity_engine/resource_management/resourcemanager/ResourceManager_DiagnosticEventContext.md"))]
125 #[repr(C)]
126 #[derive(::core::clone::Clone, ::core::marker::Copy)]
127 pub struct ResourceManager_DiagnosticEventContext {}
128 impl ::unity::ClassIdentity for ResourceManager_DiagnosticEventContext {
129 const NAME: &'static str = "ResourceManager.DiagnosticEventContext";
130 const NAMESPACE: &'static str = "UnityEngine.ResourceManagement";
131
132 fn class() -> ::unity::Class {
133 static CACHE: ::std::sync::OnceLock<::unity::Class> = ::std::sync::OnceLock::new();
134 *CACHE.get_or_init(|| ::unity::Class::lookup(Self::NAMESPACE, Self::NAME))
135 }
136 }
137 impl ::unity::IlType for ResourceManager_DiagnosticEventContext {
138 fn il_type() -> &'static ::unity::il2cpp::Il2CppType {
139 &<Self as ::unity::ClassIdentity>::class().raw()._1.byval_arg
140 }
141 }
142
143 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/unity_engine/resource_management/resourcemanager/ResourceManager_DiagnosticEventType.md"))]
144 #[repr(C)]
145 #[derive(::core::clone::Clone, ::core::marker::Copy, ::core::fmt::Debug, ::core::cmp::PartialEq, ::core::cmp::Eq)]
146 pub struct ResourceManager_DiagnosticEventType {
147 pub value: i32,
148 }
149 impl ::unity::ClassIdentity for ResourceManager_DiagnosticEventType {
150 const NAME: &'static str = "ResourceManager.DiagnosticEventType";
151 const NAMESPACE: &'static str = "UnityEngine.ResourceManagement";
152
153 fn class() -> ::unity::Class {
154 static CACHE: ::std::sync::OnceLock<::unity::Class> = ::std::sync::OnceLock::new();
155 *CACHE.get_or_init(|| ::unity::Class::lookup(Self::NAMESPACE, Self::NAME))
156 }
157 }
158 impl ::unity::IlType for ResourceManager_DiagnosticEventType {
159 fn il_type() -> &'static ::unity::il2cpp::Il2CppType {
160 &<Self as ::unity::ClassIdentity>::class().raw()._1.byval_arg
161 }
162 }
163 impl ResourceManager_DiagnosticEventType {
164 pub fn async_operation_fail() -> Self {
165 Self { value: 0 }
166 }
167
168 pub fn async_operation_create() -> Self {
169 Self { value: 1 }
170 }
171
172 pub fn async_operation_percent_complete() -> Self {
173 Self { value: 2 }
174 }
175
176 pub fn async_operation_complete() -> Self {
177 Self { value: 3 }
178 }
179
180 pub fn async_operation_reference_count() -> Self {
181 Self { value: 4 }
182 }
183
184 pub fn async_operation_destroy() -> Self {
185 Self { value: 5 }
186 }
187 }
188
189 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/unity_engine/resource_management/resourcemanager/ResourceManager_InstanceOperation.md"))]
190 #[::unity::class(namespace = "UnityEngine.ResourceManagement", name = "ResourceManager.InstanceOperation")]
191 #[parent(crate::unity_engine::resource_management::async_operations::asyncoperationbase_1::AsyncOperationBase_1<crate::unity_engine::gameobject::GameObject>)]
192 pub struct ResourceManager_InstanceOperation {
193 #[offset(136)]
194 #[rename(name = "m_dependency")]
195 pub m_dependency: crate::unity_engine::resource_management::async_operations::asyncoperationhandle_1::AsyncOperationHandle_1<
196 crate::unity_engine::gameobject::GameObject,
197 >,
198 #[offset(160)]
199 #[rename(name = "m_instantiationParams")]
200 pub m_instantiation_params: crate::unity_engine::resource_management::resource_providers::instantiationparameters::InstantiationParameters,
201 #[offset(208)]
202 #[rename(name = "m_instanceProvider")]
203 pub m_instance_provider:
204 crate::unity_engine::resource_management::resource_providers::iinstanceprovider_interface::IInstanceProvider_Interface,
205 #[offset(216)]
206 #[rename(name = "m_instance")]
207 pub m_instance: crate::unity_engine::gameobject::GameObject,
208 #[offset(224)]
209 #[rename(name = "m_scene")]
210 pub m_scene: crate::unity_engine::scene_management::scene::Scene,
211 }
212}
213
214#[cfg(feature = "unity_engine-resource_management-resourcemanager-types")]
215pub use __types::*;
216
217#[cfg(feature = "unity_engine-resource_management-resourcemanager")]
218#[::unity::methods]
219impl<T0: ::unity::ClassIdentity> ResourceManager_CompletedOperation_1<T0> {
220 #[doc = "`.ctor()` overload"]
221 #[method(name = ".ctor", args = 0)]
222 pub fn ctor(self) -> ();
223
224 #[doc = "`Init(T0, bool, ::unity::Il2CppString, bool)` overload"]
225 #[method(name = "Init", args = 4)]
226 pub fn init(self, result: T0, success: bool, error_msg: ::unity::Il2CppString, release_dependencies_on_failure: bool) -> ();
227
228 #[doc = "`get_DebugName()` overload"]
229 #[method(name = "get_DebugName", args = 0)]
230 pub fn get_debug_name(self) -> ::unity::Il2CppString;
231
232 #[doc = "`InvokeWaitForCompletion()` overload"]
233 #[method(name = "InvokeWaitForCompletion", args = 0)]
234 pub fn invoke_wait_for_completion(self) -> bool;
235
236 #[doc = "`Execute()` overload"]
237 #[method(name = "Execute", args = 0)]
238 pub fn execute(self) -> ();
239}
240
241#[cfg(feature = "unity_engine-resource_management-resourcemanager")]
242impl<T0: ::unity::ClassIdentity> ResourceManager_CompletedOperation_1<T0> {
243 #[doc = "`.ctor()` — no args"]
244 pub fn new() -> Self {
245 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
246 panic!(
247 "{}
248::{}
249 failed to instantiate",
250 ::core::stringify!(ResourceManager_CompletedOperation_1),
251 ::core::stringify!(new),
252 )
253 });
254 <Self as IResourceManager_CompletedOperation_1Methods<T0>>::ctor(this);
255 this
256 }
257}
258
259#[cfg(feature = "unity_engine-resource_management-resourcemanager")]
260#[doc(hidden)]
261#[allow(non_snake_case, non_camel_case_types, clippy::too_many_arguments)]
262mod __ResourceManager_unity_raw {
263 use super::*;
264 #[doc(hidden)]
265 #[allow(non_snake_case)]
266 pub mod __lookup_get_internal_id_transform_func {
267 use super::*;
268 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
269 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[];
270 ::unity::lookup::method_info_on_class_with_signature(
271 <ResourceManager as ::unity::ClassIdentity>::class(),
272 "get_InternalIdTransformFunc",
273 0,
274 param_types,
275 false,
276 )
277 });
278 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
279 match &*METHOD {
280 ::core::result::Result::Ok(mi) => *mi,
281 ::core::result::Result::Err(e) => {
282 panic!(
283 "method lookup failed: {}
284::{}
285: {}
286",
287 <ResourceManager as ::unity::ClassIdentity>::NAME,
288 "get_InternalIdTransformFunc",
289 e
290 )
291 },
292 }
293 }
294 }
295 #[doc(hidden)]
296 #[allow(non_snake_case)]
297 pub mod __lookup_set_internal_id_transform_func {
298 use super::*;
299 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
300 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[<crate::system::func_2::Func_2<
301 crate::unity_engine::resource_management::resource_locations::iresourcelocation::IResourceLocation,
302 ::unity::Il2CppString,
303 > as ::unity::IlType>::il_type()];
304 ::unity::lookup::method_info_on_class_with_signature(
305 <ResourceManager as ::unity::ClassIdentity>::class(),
306 "set_InternalIdTransformFunc",
307 1,
308 param_types,
309 false,
310 )
311 });
312 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
313 match &*METHOD {
314 ::core::result::Result::Ok(mi) => *mi,
315 ::core::result::Result::Err(e) => {
316 panic!(
317 "method lookup failed: {}
318::{}
319: {}
320",
321 <ResourceManager as ::unity::ClassIdentity>::NAME,
322 "set_InternalIdTransformFunc",
323 e
324 )
325 },
326 }
327 }
328 }
329 #[doc(hidden)]
330 #[allow(non_snake_case)]
331 pub mod __lookup_transform_internal_id {
332 use super::*;
333 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
334 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[
335 <crate::unity_engine::resource_management::resource_locations::iresourcelocation::IResourceLocation as ::unity::IlType>::il_type(),
336 ];
337 ::unity::lookup::method_info_on_class_with_signature(
338 <ResourceManager as ::unity::ClassIdentity>::class(),
339 "TransformInternalId",
340 1,
341 param_types,
342 false,
343 )
344 });
345 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
346 match &*METHOD {
347 ::core::result::Result::Ok(mi) => *mi,
348 ::core::result::Result::Err(e) => {
349 panic!(
350 "method lookup failed: {}
351::{}
352: {}
353",
354 <ResourceManager as ::unity::ClassIdentity>::NAME,
355 "TransformInternalId",
356 e
357 )
358 },
359 }
360 }
361 }
362 #[doc(hidden)]
363 #[allow(non_snake_case)]
364 pub mod __lookup_get_web_request_override {
365 use super::*;
366 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
367 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[];
368 ::unity::lookup::method_info_on_class_with_signature(
369 <ResourceManager as ::unity::ClassIdentity>::class(),
370 "get_WebRequestOverride",
371 0,
372 param_types,
373 false,
374 )
375 });
376 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
377 match &*METHOD {
378 ::core::result::Result::Ok(mi) => *mi,
379 ::core::result::Result::Err(e) => {
380 panic!(
381 "method lookup failed: {}
382::{}
383: {}
384",
385 <ResourceManager as ::unity::ClassIdentity>::NAME,
386 "get_WebRequestOverride",
387 e
388 )
389 },
390 }
391 }
392 }
393 #[doc(hidden)]
394 #[allow(non_snake_case)]
395 pub mod __lookup_set_web_request_override {
396 use super::*;
397 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
398 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[<crate::system::action_1::Action_1<
399 crate::unity_engine::networking::unitywebrequest::UnityWebRequest,
400 > as ::unity::IlType>::il_type()];
401 ::unity::lookup::method_info_on_class_with_signature(
402 <ResourceManager as ::unity::ClassIdentity>::class(),
403 "set_WebRequestOverride",
404 1,
405 param_types,
406 false,
407 )
408 });
409 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
410 match &*METHOD {
411 ::core::result::Result::Ok(mi) => *mi,
412 ::core::result::Result::Err(e) => {
413 panic!(
414 "method lookup failed: {}
415::{}
416: {}
417",
418 <ResourceManager as ::unity::ClassIdentity>::NAME,
419 "set_WebRequestOverride",
420 e
421 )
422 },
423 }
424 }
425 }
426 #[doc(hidden)]
427 #[allow(non_snake_case)]
428 pub mod __lookup_get_operation_cache_count {
429 use super::*;
430 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
431 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[];
432 ::unity::lookup::method_info_on_class_with_signature(
433 <ResourceManager as ::unity::ClassIdentity>::class(),
434 "get_OperationCacheCount",
435 0,
436 param_types,
437 false,
438 )
439 });
440 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
441 match &*METHOD {
442 ::core::result::Result::Ok(mi) => *mi,
443 ::core::result::Result::Err(e) => {
444 panic!(
445 "method lookup failed: {}
446::{}
447: {}
448",
449 <ResourceManager as ::unity::ClassIdentity>::NAME,
450 "get_OperationCacheCount",
451 e
452 )
453 },
454 }
455 }
456 }
457 #[doc(hidden)]
458 #[allow(non_snake_case)]
459 pub mod __lookup_get_instance_operation_count {
460 use super::*;
461 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
462 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[];
463 ::unity::lookup::method_info_on_class_with_signature(
464 <ResourceManager as ::unity::ClassIdentity>::class(),
465 "get_InstanceOperationCount",
466 0,
467 param_types,
468 false,
469 )
470 });
471 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
472 match &*METHOD {
473 ::core::result::Result::Ok(mi) => *mi,
474 ::core::result::Result::Err(e) => {
475 panic!(
476 "method lookup failed: {}
477::{}
478: {}
479",
480 <ResourceManager as ::unity::ClassIdentity>::NAME,
481 "get_InstanceOperationCount",
482 e
483 )
484 },
485 }
486 }
487 }
488 #[doc(hidden)]
489 #[allow(non_snake_case)]
490 pub mod __lookup_add_update_receiver {
491 use super::*;
492 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
493 let param_types: &[&'static ::unity::il2cpp::Il2CppType] =
494 &[<crate::unity_engine::resource_management::iupdatereceiver::IUpdateReceiver as ::unity::IlType>::il_type()];
495 ::unity::lookup::method_info_on_class_with_signature(
496 <ResourceManager as ::unity::ClassIdentity>::class(),
497 "AddUpdateReceiver",
498 1,
499 param_types,
500 false,
501 )
502 });
503 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
504 match &*METHOD {
505 ::core::result::Result::Ok(mi) => *mi,
506 ::core::result::Result::Err(e) => {
507 panic!(
508 "method lookup failed: {}
509::{}
510: {}
511",
512 <ResourceManager as ::unity::ClassIdentity>::NAME,
513 "AddUpdateReceiver",
514 e
515 )
516 },
517 }
518 }
519 }
520 #[doc(hidden)]
521 #[allow(non_snake_case)]
522 pub mod __lookup_remove_update_reciever {
523 use super::*;
524 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
525 let param_types: &[&'static ::unity::il2cpp::Il2CppType] =
526 &[<crate::unity_engine::resource_management::iupdatereceiver::IUpdateReceiver as ::unity::IlType>::il_type()];
527 ::unity::lookup::method_info_on_class_with_signature(
528 <ResourceManager as ::unity::ClassIdentity>::class(),
529 "RemoveUpdateReciever",
530 1,
531 param_types,
532 false,
533 )
534 });
535 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
536 match &*METHOD {
537 ::core::result::Result::Ok(mi) => *mi,
538 ::core::result::Result::Err(e) => {
539 panic!(
540 "method lookup failed: {}
541::{}
542: {}
543",
544 <ResourceManager as ::unity::ClassIdentity>::NAME,
545 "RemoveUpdateReciever",
546 e
547 )
548 },
549 }
550 }
551 }
552 #[doc(hidden)]
553 #[allow(non_snake_case)]
554 pub mod __lookup_get_allocator {
555 use super::*;
556 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
557 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[];
558 ::unity::lookup::method_info_on_class_with_signature(
559 <ResourceManager as ::unity::ClassIdentity>::class(),
560 "get_Allocator",
561 0,
562 param_types,
563 false,
564 )
565 });
566 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
567 match &*METHOD {
568 ::core::result::Result::Ok(mi) => *mi,
569 ::core::result::Result::Err(e) => {
570 panic!(
571 "method lookup failed: {}
572::{}
573: {}
574",
575 <ResourceManager as ::unity::ClassIdentity>::NAME,
576 "get_Allocator",
577 e
578 )
579 },
580 }
581 }
582 }
583 #[doc(hidden)]
584 #[allow(non_snake_case)]
585 pub mod __lookup_set_allocator {
586 use super::*;
587 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
588 let param_types: &[&'static ::unity::il2cpp::Il2CppType] =
589 &[<crate::unity_engine::resource_management::util::iallocationstrategy::IAllocationStrategy as ::unity::IlType>::il_type()];
590 ::unity::lookup::method_info_on_class_with_signature(
591 <ResourceManager as ::unity::ClassIdentity>::class(),
592 "set_Allocator",
593 1,
594 param_types,
595 false,
596 )
597 });
598 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
599 match &*METHOD {
600 ::core::result::Result::Ok(mi) => *mi,
601 ::core::result::Result::Err(e) => {
602 panic!(
603 "method lookup failed: {}
604::{}
605: {}
606",
607 <ResourceManager as ::unity::ClassIdentity>::NAME,
608 "set_Allocator",
609 e
610 )
611 },
612 }
613 }
614 }
615 #[doc(hidden)]
616 #[allow(non_snake_case)]
617 pub mod __lookup_get_resource_providers {
618 use super::*;
619 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
620 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[];
621 ::unity::lookup::method_info_on_class_with_signature(
622 <ResourceManager as ::unity::ClassIdentity>::class(),
623 "get_ResourceProviders",
624 0,
625 param_types,
626 false,
627 )
628 });
629 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
630 match &*METHOD {
631 ::core::result::Result::Ok(mi) => *mi,
632 ::core::result::Result::Err(e) => {
633 panic!(
634 "method lookup failed: {}
635::{}
636: {}
637",
638 <ResourceManager as ::unity::ClassIdentity>::NAME,
639 "get_ResourceProviders",
640 e
641 )
642 },
643 }
644 }
645 }
646 #[doc(hidden)]
647 #[allow(non_snake_case)]
648 pub mod __lookup_get_certificate_handler_instance {
649 use super::*;
650 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
651 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[];
652 ::unity::lookup::method_info_on_class_with_signature(
653 <ResourceManager as ::unity::ClassIdentity>::class(),
654 "get_CertificateHandlerInstance",
655 0,
656 param_types,
657 false,
658 )
659 });
660 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
661 match &*METHOD {
662 ::core::result::Result::Ok(mi) => *mi,
663 ::core::result::Result::Err(e) => {
664 panic!(
665 "method lookup failed: {}
666::{}
667: {}
668",
669 <ResourceManager as ::unity::ClassIdentity>::NAME,
670 "get_CertificateHandlerInstance",
671 e
672 )
673 },
674 }
675 }
676 }
677 #[doc(hidden)]
678 #[allow(non_snake_case)]
679 pub mod __lookup_set_certificate_handler_instance {
680 use super::*;
681 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
682 let param_types: &[&'static ::unity::il2cpp::Il2CppType] =
683 &[<crate::unity_engine::networking::certificatehandler::CertificateHandler as ::unity::IlType>::il_type()];
684 ::unity::lookup::method_info_on_class_with_signature(
685 <ResourceManager as ::unity::ClassIdentity>::class(),
686 "set_CertificateHandlerInstance",
687 1,
688 param_types,
689 false,
690 )
691 });
692 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
693 match &*METHOD {
694 ::core::result::Result::Ok(mi) => *mi,
695 ::core::result::Result::Err(e) => {
696 panic!(
697 "method lookup failed: {}
698::{}
699: {}
700",
701 <ResourceManager as ::unity::ClassIdentity>::NAME,
702 "set_CertificateHandlerInstance",
703 e
704 )
705 },
706 }
707 }
708 }
709 #[doc(hidden)]
710 #[allow(non_snake_case)]
711 pub mod __lookup_ctor {
712 use super::*;
713 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
714 let param_types: &[&'static ::unity::il2cpp::Il2CppType] =
715 &[<crate::unity_engine::resource_management::util::iallocationstrategy::IAllocationStrategy as ::unity::IlType>::il_type()];
716 ::unity::lookup::method_info_on_class_with_signature(<ResourceManager as ::unity::ClassIdentity>::class(), ".ctor", 1, param_types, false)
717 });
718 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
719 match &*METHOD {
720 ::core::result::Result::Ok(mi) => *mi,
721 ::core::result::Result::Err(e) => {
722 panic!(
723 "method lookup failed: {}
724::{}
725: {}
726",
727 <ResourceManager as ::unity::ClassIdentity>::NAME,
728 ".ctor",
729 e
730 )
731 },
732 }
733 }
734 }
735 #[doc(hidden)]
736 #[allow(non_snake_case)]
737 pub mod __lookup_on_object_added {
738 use super::*;
739 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
740 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[<crate::system::object::Object as ::unity::IlType>::il_type()];
741 ::unity::lookup::method_info_on_class_with_signature(
742 <ResourceManager as ::unity::ClassIdentity>::class(),
743 "OnObjectAdded",
744 1,
745 param_types,
746 false,
747 )
748 });
749 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
750 match &*METHOD {
751 ::core::result::Result::Ok(mi) => *mi,
752 ::core::result::Result::Err(e) => {
753 panic!(
754 "method lookup failed: {}
755::{}
756: {}
757",
758 <ResourceManager as ::unity::ClassIdentity>::NAME,
759 "OnObjectAdded",
760 e
761 )
762 },
763 }
764 }
765 }
766 #[doc(hidden)]
767 #[allow(non_snake_case)]
768 pub mod __lookup_on_object_removed {
769 use super::*;
770 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
771 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[<crate::system::object::Object as ::unity::IlType>::il_type()];
772 ::unity::lookup::method_info_on_class_with_signature(
773 <ResourceManager as ::unity::ClassIdentity>::class(),
774 "OnObjectRemoved",
775 1,
776 param_types,
777 false,
778 )
779 });
780 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
781 match &*METHOD {
782 ::core::result::Result::Ok(mi) => *mi,
783 ::core::result::Result::Err(e) => {
784 panic!(
785 "method lookup failed: {}
786::{}
787: {}
788",
789 <ResourceManager as ::unity::ClassIdentity>::NAME,
790 "OnObjectRemoved",
791 e
792 )
793 },
794 }
795 }
796 }
797 #[doc(hidden)]
798 #[allow(non_snake_case)]
799 pub mod __lookup_register_for_callbacks {
800 use super::*;
801 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
802 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[];
803 ::unity::lookup::method_info_on_class_with_signature(
804 <ResourceManager as ::unity::ClassIdentity>::class(),
805 "RegisterForCallbacks",
806 0,
807 param_types,
808 false,
809 )
810 });
811 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
812 match &*METHOD {
813 ::core::result::Result::Ok(mi) => *mi,
814 ::core::result::Result::Err(e) => {
815 panic!(
816 "method lookup failed: {}
817::{}
818: {}
819",
820 <ResourceManager as ::unity::ClassIdentity>::NAME,
821 "RegisterForCallbacks",
822 e
823 )
824 },
825 }
826 }
827 }
828 #[doc(hidden)]
829 #[allow(non_snake_case)]
830 pub mod __lookup_clear_diagnostics_callback {
831 use super::*;
832 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
833 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[];
834 ::unity::lookup::method_info_on_class_with_signature(
835 <ResourceManager as ::unity::ClassIdentity>::class(),
836 "ClearDiagnosticsCallback",
837 0,
838 param_types,
839 false,
840 )
841 });
842 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
843 match &*METHOD {
844 ::core::result::Result::Ok(mi) => *mi,
845 ::core::result::Result::Err(e) => {
846 panic!(
847 "method lookup failed: {}
848::{}
849: {}
850",
851 <ResourceManager as ::unity::ClassIdentity>::NAME,
852 "ClearDiagnosticsCallback",
853 e
854 )
855 },
856 }
857 }
858 }
859 #[doc(hidden)]
860 #[allow(non_snake_case)]
861 pub mod __lookup_clear_diagnostic_callbacks {
862 use super::*;
863 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
864 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[];
865 ::unity::lookup::method_info_on_class_with_signature(
866 <ResourceManager as ::unity::ClassIdentity>::class(),
867 "ClearDiagnosticCallbacks",
868 0,
869 param_types,
870 false,
871 )
872 });
873 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
874 match &*METHOD {
875 ::core::result::Result::Ok(mi) => *mi,
876 ::core::result::Result::Err(e) => {
877 panic!(
878 "method lookup failed: {}
879::{}
880: {}
881",
882 <ResourceManager as ::unity::ClassIdentity>::NAME,
883 "ClearDiagnosticCallbacks",
884 e
885 )
886 },
887 }
888 }
889 }
890 #[doc(hidden)]
891 #[allow(non_snake_case)]
892 pub mod __lookup_unregister_diagnostic_callback {
893 use super::*;
894 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
895 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[<crate::system::action_1::Action_1<
896 crate::unity_engine::resource_management::resourcemanager::ResourceManager_DiagnosticEventContext,
897 > as ::unity::IlType>::il_type()];
898 ::unity::lookup::method_info_on_class_with_signature(
899 <ResourceManager as ::unity::ClassIdentity>::class(),
900 "UnregisterDiagnosticCallback",
901 1,
902 param_types,
903 false,
904 )
905 });
906 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
907 match &*METHOD {
908 ::core::result::Result::Ok(mi) => *mi,
909 ::core::result::Result::Err(e) => {
910 panic!(
911 "method lookup failed: {}
912::{}
913: {}
914",
915 <ResourceManager as ::unity::ClassIdentity>::NAME,
916 "UnregisterDiagnosticCallback",
917 e
918 )
919 },
920 }
921 }
922 }
923 #[doc(hidden)]
924 #[allow(non_snake_case)]
925 pub mod __lookup_register_diagnostic_callback {
926 use super::*;
927 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
928 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[<crate::system::action_4::Action_4<
929 crate::unity_engine::resource_management::async_operations::asyncoperationhandle::AsyncOperationHandle,
930 crate::unity_engine::resource_management::resourcemanager::ResourceManager_DiagnosticEventType,
931 i32,
932 crate::system::object::Object,
933 > as ::unity::IlType>::il_type()];
934 ::unity::lookup::method_info_on_class_with_signature(
935 <ResourceManager as ::unity::ClassIdentity>::class(),
936 "RegisterDiagnosticCallback",
937 1,
938 param_types,
939 false,
940 )
941 });
942 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
943 match &*METHOD {
944 ::core::result::Result::Ok(mi) => *mi,
945 ::core::result::Result::Err(e) => {
946 panic!(
947 "method lookup failed: {}
948::{}
949: {}
950",
951 <ResourceManager as ::unity::ClassIdentity>::NAME,
952 "RegisterDiagnosticCallback",
953 e
954 )
955 },
956 }
957 }
958 }
959 #[doc(hidden)]
960 #[allow(non_snake_case)]
961 pub mod __lookup_register_diagnostic_callback_2 {
962 use super::*;
963 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
964 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[<crate::system::action_1::Action_1<
965 crate::unity_engine::resource_management::resourcemanager::ResourceManager_DiagnosticEventContext,
966 > as ::unity::IlType>::il_type()];
967 ::unity::lookup::method_info_on_class_with_signature(
968 <ResourceManager as ::unity::ClassIdentity>::class(),
969 "RegisterDiagnosticCallback",
970 1,
971 param_types,
972 false,
973 )
974 });
975 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
976 match &*METHOD {
977 ::core::result::Result::Ok(mi) => *mi,
978 ::core::result::Result::Err(e) => {
979 panic!(
980 "method lookup failed: {}
981::{}
982: {}
983",
984 <ResourceManager as ::unity::ClassIdentity>::NAME,
985 "RegisterDiagnosticCallback",
986 e
987 )
988 },
989 }
990 }
991 }
992 #[doc(hidden)]
993 #[allow(non_snake_case)]
994 pub mod __lookup_post_diagnostic_event {
995 use super::*;
996 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
997 let param_types: &[&'static ::unity::il2cpp::Il2CppType] =
998 &[<crate::unity_engine::resource_management::resourcemanager::ResourceManager_DiagnosticEventContext as ::unity::IlType>::il_type()];
999 ::unity::lookup::method_info_on_class_with_signature(
1000 <ResourceManager as ::unity::ClassIdentity>::class(),
1001 "PostDiagnosticEvent",
1002 1,
1003 param_types,
1004 false,
1005 )
1006 });
1007 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1008 match &*METHOD {
1009 ::core::result::Result::Ok(mi) => *mi,
1010 ::core::result::Result::Err(e) => {
1011 panic!(
1012 "method lookup failed: {}
1013::{}
1014: {}
1015",
1016 <ResourceManager as ::unity::ClassIdentity>::NAME,
1017 "PostDiagnosticEvent",
1018 e
1019 )
1020 },
1021 }
1022 }
1023 }
1024 #[doc(hidden)]
1025 #[allow(non_snake_case)]
1026 pub mod __lookup_get_resource_provider {
1027 use super::*;
1028 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
1029 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[
1030 <::unity::SystemType as ::unity::IlType>::il_type(),
1031 <crate::unity_engine::resource_management::resource_locations::iresourcelocation::IResourceLocation as ::unity::IlType>::il_type(),
1032 ];
1033 ::unity::lookup::method_info_on_class_with_signature(
1034 <ResourceManager as ::unity::ClassIdentity>::class(),
1035 "GetResourceProvider",
1036 2,
1037 param_types,
1038 false,
1039 )
1040 });
1041 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1042 match &*METHOD {
1043 ::core::result::Result::Ok(mi) => *mi,
1044 ::core::result::Result::Err(e) => {
1045 panic!(
1046 "method lookup failed: {}
1047::{}
1048: {}
1049",
1050 <ResourceManager as ::unity::ClassIdentity>::NAME,
1051 "GetResourceProvider",
1052 e
1053 )
1054 },
1055 }
1056 }
1057 }
1058 #[doc(hidden)]
1059 #[allow(non_snake_case)]
1060 pub mod __lookup_get_default_type_for_location {
1061 use super::*;
1062 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
1063 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[
1064 <crate::unity_engine::resource_management::resource_locations::iresourcelocation::IResourceLocation as ::unity::IlType>::il_type(),
1065 ];
1066 ::unity::lookup::method_info_on_class_with_signature(
1067 <ResourceManager as ::unity::ClassIdentity>::class(),
1068 "GetDefaultTypeForLocation",
1069 1,
1070 param_types,
1071 false,
1072 )
1073 });
1074 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1075 match &*METHOD {
1076 ::core::result::Result::Ok(mi) => *mi,
1077 ::core::result::Result::Err(e) => {
1078 panic!(
1079 "method lookup failed: {}
1080::{}
1081: {}
1082",
1083 <ResourceManager as ::unity::ClassIdentity>::NAME,
1084 "GetDefaultTypeForLocation",
1085 e
1086 )
1087 },
1088 }
1089 }
1090 }
1091 #[doc(hidden)]
1092 #[allow(non_snake_case)]
1093 pub mod __lookup_calculate_locations_hash {
1094 use super::*;
1095 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
1096 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[
1097 <crate::system::collections::generic::ilist_1_interface::IList_1_Interface<
1098 crate::unity_engine::resource_management::resource_locations::iresourcelocation::IResourceLocation,
1099 > as ::unity::IlType>::il_type(),
1100 <::unity::SystemType as ::unity::IlType>::il_type(),
1101 ];
1102 ::unity::lookup::method_info_on_class_with_signature(
1103 <ResourceManager as ::unity::ClassIdentity>::class(),
1104 "CalculateLocationsHash",
1105 2,
1106 param_types,
1107 false,
1108 )
1109 });
1110 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1111 match &*METHOD {
1112 ::core::result::Result::Ok(mi) => *mi,
1113 ::core::result::Result::Err(e) => {
1114 panic!(
1115 "method lookup failed: {}
1116::{}
1117: {}
1118",
1119 <ResourceManager as ::unity::ClassIdentity>::NAME,
1120 "CalculateLocationsHash",
1121 e
1122 )
1123 },
1124 }
1125 }
1126 }
1127 #[doc(hidden)]
1128 #[allow(non_snake_case)]
1129 pub mod __lookup_provide_resource {
1130 use super::*;
1131 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
1132 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[
1133 <crate::unity_engine::resource_management::resource_locations::iresourcelocation::IResourceLocation as ::unity::IlType>::il_type(),
1134 <::unity::SystemType as ::unity::IlType>::il_type(),
1135 <bool as ::unity::IlType>::il_type(),
1136 ];
1137 ::unity::lookup::method_info_on_class_with_signature(
1138 <ResourceManager as ::unity::ClassIdentity>::class(),
1139 "ProvideResource",
1140 3,
1141 param_types,
1142 false,
1143 )
1144 });
1145 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1146 match &*METHOD {
1147 ::core::result::Result::Ok(mi) => *mi,
1148 ::core::result::Result::Err(e) => {
1149 panic!(
1150 "method lookup failed: {}
1151::{}
1152: {}
1153",
1154 <ResourceManager as ::unity::ClassIdentity>::NAME,
1155 "ProvideResource",
1156 e
1157 )
1158 },
1159 }
1160 }
1161 }
1162 #[doc(hidden)]
1163 #[allow(non_snake_case)]
1164 pub mod __lookup_start_operation_2 {
1165 use super::*;
1166 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
1167 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[
1168 <crate::unity_engine::resource_management::async_operations::iasyncoperation::IAsyncOperation as ::unity::IlType>::il_type(),
1169 <crate::unity_engine::resource_management::async_operations::asyncoperationhandle::AsyncOperationHandle as ::unity::IlType>::il_type(
1170 ),
1171 ];
1172 ::unity::lookup::method_info_on_class_with_signature(
1173 <ResourceManager as ::unity::ClassIdentity>::class(),
1174 "StartOperation",
1175 2,
1176 param_types,
1177 false,
1178 )
1179 });
1180 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1181 match &*METHOD {
1182 ::core::result::Result::Ok(mi) => *mi,
1183 ::core::result::Result::Err(e) => {
1184 panic!(
1185 "method lookup failed: {}
1186::{}
1187: {}
1188",
1189 <ResourceManager as ::unity::ClassIdentity>::NAME,
1190 "StartOperation",
1191 e
1192 )
1193 },
1194 }
1195 }
1196 }
1197 #[doc(hidden)]
1198 #[allow(non_snake_case)]
1199 pub mod __lookup_on_instance_operation_destroy {
1200 use super::*;
1201 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
1202 let param_types: &[&'static ::unity::il2cpp::Il2CppType] =
1203 &[<crate::unity_engine::resource_management::async_operations::iasyncoperation::IAsyncOperation as ::unity::IlType>::il_type()];
1204 ::unity::lookup::method_info_on_class_with_signature(
1205 <ResourceManager as ::unity::ClassIdentity>::class(),
1206 "OnInstanceOperationDestroy",
1207 1,
1208 param_types,
1209 false,
1210 )
1211 });
1212 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1213 match &*METHOD {
1214 ::core::result::Result::Ok(mi) => *mi,
1215 ::core::result::Result::Err(e) => {
1216 panic!(
1217 "method lookup failed: {}
1218::{}
1219: {}
1220",
1221 <ResourceManager as ::unity::ClassIdentity>::NAME,
1222 "OnInstanceOperationDestroy",
1223 e
1224 )
1225 },
1226 }
1227 }
1228 }
1229 #[doc(hidden)]
1230 #[allow(non_snake_case)]
1231 pub mod __lookup_on_operation_destroy_non_cached {
1232 use super::*;
1233 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
1234 let param_types: &[&'static ::unity::il2cpp::Il2CppType] =
1235 &[<crate::unity_engine::resource_management::async_operations::iasyncoperation::IAsyncOperation as ::unity::IlType>::il_type()];
1236 ::unity::lookup::method_info_on_class_with_signature(
1237 <ResourceManager as ::unity::ClassIdentity>::class(),
1238 "OnOperationDestroyNonCached",
1239 1,
1240 param_types,
1241 false,
1242 )
1243 });
1244 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1245 match &*METHOD {
1246 ::core::result::Result::Ok(mi) => *mi,
1247 ::core::result::Result::Err(e) => {
1248 panic!(
1249 "method lookup failed: {}
1250::{}
1251: {}
1252",
1253 <ResourceManager as ::unity::ClassIdentity>::NAME,
1254 "OnOperationDestroyNonCached",
1255 e
1256 )
1257 },
1258 }
1259 }
1260 }
1261 #[doc(hidden)]
1262 #[allow(non_snake_case)]
1263 pub mod __lookup_on_operation_destroy_cached {
1264 use super::*;
1265 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
1266 let param_types: &[&'static ::unity::il2cpp::Il2CppType] =
1267 &[<crate::unity_engine::resource_management::async_operations::iasyncoperation::IAsyncOperation as ::unity::IlType>::il_type()];
1268 ::unity::lookup::method_info_on_class_with_signature(
1269 <ResourceManager as ::unity::ClassIdentity>::class(),
1270 "OnOperationDestroyCached",
1271 1,
1272 param_types,
1273 false,
1274 )
1275 });
1276 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1277 match &*METHOD {
1278 ::core::result::Result::Ok(mi) => *mi,
1279 ::core::result::Result::Err(e) => {
1280 panic!(
1281 "method lookup failed: {}
1282::{}
1283: {}
1284",
1285 <ResourceManager as ::unity::ClassIdentity>::NAME,
1286 "OnOperationDestroyCached",
1287 e
1288 )
1289 },
1290 }
1291 }
1292 }
1293 #[doc(hidden)]
1294 #[allow(non_snake_case)]
1295 pub mod __lookup_add_operation_to_cache {
1296 use super::*;
1297 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
1298 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[
1299 <crate::unity_engine::resource_management::util::ioperationcachekey::IOperationCacheKey as ::unity::IlType>::il_type(),
1300 <crate::unity_engine::resource_management::async_operations::iasyncoperation::IAsyncOperation as ::unity::IlType>::il_type(),
1301 ];
1302 ::unity::lookup::method_info_on_class_with_signature(
1303 <ResourceManager as ::unity::ClassIdentity>::class(),
1304 "AddOperationToCache",
1305 2,
1306 param_types,
1307 false,
1308 )
1309 });
1310 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1311 match &*METHOD {
1312 ::core::result::Result::Ok(mi) => *mi,
1313 ::core::result::Result::Err(e) => {
1314 panic!(
1315 "method lookup failed: {}
1316::{}
1317: {}
1318",
1319 <ResourceManager as ::unity::ClassIdentity>::NAME,
1320 "AddOperationToCache",
1321 e
1322 )
1323 },
1324 }
1325 }
1326 }
1327 #[doc(hidden)]
1328 #[allow(non_snake_case)]
1329 pub mod __lookup_remove_operation_from_cache {
1330 use super::*;
1331 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
1332 let param_types: &[&'static ::unity::il2cpp::Il2CppType] =
1333 &[<crate::unity_engine::resource_management::util::ioperationcachekey::IOperationCacheKey as ::unity::IlType>::il_type()];
1334 ::unity::lookup::method_info_on_class_with_signature(
1335 <ResourceManager as ::unity::ClassIdentity>::class(),
1336 "RemoveOperationFromCache",
1337 1,
1338 param_types,
1339 false,
1340 )
1341 });
1342 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1343 match &*METHOD {
1344 ::core::result::Result::Ok(mi) => *mi,
1345 ::core::result::Result::Err(e) => {
1346 panic!(
1347 "method lookup failed: {}
1348::{}
1349: {}
1350",
1351 <ResourceManager as ::unity::ClassIdentity>::NAME,
1352 "RemoveOperationFromCache",
1353 e
1354 )
1355 },
1356 }
1357 }
1358 }
1359 #[doc(hidden)]
1360 #[allow(non_snake_case)]
1361 pub mod __lookup_is_operation_cached {
1362 use super::*;
1363 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
1364 let param_types: &[&'static ::unity::il2cpp::Il2CppType] =
1365 &[<crate::unity_engine::resource_management::util::ioperationcachekey::IOperationCacheKey as ::unity::IlType>::il_type()];
1366 ::unity::lookup::method_info_on_class_with_signature(
1367 <ResourceManager as ::unity::ClassIdentity>::class(),
1368 "IsOperationCached",
1369 1,
1370 param_types,
1371 false,
1372 )
1373 });
1374 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1375 match &*METHOD {
1376 ::core::result::Result::Ok(mi) => *mi,
1377 ::core::result::Result::Err(e) => {
1378 panic!(
1379 "method lookup failed: {}
1380::{}
1381: {}
1382",
1383 <ResourceManager as ::unity::ClassIdentity>::NAME,
1384 "IsOperationCached",
1385 e
1386 )
1387 },
1388 }
1389 }
1390 }
1391 #[doc(hidden)]
1392 #[allow(non_snake_case)]
1393 pub mod __lookup_cached_operation_count {
1394 use super::*;
1395 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
1396 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[];
1397 ::unity::lookup::method_info_on_class_with_signature(
1398 <ResourceManager as ::unity::ClassIdentity>::class(),
1399 "CachedOperationCount",
1400 0,
1401 param_types,
1402 false,
1403 )
1404 });
1405 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1406 match &*METHOD {
1407 ::core::result::Result::Ok(mi) => *mi,
1408 ::core::result::Result::Err(e) => {
1409 panic!(
1410 "method lookup failed: {}
1411::{}
1412: {}
1413",
1414 <ResourceManager as ::unity::ClassIdentity>::NAME,
1415 "CachedOperationCount",
1416 e
1417 )
1418 },
1419 }
1420 }
1421 }
1422 #[doc(hidden)]
1423 #[allow(non_snake_case)]
1424 pub mod __lookup_release {
1425 use super::*;
1426 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
1427 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[
1428 <crate::unity_engine::resource_management::async_operations::asyncoperationhandle::AsyncOperationHandle as ::unity::IlType>::il_type(
1429 ),
1430 ];
1431 ::unity::lookup::method_info_on_class_with_signature(
1432 <ResourceManager as ::unity::ClassIdentity>::class(),
1433 "Release",
1434 1,
1435 param_types,
1436 false,
1437 )
1438 });
1439 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1440 match &*METHOD {
1441 ::core::result::Result::Ok(mi) => *mi,
1442 ::core::result::Result::Err(e) => {
1443 panic!(
1444 "method lookup failed: {}
1445::{}
1446: {}
1447",
1448 <ResourceManager as ::unity::ClassIdentity>::NAME,
1449 "Release",
1450 e
1451 )
1452 },
1453 }
1454 }
1455 }
1456 #[doc(hidden)]
1457 #[allow(non_snake_case)]
1458 pub mod __lookup_acquire {
1459 use super::*;
1460 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
1461 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[
1462 <crate::unity_engine::resource_management::async_operations::asyncoperationhandle::AsyncOperationHandle as ::unity::IlType>::il_type(
1463 ),
1464 ];
1465 ::unity::lookup::method_info_on_class_with_signature(
1466 <ResourceManager as ::unity::ClassIdentity>::class(),
1467 "Acquire",
1468 1,
1469 param_types,
1470 false,
1471 )
1472 });
1473 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1474 match &*METHOD {
1475 ::core::result::Result::Ok(mi) => *mi,
1476 ::core::result::Result::Err(e) => {
1477 panic!(
1478 "method lookup failed: {}
1479::{}
1480: {}
1481",
1482 <ResourceManager as ::unity::ClassIdentity>::NAME,
1483 "Acquire",
1484 e
1485 )
1486 },
1487 }
1488 }
1489 }
1490 #[doc(hidden)]
1491 #[allow(non_snake_case)]
1492 pub mod __lookup_acquire_group_op_from_cache {
1493 use super::*;
1494 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
1495 let param_types: &[&'static ::unity::il2cpp::Il2CppType] =
1496 &[<crate::unity_engine::resource_management::util::ioperationcachekey::IOperationCacheKey as ::unity::IlType>::il_type()];
1497 ::unity::lookup::method_info_on_class_with_signature(
1498 <ResourceManager as ::unity::ClassIdentity>::class(),
1499 "AcquireGroupOpFromCache",
1500 1,
1501 param_types,
1502 false,
1503 )
1504 });
1505 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1506 match &*METHOD {
1507 ::core::result::Result::Ok(mi) => *mi,
1508 ::core::result::Result::Err(e) => {
1509 panic!(
1510 "method lookup failed: {}
1511::{}
1512: {}
1513",
1514 <ResourceManager as ::unity::ClassIdentity>::NAME,
1515 "AcquireGroupOpFromCache",
1516 e
1517 )
1518 },
1519 }
1520 }
1521 }
1522 #[doc(hidden)]
1523 #[allow(non_snake_case)]
1524 pub mod __lookup_create_generic_group_operation {
1525 use super::*;
1526 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
1527 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[
1528 <crate::system::collections::generic::list_1::List_1<
1529 crate::unity_engine::resource_management::async_operations::asyncoperationhandle::AsyncOperationHandle,
1530 > as ::unity::IlType>::il_type(),
1531 <bool as ::unity::IlType>::il_type(),
1532 ];
1533 ::unity::lookup::method_info_on_class_with_signature(
1534 <ResourceManager as ::unity::ClassIdentity>::class(),
1535 "CreateGenericGroupOperation",
1536 2,
1537 param_types,
1538 false,
1539 )
1540 });
1541 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1542 match &*METHOD {
1543 ::core::result::Result::Ok(mi) => *mi,
1544 ::core::result::Result::Err(e) => {
1545 panic!(
1546 "method lookup failed: {}
1547::{}
1548: {}
1549",
1550 <ResourceManager as ::unity::ClassIdentity>::NAME,
1551 "CreateGenericGroupOperation",
1552 e
1553 )
1554 },
1555 }
1556 }
1557 }
1558 #[doc(hidden)]
1559 #[allow(non_snake_case)]
1560 pub mod __lookup_provide_resource_group_cached {
1561 use super::*;
1562 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
1563 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[
1564 <crate::system::collections::generic::ilist_1_interface::IList_1_Interface<
1565 crate::unity_engine::resource_management::resource_locations::iresourcelocation::IResourceLocation,
1566 > as ::unity::IlType>::il_type(),
1567 <i32 as ::unity::IlType>::il_type(),
1568 <::unity::SystemType as ::unity::IlType>::il_type(),
1569 <crate::system::action_1::Action_1<
1570 crate::unity_engine::resource_management::async_operations::asyncoperationhandle::AsyncOperationHandle,
1571 > as ::unity::IlType>::il_type(),
1572 <bool as ::unity::IlType>::il_type(),
1573 ];
1574 ::unity::lookup::method_info_on_class_with_signature(
1575 <ResourceManager as ::unity::ClassIdentity>::class(),
1576 "ProvideResourceGroupCached",
1577 5,
1578 param_types,
1579 false,
1580 )
1581 });
1582 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1583 match &*METHOD {
1584 ::core::result::Result::Ok(mi) => *mi,
1585 ::core::result::Result::Err(e) => {
1586 panic!(
1587 "method lookup failed: {}
1588::{}
1589: {}
1590",
1591 <ResourceManager as ::unity::ClassIdentity>::NAME,
1592 "ProvideResourceGroupCached",
1593 e
1594 )
1595 },
1596 }
1597 }
1598 }
1599 #[doc(hidden)]
1600 #[allow(non_snake_case)]
1601 pub mod __lookup_provide_scene {
1602 use super::*;
1603 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
1604 let param_types: &[& 'static::unity::il2cpp::Il2CppType]= &[<crate::unity_engine::resource_management::resource_providers::isceneprovider_interface::ISceneProvider_Interface as::unity::IlType> ::il_type(), <crate::unity_engine::resource_management::resource_locations::iresourcelocation::IResourceLocation as::unity::IlType> ::il_type(), <crate::unity_engine::scene_management::loadscenemode::LoadSceneMode as::unity::IlType> ::il_type(), <bool as::unity::IlType> ::il_type(), <i32 as::unity::IlType> ::il_type()];
1605 ::unity::lookup::method_info_on_class_with_signature(
1606 <ResourceManager as ::unity::ClassIdentity>::class(),
1607 "ProvideScene",
1608 5,
1609 param_types,
1610 false,
1611 )
1612 });
1613 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1614 match &*METHOD {
1615 ::core::result::Result::Ok(mi) => *mi,
1616 ::core::result::Result::Err(e) => {
1617 panic!(
1618 "method lookup failed: {}
1619::{}
1620: {}
1621",
1622 <ResourceManager as ::unity::ClassIdentity>::NAME,
1623 "ProvideScene",
1624 e
1625 )
1626 },
1627 }
1628 }
1629 }
1630 #[doc(hidden)]
1631 #[allow(non_snake_case)]
1632 pub mod __lookup_release_scene {
1633 use super::*;
1634 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
1635 let param_types: &[& 'static::unity::il2cpp::Il2CppType]= &[<crate::unity_engine::resource_management::resource_providers::isceneprovider_interface::ISceneProvider_Interface as::unity::IlType> ::il_type(), <crate::unity_engine::resource_management::async_operations::asyncoperationhandle_1::AsyncOperationHandle_1<crate::unity_engine::resource_management::resource_providers::sceneinstance::SceneInstance>as::unity::IlType> ::il_type()];
1636 ::unity::lookup::method_info_on_class_with_signature(
1637 <ResourceManager as ::unity::ClassIdentity>::class(),
1638 "ReleaseScene",
1639 2,
1640 param_types,
1641 false,
1642 )
1643 });
1644 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1645 match &*METHOD {
1646 ::core::result::Result::Ok(mi) => *mi,
1647 ::core::result::Result::Err(e) => {
1648 panic!(
1649 "method lookup failed: {}
1650::{}
1651: {}
1652",
1653 <ResourceManager as ::unity::ClassIdentity>::NAME,
1654 "ReleaseScene",
1655 e
1656 )
1657 },
1658 }
1659 }
1660 }
1661 #[doc(hidden)]
1662 #[allow(non_snake_case)]
1663 pub mod __lookup_provide_instance {
1664 use super::*;
1665 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
1666 let param_types: &[& 'static::unity::il2cpp::Il2CppType]= &[<crate::unity_engine::resource_management::resource_providers::iinstanceprovider_interface::IInstanceProvider_Interface as::unity::IlType> ::il_type(), <crate::unity_engine::resource_management::resource_locations::iresourcelocation::IResourceLocation as::unity::IlType> ::il_type(), <crate::unity_engine::resource_management::resource_providers::instantiationparameters::InstantiationParameters as::unity::IlType> ::il_type()];
1667 ::unity::lookup::method_info_on_class_with_signature(
1668 <ResourceManager as ::unity::ClassIdentity>::class(),
1669 "ProvideInstance",
1670 3,
1671 param_types,
1672 false,
1673 )
1674 });
1675 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1676 match &*METHOD {
1677 ::core::result::Result::Ok(mi) => *mi,
1678 ::core::result::Result::Err(e) => {
1679 panic!(
1680 "method lookup failed: {}
1681::{}
1682: {}
1683",
1684 <ResourceManager as ::unity::ClassIdentity>::NAME,
1685 "ProvideInstance",
1686 e
1687 )
1688 },
1689 }
1690 }
1691 }
1692 #[doc(hidden)]
1693 #[allow(non_snake_case)]
1694 pub mod __lookup_cleanup_scene_instances {
1695 use super::*;
1696 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
1697 let param_types: &[&'static ::unity::il2cpp::Il2CppType] =
1698 &[<crate::unity_engine::scene_management::scene::Scene as ::unity::IlType>::il_type()];
1699 ::unity::lookup::method_info_on_class_with_signature(
1700 <ResourceManager as ::unity::ClassIdentity>::class(),
1701 "CleanupSceneInstances",
1702 1,
1703 param_types,
1704 false,
1705 )
1706 });
1707 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1708 match &*METHOD {
1709 ::core::result::Result::Ok(mi) => *mi,
1710 ::core::result::Result::Err(e) => {
1711 panic!(
1712 "method lookup failed: {}
1713::{}
1714: {}
1715",
1716 <ResourceManager as ::unity::ClassIdentity>::NAME,
1717 "CleanupSceneInstances",
1718 e
1719 )
1720 },
1721 }
1722 }
1723 }
1724 #[doc(hidden)]
1725 #[allow(non_snake_case)]
1726 pub mod __lookup_execute_deferred_callbacks {
1727 use super::*;
1728 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
1729 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[];
1730 ::unity::lookup::method_info_on_class_with_signature(
1731 <ResourceManager as ::unity::ClassIdentity>::class(),
1732 "ExecuteDeferredCallbacks",
1733 0,
1734 param_types,
1735 false,
1736 )
1737 });
1738 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1739 match &*METHOD {
1740 ::core::result::Result::Ok(mi) => *mi,
1741 ::core::result::Result::Err(e) => {
1742 panic!(
1743 "method lookup failed: {}
1744::{}
1745: {}
1746",
1747 <ResourceManager as ::unity::ClassIdentity>::NAME,
1748 "ExecuteDeferredCallbacks",
1749 e
1750 )
1751 },
1752 }
1753 }
1754 }
1755 #[doc(hidden)]
1756 #[allow(non_snake_case)]
1757 pub mod __lookup_register_for_deferred_callback {
1758 use super::*;
1759 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
1760 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[
1761 <crate::unity_engine::resource_management::async_operations::iasyncoperation::IAsyncOperation as ::unity::IlType>::il_type(),
1762 <bool as ::unity::IlType>::il_type(),
1763 ];
1764 ::unity::lookup::method_info_on_class_with_signature(
1765 <ResourceManager as ::unity::ClassIdentity>::class(),
1766 "RegisterForDeferredCallback",
1767 2,
1768 param_types,
1769 false,
1770 )
1771 });
1772 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1773 match &*METHOD {
1774 ::core::result::Result::Ok(mi) => *mi,
1775 ::core::result::Result::Err(e) => {
1776 panic!(
1777 "method lookup failed: {}
1778::{}
1779: {}
1780",
1781 <ResourceManager as ::unity::ClassIdentity>::NAME,
1782 "RegisterForDeferredCallback",
1783 e
1784 )
1785 },
1786 }
1787 }
1788 }
1789 #[doc(hidden)]
1790 #[allow(non_snake_case)]
1791 pub mod __lookup_update {
1792 use super::*;
1793 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
1794 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[<f32 as ::unity::IlType>::il_type()];
1795 ::unity::lookup::method_info_on_class_with_signature(
1796 <ResourceManager as ::unity::ClassIdentity>::class(),
1797 "Update",
1798 1,
1799 param_types,
1800 false,
1801 )
1802 });
1803 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1804 match &*METHOD {
1805 ::core::result::Result::Ok(mi) => *mi,
1806 ::core::result::Result::Err(e) => {
1807 panic!(
1808 "method lookup failed: {}
1809::{}
1810: {}
1811",
1812 <ResourceManager as ::unity::ClassIdentity>::NAME,
1813 "Update",
1814 e
1815 )
1816 },
1817 }
1818 }
1819 }
1820 #[doc(hidden)]
1821 #[allow(non_snake_case)]
1822 pub mod __lookup_cctor {
1823 use super::*;
1824 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
1825 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[];
1826 ::unity::lookup::method_info_on_class_with_signature(<ResourceManager as ::unity::ClassIdentity>::class(), ".cctor", 0, param_types, true)
1827 });
1828 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1829 match &*METHOD {
1830 ::core::result::Result::Ok(mi) => *mi,
1831 ::core::result::Result::Err(e) => {
1832 panic!(
1833 "method lookup failed: {}
1834::{}
1835: {}
1836",
1837 <ResourceManager as ::unity::ClassIdentity>::NAME,
1838 ".cctor",
1839 e
1840 )
1841 },
1842 }
1843 }
1844 }
1845}
1846
1847#[cfg(feature = "unity_engine-resource_management-resourcemanager")]
1848impl ResourceManager {
1849 #[doc = "`.cctor()` overload"]
1850 pub fn cctor() -> () {
1851 unsafe {
1852 ::unity::il2cpp_call!(__ResourceManager_unity_raw::__lookup_cctor::get_method_info().method_ptr,();
1853 )
1854 }
1855 }
1856}
1857
1858#[cfg(feature = "unity_engine-resource_management-resourcemanager")]
1859pub trait IResourceManagerMethods: IResourceManager {
1860 #[doc = "`get_InternalIdTransformFunc()` overload"]
1861 fn get_internal_id_transform_func(
1862 self,
1863 ) -> crate::system::func_2::Func_2<
1864 crate::unity_engine::resource_management::resource_locations::iresourcelocation::IResourceLocation,
1865 ::unity::Il2CppString,
1866 > {
1867 unsafe {
1868 let __receiver = <ResourceManager as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1869 ::unity::il2cpp_call!(__ResourceManager_unity_raw::__lookup_get_internal_id_transform_func::get_method_info().method_ptr,crate::system::func_2::Func_2<crate::unity_engine::resource_management::resource_locations::iresourcelocation::IResourceLocation, ::unity::Il2CppString> ;
1870(ResourceManager)__receiver)
1871 }
1872 }
1873 #[doc = "`set_InternalIdTransformFunc(crate::system::func_2::Func_2<crate::unity_engine::resource_management::resource_locations::iresourcelocation::IResourceLocation,::unity::Il2CppString>)` overload"]
1874 fn set_internal_id_transform_func(
1875 self,
1876 value: impl ::core::convert::Into<
1877 crate::system::func_2::Func_2<
1878 crate::unity_engine::resource_management::resource_locations::iresourcelocation::IResourceLocation,
1879 ::unity::Il2CppString,
1880 >,
1881 >,
1882 ) -> () {
1883 unsafe {
1884 let __receiver = <ResourceManager as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1885 ::unity::il2cpp_call!(__ResourceManager_unity_raw::__lookup_set_internal_id_transform_func::get_method_info().method_ptr,();
1886(ResourceManager)__receiver,(crate::system::func_2::Func_2<crate::unity_engine::resource_management::resource_locations::iresourcelocation::IResourceLocation, ::unity::Il2CppString>)::core::convert::Into::into(value))
1887 }
1888 }
1889 #[doc = "`TransformInternalId(crate::unity_engine::resource_management::resource_locations::iresourcelocation::IResourceLocation)` overload"]
1890 fn transform_internal_id(
1891 self,
1892 location: impl ::core::convert::Into<crate::unity_engine::resource_management::resource_locations::iresourcelocation::IResourceLocation>,
1893 ) -> ::unity::Il2CppString {
1894 unsafe {
1895 let __receiver = <ResourceManager as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1896 ::unity::il2cpp_call!(__ResourceManager_unity_raw::__lookup_transform_internal_id::get_method_info().method_ptr, ::unity::Il2CppString;
1897(ResourceManager)__receiver,(crate::unity_engine::resource_management::resource_locations::iresourcelocation::IResourceLocation)::core::convert::Into::into(location))
1898 }
1899 }
1900 #[doc = "`get_WebRequestOverride()` overload"]
1901 fn get_web_request_override(self) -> crate::system::action_1::Action_1<crate::unity_engine::networking::unitywebrequest::UnityWebRequest> {
1902 unsafe {
1903 let __receiver = <ResourceManager as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1904 ::unity::il2cpp_call!(__ResourceManager_unity_raw::__lookup_get_web_request_override::get_method_info().method_ptr,crate::system::action_1::Action_1<crate::unity_engine::networking::unitywebrequest::UnityWebRequest> ;
1905(ResourceManager)__receiver)
1906 }
1907 }
1908 #[doc = "`set_WebRequestOverride(crate::system::action_1::Action_1<crate::unity_engine::networking::unitywebrequest::UnityWebRequest>)` overload"]
1909 fn set_web_request_override(
1910 self,
1911 value: impl ::core::convert::Into<crate::system::action_1::Action_1<crate::unity_engine::networking::unitywebrequest::UnityWebRequest>>,
1912 ) -> () {
1913 unsafe {
1914 let __receiver = <ResourceManager as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1915 ::unity::il2cpp_call!(__ResourceManager_unity_raw::__lookup_set_web_request_override::get_method_info().method_ptr,();
1916(ResourceManager)__receiver,(crate::system::action_1::Action_1<crate::unity_engine::networking::unitywebrequest::UnityWebRequest>)::core::convert::Into::into(value))
1917 }
1918 }
1919 #[doc = "`get_OperationCacheCount()` overload"]
1920 fn get_operation_cache_count(self) -> i32 {
1921 unsafe {
1922 let __receiver = <ResourceManager as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1923 ::unity::il2cpp_call!(__ResourceManager_unity_raw::__lookup_get_operation_cache_count::get_method_info().method_ptr,i32;
1924(ResourceManager)__receiver)
1925 }
1926 }
1927 #[doc = "`get_InstanceOperationCount()` overload"]
1928 fn get_instance_operation_count(self) -> i32 {
1929 unsafe {
1930 let __receiver = <ResourceManager as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1931 ::unity::il2cpp_call!(__ResourceManager_unity_raw::__lookup_get_instance_operation_count::get_method_info().method_ptr,i32;
1932(ResourceManager)__receiver)
1933 }
1934 }
1935 #[doc = "`AddUpdateReceiver(crate::unity_engine::resource_management::iupdatereceiver::IUpdateReceiver)` overload"]
1936 fn add_update_receiver(
1937 self,
1938 receiver: impl ::core::convert::Into<crate::unity_engine::resource_management::iupdatereceiver::IUpdateReceiver>,
1939 ) -> () {
1940 unsafe {
1941 let __receiver = <ResourceManager as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1942 ::unity::il2cpp_call!(__ResourceManager_unity_raw::__lookup_add_update_receiver::get_method_info().method_ptr,();
1943(ResourceManager)__receiver,(crate::unity_engine::resource_management::iupdatereceiver::IUpdateReceiver)::core::convert::Into::into(receiver))
1944 }
1945 }
1946 #[doc = "`RemoveUpdateReciever(crate::unity_engine::resource_management::iupdatereceiver::IUpdateReceiver)` overload"]
1947 fn remove_update_reciever(
1948 self,
1949 receiver: impl ::core::convert::Into<crate::unity_engine::resource_management::iupdatereceiver::IUpdateReceiver>,
1950 ) -> () {
1951 unsafe {
1952 let __receiver = <ResourceManager as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1953 ::unity::il2cpp_call!(__ResourceManager_unity_raw::__lookup_remove_update_reciever::get_method_info().method_ptr,();
1954(ResourceManager)__receiver,(crate::unity_engine::resource_management::iupdatereceiver::IUpdateReceiver)::core::convert::Into::into(receiver))
1955 }
1956 }
1957 #[doc = "`get_Allocator()` overload"]
1958 fn get_allocator(self) -> crate::unity_engine::resource_management::util::iallocationstrategy::IAllocationStrategy {
1959 unsafe {
1960 let __receiver = <ResourceManager as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1961 ::unity::il2cpp_call!(__ResourceManager_unity_raw::__lookup_get_allocator::get_method_info().method_ptr,crate::unity_engine::resource_management::util::iallocationstrategy::IAllocationStrategy;
1962(ResourceManager)__receiver)
1963 }
1964 }
1965 #[doc = "`set_Allocator(crate::unity_engine::resource_management::util::iallocationstrategy::IAllocationStrategy)` overload"]
1966 fn set_allocator(
1967 self,
1968 value: impl ::core::convert::Into<crate::unity_engine::resource_management::util::iallocationstrategy::IAllocationStrategy>,
1969 ) -> () {
1970 unsafe {
1971 let __receiver = <ResourceManager as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1972 ::unity::il2cpp_call!(__ResourceManager_unity_raw::__lookup_set_allocator::get_method_info().method_ptr,();
1973(ResourceManager)__receiver,(crate::unity_engine::resource_management::util::iallocationstrategy::IAllocationStrategy)::core::convert::Into::into(value))
1974 }
1975 }
1976 #[doc = "`get_ResourceProviders()` overload"]
1977 fn get_resource_providers(
1978 self,
1979 ) -> crate::system::collections::generic::ilist_1_interface::IList_1_Interface<
1980 crate::unity_engine::resource_management::resource_providers::iresourceprovider::IResourceProvider,
1981 > {
1982 unsafe {
1983 let __receiver = <ResourceManager as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1984 ::unity::il2cpp_call!(__ResourceManager_unity_raw::__lookup_get_resource_providers::get_method_info().method_ptr,crate::system::collections::generic::ilist_1_interface::IList_1_Interface<crate::unity_engine::resource_management::resource_providers::iresourceprovider::IResourceProvider> ;
1985(ResourceManager)__receiver)
1986 }
1987 }
1988 #[doc = "`get_CertificateHandlerInstance()` overload"]
1989 fn get_certificate_handler_instance(self) -> crate::unity_engine::networking::certificatehandler::CertificateHandler {
1990 unsafe {
1991 let __receiver = <ResourceManager as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1992 ::unity::il2cpp_call!(__ResourceManager_unity_raw::__lookup_get_certificate_handler_instance::get_method_info().method_ptr,crate::unity_engine::networking::certificatehandler::CertificateHandler;
1993(ResourceManager)__receiver)
1994 }
1995 }
1996 #[doc = "`set_CertificateHandlerInstance(crate::unity_engine::networking::certificatehandler::CertificateHandler)` overload"]
1997 fn set_certificate_handler_instance(
1998 self,
1999 value: impl ::core::convert::Into<crate::unity_engine::networking::certificatehandler::CertificateHandler>,
2000 ) -> () {
2001 unsafe {
2002 let __receiver = <ResourceManager as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2003 ::unity::il2cpp_call!(__ResourceManager_unity_raw::__lookup_set_certificate_handler_instance::get_method_info().method_ptr,();
2004(ResourceManager)__receiver,(crate::unity_engine::networking::certificatehandler::CertificateHandler)::core::convert::Into::into(value))
2005 }
2006 }
2007 #[doc = "`.ctor(crate::unity_engine::resource_management::util::iallocationstrategy::IAllocationStrategy)` overload"]
2008 fn ctor(self, alloc: impl ::core::convert::Into<crate::unity_engine::resource_management::util::iallocationstrategy::IAllocationStrategy>) -> () {
2009 unsafe {
2010 let __receiver = <ResourceManager as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2011 ::unity::il2cpp_call!(__ResourceManager_unity_raw::__lookup_ctor::get_method_info().method_ptr,();
2012(ResourceManager)__receiver,(crate::unity_engine::resource_management::util::iallocationstrategy::IAllocationStrategy)::core::convert::Into::into(alloc))
2013 }
2014 }
2015 #[doc = "`OnObjectAdded(crate::system::object::Object)` overload"]
2016 fn on_object_added(self, obj: impl ::core::convert::Into<crate::system::object::Object>) -> () {
2017 unsafe {
2018 let __receiver = <ResourceManager as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2019 ::unity::il2cpp_call!(__ResourceManager_unity_raw::__lookup_on_object_added::get_method_info().method_ptr,();
2020(ResourceManager)__receiver,(crate::system::object::Object)::core::convert::Into::into(obj))
2021 }
2022 }
2023 #[doc = "`OnObjectRemoved(crate::system::object::Object)` overload"]
2024 fn on_object_removed(self, obj: impl ::core::convert::Into<crate::system::object::Object>) -> () {
2025 unsafe {
2026 let __receiver = <ResourceManager as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2027 ::unity::il2cpp_call!(__ResourceManager_unity_raw::__lookup_on_object_removed::get_method_info().method_ptr,();
2028(ResourceManager)__receiver,(crate::system::object::Object)::core::convert::Into::into(obj))
2029 }
2030 }
2031 #[doc = "`RegisterForCallbacks()` overload"]
2032 fn register_for_callbacks(self) -> () {
2033 unsafe {
2034 let __receiver = <ResourceManager as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2035 ::unity::il2cpp_call!(__ResourceManager_unity_raw::__lookup_register_for_callbacks::get_method_info().method_ptr,();
2036(ResourceManager)__receiver)
2037 }
2038 }
2039 #[doc = "`ClearDiagnosticsCallback()` overload"]
2040 fn clear_diagnostics_callback(self) -> () {
2041 unsafe {
2042 let __receiver = <ResourceManager as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2043 ::unity::il2cpp_call!(__ResourceManager_unity_raw::__lookup_clear_diagnostics_callback::get_method_info().method_ptr,();
2044(ResourceManager)__receiver)
2045 }
2046 }
2047 #[doc = "`ClearDiagnosticCallbacks()` overload"]
2048 fn clear_diagnostic_callbacks(self) -> () {
2049 unsafe {
2050 let __receiver = <ResourceManager as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2051 ::unity::il2cpp_call!(__ResourceManager_unity_raw::__lookup_clear_diagnostic_callbacks::get_method_info().method_ptr,();
2052(ResourceManager)__receiver)
2053 }
2054 }
2055 #[doc = "`UnregisterDiagnosticCallback(crate::system::action_1::Action_1<crate::unity_engine::resource_management::resourcemanager::ResourceManager_DiagnosticEventContext>)` overload"]
2056 fn unregister_diagnostic_callback(
2057 self,
2058 func: impl ::core::convert::Into<
2059 crate::system::action_1::Action_1<crate::unity_engine::resource_management::resourcemanager::ResourceManager_DiagnosticEventContext>,
2060 >,
2061 ) -> () {
2062 unsafe {
2063 let __receiver = <ResourceManager as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2064 ::unity::il2cpp_call!(__ResourceManager_unity_raw::__lookup_unregister_diagnostic_callback::get_method_info().method_ptr,();
2065(ResourceManager)__receiver,(crate::system::action_1::Action_1<crate::unity_engine::resource_management::resourcemanager::ResourceManager_DiagnosticEventContext>)::core::convert::Into::into(func))
2066 }
2067 }
2068 #[doc = "`RegisterDiagnosticCallback(crate::system::action_4::Action_4<crate::unity_engine::resource_management::async_operations::asyncoperationhandle::AsyncOperationHandle,crate::unity_engine::resource_management::resourcemanager::ResourceManager_DiagnosticEventType,i32,crate::system::object::Object>)` overload"]
2069 fn register_diagnostic_callback(
2070 self,
2071 func: impl ::core::convert::Into<
2072 crate::system::action_4::Action_4<
2073 crate::unity_engine::resource_management::async_operations::asyncoperationhandle::AsyncOperationHandle,
2074 crate::unity_engine::resource_management::resourcemanager::ResourceManager_DiagnosticEventType,
2075 i32,
2076 crate::system::object::Object,
2077 >,
2078 >,
2079 ) -> () {
2080 unsafe {
2081 let __receiver = <ResourceManager as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2082 ::unity::il2cpp_call!(__ResourceManager_unity_raw::__lookup_register_diagnostic_callback::get_method_info().method_ptr,();
2083(ResourceManager)__receiver,(crate::system::action_4::Action_4<crate::unity_engine::resource_management::async_operations::asyncoperationhandle::AsyncOperationHandle,crate::unity_engine::resource_management::resourcemanager::ResourceManager_DiagnosticEventType,i32,crate::system::object::Object>)::core::convert::Into::into(func))
2084 }
2085 }
2086 #[doc = "`RegisterDiagnosticCallback(crate::system::action_1::Action_1<crate::unity_engine::resource_management::resourcemanager::ResourceManager_DiagnosticEventContext>)` overload"]
2087 fn register_diagnostic_callback_2(
2088 self,
2089 func: impl ::core::convert::Into<
2090 crate::system::action_1::Action_1<crate::unity_engine::resource_management::resourcemanager::ResourceManager_DiagnosticEventContext>,
2091 >,
2092 ) -> () {
2093 unsafe {
2094 let __receiver = <ResourceManager as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2095 ::unity::il2cpp_call!(__ResourceManager_unity_raw::__lookup_register_diagnostic_callback_2::get_method_info().method_ptr,();
2096(ResourceManager)__receiver,(crate::system::action_1::Action_1<crate::unity_engine::resource_management::resourcemanager::ResourceManager_DiagnosticEventContext>)::core::convert::Into::into(func))
2097 }
2098 }
2099 #[doc = "`PostDiagnosticEvent(crate::unity_engine::resource_management::resourcemanager::ResourceManager_DiagnosticEventContext)` overload"]
2100 fn post_diagnostic_event(
2101 self,
2102 context: impl ::core::convert::Into<crate::unity_engine::resource_management::resourcemanager::ResourceManager_DiagnosticEventContext>,
2103 ) -> () {
2104 unsafe {
2105 let __receiver = <ResourceManager as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2106 ::unity::il2cpp_call!(__ResourceManager_unity_raw::__lookup_post_diagnostic_event::get_method_info().method_ptr,();
2107(ResourceManager)__receiver,(crate::unity_engine::resource_management::resourcemanager::ResourceManager_DiagnosticEventContext)::core::convert::Into::into(context))
2108 }
2109 }
2110 #[doc = "`GetResourceProvider(::unity::SystemType, crate::unity_engine::resource_management::resource_locations::iresourcelocation::IResourceLocation)` overload"]
2111 fn get_resource_provider(
2112 self,
2113 t: impl ::core::convert::Into<::unity::SystemType>,
2114 location: impl ::core::convert::Into<crate::unity_engine::resource_management::resource_locations::iresourcelocation::IResourceLocation>,
2115 ) -> crate::unity_engine::resource_management::resource_providers::iresourceprovider::IResourceProvider {
2116 unsafe {
2117 let __receiver = <ResourceManager as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2118 ::unity::il2cpp_call!(__ResourceManager_unity_raw::__lookup_get_resource_provider::get_method_info().method_ptr,crate::unity_engine::resource_management::resource_providers::iresourceprovider::IResourceProvider;
2119(ResourceManager)__receiver,(::unity::SystemType)::core::convert::Into::into(t),(crate::unity_engine::resource_management::resource_locations::iresourcelocation::IResourceLocation)::core::convert::Into::into(location))
2120 }
2121 }
2122 #[doc = "`GetDefaultTypeForLocation(crate::unity_engine::resource_management::resource_locations::iresourcelocation::IResourceLocation)` overload"]
2123 fn get_default_type_for_location(
2124 self,
2125 loc: impl ::core::convert::Into<crate::unity_engine::resource_management::resource_locations::iresourcelocation::IResourceLocation>,
2126 ) -> ::unity::SystemType {
2127 unsafe {
2128 let __receiver = <ResourceManager as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2129 ::unity::il2cpp_call!(__ResourceManager_unity_raw::__lookup_get_default_type_for_location::get_method_info().method_ptr, ::unity::SystemType;
2130(ResourceManager)__receiver,(crate::unity_engine::resource_management::resource_locations::iresourcelocation::IResourceLocation)::core::convert::Into::into(loc))
2131 }
2132 }
2133 #[doc = "`CalculateLocationsHash(crate::system::collections::generic::ilist_1_interface::IList_1_Interface<crate::unity_engine::resource_management::resource_locations::iresourcelocation::IResourceLocation>, ::unity::SystemType)` overload"]
2134 fn calculate_locations_hash(
2135 self,
2136 locations: impl ::core::convert::Into<
2137 crate::system::collections::generic::ilist_1_interface::IList_1_Interface<
2138 crate::unity_engine::resource_management::resource_locations::iresourcelocation::IResourceLocation,
2139 >,
2140 >,
2141 t: impl ::core::convert::Into<::unity::SystemType>,
2142 ) -> i32 {
2143 unsafe {
2144 let __receiver = <ResourceManager as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2145 ::unity::il2cpp_call!(__ResourceManager_unity_raw::__lookup_calculate_locations_hash::get_method_info().method_ptr,i32;
2146(ResourceManager)__receiver,(crate::system::collections::generic::ilist_1_interface::IList_1_Interface<crate::unity_engine::resource_management::resource_locations::iresourcelocation::IResourceLocation>)::core::convert::Into::into(locations),(::unity::SystemType)::core::convert::Into::into(t))
2147 }
2148 }
2149 #[doc = "`ProvideResource(crate::unity_engine::resource_management::resource_locations::iresourcelocation::IResourceLocation, ::unity::SystemType, bool)` overload"]
2150 fn provide_resource(
2151 self,
2152 location: impl ::core::convert::Into<crate::unity_engine::resource_management::resource_locations::iresourcelocation::IResourceLocation>,
2153 desired_type: impl ::core::convert::Into<::unity::SystemType>,
2154 release_dependencies_on_failure: impl ::core::convert::Into<bool>,
2155 ) -> crate::unity_engine::resource_management::async_operations::asyncoperationhandle::AsyncOperationHandle {
2156 unsafe {
2157 let __receiver = <ResourceManager as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2158 ::unity::il2cpp_call!(__ResourceManager_unity_raw::__lookup_provide_resource::get_method_info().method_ptr,crate::unity_engine::resource_management::async_operations::asyncoperationhandle::AsyncOperationHandle;
2159(ResourceManager)__receiver,(crate::unity_engine::resource_management::resource_locations::iresourcelocation::IResourceLocation)::core::convert::Into::into(location),(::unity::SystemType)::core::convert::Into::into(desired_type),(bool)::core::convert::Into::into(release_dependencies_on_failure))
2160 }
2161 }
2162 fn provide_resource_2<M0: ::unity::IlType + ::core::marker::Copy + ::unity::ClassIdentity>(
2163 self,
2164 location: impl ::core::convert::Into<crate::unity_engine::resource_management::resource_locations::iresourcelocation::IResourceLocation>,
2165 ) -> crate::unity_engine::resource_management::async_operations::asyncoperationhandle_1::AsyncOperationHandle_1<M0> {
2166 static OPEN: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
2167 ::unity::lookup::method_info_on_class(<ResourceManager as ::unity::ClassIdentity>::class(), "ProvideResource", 1)
2168 });
2169 #[allow(clippy::type_complexity)]
2170 static CACHE: ::std::sync::OnceLock<::std::sync::Mutex<::std::collections::HashMap<usize, &'static ::unity::il2cpp::MethodInfo>>> =
2171 ::std::sync::OnceLock::new();
2172 let _ = false;
2173 let __open: &'static ::unity::il2cpp::MethodInfo = match &*OPEN {
2174 ::core::result::Result::Ok(mi) => *mi,
2175 ::core::result::Result::Err(e) => {
2176 panic!(
2177 "method lookup failed: {}
2178::{}
2179: {}
2180",
2181 <ResourceManager as ::unity::ClassIdentity>::NAME,
2182 "ProvideResource",
2183 e
2184 )
2185 },
2186 };
2187 let __cache = CACHE.get_or_init(|| ::std::sync::Mutex::new(::std::collections::HashMap::new()));
2188 let __key: usize = <M0 as ::unity::IlType>::il_type() as *const _ as usize;
2189 let __inflated: &'static ::unity::il2cpp::MethodInfo = {
2190 let mut __guard = __cache.lock().unwrap();
2191 *__guard
2192 .entry(__key)
2193 .or_insert_with(|| ::unity::il2cpp::generic::create_generic_method_info(__open, &[<M0 as ::unity::IlType>::il_type()]))
2194 };
2195 unsafe {
2196 let __receiver = <ResourceManager as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2197 let __f: extern "C" fn(
2198 ResourceManager,
2199 crate::unity_engine::resource_management::resource_locations::iresourcelocation::IResourceLocation,
2200 ::unity::OptionalMethod,
2201 )
2202 -> crate::unity_engine::resource_management::async_operations::asyncoperationhandle_1::AsyncOperationHandle_1<M0> =
2203 ::core::mem::transmute(__inflated.method_ptr);
2204 let __mi_opaque: &'static () = &*(__inflated as *const _ as *const ());
2205 __f(
2206 __receiver,
2207 ::core::convert::Into::into(location),
2208 ::core::option::Option::Some(__mi_opaque),
2209 )
2210 }
2211 }
2212 fn start_operation<M0: ::unity::IlType + ::core::marker::Copy + ::unity::ClassIdentity>(
2213 self,
2214 operation: impl ::core::convert::Into<crate::unity_engine::resource_management::async_operations::asyncoperationbase_1::AsyncOperationBase_1<M0>>,
2215 dependency: impl ::core::convert::Into<crate::unity_engine::resource_management::async_operations::asyncoperationhandle::AsyncOperationHandle>,
2216 ) -> crate::unity_engine::resource_management::async_operations::asyncoperationhandle_1::AsyncOperationHandle_1<M0> {
2217 static OPEN: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
2218 ::unity::lookup::method_info_on_class(<ResourceManager as ::unity::ClassIdentity>::class(), "StartOperation", 2)
2219 });
2220 #[allow(clippy::type_complexity)]
2221 static CACHE: ::std::sync::OnceLock<::std::sync::Mutex<::std::collections::HashMap<usize, &'static ::unity::il2cpp::MethodInfo>>> =
2222 ::std::sync::OnceLock::new();
2223 let _ = false;
2224 let __open: &'static ::unity::il2cpp::MethodInfo = match &*OPEN {
2225 ::core::result::Result::Ok(mi) => *mi,
2226 ::core::result::Result::Err(e) => {
2227 panic!(
2228 "method lookup failed: {}
2229::{}
2230: {}
2231",
2232 <ResourceManager as ::unity::ClassIdentity>::NAME,
2233 "StartOperation",
2234 e
2235 )
2236 },
2237 };
2238 let __cache = CACHE.get_or_init(|| ::std::sync::Mutex::new(::std::collections::HashMap::new()));
2239 let __key: usize = <M0 as ::unity::IlType>::il_type() as *const _ as usize;
2240 let __inflated: &'static ::unity::il2cpp::MethodInfo = {
2241 let mut __guard = __cache.lock().unwrap();
2242 *__guard
2243 .entry(__key)
2244 .or_insert_with(|| ::unity::il2cpp::generic::create_generic_method_info(__open, &[<M0 as ::unity::IlType>::il_type()]))
2245 };
2246 unsafe {
2247 let __receiver = <ResourceManager as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2248 let __f: extern "C" fn(
2249 ResourceManager,
2250 crate::unity_engine::resource_management::async_operations::asyncoperationbase_1::AsyncOperationBase_1<M0>,
2251 crate::unity_engine::resource_management::async_operations::asyncoperationhandle::AsyncOperationHandle,
2252 ::unity::OptionalMethod,
2253 )
2254 -> crate::unity_engine::resource_management::async_operations::asyncoperationhandle_1::AsyncOperationHandle_1<M0> =
2255 ::core::mem::transmute(__inflated.method_ptr);
2256 let __mi_opaque: &'static () = &*(__inflated as *const _ as *const ());
2257 __f(
2258 __receiver,
2259 ::core::convert::Into::into(operation),
2260 ::core::convert::Into::into(dependency),
2261 ::core::option::Option::Some(__mi_opaque),
2262 )
2263 }
2264 }
2265 #[doc = "`StartOperation(crate::unity_engine::resource_management::async_operations::iasyncoperation::IAsyncOperation, crate::unity_engine::resource_management::async_operations::asyncoperationhandle::AsyncOperationHandle)` overload"]
2266 fn start_operation_2(
2267 self,
2268 operation: impl ::core::convert::Into<crate::unity_engine::resource_management::async_operations::iasyncoperation::IAsyncOperation>,
2269 dependency: impl ::core::convert::Into<crate::unity_engine::resource_management::async_operations::asyncoperationhandle::AsyncOperationHandle>,
2270 ) -> crate::unity_engine::resource_management::async_operations::asyncoperationhandle::AsyncOperationHandle {
2271 unsafe {
2272 let __receiver = <ResourceManager as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2273 ::unity::il2cpp_call!(__ResourceManager_unity_raw::__lookup_start_operation_2::get_method_info().method_ptr,crate::unity_engine::resource_management::async_operations::asyncoperationhandle::AsyncOperationHandle;
2274(ResourceManager)__receiver,(crate::unity_engine::resource_management::async_operations::iasyncoperation::IAsyncOperation)::core::convert::Into::into(operation),(crate::unity_engine::resource_management::async_operations::asyncoperationhandle::AsyncOperationHandle)::core::convert::Into::into(dependency))
2275 }
2276 }
2277 #[doc = "`OnInstanceOperationDestroy(crate::unity_engine::resource_management::async_operations::iasyncoperation::IAsyncOperation)` overload"]
2278 fn on_instance_operation_destroy(
2279 self,
2280 o: impl ::core::convert::Into<crate::unity_engine::resource_management::async_operations::iasyncoperation::IAsyncOperation>,
2281 ) -> () {
2282 unsafe {
2283 let __receiver = <ResourceManager as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2284 ::unity::il2cpp_call!(__ResourceManager_unity_raw::__lookup_on_instance_operation_destroy::get_method_info().method_ptr,();
2285(ResourceManager)__receiver,(crate::unity_engine::resource_management::async_operations::iasyncoperation::IAsyncOperation)::core::convert::Into::into(o))
2286 }
2287 }
2288 #[doc = "`OnOperationDestroyNonCached(crate::unity_engine::resource_management::async_operations::iasyncoperation::IAsyncOperation)` overload"]
2289 fn on_operation_destroy_non_cached(
2290 self,
2291 o: impl ::core::convert::Into<crate::unity_engine::resource_management::async_operations::iasyncoperation::IAsyncOperation>,
2292 ) -> () {
2293 unsafe {
2294 let __receiver = <ResourceManager as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2295 ::unity::il2cpp_call!(__ResourceManager_unity_raw::__lookup_on_operation_destroy_non_cached::get_method_info().method_ptr,();
2296(ResourceManager)__receiver,(crate::unity_engine::resource_management::async_operations::iasyncoperation::IAsyncOperation)::core::convert::Into::into(o))
2297 }
2298 }
2299 #[doc = "`OnOperationDestroyCached(crate::unity_engine::resource_management::async_operations::iasyncoperation::IAsyncOperation)` overload"]
2300 fn on_operation_destroy_cached(
2301 self,
2302 o: impl ::core::convert::Into<crate::unity_engine::resource_management::async_operations::iasyncoperation::IAsyncOperation>,
2303 ) -> () {
2304 unsafe {
2305 let __receiver = <ResourceManager as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2306 ::unity::il2cpp_call!(__ResourceManager_unity_raw::__lookup_on_operation_destroy_cached::get_method_info().method_ptr,();
2307(ResourceManager)__receiver,(crate::unity_engine::resource_management::async_operations::iasyncoperation::IAsyncOperation)::core::convert::Into::into(o))
2308 }
2309 }
2310 fn create_operation<M0: ::unity::IlType + ::core::marker::Copy + ::unity::ClassIdentity>(
2311 self,
2312 actual_type: impl ::core::convert::Into<::unity::SystemType>,
2313 type_hash: impl ::core::convert::Into<i32>,
2314 cache_key: impl ::core::convert::Into<crate::unity_engine::resource_management::util::ioperationcachekey::IOperationCacheKey>,
2315 on_destroy_action: impl ::core::convert::Into<
2316 crate::system::action_1::Action_1<crate::unity_engine::resource_management::async_operations::iasyncoperation::IAsyncOperation>,
2317 >,
2318 ) -> M0 {
2319 static OPEN: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
2320 ::unity::lookup::method_info_on_class(<ResourceManager as ::unity::ClassIdentity>::class(), "CreateOperation", 4)
2321 });
2322 #[allow(clippy::type_complexity)]
2323 static CACHE: ::std::sync::OnceLock<::std::sync::Mutex<::std::collections::HashMap<usize, &'static ::unity::il2cpp::MethodInfo>>> =
2324 ::std::sync::OnceLock::new();
2325 let _ = false;
2326 let __open: &'static ::unity::il2cpp::MethodInfo = match &*OPEN {
2327 ::core::result::Result::Ok(mi) => *mi,
2328 ::core::result::Result::Err(e) => {
2329 panic!(
2330 "method lookup failed: {}
2331::{}
2332: {}
2333",
2334 <ResourceManager as ::unity::ClassIdentity>::NAME,
2335 "CreateOperation",
2336 e
2337 )
2338 },
2339 };
2340 let __cache = CACHE.get_or_init(|| ::std::sync::Mutex::new(::std::collections::HashMap::new()));
2341 let __key: usize = <M0 as ::unity::IlType>::il_type() as *const _ as usize;
2342 let __inflated: &'static ::unity::il2cpp::MethodInfo = {
2343 let mut __guard = __cache.lock().unwrap();
2344 *__guard
2345 .entry(__key)
2346 .or_insert_with(|| ::unity::il2cpp::generic::create_generic_method_info(__open, &[<M0 as ::unity::IlType>::il_type()]))
2347 };
2348 unsafe {
2349 let __receiver = <ResourceManager as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2350 let __f: extern "C" fn(
2351 ResourceManager,
2352 ::unity::SystemType,
2353 i32,
2354 crate::unity_engine::resource_management::util::ioperationcachekey::IOperationCacheKey,
2355 crate::system::action_1::Action_1<crate::unity_engine::resource_management::async_operations::iasyncoperation::IAsyncOperation>,
2356 ::unity::OptionalMethod,
2357 ) -> M0 = ::core::mem::transmute(__inflated.method_ptr);
2358 let __mi_opaque: &'static () = &*(__inflated as *const _ as *const ());
2359 __f(
2360 __receiver,
2361 ::core::convert::Into::into(actual_type),
2362 ::core::convert::Into::into(type_hash),
2363 ::core::convert::Into::into(cache_key),
2364 ::core::convert::Into::into(on_destroy_action),
2365 ::core::option::Option::Some(__mi_opaque),
2366 )
2367 }
2368 }
2369 #[doc = "`AddOperationToCache(crate::unity_engine::resource_management::util::ioperationcachekey::IOperationCacheKey, crate::unity_engine::resource_management::async_operations::iasyncoperation::IAsyncOperation)` overload"]
2370 fn add_operation_to_cache(
2371 self,
2372 key: impl ::core::convert::Into<crate::unity_engine::resource_management::util::ioperationcachekey::IOperationCacheKey>,
2373 operation: impl ::core::convert::Into<crate::unity_engine::resource_management::async_operations::iasyncoperation::IAsyncOperation>,
2374 ) -> () {
2375 unsafe {
2376 let __receiver = <ResourceManager as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2377 ::unity::il2cpp_call!(__ResourceManager_unity_raw::__lookup_add_operation_to_cache::get_method_info().method_ptr,();
2378(ResourceManager)__receiver,(crate::unity_engine::resource_management::util::ioperationcachekey::IOperationCacheKey)::core::convert::Into::into(key),(crate::unity_engine::resource_management::async_operations::iasyncoperation::IAsyncOperation)::core::convert::Into::into(operation))
2379 }
2380 }
2381 #[doc = "`RemoveOperationFromCache(crate::unity_engine::resource_management::util::ioperationcachekey::IOperationCacheKey)` overload"]
2382 fn remove_operation_from_cache(
2383 self,
2384 key: impl ::core::convert::Into<crate::unity_engine::resource_management::util::ioperationcachekey::IOperationCacheKey>,
2385 ) -> bool {
2386 unsafe {
2387 let __receiver = <ResourceManager as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2388 ::unity::il2cpp_call!(__ResourceManager_unity_raw::__lookup_remove_operation_from_cache::get_method_info().method_ptr,bool;
2389(ResourceManager)__receiver,(crate::unity_engine::resource_management::util::ioperationcachekey::IOperationCacheKey)::core::convert::Into::into(key))
2390 }
2391 }
2392 #[doc = "`IsOperationCached(crate::unity_engine::resource_management::util::ioperationcachekey::IOperationCacheKey)` overload"]
2393 fn is_operation_cached(
2394 self,
2395 key: impl ::core::convert::Into<crate::unity_engine::resource_management::util::ioperationcachekey::IOperationCacheKey>,
2396 ) -> bool {
2397 unsafe {
2398 let __receiver = <ResourceManager as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2399 ::unity::il2cpp_call!(__ResourceManager_unity_raw::__lookup_is_operation_cached::get_method_info().method_ptr,bool;
2400(ResourceManager)__receiver,(crate::unity_engine::resource_management::util::ioperationcachekey::IOperationCacheKey)::core::convert::Into::into(key))
2401 }
2402 }
2403 #[doc = "`CachedOperationCount()` overload"]
2404 fn cached_operation_count(self) -> i32 {
2405 unsafe {
2406 let __receiver = <ResourceManager as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2407 ::unity::il2cpp_call!(__ResourceManager_unity_raw::__lookup_cached_operation_count::get_method_info().method_ptr,i32;
2408(ResourceManager)__receiver)
2409 }
2410 }
2411 fn create_completed_operation<M0: ::unity::IlType + ::core::marker::Copy + ::unity::ClassIdentity>(
2412 self,
2413 result: impl ::core::convert::Into<M0>,
2414 error_msg: impl ::core::convert::Into<::unity::Il2CppString>,
2415 ) -> crate::unity_engine::resource_management::async_operations::asyncoperationhandle_1::AsyncOperationHandle_1<M0> {
2416 static OPEN: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
2417 ::unity::lookup::method_info_on_class(<ResourceManager as ::unity::ClassIdentity>::class(), "CreateCompletedOperation", 2)
2418 });
2419 #[allow(clippy::type_complexity)]
2420 static CACHE: ::std::sync::OnceLock<::std::sync::Mutex<::std::collections::HashMap<usize, &'static ::unity::il2cpp::MethodInfo>>> =
2421 ::std::sync::OnceLock::new();
2422 let _ = false;
2423 let __open: &'static ::unity::il2cpp::MethodInfo = match &*OPEN {
2424 ::core::result::Result::Ok(mi) => *mi,
2425 ::core::result::Result::Err(e) => {
2426 panic!(
2427 "method lookup failed: {}
2428::{}
2429: {}
2430",
2431 <ResourceManager as ::unity::ClassIdentity>::NAME,
2432 "CreateCompletedOperation",
2433 e
2434 )
2435 },
2436 };
2437 let __cache = CACHE.get_or_init(|| ::std::sync::Mutex::new(::std::collections::HashMap::new()));
2438 let __key: usize = <M0 as ::unity::IlType>::il_type() as *const _ as usize;
2439 let __inflated: &'static ::unity::il2cpp::MethodInfo = {
2440 let mut __guard = __cache.lock().unwrap();
2441 *__guard
2442 .entry(__key)
2443 .or_insert_with(|| ::unity::il2cpp::generic::create_generic_method_info(__open, &[<M0 as ::unity::IlType>::il_type()]))
2444 };
2445 unsafe {
2446 let __receiver = <ResourceManager as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2447 let __f: extern "C" fn(
2448 ResourceManager,
2449 M0,
2450 ::unity::Il2CppString,
2451 ::unity::OptionalMethod,
2452 )
2453 -> crate::unity_engine::resource_management::async_operations::asyncoperationhandle_1::AsyncOperationHandle_1<M0> =
2454 ::core::mem::transmute(__inflated.method_ptr);
2455 let __mi_opaque: &'static () = &*(__inflated as *const _ as *const ());
2456 __f(
2457 __receiver,
2458 ::core::convert::Into::into(result),
2459 ::core::convert::Into::into(error_msg),
2460 ::core::option::Option::Some(__mi_opaque),
2461 )
2462 }
2463 }
2464 #[doc = "`Release(crate::unity_engine::resource_management::async_operations::asyncoperationhandle::AsyncOperationHandle)` overload"]
2465 fn release(
2466 self,
2467 handle: impl ::core::convert::Into<crate::unity_engine::resource_management::async_operations::asyncoperationhandle::AsyncOperationHandle>,
2468 ) -> () {
2469 unsafe {
2470 let __receiver = <ResourceManager as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2471 ::unity::il2cpp_call!(__ResourceManager_unity_raw::__lookup_release::get_method_info().method_ptr,();
2472(ResourceManager)__receiver,(crate::unity_engine::resource_management::async_operations::asyncoperationhandle::AsyncOperationHandle)::core::convert::Into::into(handle))
2473 }
2474 }
2475 #[doc = "`Acquire(crate::unity_engine::resource_management::async_operations::asyncoperationhandle::AsyncOperationHandle)` overload"]
2476 fn acquire(
2477 self,
2478 handle: impl ::core::convert::Into<crate::unity_engine::resource_management::async_operations::asyncoperationhandle::AsyncOperationHandle>,
2479 ) -> () {
2480 unsafe {
2481 let __receiver = <ResourceManager as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2482 ::unity::il2cpp_call!(__ResourceManager_unity_raw::__lookup_acquire::get_method_info().method_ptr,();
2483(ResourceManager)__receiver,(crate::unity_engine::resource_management::async_operations::asyncoperationhandle::AsyncOperationHandle)::core::convert::Into::into(handle))
2484 }
2485 }
2486 #[doc = "`AcquireGroupOpFromCache(crate::unity_engine::resource_management::util::ioperationcachekey::IOperationCacheKey)` overload"]
2487 fn acquire_group_op_from_cache(
2488 self,
2489 key: impl ::core::convert::Into<crate::unity_engine::resource_management::util::ioperationcachekey::IOperationCacheKey>,
2490 ) -> crate::unity_engine::resource_management::async_operations::groupoperation::GroupOperation {
2491 unsafe {
2492 let __receiver = <ResourceManager as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2493 ::unity::il2cpp_call!(__ResourceManager_unity_raw::__lookup_acquire_group_op_from_cache::get_method_info().method_ptr,crate::unity_engine::resource_management::async_operations::groupoperation::GroupOperation;
2494(ResourceManager)__receiver,(crate::unity_engine::resource_management::util::ioperationcachekey::IOperationCacheKey)::core::convert::Into::into(key))
2495 }
2496 }
2497 fn create_group_operation<M0: ::unity::IlType + ::core::marker::Copy + ::unity::ClassIdentity>(
2498 self,
2499 locations: impl ::core::convert::Into<
2500 crate::system::collections::generic::ilist_1_interface::IList_1_Interface<
2501 crate::unity_engine::resource_management::resource_locations::iresourcelocation::IResourceLocation,
2502 >,
2503 >,
2504 ) -> crate::unity_engine::resource_management::async_operations::asyncoperationhandle_1::AsyncOperationHandle_1<
2505 crate::system::collections::generic::ilist_1_interface::IList_1_Interface<
2506 crate::unity_engine::resource_management::async_operations::asyncoperationhandle::AsyncOperationHandle,
2507 >,
2508 > {
2509 static OPEN: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
2510 ::unity::lookup::method_info_on_class(<ResourceManager as ::unity::ClassIdentity>::class(), "CreateGroupOperation", 1)
2511 });
2512 #[allow(clippy::type_complexity)]
2513 static CACHE: ::std::sync::OnceLock<::std::sync::Mutex<::std::collections::HashMap<usize, &'static ::unity::il2cpp::MethodInfo>>> =
2514 ::std::sync::OnceLock::new();
2515 let _ = false;
2516 let __open: &'static ::unity::il2cpp::MethodInfo = match &*OPEN {
2517 ::core::result::Result::Ok(mi) => *mi,
2518 ::core::result::Result::Err(e) => {
2519 panic!(
2520 "method lookup failed: {}
2521::{}
2522: {}
2523",
2524 <ResourceManager as ::unity::ClassIdentity>::NAME,
2525 "CreateGroupOperation",
2526 e
2527 )
2528 },
2529 };
2530 let __cache = CACHE.get_or_init(|| ::std::sync::Mutex::new(::std::collections::HashMap::new()));
2531 let __key: usize = <M0 as ::unity::IlType>::il_type() as *const _ as usize;
2532 let __inflated: &'static ::unity::il2cpp::MethodInfo = {
2533 let mut __guard = __cache.lock().unwrap();
2534 *__guard
2535 .entry(__key)
2536 .or_insert_with(|| ::unity::il2cpp::generic::create_generic_method_info(__open, &[<M0 as ::unity::IlType>::il_type()]))
2537 };
2538 unsafe {
2539 let __receiver = <ResourceManager as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2540 let __f: extern "C" fn(
2541 ResourceManager,
2542 crate::system::collections::generic::ilist_1_interface::IList_1_Interface<
2543 crate::unity_engine::resource_management::resource_locations::iresourcelocation::IResourceLocation,
2544 >,
2545 ::unity::OptionalMethod,
2546 )
2547 -> crate::unity_engine::resource_management::async_operations::asyncoperationhandle_1::AsyncOperationHandle_1<
2548 crate::system::collections::generic::ilist_1_interface::IList_1_Interface<
2549 crate::unity_engine::resource_management::async_operations::asyncoperationhandle::AsyncOperationHandle,
2550 >,
2551 > = ::core::mem::transmute(__inflated.method_ptr);
2552 let __mi_opaque: &'static () = &*(__inflated as *const _ as *const ());
2553 __f(
2554 __receiver,
2555 ::core::convert::Into::into(locations),
2556 ::core::option::Option::Some(__mi_opaque),
2557 )
2558 }
2559 }
2560 fn create_group_operation_2<M0: ::unity::IlType + ::core::marker::Copy + ::unity::ClassIdentity>(
2561 self,
2562 locations: impl ::core::convert::Into<
2563 crate::system::collections::generic::ilist_1_interface::IList_1_Interface<
2564 crate::unity_engine::resource_management::resource_locations::iresourcelocation::IResourceLocation,
2565 >,
2566 >,
2567 allow_failed_dependencies: impl ::core::convert::Into<bool>,
2568 ) -> crate::unity_engine::resource_management::async_operations::asyncoperationhandle_1::AsyncOperationHandle_1<
2569 crate::system::collections::generic::ilist_1_interface::IList_1_Interface<
2570 crate::unity_engine::resource_management::async_operations::asyncoperationhandle::AsyncOperationHandle,
2571 >,
2572 > {
2573 static OPEN: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
2574 ::unity::lookup::method_info_on_class(<ResourceManager as ::unity::ClassIdentity>::class(), "CreateGroupOperation", 2)
2575 });
2576 #[allow(clippy::type_complexity)]
2577 static CACHE: ::std::sync::OnceLock<::std::sync::Mutex<::std::collections::HashMap<usize, &'static ::unity::il2cpp::MethodInfo>>> =
2578 ::std::sync::OnceLock::new();
2579 let _ = false;
2580 let __open: &'static ::unity::il2cpp::MethodInfo = match &*OPEN {
2581 ::core::result::Result::Ok(mi) => *mi,
2582 ::core::result::Result::Err(e) => {
2583 panic!(
2584 "method lookup failed: {}
2585::{}
2586: {}
2587",
2588 <ResourceManager as ::unity::ClassIdentity>::NAME,
2589 "CreateGroupOperation",
2590 e
2591 )
2592 },
2593 };
2594 let __cache = CACHE.get_or_init(|| ::std::sync::Mutex::new(::std::collections::HashMap::new()));
2595 let __key: usize = <M0 as ::unity::IlType>::il_type() as *const _ as usize;
2596 let __inflated: &'static ::unity::il2cpp::MethodInfo = {
2597 let mut __guard = __cache.lock().unwrap();
2598 *__guard
2599 .entry(__key)
2600 .or_insert_with(|| ::unity::il2cpp::generic::create_generic_method_info(__open, &[<M0 as ::unity::IlType>::il_type()]))
2601 };
2602 unsafe {
2603 let __receiver = <ResourceManager as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2604 let __f: extern "C" fn(
2605 ResourceManager,
2606 crate::system::collections::generic::ilist_1_interface::IList_1_Interface<
2607 crate::unity_engine::resource_management::resource_locations::iresourcelocation::IResourceLocation,
2608 >,
2609 bool,
2610 ::unity::OptionalMethod,
2611 )
2612 -> crate::unity_engine::resource_management::async_operations::asyncoperationhandle_1::AsyncOperationHandle_1<
2613 crate::system::collections::generic::ilist_1_interface::IList_1_Interface<
2614 crate::unity_engine::resource_management::async_operations::asyncoperationhandle::AsyncOperationHandle,
2615 >,
2616 > = ::core::mem::transmute(__inflated.method_ptr);
2617 let __mi_opaque: &'static () = &*(__inflated as *const _ as *const ());
2618 __f(
2619 __receiver,
2620 ::core::convert::Into::into(locations),
2621 ::core::convert::Into::into(allow_failed_dependencies),
2622 ::core::option::Option::Some(__mi_opaque),
2623 )
2624 }
2625 }
2626 #[doc = "`CreateGenericGroupOperation(crate::system::collections::generic::list_1::List_1<crate::unity_engine::resource_management::async_operations::asyncoperationhandle::AsyncOperationHandle>, bool)` overload"]
2627 fn create_generic_group_operation(
2628 self,
2629 operations: impl ::core::convert::Into<
2630 crate::system::collections::generic::list_1::List_1<
2631 crate::unity_engine::resource_management::async_operations::asyncoperationhandle::AsyncOperationHandle,
2632 >,
2633 >,
2634 released_cached_op_on_complete: impl ::core::convert::Into<bool>,
2635 ) -> crate::unity_engine::resource_management::async_operations::asyncoperationhandle_1::AsyncOperationHandle_1<
2636 crate::system::collections::generic::ilist_1_interface::IList_1_Interface<
2637 crate::unity_engine::resource_management::async_operations::asyncoperationhandle::AsyncOperationHandle,
2638 >,
2639 > {
2640 unsafe {
2641 let __receiver = <ResourceManager as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2642 ::unity::il2cpp_call!(__ResourceManager_unity_raw::__lookup_create_generic_group_operation::get_method_info().method_ptr,crate::unity_engine::resource_management::async_operations::asyncoperationhandle_1::AsyncOperationHandle_1<crate::system::collections::generic::ilist_1_interface::IList_1_Interface<crate::unity_engine::resource_management::async_operations::asyncoperationhandle::AsyncOperationHandle> > ;
2643(ResourceManager)__receiver,(crate::system::collections::generic::list_1::List_1<crate::unity_engine::resource_management::async_operations::asyncoperationhandle::AsyncOperationHandle>)::core::convert::Into::into(operations),(bool)::core::convert::Into::into(released_cached_op_on_complete))
2644 }
2645 }
2646 #[doc = "`ProvideResourceGroupCached(crate::system::collections::generic::ilist_1_interface::IList_1_Interface<crate::unity_engine::resource_management::resource_locations::iresourcelocation::IResourceLocation>, i32, ::unity::SystemType, crate::system::action_1::Action_1<crate::unity_engine::resource_management::async_operations::asyncoperationhandle::AsyncOperationHandle>, bool)` overload"]
2647 fn provide_resource_group_cached(
2648 self,
2649 locations: impl ::core::convert::Into<
2650 crate::system::collections::generic::ilist_1_interface::IList_1_Interface<
2651 crate::unity_engine::resource_management::resource_locations::iresourcelocation::IResourceLocation,
2652 >,
2653 >,
2654 group_hash: impl ::core::convert::Into<i32>,
2655 desired_type: impl ::core::convert::Into<::unity::SystemType>,
2656 callback: impl ::core::convert::Into<
2657 crate::system::action_1::Action_1<crate::unity_engine::resource_management::async_operations::asyncoperationhandle::AsyncOperationHandle>,
2658 >,
2659 release_dependencies_on_failure: impl ::core::convert::Into<bool>,
2660 ) -> crate::unity_engine::resource_management::async_operations::asyncoperationhandle_1::AsyncOperationHandle_1<
2661 crate::system::collections::generic::ilist_1_interface::IList_1_Interface<
2662 crate::unity_engine::resource_management::async_operations::asyncoperationhandle::AsyncOperationHandle,
2663 >,
2664 > {
2665 unsafe {
2666 let __receiver = <ResourceManager as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2667 ::unity::il2cpp_call!(__ResourceManager_unity_raw::__lookup_provide_resource_group_cached::get_method_info().method_ptr,crate::unity_engine::resource_management::async_operations::asyncoperationhandle_1::AsyncOperationHandle_1<crate::system::collections::generic::ilist_1_interface::IList_1_Interface<crate::unity_engine::resource_management::async_operations::asyncoperationhandle::AsyncOperationHandle> > ;
2668(ResourceManager)__receiver,(crate::system::collections::generic::ilist_1_interface::IList_1_Interface<crate::unity_engine::resource_management::resource_locations::iresourcelocation::IResourceLocation>)::core::convert::Into::into(locations),(i32)::core::convert::Into::into(group_hash),(::unity::SystemType)::core::convert::Into::into(desired_type),(crate::system::action_1::Action_1<crate::unity_engine::resource_management::async_operations::asyncoperationhandle::AsyncOperationHandle>)::core::convert::Into::into(callback),(bool)::core::convert::Into::into(release_dependencies_on_failure))
2669 }
2670 }
2671 fn provide_resources<M0: ::unity::IlType + ::core::marker::Copy + ::unity::ClassIdentity>(
2672 self,
2673 locations: impl ::core::convert::Into<
2674 crate::system::collections::generic::ilist_1_interface::IList_1_Interface<
2675 crate::unity_engine::resource_management::resource_locations::iresourcelocation::IResourceLocation,
2676 >,
2677 >,
2678 callback: impl ::core::convert::Into<crate::system::action_1::Action_1<M0>>,
2679 ) -> crate::unity_engine::resource_management::async_operations::asyncoperationhandle_1::AsyncOperationHandle_1<
2680 crate::system::collections::generic::ilist_1_interface::IList_1_Interface<M0>,
2681 > {
2682 static OPEN: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
2683 ::unity::lookup::method_info_on_class(<ResourceManager as ::unity::ClassIdentity>::class(), "ProvideResources", 2)
2684 });
2685 #[allow(clippy::type_complexity)]
2686 static CACHE: ::std::sync::OnceLock<::std::sync::Mutex<::std::collections::HashMap<usize, &'static ::unity::il2cpp::MethodInfo>>> =
2687 ::std::sync::OnceLock::new();
2688 let _ = false;
2689 let __open: &'static ::unity::il2cpp::MethodInfo = match &*OPEN {
2690 ::core::result::Result::Ok(mi) => *mi,
2691 ::core::result::Result::Err(e) => {
2692 panic!(
2693 "method lookup failed: {}
2694::{}
2695: {}
2696",
2697 <ResourceManager as ::unity::ClassIdentity>::NAME,
2698 "ProvideResources",
2699 e
2700 )
2701 },
2702 };
2703 let __cache = CACHE.get_or_init(|| ::std::sync::Mutex::new(::std::collections::HashMap::new()));
2704 let __key: usize = <M0 as ::unity::IlType>::il_type() as *const _ as usize;
2705 let __inflated: &'static ::unity::il2cpp::MethodInfo = {
2706 let mut __guard = __cache.lock().unwrap();
2707 *__guard
2708 .entry(__key)
2709 .or_insert_with(|| ::unity::il2cpp::generic::create_generic_method_info(__open, &[<M0 as ::unity::IlType>::il_type()]))
2710 };
2711 unsafe {
2712 let __receiver = <ResourceManager as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2713 let __f: extern "C" fn(
2714 ResourceManager,
2715 crate::system::collections::generic::ilist_1_interface::IList_1_Interface<
2716 crate::unity_engine::resource_management::resource_locations::iresourcelocation::IResourceLocation,
2717 >,
2718 crate::system::action_1::Action_1<M0>,
2719 ::unity::OptionalMethod,
2720 )
2721 -> crate::unity_engine::resource_management::async_operations::asyncoperationhandle_1::AsyncOperationHandle_1<
2722 crate::system::collections::generic::ilist_1_interface::IList_1_Interface<M0>,
2723 > = ::core::mem::transmute(__inflated.method_ptr);
2724 let __mi_opaque: &'static () = &*(__inflated as *const _ as *const ());
2725 __f(
2726 __receiver,
2727 ::core::convert::Into::into(locations),
2728 ::core::convert::Into::into(callback),
2729 ::core::option::Option::Some(__mi_opaque),
2730 )
2731 }
2732 }
2733 fn provide_resources_2<M0: ::unity::IlType + ::core::marker::Copy + ::unity::ClassIdentity>(
2734 self,
2735 locations: impl ::core::convert::Into<
2736 crate::system::collections::generic::ilist_1_interface::IList_1_Interface<
2737 crate::unity_engine::resource_management::resource_locations::iresourcelocation::IResourceLocation,
2738 >,
2739 >,
2740 release_dependencies_on_failure: impl ::core::convert::Into<bool>,
2741 callback: impl ::core::convert::Into<crate::system::action_1::Action_1<M0>>,
2742 ) -> crate::unity_engine::resource_management::async_operations::asyncoperationhandle_1::AsyncOperationHandle_1<
2743 crate::system::collections::generic::ilist_1_interface::IList_1_Interface<M0>,
2744 > {
2745 static OPEN: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
2746 ::unity::lookup::method_info_on_class(<ResourceManager as ::unity::ClassIdentity>::class(), "ProvideResources", 3)
2747 });
2748 #[allow(clippy::type_complexity)]
2749 static CACHE: ::std::sync::OnceLock<::std::sync::Mutex<::std::collections::HashMap<usize, &'static ::unity::il2cpp::MethodInfo>>> =
2750 ::std::sync::OnceLock::new();
2751 let _ = false;
2752 let __open: &'static ::unity::il2cpp::MethodInfo = match &*OPEN {
2753 ::core::result::Result::Ok(mi) => *mi,
2754 ::core::result::Result::Err(e) => {
2755 panic!(
2756 "method lookup failed: {}
2757::{}
2758: {}
2759",
2760 <ResourceManager as ::unity::ClassIdentity>::NAME,
2761 "ProvideResources",
2762 e
2763 )
2764 },
2765 };
2766 let __cache = CACHE.get_or_init(|| ::std::sync::Mutex::new(::std::collections::HashMap::new()));
2767 let __key: usize = <M0 as ::unity::IlType>::il_type() as *const _ as usize;
2768 let __inflated: &'static ::unity::il2cpp::MethodInfo = {
2769 let mut __guard = __cache.lock().unwrap();
2770 *__guard
2771 .entry(__key)
2772 .or_insert_with(|| ::unity::il2cpp::generic::create_generic_method_info(__open, &[<M0 as ::unity::IlType>::il_type()]))
2773 };
2774 unsafe {
2775 let __receiver = <ResourceManager as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2776 let __f: extern "C" fn(
2777 ResourceManager,
2778 crate::system::collections::generic::ilist_1_interface::IList_1_Interface<
2779 crate::unity_engine::resource_management::resource_locations::iresourcelocation::IResourceLocation,
2780 >,
2781 bool,
2782 crate::system::action_1::Action_1<M0>,
2783 ::unity::OptionalMethod,
2784 )
2785 -> crate::unity_engine::resource_management::async_operations::asyncoperationhandle_1::AsyncOperationHandle_1<
2786 crate::system::collections::generic::ilist_1_interface::IList_1_Interface<M0>,
2787 > = ::core::mem::transmute(__inflated.method_ptr);
2788 let __mi_opaque: &'static () = &*(__inflated as *const _ as *const ());
2789 __f(
2790 __receiver,
2791 ::core::convert::Into::into(locations),
2792 ::core::convert::Into::into(release_dependencies_on_failure),
2793 ::core::convert::Into::into(callback),
2794 ::core::option::Option::Some(__mi_opaque),
2795 )
2796 }
2797 }
2798 fn create_chain_operation<
2799 M0: ::unity::IlType + ::core::marker::Copy + ::unity::ClassIdentity,
2800 M1: ::unity::IlType + ::core::marker::Copy + ::unity::ClassIdentity,
2801 >(
2802 self,
2803 dependent_op: impl ::core::convert::Into<
2804 crate::unity_engine::resource_management::async_operations::asyncoperationhandle_1::AsyncOperationHandle_1<M1>,
2805 >,
2806 callback: impl ::core::convert::Into<
2807 crate::system::func_2::Func_2<
2808 crate::unity_engine::resource_management::async_operations::asyncoperationhandle_1::AsyncOperationHandle_1<M1>,
2809 crate::unity_engine::resource_management::async_operations::asyncoperationhandle_1::AsyncOperationHandle_1<M0>,
2810 >,
2811 >,
2812 ) -> crate::unity_engine::resource_management::async_operations::asyncoperationhandle_1::AsyncOperationHandle_1<M0> {
2813 static OPEN: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
2814 ::unity::lookup::method_info_on_class(<ResourceManager as ::unity::ClassIdentity>::class(), "CreateChainOperation", 2)
2815 });
2816 #[allow(clippy::type_complexity)]
2817 static CACHE: ::std::sync::OnceLock<::std::sync::Mutex<::std::collections::HashMap<usize, &'static ::unity::il2cpp::MethodInfo>>> =
2818 ::std::sync::OnceLock::new();
2819 let _ = false;
2820 let __open: &'static ::unity::il2cpp::MethodInfo = match &*OPEN {
2821 ::core::result::Result::Ok(mi) => *mi,
2822 ::core::result::Result::Err(e) => {
2823 panic!(
2824 "method lookup failed: {}
2825::{}
2826: {}
2827",
2828 <ResourceManager as ::unity::ClassIdentity>::NAME,
2829 "CreateChainOperation",
2830 e
2831 )
2832 },
2833 };
2834 let __cache = CACHE.get_or_init(|| ::std::sync::Mutex::new(::std::collections::HashMap::new()));
2835 let __key: usize = (<M0 as ::unity::IlType>::il_type() as *const _ as usize) ^ (<M1 as ::unity::IlType>::il_type() as *const _ as usize);
2836 let __inflated: &'static ::unity::il2cpp::MethodInfo = {
2837 let mut __guard = __cache.lock().unwrap();
2838 *__guard.entry(__key).or_insert_with(|| {
2839 ::unity::il2cpp::generic::create_generic_method_info(__open, &[
2840 <M0 as ::unity::IlType>::il_type(),
2841 <M1 as ::unity::IlType>::il_type(),
2842 ])
2843 })
2844 };
2845 unsafe {
2846 let __receiver = <ResourceManager as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2847 let __f: extern "C" fn(
2848 ResourceManager,
2849 crate::unity_engine::resource_management::async_operations::asyncoperationhandle_1::AsyncOperationHandle_1<M1>,
2850 crate::system::func_2::Func_2<
2851 crate::unity_engine::resource_management::async_operations::asyncoperationhandle_1::AsyncOperationHandle_1<M1>,
2852 crate::unity_engine::resource_management::async_operations::asyncoperationhandle_1::AsyncOperationHandle_1<M0>,
2853 >,
2854 ::unity::OptionalMethod,
2855 )
2856 -> crate::unity_engine::resource_management::async_operations::asyncoperationhandle_1::AsyncOperationHandle_1<M0> =
2857 ::core::mem::transmute(__inflated.method_ptr);
2858 let __mi_opaque: &'static () = &*(__inflated as *const _ as *const ());
2859 __f(
2860 __receiver,
2861 ::core::convert::Into::into(dependent_op),
2862 ::core::convert::Into::into(callback),
2863 ::core::option::Option::Some(__mi_opaque),
2864 )
2865 }
2866 }
2867 fn create_chain_operation_2<M0: ::unity::IlType + ::core::marker::Copy + ::unity::ClassIdentity>(
2868 self,
2869 dependent_op: impl ::core::convert::Into<crate::unity_engine::resource_management::async_operations::asyncoperationhandle::AsyncOperationHandle>,
2870 callback: impl ::core::convert::Into<
2871 crate::system::func_2::Func_2<
2872 crate::unity_engine::resource_management::async_operations::asyncoperationhandle::AsyncOperationHandle,
2873 crate::unity_engine::resource_management::async_operations::asyncoperationhandle_1::AsyncOperationHandle_1<M0>,
2874 >,
2875 >,
2876 ) -> crate::unity_engine::resource_management::async_operations::asyncoperationhandle_1::AsyncOperationHandle_1<M0> {
2877 static OPEN: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
2878 ::unity::lookup::method_info_on_class(<ResourceManager as ::unity::ClassIdentity>::class(), "CreateChainOperation", 2)
2879 });
2880 #[allow(clippy::type_complexity)]
2881 static CACHE: ::std::sync::OnceLock<::std::sync::Mutex<::std::collections::HashMap<usize, &'static ::unity::il2cpp::MethodInfo>>> =
2882 ::std::sync::OnceLock::new();
2883 let _ = false;
2884 let __open: &'static ::unity::il2cpp::MethodInfo = match &*OPEN {
2885 ::core::result::Result::Ok(mi) => *mi,
2886 ::core::result::Result::Err(e) => {
2887 panic!(
2888 "method lookup failed: {}
2889::{}
2890: {}
2891",
2892 <ResourceManager as ::unity::ClassIdentity>::NAME,
2893 "CreateChainOperation",
2894 e
2895 )
2896 },
2897 };
2898 let __cache = CACHE.get_or_init(|| ::std::sync::Mutex::new(::std::collections::HashMap::new()));
2899 let __key: usize = <M0 as ::unity::IlType>::il_type() as *const _ as usize;
2900 let __inflated: &'static ::unity::il2cpp::MethodInfo = {
2901 let mut __guard = __cache.lock().unwrap();
2902 *__guard
2903 .entry(__key)
2904 .or_insert_with(|| ::unity::il2cpp::generic::create_generic_method_info(__open, &[<M0 as ::unity::IlType>::il_type()]))
2905 };
2906 unsafe {
2907 let __receiver = <ResourceManager as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2908 let __f: extern "C" fn(
2909 ResourceManager,
2910 crate::unity_engine::resource_management::async_operations::asyncoperationhandle::AsyncOperationHandle,
2911 crate::system::func_2::Func_2<
2912 crate::unity_engine::resource_management::async_operations::asyncoperationhandle::AsyncOperationHandle,
2913 crate::unity_engine::resource_management::async_operations::asyncoperationhandle_1::AsyncOperationHandle_1<M0>,
2914 >,
2915 ::unity::OptionalMethod,
2916 )
2917 -> crate::unity_engine::resource_management::async_operations::asyncoperationhandle_1::AsyncOperationHandle_1<M0> =
2918 ::core::mem::transmute(__inflated.method_ptr);
2919 let __mi_opaque: &'static () = &*(__inflated as *const _ as *const ());
2920 __f(
2921 __receiver,
2922 ::core::convert::Into::into(dependent_op),
2923 ::core::convert::Into::into(callback),
2924 ::core::option::Option::Some(__mi_opaque),
2925 )
2926 }
2927 }
2928 fn create_chain_operation_3<
2929 M0: ::unity::IlType + ::core::marker::Copy + ::unity::ClassIdentity,
2930 M1: ::unity::IlType + ::core::marker::Copy + ::unity::ClassIdentity,
2931 >(
2932 self,
2933 dependent_op: impl ::core::convert::Into<
2934 crate::unity_engine::resource_management::async_operations::asyncoperationhandle_1::AsyncOperationHandle_1<M1>,
2935 >,
2936 callback: impl ::core::convert::Into<
2937 crate::system::func_2::Func_2<
2938 crate::unity_engine::resource_management::async_operations::asyncoperationhandle_1::AsyncOperationHandle_1<M1>,
2939 crate::unity_engine::resource_management::async_operations::asyncoperationhandle_1::AsyncOperationHandle_1<M0>,
2940 >,
2941 >,
2942 release_dependencies_on_failure: impl ::core::convert::Into<bool>,
2943 ) -> crate::unity_engine::resource_management::async_operations::asyncoperationhandle_1::AsyncOperationHandle_1<M0> {
2944 static OPEN: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
2945 ::unity::lookup::method_info_on_class(<ResourceManager as ::unity::ClassIdentity>::class(), "CreateChainOperation", 3)
2946 });
2947 #[allow(clippy::type_complexity)]
2948 static CACHE: ::std::sync::OnceLock<::std::sync::Mutex<::std::collections::HashMap<usize, &'static ::unity::il2cpp::MethodInfo>>> =
2949 ::std::sync::OnceLock::new();
2950 let _ = false;
2951 let __open: &'static ::unity::il2cpp::MethodInfo = match &*OPEN {
2952 ::core::result::Result::Ok(mi) => *mi,
2953 ::core::result::Result::Err(e) => {
2954 panic!(
2955 "method lookup failed: {}
2956::{}
2957: {}
2958",
2959 <ResourceManager as ::unity::ClassIdentity>::NAME,
2960 "CreateChainOperation",
2961 e
2962 )
2963 },
2964 };
2965 let __cache = CACHE.get_or_init(|| ::std::sync::Mutex::new(::std::collections::HashMap::new()));
2966 let __key: usize = (<M0 as ::unity::IlType>::il_type() as *const _ as usize) ^ (<M1 as ::unity::IlType>::il_type() as *const _ as usize);
2967 let __inflated: &'static ::unity::il2cpp::MethodInfo = {
2968 let mut __guard = __cache.lock().unwrap();
2969 *__guard.entry(__key).or_insert_with(|| {
2970 ::unity::il2cpp::generic::create_generic_method_info(__open, &[
2971 <M0 as ::unity::IlType>::il_type(),
2972 <M1 as ::unity::IlType>::il_type(),
2973 ])
2974 })
2975 };
2976 unsafe {
2977 let __receiver = <ResourceManager as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2978 let __f: extern "C" fn(
2979 ResourceManager,
2980 crate::unity_engine::resource_management::async_operations::asyncoperationhandle_1::AsyncOperationHandle_1<M1>,
2981 crate::system::func_2::Func_2<
2982 crate::unity_engine::resource_management::async_operations::asyncoperationhandle_1::AsyncOperationHandle_1<M1>,
2983 crate::unity_engine::resource_management::async_operations::asyncoperationhandle_1::AsyncOperationHandle_1<M0>,
2984 >,
2985 bool,
2986 ::unity::OptionalMethod,
2987 )
2988 -> crate::unity_engine::resource_management::async_operations::asyncoperationhandle_1::AsyncOperationHandle_1<M0> =
2989 ::core::mem::transmute(__inflated.method_ptr);
2990 let __mi_opaque: &'static () = &*(__inflated as *const _ as *const ());
2991 __f(
2992 __receiver,
2993 ::core::convert::Into::into(dependent_op),
2994 ::core::convert::Into::into(callback),
2995 ::core::convert::Into::into(release_dependencies_on_failure),
2996 ::core::option::Option::Some(__mi_opaque),
2997 )
2998 }
2999 }
3000 fn create_chain_operation_4<M0: ::unity::IlType + ::core::marker::Copy + ::unity::ClassIdentity>(
3001 self,
3002 dependent_op: impl ::core::convert::Into<crate::unity_engine::resource_management::async_operations::asyncoperationhandle::AsyncOperationHandle>,
3003 callback: impl ::core::convert::Into<
3004 crate::system::func_2::Func_2<
3005 crate::unity_engine::resource_management::async_operations::asyncoperationhandle::AsyncOperationHandle,
3006 crate::unity_engine::resource_management::async_operations::asyncoperationhandle_1::AsyncOperationHandle_1<M0>,
3007 >,
3008 >,
3009 release_dependencies_on_failure: impl ::core::convert::Into<bool>,
3010 ) -> crate::unity_engine::resource_management::async_operations::asyncoperationhandle_1::AsyncOperationHandle_1<M0> {
3011 static OPEN: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
3012 ::unity::lookup::method_info_on_class(<ResourceManager as ::unity::ClassIdentity>::class(), "CreateChainOperation", 3)
3013 });
3014 #[allow(clippy::type_complexity)]
3015 static CACHE: ::std::sync::OnceLock<::std::sync::Mutex<::std::collections::HashMap<usize, &'static ::unity::il2cpp::MethodInfo>>> =
3016 ::std::sync::OnceLock::new();
3017 let _ = false;
3018 let __open: &'static ::unity::il2cpp::MethodInfo = match &*OPEN {
3019 ::core::result::Result::Ok(mi) => *mi,
3020 ::core::result::Result::Err(e) => {
3021 panic!(
3022 "method lookup failed: {}
3023::{}
3024: {}
3025",
3026 <ResourceManager as ::unity::ClassIdentity>::NAME,
3027 "CreateChainOperation",
3028 e
3029 )
3030 },
3031 };
3032 let __cache = CACHE.get_or_init(|| ::std::sync::Mutex::new(::std::collections::HashMap::new()));
3033 let __key: usize = <M0 as ::unity::IlType>::il_type() as *const _ as usize;
3034 let __inflated: &'static ::unity::il2cpp::MethodInfo = {
3035 let mut __guard = __cache.lock().unwrap();
3036 *__guard
3037 .entry(__key)
3038 .or_insert_with(|| ::unity::il2cpp::generic::create_generic_method_info(__open, &[<M0 as ::unity::IlType>::il_type()]))
3039 };
3040 unsafe {
3041 let __receiver = <ResourceManager as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3042 let __f: extern "C" fn(
3043 ResourceManager,
3044 crate::unity_engine::resource_management::async_operations::asyncoperationhandle::AsyncOperationHandle,
3045 crate::system::func_2::Func_2<
3046 crate::unity_engine::resource_management::async_operations::asyncoperationhandle::AsyncOperationHandle,
3047 crate::unity_engine::resource_management::async_operations::asyncoperationhandle_1::AsyncOperationHandle_1<M0>,
3048 >,
3049 bool,
3050 ::unity::OptionalMethod,
3051 )
3052 -> crate::unity_engine::resource_management::async_operations::asyncoperationhandle_1::AsyncOperationHandle_1<M0> =
3053 ::core::mem::transmute(__inflated.method_ptr);
3054 let __mi_opaque: &'static () = &*(__inflated as *const _ as *const ());
3055 __f(
3056 __receiver,
3057 ::core::convert::Into::into(dependent_op),
3058 ::core::convert::Into::into(callback),
3059 ::core::convert::Into::into(release_dependencies_on_failure),
3060 ::core::option::Option::Some(__mi_opaque),
3061 )
3062 }
3063 }
3064 #[doc = "`ProvideScene(crate::unity_engine::resource_management::resource_providers::isceneprovider_interface::ISceneProvider_Interface, crate::unity_engine::resource_management::resource_locations::iresourcelocation::IResourceLocation, crate::unity_engine::scene_management::loadscenemode::LoadSceneMode, bool, i32)` overload"]
3065 fn provide_scene(
3066 self,
3067 scene_provider: impl ::core::convert::Into<
3068 crate::unity_engine::resource_management::resource_providers::isceneprovider_interface::ISceneProvider_Interface,
3069 >,
3070 location: impl ::core::convert::Into<crate::unity_engine::resource_management::resource_locations::iresourcelocation::IResourceLocation>,
3071 load_mode: impl ::core::convert::Into<crate::unity_engine::scene_management::loadscenemode::LoadSceneMode>,
3072 activate_on_load: impl ::core::convert::Into<bool>,
3073 priority: impl ::core::convert::Into<i32>,
3074 ) -> crate::unity_engine::resource_management::async_operations::asyncoperationhandle_1::AsyncOperationHandle_1<
3075 crate::unity_engine::resource_management::resource_providers::sceneinstance::SceneInstance,
3076 > {
3077 unsafe {
3078 let __receiver = <ResourceManager as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3079 ::unity::il2cpp_call!(__ResourceManager_unity_raw::__lookup_provide_scene::get_method_info().method_ptr,crate::unity_engine::resource_management::async_operations::asyncoperationhandle_1::AsyncOperationHandle_1<crate::unity_engine::resource_management::resource_providers::sceneinstance::SceneInstance> ;
3080(ResourceManager)__receiver,(crate::unity_engine::resource_management::resource_providers::isceneprovider_interface::ISceneProvider_Interface)::core::convert::Into::into(scene_provider),(crate::unity_engine::resource_management::resource_locations::iresourcelocation::IResourceLocation)::core::convert::Into::into(location),(crate::unity_engine::scene_management::loadscenemode::LoadSceneMode)::core::convert::Into::into(load_mode),(bool)::core::convert::Into::into(activate_on_load),(i32)::core::convert::Into::into(priority))
3081 }
3082 }
3083 #[doc = "`ReleaseScene(crate::unity_engine::resource_management::resource_providers::isceneprovider_interface::ISceneProvider_Interface, crate::unity_engine::resource_management::async_operations::asyncoperationhandle_1::AsyncOperationHandle_1<crate::unity_engine::resource_management::resource_providers::sceneinstance::SceneInstance>)` overload"]
3084 fn release_scene(
3085 self,
3086 scene_provider: impl ::core::convert::Into<
3087 crate::unity_engine::resource_management::resource_providers::isceneprovider_interface::ISceneProvider_Interface,
3088 >,
3089 scene_load_handle: impl ::core::convert::Into<
3090 crate::unity_engine::resource_management::async_operations::asyncoperationhandle_1::AsyncOperationHandle_1<
3091 crate::unity_engine::resource_management::resource_providers::sceneinstance::SceneInstance,
3092 >,
3093 >,
3094 ) -> crate::unity_engine::resource_management::async_operations::asyncoperationhandle_1::AsyncOperationHandle_1<
3095 crate::unity_engine::resource_management::resource_providers::sceneinstance::SceneInstance,
3096 > {
3097 unsafe {
3098 let __receiver = <ResourceManager as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3099 ::unity::il2cpp_call!(__ResourceManager_unity_raw::__lookup_release_scene::get_method_info().method_ptr,crate::unity_engine::resource_management::async_operations::asyncoperationhandle_1::AsyncOperationHandle_1<crate::unity_engine::resource_management::resource_providers::sceneinstance::SceneInstance> ;
3100(ResourceManager)__receiver,(crate::unity_engine::resource_management::resource_providers::isceneprovider_interface::ISceneProvider_Interface)::core::convert::Into::into(scene_provider),(crate::unity_engine::resource_management::async_operations::asyncoperationhandle_1::AsyncOperationHandle_1<crate::unity_engine::resource_management::resource_providers::sceneinstance::SceneInstance>)::core::convert::Into::into(scene_load_handle))
3101 }
3102 }
3103 #[doc = "`ProvideInstance(crate::unity_engine::resource_management::resource_providers::iinstanceprovider_interface::IInstanceProvider_Interface, crate::unity_engine::resource_management::resource_locations::iresourcelocation::IResourceLocation, crate::unity_engine::resource_management::resource_providers::instantiationparameters::InstantiationParameters)` overload"]
3104 fn provide_instance(
3105 self,
3106 provider: impl ::core::convert::Into<
3107 crate::unity_engine::resource_management::resource_providers::iinstanceprovider_interface::IInstanceProvider_Interface,
3108 >,
3109 location: impl ::core::convert::Into<crate::unity_engine::resource_management::resource_locations::iresourcelocation::IResourceLocation>,
3110 instantiate_parameters: impl ::core::convert::Into<
3111 crate::unity_engine::resource_management::resource_providers::instantiationparameters::InstantiationParameters,
3112 >,
3113 ) -> crate::unity_engine::resource_management::async_operations::asyncoperationhandle_1::AsyncOperationHandle_1<
3114 crate::unity_engine::gameobject::GameObject,
3115 > {
3116 unsafe {
3117 let __receiver = <ResourceManager as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3118 ::unity::il2cpp_call!(__ResourceManager_unity_raw::__lookup_provide_instance::get_method_info().method_ptr,crate::unity_engine::resource_management::async_operations::asyncoperationhandle_1::AsyncOperationHandle_1<crate::unity_engine::gameobject::GameObject> ;
3119(ResourceManager)__receiver,(crate::unity_engine::resource_management::resource_providers::iinstanceprovider_interface::IInstanceProvider_Interface)::core::convert::Into::into(provider),(crate::unity_engine::resource_management::resource_locations::iresourcelocation::IResourceLocation)::core::convert::Into::into(location),(crate::unity_engine::resource_management::resource_providers::instantiationparameters::InstantiationParameters)::core::convert::Into::into(instantiate_parameters))
3120 }
3121 }
3122 #[doc = "`CleanupSceneInstances(crate::unity_engine::scene_management::scene::Scene)` overload"]
3123 fn cleanup_scene_instances(self, scene: impl ::core::convert::Into<crate::unity_engine::scene_management::scene::Scene>) -> () {
3124 unsafe {
3125 let __receiver = <ResourceManager as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3126 ::unity::il2cpp_call!(__ResourceManager_unity_raw::__lookup_cleanup_scene_instances::get_method_info().method_ptr,();
3127(ResourceManager)__receiver,(crate::unity_engine::scene_management::scene::Scene)::core::convert::Into::into(scene))
3128 }
3129 }
3130 #[doc = "`ExecuteDeferredCallbacks()` overload"]
3131 fn execute_deferred_callbacks(self) -> () {
3132 unsafe {
3133 let __receiver = <ResourceManager as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3134 ::unity::il2cpp_call!(__ResourceManager_unity_raw::__lookup_execute_deferred_callbacks::get_method_info().method_ptr,();
3135(ResourceManager)__receiver)
3136 }
3137 }
3138 #[doc = "`RegisterForDeferredCallback(crate::unity_engine::resource_management::async_operations::iasyncoperation::IAsyncOperation, bool)` overload"]
3139 fn register_for_deferred_callback(
3140 self,
3141 op: impl ::core::convert::Into<crate::unity_engine::resource_management::async_operations::iasyncoperation::IAsyncOperation>,
3142 increment_ref_count: impl ::core::convert::Into<bool>,
3143 ) -> () {
3144 unsafe {
3145 let __receiver = <ResourceManager as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3146 ::unity::il2cpp_call!(__ResourceManager_unity_raw::__lookup_register_for_deferred_callback::get_method_info().method_ptr,();
3147(ResourceManager)__receiver,(crate::unity_engine::resource_management::async_operations::iasyncoperation::IAsyncOperation)::core::convert::Into::into(op),(bool)::core::convert::Into::into(increment_ref_count))
3148 }
3149 }
3150 #[doc = "`Update(f32)` overload"]
3151 fn update(self, unscaled_delta_time: impl ::core::convert::Into<f32>) -> () {
3152 unsafe {
3153 let __receiver = <ResourceManager as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3154 ::unity::il2cpp_call!(__ResourceManager_unity_raw::__lookup_update::get_method_info().method_ptr,();
3155(ResourceManager)__receiver,(f32)::core::convert::Into::into(unscaled_delta_time))
3156 }
3157 }
3158 #[doc = "`Dispose()` overload"]
3159 fn dispose(self) -> () {
3160 unsafe {
3161 let __receiver = <ResourceManager as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3162 {
3163 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
3164 let __vi = *__vt.get(4usize).unwrap_or_else(|| {
3165 panic!(
3166 "unity: virtual slot {}
3167 out of range (vtable len {}
3168) on the runtime class behind {}
3169 (method `{}
3170`)",
3171 4usize,
3172 __vt.len(),
3173 <ResourceManager as ::unity::ClassIdentity>::NAME,
3174 "Dispose",
3175 )
3176 });
3177 let __inner: extern "C" fn(ResourceManager, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__vi.method_ptr);
3178 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
3179 __inner(__receiver, __mi)
3180 }
3181 }
3182 }
3183}
3184
3185#[cfg(feature = "unity_engine-resource_management-resourcemanager")]
3186impl<__T: IResourceManager> IResourceManagerMethods for __T {}
3187
3188#[cfg(feature = "unity_engine-resource_management-resourcemanager")]
3189impl ResourceManager {
3190 pub fn get_internal_id_transform_func_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3191 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
3192 }
3193
3194 pub fn set_internal_id_transform_func_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3195 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
3196 }
3197
3198 pub fn transform_internal_id_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3199 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
3200 }
3201
3202 pub fn get_web_request_override_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3203 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[5]
3204 }
3205
3206 pub fn set_web_request_override_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3207 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[6]
3208 }
3209
3210 pub fn get_operation_cache_count_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3211 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[7]
3212 }
3213
3214 pub fn get_instance_operation_count_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3215 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[8]
3216 }
3217
3218 pub fn add_update_receiver_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3219 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[9]
3220 }
3221
3222 pub fn remove_update_reciever_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3223 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[10]
3224 }
3225
3226 pub fn get_allocator_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3227 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[11]
3228 }
3229
3230 pub fn set_allocator_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3231 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[12]
3232 }
3233
3234 pub fn get_resource_providers_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3235 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[13]
3236 }
3237
3238 pub fn get_certificate_handler_instance_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3239 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[14]
3240 }
3241
3242 pub fn set_certificate_handler_instance_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3243 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[15]
3244 }
3245
3246 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3247 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[16]
3248 }
3249
3250 pub fn on_object_added_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3251 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[17]
3252 }
3253
3254 pub fn on_object_removed_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3255 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[18]
3256 }
3257
3258 pub fn register_for_callbacks_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3259 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[19]
3260 }
3261
3262 pub fn clear_diagnostics_callback_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3263 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[20]
3264 }
3265
3266 pub fn clear_diagnostic_callbacks_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3267 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[21]
3268 }
3269
3270 pub fn unregister_diagnostic_callback_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3271 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[22]
3272 }
3273
3274 pub fn register_diagnostic_callback_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3275 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[23]
3276 }
3277
3278 pub fn register_diagnostic_callback_2_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3279 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[24]
3280 }
3281
3282 pub fn post_diagnostic_event_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3283 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[25]
3284 }
3285
3286 pub fn get_resource_provider_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3287 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[26]
3288 }
3289
3290 pub fn get_default_type_for_location_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3291 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[27]
3292 }
3293
3294 pub fn calculate_locations_hash_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3295 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[28]
3296 }
3297
3298 pub fn provide_resource_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3299 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[29]
3300 }
3301
3302 pub fn start_operation_2_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3303 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[32]
3304 }
3305
3306 pub fn on_instance_operation_destroy_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3307 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[33]
3308 }
3309
3310 pub fn on_operation_destroy_non_cached_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3311 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[34]
3312 }
3313
3314 pub fn on_operation_destroy_cached_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3315 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[35]
3316 }
3317
3318 pub fn add_operation_to_cache_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3319 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[37]
3320 }
3321
3322 pub fn remove_operation_from_cache_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3323 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[38]
3324 }
3325
3326 pub fn is_operation_cached_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3327 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[39]
3328 }
3329
3330 pub fn cached_operation_count_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3331 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[40]
3332 }
3333
3334 pub fn release_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3335 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[44]
3336 }
3337
3338 pub fn acquire_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3339 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[45]
3340 }
3341
3342 pub fn acquire_group_op_from_cache_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3343 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[46]
3344 }
3345
3346 pub fn create_generic_group_operation_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3347 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[49]
3348 }
3349
3350 pub fn provide_resource_group_cached_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3351 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[50]
3352 }
3353
3354 pub fn provide_scene_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3355 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[57]
3356 }
3357
3358 pub fn release_scene_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3359 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[58]
3360 }
3361
3362 pub fn provide_instance_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3363 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[59]
3364 }
3365
3366 pub fn cleanup_scene_instances_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3367 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[60]
3368 }
3369
3370 pub fn execute_deferred_callbacks_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3371 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[61]
3372 }
3373
3374 pub fn register_for_deferred_callback_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3375 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[62]
3376 }
3377
3378 pub fn update_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3379 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[63]
3380 }
3381
3382 pub fn dispose_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3383 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[64]
3384 }
3385
3386 pub fn cctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3387 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[65]
3388 }
3389}
3390
3391#[cfg(feature = "unity_engine-resource_management-resourcemanager")]
3392impl ResourceManager {
3393 #[doc = "Direct (non-virtual) call to `ResourceManager`'s own `Dispose`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3394 pub unsafe fn dispose(this: impl ::core::convert::Into<::unity::IlInstance>) -> () {
3395 let __mi = Self::dispose_method_info();
3396 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
3397 __inner(this.into(), ::core::option::Option::None)
3398 }
3399}
3400
3401#[cfg(feature = "unity_engine-resource_management-resourcemanager")]
3402impl ResourceManager {
3403 #[doc = "`.ctor(crate::unity_engine::resource_management::util::iallocationstrategy::IAllocationStrategy)` — overload selector"]
3404 pub fn new(alloc: crate::unity_engine::resource_management::util::iallocationstrategy::IAllocationStrategy) -> Self {
3405 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
3406 panic!(
3407 "{}
3408::{}
3409 failed to instantiate",
3410 ::core::stringify!(ResourceManager),
3411 ::core::stringify!(new),
3412 )
3413 });
3414 <Self as IResourceManagerMethods>::ctor(this, alloc);
3415 this
3416 }
3417}
3418
3419#[cfg(feature = "unity_engine-resource_management-resourcemanager")]
3420#[doc(hidden)]
3421#[allow(non_snake_case, non_camel_case_types, clippy::too_many_arguments)]
3422mod __ResourceManager_DiagnosticEventContext_unity_raw {
3423 use super::*;
3424 #[doc(hidden)]
3425 #[allow(non_snake_case)]
3426 pub mod __lookup_get_operation_handle {
3427 use super::*;
3428 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
3429 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[];
3430 ::unity::lookup::method_info_on_class_with_signature(
3431 <ResourceManager_DiagnosticEventContext as ::unity::ClassIdentity>::class(),
3432 "get_OperationHandle",
3433 0,
3434 param_types,
3435 false,
3436 )
3437 });
3438 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3439 match &*METHOD {
3440 ::core::result::Result::Ok(mi) => *mi,
3441 ::core::result::Result::Err(e) => {
3442 panic!(
3443 "method lookup failed: {}
3444::{}
3445: {}
3446",
3447 <ResourceManager_DiagnosticEventContext as ::unity::ClassIdentity>::NAME,
3448 "get_OperationHandle",
3449 e
3450 )
3451 },
3452 }
3453 }
3454 }
3455 #[doc(hidden)]
3456 #[allow(non_snake_case)]
3457 pub mod __lookup_get_type {
3458 use super::*;
3459 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
3460 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[];
3461 ::unity::lookup::method_info_on_class_with_signature(
3462 <ResourceManager_DiagnosticEventContext as ::unity::ClassIdentity>::class(),
3463 "get_Type",
3464 0,
3465 param_types,
3466 false,
3467 )
3468 });
3469 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3470 match &*METHOD {
3471 ::core::result::Result::Ok(mi) => *mi,
3472 ::core::result::Result::Err(e) => {
3473 panic!(
3474 "method lookup failed: {}
3475::{}
3476: {}
3477",
3478 <ResourceManager_DiagnosticEventContext as ::unity::ClassIdentity>::NAME,
3479 "get_Type",
3480 e
3481 )
3482 },
3483 }
3484 }
3485 }
3486 #[doc(hidden)]
3487 #[allow(non_snake_case)]
3488 pub mod __lookup_get_event_value {
3489 use super::*;
3490 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
3491 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[];
3492 ::unity::lookup::method_info_on_class_with_signature(
3493 <ResourceManager_DiagnosticEventContext as ::unity::ClassIdentity>::class(),
3494 "get_EventValue",
3495 0,
3496 param_types,
3497 false,
3498 )
3499 });
3500 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3501 match &*METHOD {
3502 ::core::result::Result::Ok(mi) => *mi,
3503 ::core::result::Result::Err(e) => {
3504 panic!(
3505 "method lookup failed: {}
3506::{}
3507: {}
3508",
3509 <ResourceManager_DiagnosticEventContext as ::unity::ClassIdentity>::NAME,
3510 "get_EventValue",
3511 e
3512 )
3513 },
3514 }
3515 }
3516 }
3517 #[doc(hidden)]
3518 #[allow(non_snake_case)]
3519 pub mod __lookup_get_location {
3520 use super::*;
3521 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
3522 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[];
3523 ::unity::lookup::method_info_on_class_with_signature(
3524 <ResourceManager_DiagnosticEventContext as ::unity::ClassIdentity>::class(),
3525 "get_Location",
3526 0,
3527 param_types,
3528 false,
3529 )
3530 });
3531 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3532 match &*METHOD {
3533 ::core::result::Result::Ok(mi) => *mi,
3534 ::core::result::Result::Err(e) => {
3535 panic!(
3536 "method lookup failed: {}
3537::{}
3538: {}
3539",
3540 <ResourceManager_DiagnosticEventContext as ::unity::ClassIdentity>::NAME,
3541 "get_Location",
3542 e
3543 )
3544 },
3545 }
3546 }
3547 }
3548 #[doc(hidden)]
3549 #[allow(non_snake_case)]
3550 pub mod __lookup_get_context {
3551 use super::*;
3552 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
3553 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[];
3554 ::unity::lookup::method_info_on_class_with_signature(
3555 <ResourceManager_DiagnosticEventContext as ::unity::ClassIdentity>::class(),
3556 "get_Context",
3557 0,
3558 param_types,
3559 false,
3560 )
3561 });
3562 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3563 match &*METHOD {
3564 ::core::result::Result::Ok(mi) => *mi,
3565 ::core::result::Result::Err(e) => {
3566 panic!(
3567 "method lookup failed: {}
3568::{}
3569: {}
3570",
3571 <ResourceManager_DiagnosticEventContext as ::unity::ClassIdentity>::NAME,
3572 "get_Context",
3573 e
3574 )
3575 },
3576 }
3577 }
3578 }
3579 #[doc(hidden)]
3580 #[allow(non_snake_case)]
3581 pub mod __lookup_get_error {
3582 use super::*;
3583 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
3584 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[];
3585 ::unity::lookup::method_info_on_class_with_signature(
3586 <ResourceManager_DiagnosticEventContext as ::unity::ClassIdentity>::class(),
3587 "get_Error",
3588 0,
3589 param_types,
3590 false,
3591 )
3592 });
3593 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3594 match &*METHOD {
3595 ::core::result::Result::Ok(mi) => *mi,
3596 ::core::result::Result::Err(e) => {
3597 panic!(
3598 "method lookup failed: {}
3599::{}
3600: {}
3601",
3602 <ResourceManager_DiagnosticEventContext as ::unity::ClassIdentity>::NAME,
3603 "get_Error",
3604 e
3605 )
3606 },
3607 }
3608 }
3609 }
3610 #[doc(hidden)]
3611 #[allow(non_snake_case)]
3612 pub mod __lookup_ctor {
3613 use super::*;
3614 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
3615 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[
3616 <crate::unity_engine::resource_management::async_operations::asyncoperationhandle::AsyncOperationHandle as ::unity::IlType>::il_type(
3617 ),
3618 <crate::unity_engine::resource_management::resourcemanager::ResourceManager_DiagnosticEventType as ::unity::IlType>::il_type(),
3619 <i32 as ::unity::IlType>::il_type(),
3620 <::unity::Il2CppString as ::unity::IlType>::il_type(),
3621 <::unity::IlInstance as ::unity::IlType>::il_type(),
3622 ];
3623 ::unity::lookup::method_info_on_class_with_signature(
3624 <ResourceManager_DiagnosticEventContext as ::unity::ClassIdentity>::class(),
3625 ".ctor",
3626 5,
3627 param_types,
3628 false,
3629 )
3630 });
3631 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3632 match &*METHOD {
3633 ::core::result::Result::Ok(mi) => *mi,
3634 ::core::result::Result::Err(e) => {
3635 panic!(
3636 "method lookup failed: {}
3637::{}
3638: {}
3639",
3640 <ResourceManager_DiagnosticEventContext as ::unity::ClassIdentity>::NAME,
3641 ".ctor",
3642 e
3643 )
3644 },
3645 }
3646 }
3647 }
3648}
3649
3650#[cfg(feature = "unity_engine-resource_management-resourcemanager")]
3651impl ResourceManager_DiagnosticEventContext {
3652 #[doc = "`get_OperationHandle()` overload"]
3653 pub fn get_operation_handle(&mut self) -> crate::unity_engine::resource_management::async_operations::asyncoperationhandle::AsyncOperationHandle {
3654 unsafe {
3655 ::unity::il2cpp_call!(::unity::callable_ptr(__ResourceManager_DiagnosticEventContext_unity_raw::__lookup_get_operation_handle::get_method_info().method_ptr),crate::unity_engine::resource_management::async_operations::asyncoperationhandle::AsyncOperationHandle;
3656(*mut ResourceManager_DiagnosticEventContext)self as*mut ResourceManager_DiagnosticEventContext)
3657 }
3658 }
3659
3660 #[doc = "`get_Type()` overload"]
3661 pub fn get_type(&mut self) -> crate::unity_engine::resource_management::resourcemanager::ResourceManager_DiagnosticEventType {
3662 unsafe {
3663 ::unity::il2cpp_call!(::unity::callable_ptr(__ResourceManager_DiagnosticEventContext_unity_raw::__lookup_get_type::get_method_info().method_ptr),crate::unity_engine::resource_management::resourcemanager::ResourceManager_DiagnosticEventType;
3664(*mut ResourceManager_DiagnosticEventContext)self as*mut ResourceManager_DiagnosticEventContext)
3665 }
3666 }
3667
3668 #[doc = "`get_EventValue()` overload"]
3669 pub fn get_event_value(&mut self) -> i32 {
3670 unsafe {
3671 ::unity::il2cpp_call!(::unity::callable_ptr(__ResourceManager_DiagnosticEventContext_unity_raw::__lookup_get_event_value::get_method_info().method_ptr),i32;
3672(*mut ResourceManager_DiagnosticEventContext)self as*mut ResourceManager_DiagnosticEventContext)
3673 }
3674 }
3675
3676 #[doc = "`get_Location()` overload"]
3677 pub fn get_location(&mut self) -> crate::unity_engine::resource_management::resource_locations::iresourcelocation::IResourceLocation {
3678 unsafe {
3679 ::unity::il2cpp_call!(::unity::callable_ptr(__ResourceManager_DiagnosticEventContext_unity_raw::__lookup_get_location::get_method_info().method_ptr),crate::unity_engine::resource_management::resource_locations::iresourcelocation::IResourceLocation;
3680(*mut ResourceManager_DiagnosticEventContext)self as*mut ResourceManager_DiagnosticEventContext)
3681 }
3682 }
3683
3684 #[doc = "`get_Context()` overload"]
3685 pub fn get_context(&mut self) -> crate::system::object::Object {
3686 unsafe {
3687 ::unity::il2cpp_call!(::unity::callable_ptr(__ResourceManager_DiagnosticEventContext_unity_raw::__lookup_get_context::get_method_info().method_ptr),crate::system::object::Object;
3688(*mut ResourceManager_DiagnosticEventContext)self as*mut ResourceManager_DiagnosticEventContext)
3689 }
3690 }
3691
3692 #[doc = "`get_Error()` overload"]
3693 pub fn get_error(&mut self) -> ::unity::Il2CppString {
3694 unsafe {
3695 ::unity::il2cpp_call!(::unity::callable_ptr(__ResourceManager_DiagnosticEventContext_unity_raw::__lookup_get_error::get_method_info().method_ptr), ::unity::Il2CppString;
3696(*mut ResourceManager_DiagnosticEventContext)self as*mut ResourceManager_DiagnosticEventContext)
3697 }
3698 }
3699
3700 #[doc = "`.ctor(crate::unity_engine::resource_management::async_operations::asyncoperationhandle::AsyncOperationHandle, crate::unity_engine::resource_management::resourcemanager::ResourceManager_DiagnosticEventType, i32, ::unity::Il2CppString, ::unity::IlInstance)` overload"]
3701 pub fn ctor(
3702 &mut self,
3703 op: impl ::core::convert::Into<crate::unity_engine::resource_management::async_operations::asyncoperationhandle::AsyncOperationHandle>,
3704 r#type: impl ::core::convert::Into<crate::unity_engine::resource_management::resourcemanager::ResourceManager_DiagnosticEventType>,
3705 event_value: impl ::core::convert::Into<i32>,
3706 error: impl ::core::convert::Into<::unity::Il2CppString>,
3707 context: impl ::core::convert::Into<::unity::IlInstance>,
3708 ) -> () {
3709 unsafe {
3710 ::unity::il2cpp_call!(::unity::callable_ptr(__ResourceManager_DiagnosticEventContext_unity_raw::__lookup_ctor::get_method_info().method_ptr),();
3711(*mut ResourceManager_DiagnosticEventContext)self as*mut ResourceManager_DiagnosticEventContext,(crate::unity_engine::resource_management::async_operations::asyncoperationhandle::AsyncOperationHandle)::core::convert::Into::into(op),(crate::unity_engine::resource_management::resourcemanager::ResourceManager_DiagnosticEventType)::core::convert::Into::into(r#type),(i32)::core::convert::Into::into(event_value),(::unity::Il2CppString)::core::convert::Into::into(error),(::unity::IlInstance)::core::convert::Into::into(context))
3712 }
3713 }
3714}
3715
3716#[cfg(feature = "unity_engine-resource_management-resourcemanager")]
3717impl ResourceManager_DiagnosticEventContext {
3718 pub fn get_operation_handle_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3719 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
3720 }
3721
3722 pub fn get_type_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3723 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
3724 }
3725
3726 pub fn get_event_value_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3727 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
3728 }
3729
3730 pub fn get_location_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3731 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
3732 }
3733
3734 pub fn get_context_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3735 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
3736 }
3737
3738 pub fn get_error_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3739 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[5]
3740 }
3741
3742 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3743 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[6]
3744 }
3745}
3746
3747#[cfg(feature = "unity_engine-resource_management-resourcemanager")]
3748#[doc(hidden)]
3749#[allow(non_snake_case, non_camel_case_types, clippy::too_many_arguments)]
3750mod __ResourceManager_InstanceOperation_unity_raw {
3751 use super::*;
3752 #[doc(hidden)]
3753 #[allow(non_snake_case)]
3754 pub mod __lookup_init {
3755 use super::*;
3756 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
3757 let param_types: &[& 'static::unity::il2cpp::Il2CppType]= &[<crate::unity_engine::resource_management::resourcemanager::ResourceManager as::unity::IlType> ::il_type(), <crate::unity_engine::resource_management::resource_providers::iinstanceprovider_interface::IInstanceProvider_Interface as::unity::IlType> ::il_type(), <crate::unity_engine::resource_management::resource_providers::instantiationparameters::InstantiationParameters as::unity::IlType> ::il_type(), <crate::unity_engine::resource_management::async_operations::asyncoperationhandle_1::AsyncOperationHandle_1<crate::unity_engine::gameobject::GameObject>as::unity::IlType> ::il_type()];
3758 ::unity::lookup::method_info_on_class_with_signature(
3759 <ResourceManager_InstanceOperation as ::unity::ClassIdentity>::class(),
3760 "Init",
3761 4,
3762 param_types,
3763 false,
3764 )
3765 });
3766 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3767 match &*METHOD {
3768 ::core::result::Result::Ok(mi) => *mi,
3769 ::core::result::Result::Err(e) => {
3770 panic!(
3771 "method lookup failed: {}
3772::{}
3773: {}
3774",
3775 <ResourceManager_InstanceOperation as ::unity::ClassIdentity>::NAME,
3776 "Init",
3777 e
3778 )
3779 },
3780 }
3781 }
3782 }
3783 #[doc(hidden)]
3784 #[allow(non_snake_case)]
3785 pub mod __lookup_instance_scene {
3786 use super::*;
3787 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
3788 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[];
3789 ::unity::lookup::method_info_on_class_with_signature(
3790 <ResourceManager_InstanceOperation as ::unity::ClassIdentity>::class(),
3791 "InstanceScene",
3792 0,
3793 param_types,
3794 false,
3795 )
3796 });
3797 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3798 match &*METHOD {
3799 ::core::result::Result::Ok(mi) => *mi,
3800 ::core::result::Result::Err(e) => {
3801 panic!(
3802 "method lookup failed: {}
3803::{}
3804: {}
3805",
3806 <ResourceManager_InstanceOperation as ::unity::ClassIdentity>::NAME,
3807 "InstanceScene",
3808 e
3809 )
3810 },
3811 }
3812 }
3813 }
3814 #[doc(hidden)]
3815 #[allow(non_snake_case)]
3816 pub mod __lookup_ctor {
3817 use super::*;
3818 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
3819 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[];
3820 ::unity::lookup::method_info_on_class_with_signature(
3821 <ResourceManager_InstanceOperation as ::unity::ClassIdentity>::class(),
3822 ".ctor",
3823 0,
3824 param_types,
3825 false,
3826 )
3827 });
3828 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3829 match &*METHOD {
3830 ::core::result::Result::Ok(mi) => *mi,
3831 ::core::result::Result::Err(e) => {
3832 panic!(
3833 "method lookup failed: {}
3834::{}
3835: {}
3836",
3837 <ResourceManager_InstanceOperation as ::unity::ClassIdentity>::NAME,
3838 ".ctor",
3839 e
3840 )
3841 },
3842 }
3843 }
3844 }
3845}
3846
3847#[cfg(feature = "unity_engine-resource_management-resourcemanager")]
3848pub trait IResourceManager_InstanceOperationMethods: IResourceManager_InstanceOperation {
3849 #[doc = "`Init(crate::unity_engine::resource_management::resourcemanager::ResourceManager, crate::unity_engine::resource_management::resource_providers::iinstanceprovider_interface::IInstanceProvider_Interface, crate::unity_engine::resource_management::resource_providers::instantiationparameters::InstantiationParameters, crate::unity_engine::resource_management::async_operations::asyncoperationhandle_1::AsyncOperationHandle_1<crate::unity_engine::gameobject::GameObject>)` overload"]
3850 fn init(
3851 self,
3852 rm: impl ::core::convert::Into<crate::unity_engine::resource_management::resourcemanager::ResourceManager>,
3853 instance_provider: impl ::core::convert::Into<
3854 crate::unity_engine::resource_management::resource_providers::iinstanceprovider_interface::IInstanceProvider_Interface,
3855 >,
3856 instantiation_params: impl ::core::convert::Into<
3857 crate::unity_engine::resource_management::resource_providers::instantiationparameters::InstantiationParameters,
3858 >,
3859 dependency: impl ::core::convert::Into<
3860 crate::unity_engine::resource_management::async_operations::asyncoperationhandle_1::AsyncOperationHandle_1<
3861 crate::unity_engine::gameobject::GameObject,
3862 >,
3863 >,
3864 ) -> () {
3865 unsafe {
3866 let __receiver =
3867 <ResourceManager_InstanceOperation as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3868 ::unity::il2cpp_call!(__ResourceManager_InstanceOperation_unity_raw::__lookup_init::get_method_info().method_ptr,();
3869(ResourceManager_InstanceOperation)__receiver,(crate::unity_engine::resource_management::resourcemanager::ResourceManager)::core::convert::Into::into(rm),(crate::unity_engine::resource_management::resource_providers::iinstanceprovider_interface::IInstanceProvider_Interface)::core::convert::Into::into(instance_provider),(crate::unity_engine::resource_management::resource_providers::instantiationparameters::InstantiationParameters)::core::convert::Into::into(instantiation_params),(crate::unity_engine::resource_management::async_operations::asyncoperationhandle_1::AsyncOperationHandle_1<crate::unity_engine::gameobject::GameObject>)::core::convert::Into::into(dependency))
3870 }
3871 }
3872 #[doc = "`GetDownloadStatus(crate::system::collections::generic::hashset_1::HashSet_1<crate::system::object::Object>)` overload"]
3873 fn get_download_status(
3874 self,
3875 visited: impl ::core::convert::Into<crate::system::collections::generic::hashset_1::HashSet_1<crate::system::object::Object>>,
3876 ) -> crate::unity_engine::resource_management::async_operations::downloadstatus::DownloadStatus {
3877 unsafe {
3878 let __receiver =
3879 <ResourceManager_InstanceOperation as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3880 {
3881 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
3882 let __vi = *__vt.get(35usize).unwrap_or_else(|| {
3883 panic!(
3884 "unity: virtual slot {}
3885 out of range (vtable len {}
3886) on the runtime class behind {}
3887 (method `{}
3888`)",
3889 35usize,
3890 __vt.len(),
3891 <ResourceManager_InstanceOperation as ::unity::ClassIdentity>::NAME,
3892 "GetDownloadStatus",
3893 )
3894 });
3895 let __inner: extern "C" fn(
3896 ResourceManager_InstanceOperation,
3897 crate::system::collections::generic::hashset_1::HashSet_1<crate::system::object::Object>,
3898 ::unity::OptionalMethod,
3899 )
3900 -> crate::unity_engine::resource_management::async_operations::downloadstatus::DownloadStatus =
3901 ::core::mem::transmute(__vi.method_ptr);
3902 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
3903 __inner(__receiver, ::core::convert::Into::into(visited), __mi)
3904 }
3905 }
3906 }
3907 #[doc = "`GetDependencies(crate::system::collections::generic::list_1::List_1<crate::unity_engine::resource_management::async_operations::asyncoperationhandle::AsyncOperationHandle>)` overload"]
3908 fn get_dependencies(
3909 self,
3910 deps: impl ::core::convert::Into<
3911 crate::system::collections::generic::list_1::List_1<
3912 crate::unity_engine::resource_management::async_operations::asyncoperationhandle::AsyncOperationHandle,
3913 >,
3914 >,
3915 ) -> () {
3916 unsafe {
3917 let __receiver =
3918 <ResourceManager_InstanceOperation as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3919 {
3920 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
3921 let __vi = *__vt.get(32usize).unwrap_or_else(|| {
3922 panic!(
3923 "unity: virtual slot {}
3924 out of range (vtable len {}
3925) on the runtime class behind {}
3926 (method `{}
3927`)",
3928 32usize,
3929 __vt.len(),
3930 <ResourceManager_InstanceOperation as ::unity::ClassIdentity>::NAME,
3931 "GetDependencies",
3932 )
3933 });
3934 let __inner: extern "C" fn(
3935 ResourceManager_InstanceOperation,
3936 crate::system::collections::generic::list_1::List_1<
3937 crate::unity_engine::resource_management::async_operations::asyncoperationhandle::AsyncOperationHandle,
3938 >,
3939 ::unity::OptionalMethod,
3940 ) -> () = ::core::mem::transmute(__vi.method_ptr);
3941 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
3942 __inner(__receiver, ::core::convert::Into::into(deps), __mi)
3943 }
3944 }
3945 }
3946 #[doc = "`get_DebugName()` overload"]
3947 fn get_debug_name(self) -> ::unity::Il2CppString {
3948 unsafe {
3949 let __receiver =
3950 <ResourceManager_InstanceOperation as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3951 {
3952 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
3953 let __vi = *__vt.get(31usize).unwrap_or_else(|| {
3954 panic!(
3955 "unity: virtual slot {}
3956 out of range (vtable len {}
3957) on the runtime class behind {}
3958 (method `{}
3959`)",
3960 31usize,
3961 __vt.len(),
3962 <ResourceManager_InstanceOperation as ::unity::ClassIdentity>::NAME,
3963 "get_DebugName",
3964 )
3965 });
3966 let __inner: extern "C" fn(ResourceManager_InstanceOperation, ::unity::OptionalMethod) -> ::unity::Il2CppString =
3967 ::core::mem::transmute(__vi.method_ptr);
3968 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
3969 __inner(__receiver, __mi)
3970 }
3971 }
3972 }
3973 #[doc = "`InstanceScene()` overload"]
3974 fn instance_scene(self) -> crate::unity_engine::scene_management::scene::Scene {
3975 unsafe {
3976 let __receiver =
3977 <ResourceManager_InstanceOperation as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3978 ::unity::il2cpp_call!(__ResourceManager_InstanceOperation_unity_raw::__lookup_instance_scene::get_method_info().method_ptr,crate::unity_engine::scene_management::scene::Scene;
3979(ResourceManager_InstanceOperation)__receiver)
3980 }
3981 }
3982 #[doc = "`Destroy()` overload"]
3983 fn destroy(self) -> () {
3984 unsafe {
3985 let __receiver =
3986 <ResourceManager_InstanceOperation as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3987 {
3988 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
3989 let __vi = *__vt.get(29usize).unwrap_or_else(|| {
3990 panic!(
3991 "unity: virtual slot {}
3992 out of range (vtable len {}
3993) on the runtime class behind {}
3994 (method `{}
3995`)",
3996 29usize,
3997 __vt.len(),
3998 <ResourceManager_InstanceOperation as ::unity::ClassIdentity>::NAME,
3999 "Destroy",
4000 )
4001 });
4002 let __inner: extern "C" fn(ResourceManager_InstanceOperation, ::unity::OptionalMethod) -> () =
4003 ::core::mem::transmute(__vi.method_ptr);
4004 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
4005 __inner(__receiver, __mi)
4006 }
4007 }
4008 }
4009 #[doc = "`get_Progress()` overload"]
4010 fn get_progress(self) -> f32 {
4011 unsafe {
4012 let __receiver =
4013 <ResourceManager_InstanceOperation as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
4014 {
4015 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
4016 let __vi = *__vt.get(30usize).unwrap_or_else(|| {
4017 panic!(
4018 "unity: virtual slot {}
4019 out of range (vtable len {}
4020) on the runtime class behind {}
4021 (method `{}
4022`)",
4023 30usize,
4024 __vt.len(),
4025 <ResourceManager_InstanceOperation as ::unity::ClassIdentity>::NAME,
4026 "get_Progress",
4027 )
4028 });
4029 let __inner: extern "C" fn(ResourceManager_InstanceOperation, ::unity::OptionalMethod) -> f32 =
4030 ::core::mem::transmute(__vi.method_ptr);
4031 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
4032 __inner(__receiver, __mi)
4033 }
4034 }
4035 }
4036 #[doc = "`InvokeWaitForCompletion()` overload"]
4037 fn invoke_wait_for_completion(self) -> bool {
4038 unsafe {
4039 let __receiver =
4040 <ResourceManager_InstanceOperation as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
4041 {
4042 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
4043 let __vi = *__vt.get(33usize).unwrap_or_else(|| {
4044 panic!(
4045 "unity: virtual slot {}
4046 out of range (vtable len {}
4047) on the runtime class behind {}
4048 (method `{}
4049`)",
4050 33usize,
4051 __vt.len(),
4052 <ResourceManager_InstanceOperation as ::unity::ClassIdentity>::NAME,
4053 "InvokeWaitForCompletion",
4054 )
4055 });
4056 let __inner: extern "C" fn(ResourceManager_InstanceOperation, ::unity::OptionalMethod) -> bool =
4057 ::core::mem::transmute(__vi.method_ptr);
4058 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
4059 __inner(__receiver, __mi)
4060 }
4061 }
4062 }
4063 #[doc = "`Execute()` overload"]
4064 fn execute(self) -> () {
4065 unsafe {
4066 let __receiver =
4067 <ResourceManager_InstanceOperation as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
4068 {
4069 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
4070 let __vi = *__vt.get(28usize).unwrap_or_else(|| {
4071 panic!(
4072 "unity: virtual slot {}
4073 out of range (vtable len {}
4074) on the runtime class behind {}
4075 (method `{}
4076`)",
4077 28usize,
4078 __vt.len(),
4079 <ResourceManager_InstanceOperation as ::unity::ClassIdentity>::NAME,
4080 "Execute",
4081 )
4082 });
4083 let __inner: extern "C" fn(ResourceManager_InstanceOperation, ::unity::OptionalMethod) -> () =
4084 ::core::mem::transmute(__vi.method_ptr);
4085 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
4086 __inner(__receiver, __mi)
4087 }
4088 }
4089 }
4090 #[doc = "`.ctor()` overload"]
4091 fn ctor(self) -> () {
4092 unsafe {
4093 let __receiver =
4094 <ResourceManager_InstanceOperation as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
4095 ::unity::il2cpp_call!(__ResourceManager_InstanceOperation_unity_raw::__lookup_ctor::get_method_info().method_ptr,();
4096(ResourceManager_InstanceOperation)__receiver)
4097 }
4098 }
4099}
4100
4101#[cfg(feature = "unity_engine-resource_management-resourcemanager")]
4102impl<__T: IResourceManager_InstanceOperation> IResourceManager_InstanceOperationMethods for __T {}
4103
4104#[cfg(feature = "unity_engine-resource_management-resourcemanager")]
4105impl ResourceManager_InstanceOperation {
4106 pub fn init_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4107 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
4108 }
4109
4110 pub fn get_download_status_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4111 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
4112 }
4113
4114 pub fn get_dependencies_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4115 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
4116 }
4117
4118 pub fn get_debug_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4119 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
4120 }
4121
4122 pub fn instance_scene_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4123 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
4124 }
4125
4126 pub fn destroy_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4127 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[5]
4128 }
4129
4130 pub fn get_progress_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4131 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[6]
4132 }
4133
4134 pub fn invoke_wait_for_completion_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4135 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[7]
4136 }
4137
4138 pub fn execute_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4139 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[8]
4140 }
4141
4142 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4143 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[9]
4144 }
4145}
4146
4147#[cfg(feature = "unity_engine-resource_management-resourcemanager")]
4148impl ResourceManager_InstanceOperation {
4149 #[doc = "Direct (non-virtual) call to `ResourceManager_InstanceOperation`'s own `GetDownloadStatus`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
4150 pub unsafe fn get_download_status(
4151 this: impl ::core::convert::Into<::unity::IlInstance>,
4152 visited: crate::system::collections::generic::hashset_1::HashSet_1<crate::system::object::Object>,
4153 ) -> crate::unity_engine::resource_management::async_operations::downloadstatus::DownloadStatus {
4154 let __mi = Self::get_download_status_method_info();
4155 let __inner: extern "C" fn(
4156 ::unity::IlInstance,
4157 crate::system::collections::generic::hashset_1::HashSet_1<crate::system::object::Object>,
4158 ::unity::OptionalMethod,
4159 ) -> crate::unity_engine::resource_management::async_operations::downloadstatus::DownloadStatus = ::core::mem::transmute(__mi.method_ptr);
4160 __inner(this.into(), visited, ::core::option::Option::None)
4161 }
4162
4163 #[doc = "Direct (non-virtual) call to `ResourceManager_InstanceOperation`'s own `GetDependencies`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
4164 pub unsafe fn get_dependencies(
4165 this: impl ::core::convert::Into<::unity::IlInstance>,
4166 deps: crate::system::collections::generic::list_1::List_1<
4167 crate::unity_engine::resource_management::async_operations::asyncoperationhandle::AsyncOperationHandle,
4168 >,
4169 ) -> () {
4170 let __mi = Self::get_dependencies_method_info();
4171 let __inner: extern "C" fn(
4172 ::unity::IlInstance,
4173 crate::system::collections::generic::list_1::List_1<
4174 crate::unity_engine::resource_management::async_operations::asyncoperationhandle::AsyncOperationHandle,
4175 >,
4176 ::unity::OptionalMethod,
4177 ) -> () = ::core::mem::transmute(__mi.method_ptr);
4178 __inner(this.into(), deps, ::core::option::Option::None)
4179 }
4180
4181 #[doc = "Direct (non-virtual) call to `ResourceManager_InstanceOperation`'s own `get_DebugName`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
4182 pub unsafe fn get_debug_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
4183 let __mi = Self::get_debug_name_method_info();
4184 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
4185 __inner(this.into(), ::core::option::Option::None)
4186 }
4187
4188 #[doc = "Direct (non-virtual) call to `ResourceManager_InstanceOperation`'s own `Destroy`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
4189 pub unsafe fn destroy(this: impl ::core::convert::Into<::unity::IlInstance>) -> () {
4190 let __mi = Self::destroy_method_info();
4191 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
4192 __inner(this.into(), ::core::option::Option::None)
4193 }
4194
4195 #[doc = "Direct (non-virtual) call to `ResourceManager_InstanceOperation`'s own `get_Progress`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
4196 pub unsafe fn get_progress(this: impl ::core::convert::Into<::unity::IlInstance>) -> f32 {
4197 let __mi = Self::get_progress_method_info();
4198 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> f32 = ::core::mem::transmute(__mi.method_ptr);
4199 __inner(this.into(), ::core::option::Option::None)
4200 }
4201
4202 #[doc = "Direct (non-virtual) call to `ResourceManager_InstanceOperation`'s own `InvokeWaitForCompletion`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
4203 pub unsafe fn invoke_wait_for_completion(this: impl ::core::convert::Into<::unity::IlInstance>) -> bool {
4204 let __mi = Self::invoke_wait_for_completion_method_info();
4205 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__mi.method_ptr);
4206 __inner(this.into(), ::core::option::Option::None)
4207 }
4208
4209 #[doc = "Direct (non-virtual) call to `ResourceManager_InstanceOperation`'s own `Execute`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
4210 pub unsafe fn execute(this: impl ::core::convert::Into<::unity::IlInstance>) -> () {
4211 let __mi = Self::execute_method_info();
4212 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
4213 __inner(this.into(), ::core::option::Option::None)
4214 }
4215}
4216
4217#[cfg(feature = "unity_engine-resource_management-resourcemanager")]
4218impl ResourceManager_InstanceOperation {
4219 #[doc = "`.ctor()` — no args"]
4220 pub fn new() -> Self {
4221 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
4222 panic!(
4223 "{}
4224::{}
4225 failed to instantiate",
4226 ::core::stringify!(ResourceManager_InstanceOperation),
4227 ::core::stringify!(new),
4228 )
4229 });
4230 <Self as IResourceManager_InstanceOperationMethods>::ctor(this);
4231 this
4232 }
4233}
4234
4235#[cfg(feature = "unity_engine-resource_management-resourcemanager")]
4236#[doc(hidden)]
4237pub mod prelude {
4238 pub use super::{
4239 IResourceManager, IResourceManagerMethods, IResourceManager_CompletedOperation_1, IResourceManager_CompletedOperation_1Methods,
4240 IResourceManager_InstanceOperation, IResourceManager_InstanceOperationMethods, ResourceManager, ResourceManager_CompletedOperation_1,
4241 ResourceManager_DiagnosticEventContext, ResourceManager_DiagnosticEventType, ResourceManager_InstanceOperation,
4242 };
4243 #[cfg(feature = "system-object")]
4244 pub use crate::system::object::IObjectMethods;
4245 #[cfg(feature = "system-enum")]
4246 pub use crate::system::r#enum::IEnumMethods;
4247 #[cfg(feature = "system-valuetype")]
4248 pub use crate::system::valuetype::IValueTypeMethods;
4249 #[cfg(feature = "unity_engine-resource_management-async_operations-asyncoperationbase_1")]
4250 pub use crate::unity_engine::resource_management::async_operations::asyncoperationbase_1::IAsyncOperationBase_1Methods;
4251 pub use crate::{
4252 system::{object::IObject, r#enum::IEnum, valuetype::IValueType},
4253 unity_engine::resource_management::async_operations::asyncoperationbase_1::IAsyncOperationBase_1,
4254 };
4255}