1#[cfg(feature = "unity_engine-playables-playableextensions-types")]
4mod __types {
5 #[allow(unused_imports)] use ::unity::prelude::*;
6
7 use super::*;
8 use crate::system::object::{IObject, Object};
9
10 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/unity_engine/playables/playableextensions/PlayableExtensions.md"))]
11 #[::unity::class(namespace = "UnityEngine.Playables", name = "PlayableExtensions")]
12 #[parent(crate::system::object::Object)]
13 pub struct PlayableExtensions {}
14}
15
16#[cfg(feature = "unity_engine-playables-playableextensions-types")]
17pub use __types::*;
18
19#[cfg(feature = "unity_engine-playables-playableextensions")]
20impl PlayableExtensions {
21 pub fn is_valid<M0: ::unity::IlType + ::core::marker::Copy + ::unity::ClassIdentity>(playable: impl ::core::convert::Into<M0>) -> bool {
22 static OPEN: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
23 ::unity::lookup::method_info_on_class(<PlayableExtensions as ::unity::ClassIdentity>::class(), "IsValid", 1)
24 });
25 #[allow(clippy::type_complexity)]
26 static CACHE: ::std::sync::OnceLock<::std::sync::Mutex<::std::collections::HashMap<usize, &'static ::unity::il2cpp::MethodInfo>>> =
27 ::std::sync::OnceLock::new();
28 let _ = true;
29 let __open: &'static ::unity::il2cpp::MethodInfo = match &*OPEN {
30 ::core::result::Result::Ok(mi) => *mi,
31 ::core::result::Result::Err(e) => {
32 panic!(
33 "method lookup failed: {}
34::{}
35: {}
36",
37 <PlayableExtensions as ::unity::ClassIdentity>::NAME,
38 "IsValid",
39 e
40 )
41 },
42 };
43 let __cache = CACHE.get_or_init(|| ::std::sync::Mutex::new(::std::collections::HashMap::new()));
44 let __key: usize = <M0 as ::unity::IlType>::il_type() as *const _ as usize;
45 let __inflated: &'static ::unity::il2cpp::MethodInfo = {
46 let mut __guard = __cache.lock().unwrap();
47 *__guard
48 .entry(__key)
49 .or_insert_with(|| ::unity::il2cpp::generic::create_generic_method_info(__open, &[<M0 as ::unity::IlType>::il_type()]))
50 };
51 unsafe {
52 let __f: extern "C" fn(M0, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__inflated.method_ptr);
53 let __mi_opaque: &'static () = &*(__inflated as *const _ as *const ());
54 __f(::core::convert::Into::into(playable), ::core::option::Option::Some(__mi_opaque))
55 }
56 }
57
58 pub fn get_graph<M0: ::unity::IlType + ::core::marker::Copy + ::unity::ClassIdentity>(
59 playable: impl ::core::convert::Into<M0>,
60 ) -> crate::unity_engine::playables::playablegraph::PlayableGraph {
61 static OPEN: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
62 ::unity::lookup::method_info_on_class(<PlayableExtensions as ::unity::ClassIdentity>::class(), "GetGraph", 1)
63 });
64 #[allow(clippy::type_complexity)]
65 static CACHE: ::std::sync::OnceLock<::std::sync::Mutex<::std::collections::HashMap<usize, &'static ::unity::il2cpp::MethodInfo>>> =
66 ::std::sync::OnceLock::new();
67 let _ = true;
68 let __open: &'static ::unity::il2cpp::MethodInfo = match &*OPEN {
69 ::core::result::Result::Ok(mi) => *mi,
70 ::core::result::Result::Err(e) => {
71 panic!(
72 "method lookup failed: {}
73::{}
74: {}
75",
76 <PlayableExtensions as ::unity::ClassIdentity>::NAME,
77 "GetGraph",
78 e
79 )
80 },
81 };
82 let __cache = CACHE.get_or_init(|| ::std::sync::Mutex::new(::std::collections::HashMap::new()));
83 let __key: usize = <M0 as ::unity::IlType>::il_type() as *const _ as usize;
84 let __inflated: &'static ::unity::il2cpp::MethodInfo = {
85 let mut __guard = __cache.lock().unwrap();
86 *__guard
87 .entry(__key)
88 .or_insert_with(|| ::unity::il2cpp::generic::create_generic_method_info(__open, &[<M0 as ::unity::IlType>::il_type()]))
89 };
90 unsafe {
91 let __f: extern "C" fn(M0, ::unity::OptionalMethod) -> crate::unity_engine::playables::playablegraph::PlayableGraph =
92 ::core::mem::transmute(__inflated.method_ptr);
93 let __mi_opaque: &'static () = &*(__inflated as *const _ as *const ());
94 __f(::core::convert::Into::into(playable), ::core::option::Option::Some(__mi_opaque))
95 }
96 }
97
98 pub fn get_play_state<M0: ::unity::IlType + ::core::marker::Copy + ::unity::ClassIdentity>(
99 playable: impl ::core::convert::Into<M0>,
100 ) -> crate::unity_engine::playables::playstate::PlayState {
101 static OPEN: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
102 ::unity::lookup::method_info_on_class(<PlayableExtensions as ::unity::ClassIdentity>::class(), "GetPlayState", 1)
103 });
104 #[allow(clippy::type_complexity)]
105 static CACHE: ::std::sync::OnceLock<::std::sync::Mutex<::std::collections::HashMap<usize, &'static ::unity::il2cpp::MethodInfo>>> =
106 ::std::sync::OnceLock::new();
107 let _ = true;
108 let __open: &'static ::unity::il2cpp::MethodInfo = match &*OPEN {
109 ::core::result::Result::Ok(mi) => *mi,
110 ::core::result::Result::Err(e) => {
111 panic!(
112 "method lookup failed: {}
113::{}
114: {}
115",
116 <PlayableExtensions as ::unity::ClassIdentity>::NAME,
117 "GetPlayState",
118 e
119 )
120 },
121 };
122 let __cache = CACHE.get_or_init(|| ::std::sync::Mutex::new(::std::collections::HashMap::new()));
123 let __key: usize = <M0 as ::unity::IlType>::il_type() as *const _ as usize;
124 let __inflated: &'static ::unity::il2cpp::MethodInfo = {
125 let mut __guard = __cache.lock().unwrap();
126 *__guard
127 .entry(__key)
128 .or_insert_with(|| ::unity::il2cpp::generic::create_generic_method_info(__open, &[<M0 as ::unity::IlType>::il_type()]))
129 };
130 unsafe {
131 let __f: extern "C" fn(M0, ::unity::OptionalMethod) -> crate::unity_engine::playables::playstate::PlayState =
132 ::core::mem::transmute(__inflated.method_ptr);
133 let __mi_opaque: &'static () = &*(__inflated as *const _ as *const ());
134 __f(::core::convert::Into::into(playable), ::core::option::Option::Some(__mi_opaque))
135 }
136 }
137
138 pub fn play<M0: ::unity::IlType + ::core::marker::Copy + ::unity::ClassIdentity>(playable: impl ::core::convert::Into<M0>) -> () {
139 static OPEN: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> =
140 ::std::sync::LazyLock::new(|| ::unity::lookup::method_info_on_class(<PlayableExtensions as ::unity::ClassIdentity>::class(), "Play", 1));
141 #[allow(clippy::type_complexity)]
142 static CACHE: ::std::sync::OnceLock<::std::sync::Mutex<::std::collections::HashMap<usize, &'static ::unity::il2cpp::MethodInfo>>> =
143 ::std::sync::OnceLock::new();
144 let _ = true;
145 let __open: &'static ::unity::il2cpp::MethodInfo = match &*OPEN {
146 ::core::result::Result::Ok(mi) => *mi,
147 ::core::result::Result::Err(e) => {
148 panic!(
149 "method lookup failed: {}
150::{}
151: {}
152",
153 <PlayableExtensions as ::unity::ClassIdentity>::NAME,
154 "Play",
155 e
156 )
157 },
158 };
159 let __cache = CACHE.get_or_init(|| ::std::sync::Mutex::new(::std::collections::HashMap::new()));
160 let __key: usize = <M0 as ::unity::IlType>::il_type() as *const _ as usize;
161 let __inflated: &'static ::unity::il2cpp::MethodInfo = {
162 let mut __guard = __cache.lock().unwrap();
163 *__guard
164 .entry(__key)
165 .or_insert_with(|| ::unity::il2cpp::generic::create_generic_method_info(__open, &[<M0 as ::unity::IlType>::il_type()]))
166 };
167 unsafe {
168 let __f: extern "C" fn(M0, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__inflated.method_ptr);
169 let __mi_opaque: &'static () = &*(__inflated as *const _ as *const ());
170 __f(::core::convert::Into::into(playable), ::core::option::Option::Some(__mi_opaque))
171 }
172 }
173
174 pub fn pause<M0: ::unity::IlType + ::core::marker::Copy + ::unity::ClassIdentity>(playable: impl ::core::convert::Into<M0>) -> () {
175 static OPEN: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> =
176 ::std::sync::LazyLock::new(|| ::unity::lookup::method_info_on_class(<PlayableExtensions as ::unity::ClassIdentity>::class(), "Pause", 1));
177 #[allow(clippy::type_complexity)]
178 static CACHE: ::std::sync::OnceLock<::std::sync::Mutex<::std::collections::HashMap<usize, &'static ::unity::il2cpp::MethodInfo>>> =
179 ::std::sync::OnceLock::new();
180 let _ = true;
181 let __open: &'static ::unity::il2cpp::MethodInfo = match &*OPEN {
182 ::core::result::Result::Ok(mi) => *mi,
183 ::core::result::Result::Err(e) => {
184 panic!(
185 "method lookup failed: {}
186::{}
187: {}
188",
189 <PlayableExtensions as ::unity::ClassIdentity>::NAME,
190 "Pause",
191 e
192 )
193 },
194 };
195 let __cache = CACHE.get_or_init(|| ::std::sync::Mutex::new(::std::collections::HashMap::new()));
196 let __key: usize = <M0 as ::unity::IlType>::il_type() as *const _ as usize;
197 let __inflated: &'static ::unity::il2cpp::MethodInfo = {
198 let mut __guard = __cache.lock().unwrap();
199 *__guard
200 .entry(__key)
201 .or_insert_with(|| ::unity::il2cpp::generic::create_generic_method_info(__open, &[<M0 as ::unity::IlType>::il_type()]))
202 };
203 unsafe {
204 let __f: extern "C" fn(M0, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__inflated.method_ptr);
205 let __mi_opaque: &'static () = &*(__inflated as *const _ as *const ());
206 __f(::core::convert::Into::into(playable), ::core::option::Option::Some(__mi_opaque))
207 }
208 }
209
210 pub fn set_speed<M0: ::unity::IlType + ::core::marker::Copy + ::unity::ClassIdentity>(
211 playable: impl ::core::convert::Into<M0>,
212 value: impl ::core::convert::Into<f64>,
213 ) -> () {
214 static OPEN: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
215 ::unity::lookup::method_info_on_class(<PlayableExtensions as ::unity::ClassIdentity>::class(), "SetSpeed", 2)
216 });
217 #[allow(clippy::type_complexity)]
218 static CACHE: ::std::sync::OnceLock<::std::sync::Mutex<::std::collections::HashMap<usize, &'static ::unity::il2cpp::MethodInfo>>> =
219 ::std::sync::OnceLock::new();
220 let _ = true;
221 let __open: &'static ::unity::il2cpp::MethodInfo = match &*OPEN {
222 ::core::result::Result::Ok(mi) => *mi,
223 ::core::result::Result::Err(e) => {
224 panic!(
225 "method lookup failed: {}
226::{}
227: {}
228",
229 <PlayableExtensions as ::unity::ClassIdentity>::NAME,
230 "SetSpeed",
231 e
232 )
233 },
234 };
235 let __cache = CACHE.get_or_init(|| ::std::sync::Mutex::new(::std::collections::HashMap::new()));
236 let __key: usize = <M0 as ::unity::IlType>::il_type() as *const _ as usize;
237 let __inflated: &'static ::unity::il2cpp::MethodInfo = {
238 let mut __guard = __cache.lock().unwrap();
239 *__guard
240 .entry(__key)
241 .or_insert_with(|| ::unity::il2cpp::generic::create_generic_method_info(__open, &[<M0 as ::unity::IlType>::il_type()]))
242 };
243 unsafe {
244 let __f: extern "C" fn(M0, f64, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__inflated.method_ptr);
245 let __mi_opaque: &'static () = &*(__inflated as *const _ as *const ());
246 __f(
247 ::core::convert::Into::into(playable),
248 ::core::convert::Into::into(value),
249 ::core::option::Option::Some(__mi_opaque),
250 )
251 }
252 }
253
254 pub fn get_speed<M0: ::unity::IlType + ::core::marker::Copy + ::unity::ClassIdentity>(playable: impl ::core::convert::Into<M0>) -> f64 {
255 static OPEN: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
256 ::unity::lookup::method_info_on_class(<PlayableExtensions as ::unity::ClassIdentity>::class(), "GetSpeed", 1)
257 });
258 #[allow(clippy::type_complexity)]
259 static CACHE: ::std::sync::OnceLock<::std::sync::Mutex<::std::collections::HashMap<usize, &'static ::unity::il2cpp::MethodInfo>>> =
260 ::std::sync::OnceLock::new();
261 let _ = true;
262 let __open: &'static ::unity::il2cpp::MethodInfo = match &*OPEN {
263 ::core::result::Result::Ok(mi) => *mi,
264 ::core::result::Result::Err(e) => {
265 panic!(
266 "method lookup failed: {}
267::{}
268: {}
269",
270 <PlayableExtensions as ::unity::ClassIdentity>::NAME,
271 "GetSpeed",
272 e
273 )
274 },
275 };
276 let __cache = CACHE.get_or_init(|| ::std::sync::Mutex::new(::std::collections::HashMap::new()));
277 let __key: usize = <M0 as ::unity::IlType>::il_type() as *const _ as usize;
278 let __inflated: &'static ::unity::il2cpp::MethodInfo = {
279 let mut __guard = __cache.lock().unwrap();
280 *__guard
281 .entry(__key)
282 .or_insert_with(|| ::unity::il2cpp::generic::create_generic_method_info(__open, &[<M0 as ::unity::IlType>::il_type()]))
283 };
284 unsafe {
285 let __f: extern "C" fn(M0, ::unity::OptionalMethod) -> f64 = ::core::mem::transmute(__inflated.method_ptr);
286 let __mi_opaque: &'static () = &*(__inflated as *const _ as *const ());
287 __f(::core::convert::Into::into(playable), ::core::option::Option::Some(__mi_opaque))
288 }
289 }
290
291 pub fn set_duration<M0: ::unity::IlType + ::core::marker::Copy + ::unity::ClassIdentity>(
292 playable: impl ::core::convert::Into<M0>,
293 value: impl ::core::convert::Into<f64>,
294 ) -> () {
295 static OPEN: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
296 ::unity::lookup::method_info_on_class(<PlayableExtensions as ::unity::ClassIdentity>::class(), "SetDuration", 2)
297 });
298 #[allow(clippy::type_complexity)]
299 static CACHE: ::std::sync::OnceLock<::std::sync::Mutex<::std::collections::HashMap<usize, &'static ::unity::il2cpp::MethodInfo>>> =
300 ::std::sync::OnceLock::new();
301 let _ = true;
302 let __open: &'static ::unity::il2cpp::MethodInfo = match &*OPEN {
303 ::core::result::Result::Ok(mi) => *mi,
304 ::core::result::Result::Err(e) => {
305 panic!(
306 "method lookup failed: {}
307::{}
308: {}
309",
310 <PlayableExtensions as ::unity::ClassIdentity>::NAME,
311 "SetDuration",
312 e
313 )
314 },
315 };
316 let __cache = CACHE.get_or_init(|| ::std::sync::Mutex::new(::std::collections::HashMap::new()));
317 let __key: usize = <M0 as ::unity::IlType>::il_type() as *const _ as usize;
318 let __inflated: &'static ::unity::il2cpp::MethodInfo = {
319 let mut __guard = __cache.lock().unwrap();
320 *__guard
321 .entry(__key)
322 .or_insert_with(|| ::unity::il2cpp::generic::create_generic_method_info(__open, &[<M0 as ::unity::IlType>::il_type()]))
323 };
324 unsafe {
325 let __f: extern "C" fn(M0, f64, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__inflated.method_ptr);
326 let __mi_opaque: &'static () = &*(__inflated as *const _ as *const ());
327 __f(
328 ::core::convert::Into::into(playable),
329 ::core::convert::Into::into(value),
330 ::core::option::Option::Some(__mi_opaque),
331 )
332 }
333 }
334
335 pub fn get_duration<M0: ::unity::IlType + ::core::marker::Copy + ::unity::ClassIdentity>(playable: impl ::core::convert::Into<M0>) -> f64 {
336 static OPEN: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
337 ::unity::lookup::method_info_on_class(<PlayableExtensions as ::unity::ClassIdentity>::class(), "GetDuration", 1)
338 });
339 #[allow(clippy::type_complexity)]
340 static CACHE: ::std::sync::OnceLock<::std::sync::Mutex<::std::collections::HashMap<usize, &'static ::unity::il2cpp::MethodInfo>>> =
341 ::std::sync::OnceLock::new();
342 let _ = true;
343 let __open: &'static ::unity::il2cpp::MethodInfo = match &*OPEN {
344 ::core::result::Result::Ok(mi) => *mi,
345 ::core::result::Result::Err(e) => {
346 panic!(
347 "method lookup failed: {}
348::{}
349: {}
350",
351 <PlayableExtensions as ::unity::ClassIdentity>::NAME,
352 "GetDuration",
353 e
354 )
355 },
356 };
357 let __cache = CACHE.get_or_init(|| ::std::sync::Mutex::new(::std::collections::HashMap::new()));
358 let __key: usize = <M0 as ::unity::IlType>::il_type() as *const _ as usize;
359 let __inflated: &'static ::unity::il2cpp::MethodInfo = {
360 let mut __guard = __cache.lock().unwrap();
361 *__guard
362 .entry(__key)
363 .or_insert_with(|| ::unity::il2cpp::generic::create_generic_method_info(__open, &[<M0 as ::unity::IlType>::il_type()]))
364 };
365 unsafe {
366 let __f: extern "C" fn(M0, ::unity::OptionalMethod) -> f64 = ::core::mem::transmute(__inflated.method_ptr);
367 let __mi_opaque: &'static () = &*(__inflated as *const _ as *const ());
368 __f(::core::convert::Into::into(playable), ::core::option::Option::Some(__mi_opaque))
369 }
370 }
371
372 pub fn set_time<M0: ::unity::IlType + ::core::marker::Copy + ::unity::ClassIdentity>(
373 playable: impl ::core::convert::Into<M0>,
374 value: impl ::core::convert::Into<f64>,
375 ) -> () {
376 static OPEN: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
377 ::unity::lookup::method_info_on_class(<PlayableExtensions as ::unity::ClassIdentity>::class(), "SetTime", 2)
378 });
379 #[allow(clippy::type_complexity)]
380 static CACHE: ::std::sync::OnceLock<::std::sync::Mutex<::std::collections::HashMap<usize, &'static ::unity::il2cpp::MethodInfo>>> =
381 ::std::sync::OnceLock::new();
382 let _ = true;
383 let __open: &'static ::unity::il2cpp::MethodInfo = match &*OPEN {
384 ::core::result::Result::Ok(mi) => *mi,
385 ::core::result::Result::Err(e) => {
386 panic!(
387 "method lookup failed: {}
388::{}
389: {}
390",
391 <PlayableExtensions as ::unity::ClassIdentity>::NAME,
392 "SetTime",
393 e
394 )
395 },
396 };
397 let __cache = CACHE.get_or_init(|| ::std::sync::Mutex::new(::std::collections::HashMap::new()));
398 let __key: usize = <M0 as ::unity::IlType>::il_type() as *const _ as usize;
399 let __inflated: &'static ::unity::il2cpp::MethodInfo = {
400 let mut __guard = __cache.lock().unwrap();
401 *__guard
402 .entry(__key)
403 .or_insert_with(|| ::unity::il2cpp::generic::create_generic_method_info(__open, &[<M0 as ::unity::IlType>::il_type()]))
404 };
405 unsafe {
406 let __f: extern "C" fn(M0, f64, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__inflated.method_ptr);
407 let __mi_opaque: &'static () = &*(__inflated as *const _ as *const ());
408 __f(
409 ::core::convert::Into::into(playable),
410 ::core::convert::Into::into(value),
411 ::core::option::Option::Some(__mi_opaque),
412 )
413 }
414 }
415
416 pub fn get_time<M0: ::unity::IlType + ::core::marker::Copy + ::unity::ClassIdentity>(playable: impl ::core::convert::Into<M0>) -> f64 {
417 static OPEN: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
418 ::unity::lookup::method_info_on_class(<PlayableExtensions as ::unity::ClassIdentity>::class(), "GetTime", 1)
419 });
420 #[allow(clippy::type_complexity)]
421 static CACHE: ::std::sync::OnceLock<::std::sync::Mutex<::std::collections::HashMap<usize, &'static ::unity::il2cpp::MethodInfo>>> =
422 ::std::sync::OnceLock::new();
423 let _ = true;
424 let __open: &'static ::unity::il2cpp::MethodInfo = match &*OPEN {
425 ::core::result::Result::Ok(mi) => *mi,
426 ::core::result::Result::Err(e) => {
427 panic!(
428 "method lookup failed: {}
429::{}
430: {}
431",
432 <PlayableExtensions as ::unity::ClassIdentity>::NAME,
433 "GetTime",
434 e
435 )
436 },
437 };
438 let __cache = CACHE.get_or_init(|| ::std::sync::Mutex::new(::std::collections::HashMap::new()));
439 let __key: usize = <M0 as ::unity::IlType>::il_type() as *const _ as usize;
440 let __inflated: &'static ::unity::il2cpp::MethodInfo = {
441 let mut __guard = __cache.lock().unwrap();
442 *__guard
443 .entry(__key)
444 .or_insert_with(|| ::unity::il2cpp::generic::create_generic_method_info(__open, &[<M0 as ::unity::IlType>::il_type()]))
445 };
446 unsafe {
447 let __f: extern "C" fn(M0, ::unity::OptionalMethod) -> f64 = ::core::mem::transmute(__inflated.method_ptr);
448 let __mi_opaque: &'static () = &*(__inflated as *const _ as *const ());
449 __f(::core::convert::Into::into(playable), ::core::option::Option::Some(__mi_opaque))
450 }
451 }
452
453 pub fn get_previous_time<M0: ::unity::IlType + ::core::marker::Copy + ::unity::ClassIdentity>(playable: impl ::core::convert::Into<M0>) -> f64 {
454 static OPEN: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
455 ::unity::lookup::method_info_on_class(<PlayableExtensions as ::unity::ClassIdentity>::class(), "GetPreviousTime", 1)
456 });
457 #[allow(clippy::type_complexity)]
458 static CACHE: ::std::sync::OnceLock<::std::sync::Mutex<::std::collections::HashMap<usize, &'static ::unity::il2cpp::MethodInfo>>> =
459 ::std::sync::OnceLock::new();
460 let _ = true;
461 let __open: &'static ::unity::il2cpp::MethodInfo = match &*OPEN {
462 ::core::result::Result::Ok(mi) => *mi,
463 ::core::result::Result::Err(e) => {
464 panic!(
465 "method lookup failed: {}
466::{}
467: {}
468",
469 <PlayableExtensions as ::unity::ClassIdentity>::NAME,
470 "GetPreviousTime",
471 e
472 )
473 },
474 };
475 let __cache = CACHE.get_or_init(|| ::std::sync::Mutex::new(::std::collections::HashMap::new()));
476 let __key: usize = <M0 as ::unity::IlType>::il_type() as *const _ as usize;
477 let __inflated: &'static ::unity::il2cpp::MethodInfo = {
478 let mut __guard = __cache.lock().unwrap();
479 *__guard
480 .entry(__key)
481 .or_insert_with(|| ::unity::il2cpp::generic::create_generic_method_info(__open, &[<M0 as ::unity::IlType>::il_type()]))
482 };
483 unsafe {
484 let __f: extern "C" fn(M0, ::unity::OptionalMethod) -> f64 = ::core::mem::transmute(__inflated.method_ptr);
485 let __mi_opaque: &'static () = &*(__inflated as *const _ as *const ());
486 __f(::core::convert::Into::into(playable), ::core::option::Option::Some(__mi_opaque))
487 }
488 }
489
490 pub fn set_done<M0: ::unity::IlType + ::core::marker::Copy + ::unity::ClassIdentity>(
491 playable: impl ::core::convert::Into<M0>,
492 value: impl ::core::convert::Into<bool>,
493 ) -> () {
494 static OPEN: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
495 ::unity::lookup::method_info_on_class(<PlayableExtensions as ::unity::ClassIdentity>::class(), "SetDone", 2)
496 });
497 #[allow(clippy::type_complexity)]
498 static CACHE: ::std::sync::OnceLock<::std::sync::Mutex<::std::collections::HashMap<usize, &'static ::unity::il2cpp::MethodInfo>>> =
499 ::std::sync::OnceLock::new();
500 let _ = true;
501 let __open: &'static ::unity::il2cpp::MethodInfo = match &*OPEN {
502 ::core::result::Result::Ok(mi) => *mi,
503 ::core::result::Result::Err(e) => {
504 panic!(
505 "method lookup failed: {}
506::{}
507: {}
508",
509 <PlayableExtensions as ::unity::ClassIdentity>::NAME,
510 "SetDone",
511 e
512 )
513 },
514 };
515 let __cache = CACHE.get_or_init(|| ::std::sync::Mutex::new(::std::collections::HashMap::new()));
516 let __key: usize = <M0 as ::unity::IlType>::il_type() as *const _ as usize;
517 let __inflated: &'static ::unity::il2cpp::MethodInfo = {
518 let mut __guard = __cache.lock().unwrap();
519 *__guard
520 .entry(__key)
521 .or_insert_with(|| ::unity::il2cpp::generic::create_generic_method_info(__open, &[<M0 as ::unity::IlType>::il_type()]))
522 };
523 unsafe {
524 let __f: extern "C" fn(M0, bool, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__inflated.method_ptr);
525 let __mi_opaque: &'static () = &*(__inflated as *const _ as *const ());
526 __f(
527 ::core::convert::Into::into(playable),
528 ::core::convert::Into::into(value),
529 ::core::option::Option::Some(__mi_opaque),
530 )
531 }
532 }
533
534 pub fn is_done<M0: ::unity::IlType + ::core::marker::Copy + ::unity::ClassIdentity>(playable: impl ::core::convert::Into<M0>) -> bool {
535 static OPEN: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
536 ::unity::lookup::method_info_on_class(<PlayableExtensions as ::unity::ClassIdentity>::class(), "IsDone", 1)
537 });
538 #[allow(clippy::type_complexity)]
539 static CACHE: ::std::sync::OnceLock<::std::sync::Mutex<::std::collections::HashMap<usize, &'static ::unity::il2cpp::MethodInfo>>> =
540 ::std::sync::OnceLock::new();
541 let _ = true;
542 let __open: &'static ::unity::il2cpp::MethodInfo = match &*OPEN {
543 ::core::result::Result::Ok(mi) => *mi,
544 ::core::result::Result::Err(e) => {
545 panic!(
546 "method lookup failed: {}
547::{}
548: {}
549",
550 <PlayableExtensions as ::unity::ClassIdentity>::NAME,
551 "IsDone",
552 e
553 )
554 },
555 };
556 let __cache = CACHE.get_or_init(|| ::std::sync::Mutex::new(::std::collections::HashMap::new()));
557 let __key: usize = <M0 as ::unity::IlType>::il_type() as *const _ as usize;
558 let __inflated: &'static ::unity::il2cpp::MethodInfo = {
559 let mut __guard = __cache.lock().unwrap();
560 *__guard
561 .entry(__key)
562 .or_insert_with(|| ::unity::il2cpp::generic::create_generic_method_info(__open, &[<M0 as ::unity::IlType>::il_type()]))
563 };
564 unsafe {
565 let __f: extern "C" fn(M0, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__inflated.method_ptr);
566 let __mi_opaque: &'static () = &*(__inflated as *const _ as *const ());
567 __f(::core::convert::Into::into(playable), ::core::option::Option::Some(__mi_opaque))
568 }
569 }
570
571 pub fn set_propagate_set_time<M0: ::unity::IlType + ::core::marker::Copy + ::unity::ClassIdentity>(
572 playable: impl ::core::convert::Into<M0>,
573 value: impl ::core::convert::Into<bool>,
574 ) -> () {
575 static OPEN: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
576 ::unity::lookup::method_info_on_class(<PlayableExtensions as ::unity::ClassIdentity>::class(), "SetPropagateSetTime", 2)
577 });
578 #[allow(clippy::type_complexity)]
579 static CACHE: ::std::sync::OnceLock<::std::sync::Mutex<::std::collections::HashMap<usize, &'static ::unity::il2cpp::MethodInfo>>> =
580 ::std::sync::OnceLock::new();
581 let _ = true;
582 let __open: &'static ::unity::il2cpp::MethodInfo = match &*OPEN {
583 ::core::result::Result::Ok(mi) => *mi,
584 ::core::result::Result::Err(e) => {
585 panic!(
586 "method lookup failed: {}
587::{}
588: {}
589",
590 <PlayableExtensions as ::unity::ClassIdentity>::NAME,
591 "SetPropagateSetTime",
592 e
593 )
594 },
595 };
596 let __cache = CACHE.get_or_init(|| ::std::sync::Mutex::new(::std::collections::HashMap::new()));
597 let __key: usize = <M0 as ::unity::IlType>::il_type() as *const _ as usize;
598 let __inflated: &'static ::unity::il2cpp::MethodInfo = {
599 let mut __guard = __cache.lock().unwrap();
600 *__guard
601 .entry(__key)
602 .or_insert_with(|| ::unity::il2cpp::generic::create_generic_method_info(__open, &[<M0 as ::unity::IlType>::il_type()]))
603 };
604 unsafe {
605 let __f: extern "C" fn(M0, bool, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__inflated.method_ptr);
606 let __mi_opaque: &'static () = &*(__inflated as *const _ as *const ());
607 __f(
608 ::core::convert::Into::into(playable),
609 ::core::convert::Into::into(value),
610 ::core::option::Option::Some(__mi_opaque),
611 )
612 }
613 }
614
615 pub fn set_input_count<M0: ::unity::IlType + ::core::marker::Copy + ::unity::ClassIdentity>(
616 playable: impl ::core::convert::Into<M0>,
617 value: impl ::core::convert::Into<i32>,
618 ) -> () {
619 static OPEN: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
620 ::unity::lookup::method_info_on_class(<PlayableExtensions as ::unity::ClassIdentity>::class(), "SetInputCount", 2)
621 });
622 #[allow(clippy::type_complexity)]
623 static CACHE: ::std::sync::OnceLock<::std::sync::Mutex<::std::collections::HashMap<usize, &'static ::unity::il2cpp::MethodInfo>>> =
624 ::std::sync::OnceLock::new();
625 let _ = true;
626 let __open: &'static ::unity::il2cpp::MethodInfo = match &*OPEN {
627 ::core::result::Result::Ok(mi) => *mi,
628 ::core::result::Result::Err(e) => {
629 panic!(
630 "method lookup failed: {}
631::{}
632: {}
633",
634 <PlayableExtensions as ::unity::ClassIdentity>::NAME,
635 "SetInputCount",
636 e
637 )
638 },
639 };
640 let __cache = CACHE.get_or_init(|| ::std::sync::Mutex::new(::std::collections::HashMap::new()));
641 let __key: usize = <M0 as ::unity::IlType>::il_type() as *const _ as usize;
642 let __inflated: &'static ::unity::il2cpp::MethodInfo = {
643 let mut __guard = __cache.lock().unwrap();
644 *__guard
645 .entry(__key)
646 .or_insert_with(|| ::unity::il2cpp::generic::create_generic_method_info(__open, &[<M0 as ::unity::IlType>::il_type()]))
647 };
648 unsafe {
649 let __f: extern "C" fn(M0, i32, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__inflated.method_ptr);
650 let __mi_opaque: &'static () = &*(__inflated as *const _ as *const ());
651 __f(
652 ::core::convert::Into::into(playable),
653 ::core::convert::Into::into(value),
654 ::core::option::Option::Some(__mi_opaque),
655 )
656 }
657 }
658
659 pub fn get_input_count<M0: ::unity::IlType + ::core::marker::Copy + ::unity::ClassIdentity>(playable: impl ::core::convert::Into<M0>) -> i32 {
660 static OPEN: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
661 ::unity::lookup::method_info_on_class(<PlayableExtensions as ::unity::ClassIdentity>::class(), "GetInputCount", 1)
662 });
663 #[allow(clippy::type_complexity)]
664 static CACHE: ::std::sync::OnceLock<::std::sync::Mutex<::std::collections::HashMap<usize, &'static ::unity::il2cpp::MethodInfo>>> =
665 ::std::sync::OnceLock::new();
666 let _ = true;
667 let __open: &'static ::unity::il2cpp::MethodInfo = match &*OPEN {
668 ::core::result::Result::Ok(mi) => *mi,
669 ::core::result::Result::Err(e) => {
670 panic!(
671 "method lookup failed: {}
672::{}
673: {}
674",
675 <PlayableExtensions as ::unity::ClassIdentity>::NAME,
676 "GetInputCount",
677 e
678 )
679 },
680 };
681 let __cache = CACHE.get_or_init(|| ::std::sync::Mutex::new(::std::collections::HashMap::new()));
682 let __key: usize = <M0 as ::unity::IlType>::il_type() as *const _ as usize;
683 let __inflated: &'static ::unity::il2cpp::MethodInfo = {
684 let mut __guard = __cache.lock().unwrap();
685 *__guard
686 .entry(__key)
687 .or_insert_with(|| ::unity::il2cpp::generic::create_generic_method_info(__open, &[<M0 as ::unity::IlType>::il_type()]))
688 };
689 unsafe {
690 let __f: extern "C" fn(M0, ::unity::OptionalMethod) -> i32 = ::core::mem::transmute(__inflated.method_ptr);
691 let __mi_opaque: &'static () = &*(__inflated as *const _ as *const ());
692 __f(::core::convert::Into::into(playable), ::core::option::Option::Some(__mi_opaque))
693 }
694 }
695
696 pub fn get_input<M0: ::unity::IlType + ::core::marker::Copy + ::unity::ClassIdentity>(
697 playable: impl ::core::convert::Into<M0>,
698 input_port: impl ::core::convert::Into<i32>,
699 ) -> crate::unity_engine::playables::playable::Playable {
700 static OPEN: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
701 ::unity::lookup::method_info_on_class(<PlayableExtensions as ::unity::ClassIdentity>::class(), "GetInput", 2)
702 });
703 #[allow(clippy::type_complexity)]
704 static CACHE: ::std::sync::OnceLock<::std::sync::Mutex<::std::collections::HashMap<usize, &'static ::unity::il2cpp::MethodInfo>>> =
705 ::std::sync::OnceLock::new();
706 let _ = true;
707 let __open: &'static ::unity::il2cpp::MethodInfo = match &*OPEN {
708 ::core::result::Result::Ok(mi) => *mi,
709 ::core::result::Result::Err(e) => {
710 panic!(
711 "method lookup failed: {}
712::{}
713: {}
714",
715 <PlayableExtensions as ::unity::ClassIdentity>::NAME,
716 "GetInput",
717 e
718 )
719 },
720 };
721 let __cache = CACHE.get_or_init(|| ::std::sync::Mutex::new(::std::collections::HashMap::new()));
722 let __key: usize = <M0 as ::unity::IlType>::il_type() as *const _ as usize;
723 let __inflated: &'static ::unity::il2cpp::MethodInfo = {
724 let mut __guard = __cache.lock().unwrap();
725 *__guard
726 .entry(__key)
727 .or_insert_with(|| ::unity::il2cpp::generic::create_generic_method_info(__open, &[<M0 as ::unity::IlType>::il_type()]))
728 };
729 unsafe {
730 let __f: extern "C" fn(M0, i32, ::unity::OptionalMethod) -> crate::unity_engine::playables::playable::Playable =
731 ::core::mem::transmute(__inflated.method_ptr);
732 let __mi_opaque: &'static () = &*(__inflated as *const _ as *const ());
733 __f(
734 ::core::convert::Into::into(playable),
735 ::core::convert::Into::into(input_port),
736 ::core::option::Option::Some(__mi_opaque),
737 )
738 }
739 }
740
741 pub fn set_input_weight<M0: ::unity::IlType + ::core::marker::Copy + ::unity::ClassIdentity>(
742 playable: impl ::core::convert::Into<M0>,
743 input_index: impl ::core::convert::Into<i32>,
744 weight: impl ::core::convert::Into<f32>,
745 ) -> () {
746 static OPEN: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
747 ::unity::lookup::method_info_on_class(<PlayableExtensions as ::unity::ClassIdentity>::class(), "SetInputWeight", 3)
748 });
749 #[allow(clippy::type_complexity)]
750 static CACHE: ::std::sync::OnceLock<::std::sync::Mutex<::std::collections::HashMap<usize, &'static ::unity::il2cpp::MethodInfo>>> =
751 ::std::sync::OnceLock::new();
752 let _ = true;
753 let __open: &'static ::unity::il2cpp::MethodInfo = match &*OPEN {
754 ::core::result::Result::Ok(mi) => *mi,
755 ::core::result::Result::Err(e) => {
756 panic!(
757 "method lookup failed: {}
758::{}
759: {}
760",
761 <PlayableExtensions as ::unity::ClassIdentity>::NAME,
762 "SetInputWeight",
763 e
764 )
765 },
766 };
767 let __cache = CACHE.get_or_init(|| ::std::sync::Mutex::new(::std::collections::HashMap::new()));
768 let __key: usize = <M0 as ::unity::IlType>::il_type() as *const _ as usize;
769 let __inflated: &'static ::unity::il2cpp::MethodInfo = {
770 let mut __guard = __cache.lock().unwrap();
771 *__guard
772 .entry(__key)
773 .or_insert_with(|| ::unity::il2cpp::generic::create_generic_method_info(__open, &[<M0 as ::unity::IlType>::il_type()]))
774 };
775 unsafe {
776 let __f: extern "C" fn(M0, i32, f32, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__inflated.method_ptr);
777 let __mi_opaque: &'static () = &*(__inflated as *const _ as *const ());
778 __f(
779 ::core::convert::Into::into(playable),
780 ::core::convert::Into::into(input_index),
781 ::core::convert::Into::into(weight),
782 ::core::option::Option::Some(__mi_opaque),
783 )
784 }
785 }
786
787 pub fn set_input_weight_2<
788 M0: ::unity::IlType + ::core::marker::Copy + ::unity::ClassIdentity,
789 M1: ::unity::IlType + ::core::marker::Copy + ::unity::ClassIdentity,
790 >(
791 playable: impl ::core::convert::Into<M0>,
792 input: impl ::core::convert::Into<M1>,
793 weight: impl ::core::convert::Into<f32>,
794 ) -> () {
795 static OPEN: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
796 ::unity::lookup::method_info_on_class(<PlayableExtensions as ::unity::ClassIdentity>::class(), "SetInputWeight", 3)
797 });
798 #[allow(clippy::type_complexity)]
799 static CACHE: ::std::sync::OnceLock<::std::sync::Mutex<::std::collections::HashMap<usize, &'static ::unity::il2cpp::MethodInfo>>> =
800 ::std::sync::OnceLock::new();
801 let _ = true;
802 let __open: &'static ::unity::il2cpp::MethodInfo = match &*OPEN {
803 ::core::result::Result::Ok(mi) => *mi,
804 ::core::result::Result::Err(e) => {
805 panic!(
806 "method lookup failed: {}
807::{}
808: {}
809",
810 <PlayableExtensions as ::unity::ClassIdentity>::NAME,
811 "SetInputWeight",
812 e
813 )
814 },
815 };
816 let __cache = CACHE.get_or_init(|| ::std::sync::Mutex::new(::std::collections::HashMap::new()));
817 let __key: usize = (<M0 as ::unity::IlType>::il_type() as *const _ as usize) ^ (<M1 as ::unity::IlType>::il_type() as *const _ as usize);
818 let __inflated: &'static ::unity::il2cpp::MethodInfo = {
819 let mut __guard = __cache.lock().unwrap();
820 *__guard.entry(__key).or_insert_with(|| {
821 ::unity::il2cpp::generic::create_generic_method_info(__open, &[
822 <M0 as ::unity::IlType>::il_type(),
823 <M1 as ::unity::IlType>::il_type(),
824 ])
825 })
826 };
827 unsafe {
828 let __f: extern "C" fn(M0, M1, f32, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__inflated.method_ptr);
829 let __mi_opaque: &'static () = &*(__inflated as *const _ as *const ());
830 __f(
831 ::core::convert::Into::into(playable),
832 ::core::convert::Into::into(input),
833 ::core::convert::Into::into(weight),
834 ::core::option::Option::Some(__mi_opaque),
835 )
836 }
837 }
838
839 pub fn get_input_weight<M0: ::unity::IlType + ::core::marker::Copy + ::unity::ClassIdentity>(
840 playable: impl ::core::convert::Into<M0>,
841 input_index: impl ::core::convert::Into<i32>,
842 ) -> f32 {
843 static OPEN: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
844 ::unity::lookup::method_info_on_class(<PlayableExtensions as ::unity::ClassIdentity>::class(), "GetInputWeight", 2)
845 });
846 #[allow(clippy::type_complexity)]
847 static CACHE: ::std::sync::OnceLock<::std::sync::Mutex<::std::collections::HashMap<usize, &'static ::unity::il2cpp::MethodInfo>>> =
848 ::std::sync::OnceLock::new();
849 let _ = true;
850 let __open: &'static ::unity::il2cpp::MethodInfo = match &*OPEN {
851 ::core::result::Result::Ok(mi) => *mi,
852 ::core::result::Result::Err(e) => {
853 panic!(
854 "method lookup failed: {}
855::{}
856: {}
857",
858 <PlayableExtensions as ::unity::ClassIdentity>::NAME,
859 "GetInputWeight",
860 e
861 )
862 },
863 };
864 let __cache = CACHE.get_or_init(|| ::std::sync::Mutex::new(::std::collections::HashMap::new()));
865 let __key: usize = <M0 as ::unity::IlType>::il_type() as *const _ as usize;
866 let __inflated: &'static ::unity::il2cpp::MethodInfo = {
867 let mut __guard = __cache.lock().unwrap();
868 *__guard
869 .entry(__key)
870 .or_insert_with(|| ::unity::il2cpp::generic::create_generic_method_info(__open, &[<M0 as ::unity::IlType>::il_type()]))
871 };
872 unsafe {
873 let __f: extern "C" fn(M0, i32, ::unity::OptionalMethod) -> f32 = ::core::mem::transmute(__inflated.method_ptr);
874 let __mi_opaque: &'static () = &*(__inflated as *const _ as *const ());
875 __f(
876 ::core::convert::Into::into(playable),
877 ::core::convert::Into::into(input_index),
878 ::core::option::Option::Some(__mi_opaque),
879 )
880 }
881 }
882
883 pub fn set_traversal_mode<M0: ::unity::IlType + ::core::marker::Copy + ::unity::ClassIdentity>(
884 playable: impl ::core::convert::Into<M0>,
885 mode: impl ::core::convert::Into<crate::unity_engine::playables::playabletraversalmode::PlayableTraversalMode>,
886 ) -> () {
887 static OPEN: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
888 ::unity::lookup::method_info_on_class(<PlayableExtensions as ::unity::ClassIdentity>::class(), "SetTraversalMode", 2)
889 });
890 #[allow(clippy::type_complexity)]
891 static CACHE: ::std::sync::OnceLock<::std::sync::Mutex<::std::collections::HashMap<usize, &'static ::unity::il2cpp::MethodInfo>>> =
892 ::std::sync::OnceLock::new();
893 let _ = true;
894 let __open: &'static ::unity::il2cpp::MethodInfo = match &*OPEN {
895 ::core::result::Result::Ok(mi) => *mi,
896 ::core::result::Result::Err(e) => {
897 panic!(
898 "method lookup failed: {}
899::{}
900: {}
901",
902 <PlayableExtensions as ::unity::ClassIdentity>::NAME,
903 "SetTraversalMode",
904 e
905 )
906 },
907 };
908 let __cache = CACHE.get_or_init(|| ::std::sync::Mutex::new(::std::collections::HashMap::new()));
909 let __key: usize = <M0 as ::unity::IlType>::il_type() as *const _ as usize;
910 let __inflated: &'static ::unity::il2cpp::MethodInfo = {
911 let mut __guard = __cache.lock().unwrap();
912 *__guard
913 .entry(__key)
914 .or_insert_with(|| ::unity::il2cpp::generic::create_generic_method_info(__open, &[<M0 as ::unity::IlType>::il_type()]))
915 };
916 unsafe {
917 let __f: extern "C" fn(M0, crate::unity_engine::playables::playabletraversalmode::PlayableTraversalMode, ::unity::OptionalMethod) -> () =
918 ::core::mem::transmute(__inflated.method_ptr);
919 let __mi_opaque: &'static () = &*(__inflated as *const _ as *const ());
920 __f(
921 ::core::convert::Into::into(playable),
922 ::core::convert::Into::into(mode),
923 ::core::option::Option::Some(__mi_opaque),
924 )
925 }
926 }
927
928 pub fn get_time_wrap_mode<M0: ::unity::IlType + ::core::marker::Copy + ::unity::ClassIdentity>(
929 playable: impl ::core::convert::Into<M0>,
930 ) -> crate::unity_engine::playables::directorwrapmode::DirectorWrapMode {
931 static OPEN: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
932 ::unity::lookup::method_info_on_class(<PlayableExtensions as ::unity::ClassIdentity>::class(), "GetTimeWrapMode", 1)
933 });
934 #[allow(clippy::type_complexity)]
935 static CACHE: ::std::sync::OnceLock<::std::sync::Mutex<::std::collections::HashMap<usize, &'static ::unity::il2cpp::MethodInfo>>> =
936 ::std::sync::OnceLock::new();
937 let _ = true;
938 let __open: &'static ::unity::il2cpp::MethodInfo = match &*OPEN {
939 ::core::result::Result::Ok(mi) => *mi,
940 ::core::result::Result::Err(e) => {
941 panic!(
942 "method lookup failed: {}
943::{}
944: {}
945",
946 <PlayableExtensions as ::unity::ClassIdentity>::NAME,
947 "GetTimeWrapMode",
948 e
949 )
950 },
951 };
952 let __cache = CACHE.get_or_init(|| ::std::sync::Mutex::new(::std::collections::HashMap::new()));
953 let __key: usize = <M0 as ::unity::IlType>::il_type() as *const _ as usize;
954 let __inflated: &'static ::unity::il2cpp::MethodInfo = {
955 let mut __guard = __cache.lock().unwrap();
956 *__guard
957 .entry(__key)
958 .or_insert_with(|| ::unity::il2cpp::generic::create_generic_method_info(__open, &[<M0 as ::unity::IlType>::il_type()]))
959 };
960 unsafe {
961 let __f: extern "C" fn(M0, ::unity::OptionalMethod) -> crate::unity_engine::playables::directorwrapmode::DirectorWrapMode =
962 ::core::mem::transmute(__inflated.method_ptr);
963 let __mi_opaque: &'static () = &*(__inflated as *const _ as *const ());
964 __f(::core::convert::Into::into(playable), ::core::option::Option::Some(__mi_opaque))
965 }
966 }
967
968 pub fn set_time_wrap_mode<M0: ::unity::IlType + ::core::marker::Copy + ::unity::ClassIdentity>(
969 playable: impl ::core::convert::Into<M0>,
970 value: impl ::core::convert::Into<crate::unity_engine::playables::directorwrapmode::DirectorWrapMode>,
971 ) -> () {
972 static OPEN: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
973 ::unity::lookup::method_info_on_class(<PlayableExtensions as ::unity::ClassIdentity>::class(), "SetTimeWrapMode", 2)
974 });
975 #[allow(clippy::type_complexity)]
976 static CACHE: ::std::sync::OnceLock<::std::sync::Mutex<::std::collections::HashMap<usize, &'static ::unity::il2cpp::MethodInfo>>> =
977 ::std::sync::OnceLock::new();
978 let _ = true;
979 let __open: &'static ::unity::il2cpp::MethodInfo = match &*OPEN {
980 ::core::result::Result::Ok(mi) => *mi,
981 ::core::result::Result::Err(e) => {
982 panic!(
983 "method lookup failed: {}
984::{}
985: {}
986",
987 <PlayableExtensions as ::unity::ClassIdentity>::NAME,
988 "SetTimeWrapMode",
989 e
990 )
991 },
992 };
993 let __cache = CACHE.get_or_init(|| ::std::sync::Mutex::new(::std::collections::HashMap::new()));
994 let __key: usize = <M0 as ::unity::IlType>::il_type() as *const _ as usize;
995 let __inflated: &'static ::unity::il2cpp::MethodInfo = {
996 let mut __guard = __cache.lock().unwrap();
997 *__guard
998 .entry(__key)
999 .or_insert_with(|| ::unity::il2cpp::generic::create_generic_method_info(__open, &[<M0 as ::unity::IlType>::il_type()]))
1000 };
1001 unsafe {
1002 let __f: extern "C" fn(M0, crate::unity_engine::playables::directorwrapmode::DirectorWrapMode, ::unity::OptionalMethod) -> () =
1003 ::core::mem::transmute(__inflated.method_ptr);
1004 let __mi_opaque: &'static () = &*(__inflated as *const _ as *const ());
1005 __f(
1006 ::core::convert::Into::into(playable),
1007 ::core::convert::Into::into(value),
1008 ::core::option::Option::Some(__mi_opaque),
1009 )
1010 }
1011 }
1012}
1013
1014#[cfg(feature = "unity_engine-playables-playableextensions")]
1015#[doc(hidden)]
1016pub mod prelude {
1017 pub use super::{IPlayableExtensions, PlayableExtensions};
1018 pub use crate::system::object::IObject;
1019 #[cfg(feature = "system-object")]
1020 pub use crate::system::object::IObjectMethods;
1021}