1#[cfg(feature = "app-soundsystem-types")]
4mod __types {
5 #[allow(unused_imports)] use ::unity::prelude::*;
6
7 use super::*;
8 use crate::system::{
9 object::{IObject, Object},
10 r#enum::{Enum, IEnum},
11 valuetype::{IValueType, ValueType},
12 };
13
14 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/soundsystem/SoundSystem_ResultSoundLoad_Status.md"))]
15 #[repr(C)]
16 #[derive(::core::clone::Clone, ::core::marker::Copy, ::core::fmt::Debug, ::core::cmp::PartialEq, ::core::cmp::Eq)]
17 pub struct SoundSystem_ResultSoundLoad_Status {
18 pub value: i32,
19 }
20 impl ::unity::ClassIdentity for SoundSystem_ResultSoundLoad_Status {
21 const NAME: &'static str = "SoundSystem.ResultSoundLoad.Status";
22 const NAMESPACE: &'static str = "App";
23
24 fn class() -> ::unity::Class {
25 static CACHE: ::std::sync::OnceLock<::unity::Class> = ::std::sync::OnceLock::new();
26 *CACHE.get_or_init(|| ::unity::Class::lookup(Self::NAMESPACE, Self::NAME))
27 }
28 }
29 impl ::unity::IlType for SoundSystem_ResultSoundLoad_Status {
30 fn il_type() -> &'static ::unity::il2cpp::Il2CppType {
31 &<Self as ::unity::ClassIdentity>::class().raw()._1.byval_arg
32 }
33 }
34 impl SoundSystem_ResultSoundLoad_Status {
35 pub fn load() -> Self {
36 Self { value: 0 }
37 }
38
39 pub fn success() -> Self {
40 Self { value: 1 }
41 }
42
43 pub fn fault() -> Self {
44 Self { value: 2 }
45 }
46 }
47
48 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/soundsystem/SoundSystem_ResultSoundLoad.md"))]
49 #[::unity::class(namespace = "App", name = "SoundSystem.ResultSoundLoad")]
50 #[parent(crate::system::object::Object)]
51 pub struct SoundSystem_ResultSoundLoad {
52 #[offset(16)]
53 #[rename(name = "m_status")]
54 pub m_status: crate::app::soundsystem::SoundSystem_ResultSoundLoad_Status,
55 }
56
57 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/soundsystem/SoundSystem_ISoundLoad.md"))]
58 #[::unity::class(namespace = "App", name = "SoundSystem.ISoundLoad")]
59 pub struct SoundSystem_ISoundLoad {}
60
61 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/soundsystem/SoundSystem_SoundHandle.md"))]
62 #[::unity::class(namespace = "App", name = "SoundSystem.SoundHandle")]
63 #[parent(crate::system::object::Object)]
64 pub struct SoundSystem_SoundHandle {}
65
66 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/soundsystem/SoundSystem_ISoundPlay.md"))]
67 #[::unity::class(namespace = "App", name = "SoundSystem.ISoundPlay")]
68 pub struct SoundSystem_ISoundPlay {}
69
70 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/soundsystem/SoundSystem_LipSyncDataFile.md"))]
71 #[::unity::class(namespace = "App", name = "SoundSystem.LipSyncDataFile")]
72 #[parent(crate::system::object::Object)]
73 pub struct SoundSystem_LipSyncDataFile {
74 #[static_field]
75 #[rename(name = "LoadDirectoryMax")]
76 pub load_directory_max: i32,
77 #[offset(16)]
78 #[rename(name = "m_isExpandFileData")]
79 pub m_is_expand_file_data: bool,
80 #[offset(24)]
81 #[rename(name = "m_lipSyncDataList")]
82 pub m_lip_sync_data_list: crate::system::collections::generic::list_1::List_1<crate::app::soundsystem::SoundSystem_LipSyncData>,
83 #[offset(32)]
84 #[rename(name = "m_rawFileHandle")]
85 pub m_raw_file_handle: ::unity::Array<crate::app::rawfilehandle::RawFileHandle>,
86 }
87
88 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/soundsystem/SoundSystem_LipSyncStructData.md"))]
89 #[repr(C)]
90 #[derive(::core::clone::Clone, ::core::marker::Copy)]
91 pub struct SoundSystem_LipSyncStructData {
92 pub m_msec: i32,
93 pub m_width: f32,
94 pub m_height: f32,
95 pub m_tongue: f32,
96 pub m_a: f32,
97 pub m_i: f32,
98 pub m_u: f32,
99 pub m_e: f32,
100 pub m_o: f32,
101 pub m_vol: f32,
102 }
103 impl ::unity::ClassIdentity for SoundSystem_LipSyncStructData {
104 const NAME: &'static str = "SoundSystem.LipSyncStructData";
105 const NAMESPACE: &'static str = "App";
106
107 fn class() -> ::unity::Class {
108 static CACHE: ::std::sync::OnceLock<::unity::Class> = ::std::sync::OnceLock::new();
109 *CACHE.get_or_init(|| ::unity::Class::lookup(Self::NAMESPACE, Self::NAME))
110 }
111 }
112 impl ::unity::IlType for SoundSystem_LipSyncStructData {
113 fn il_type() -> &'static ::unity::il2cpp::Il2CppType {
114 &<Self as ::unity::ClassIdentity>::class().raw()._1.byval_arg
115 }
116 }
117
118 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/soundsystem/SoundSystem_LipSyncData.md"))]
119 #[::unity::class(namespace = "App", name = "SoundSystem.LipSyncData")]
120 #[parent(crate::system::object::Object)]
121 pub struct SoundSystem_LipSyncData {
122 #[offset(16)]
123 #[rename(name = "m_data")]
124 pub m_data: crate::app::soundsystem::SoundSystem_LipSyncStructData,
125 }
126
127 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/soundsystem/SoundSystem_ResultSoundLoadList.md"))]
128 #[::unity::class(namespace = "App", name = "SoundSystem.ResultSoundLoadList")]
129 #[parent(crate::system::object::Object)]
130 pub struct SoundSystem_ResultSoundLoadList {
131 #[offset(16)]
132 #[rename(name = "m_resultList")]
133 pub m_result_list: crate::system::collections::generic::list_1::List_1<crate::app::soundsystem::SoundSystem_ResultSoundLoad>,
134 }
135
136 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/soundsystem/SoundSystem.md"))]
137 #[::unity::class(namespace = "App", name = "SoundSystem")]
138 #[parent(crate::system::object::Object)]
139 pub struct SoundSystem {
140 #[static_field]
141 #[rename(name = "SoundHandleCount")]
142 pub sound_handle_count: i32,
143 }
144
145 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/soundsystem/SoundSystem_ISoundParam.md"))]
146 #[::unity::class(namespace = "App", name = "SoundSystem.ISoundParam")]
147 pub struct SoundSystem_ISoundParam {}
148}
149
150#[cfg(feature = "app-soundsystem-types")]
151pub use __types::*;
152
153#[cfg(feature = "app-soundsystem")]
154impl SoundSystem_ResultSoundLoad {
155 #[doc = "`LoadAsyncCallback(u32, ::unity::IntPtr, crate::root::akresult::AKRESULT, crate::system::object::Object)` overload"]
156 pub fn load_async_callback(
157 bank_id: impl ::core::convert::Into<u32>,
158 p_in_memory_bank_ptr: impl ::core::convert::Into<::unity::IntPtr>,
159 load_result: impl ::core::convert::Into<crate::root::akresult::AKRESULT>,
160 cookie: impl ::core::convert::Into<crate::system::object::Object>,
161 ) -> () {
162 unsafe {
163 ::unity::il2cpp_call!((::unity::module_base()+0x1d7e100usize)as*mut u8,();
164(u32)::core::convert::Into::into(bank_id),(::unity::IntPtr)::core::convert::Into::into(p_in_memory_bank_ptr),(crate::root::akresult::AKRESULT)::core::convert::Into::into(load_result),(crate::system::object::Object)::core::convert::Into::into(cookie))
165 }
166 }
167}
168
169#[cfg(feature = "app-soundsystem")]
170pub trait ISoundSystem_ResultSoundLoadMethods: ISoundSystem_ResultSoundLoad {
171 #[doc = "`.ctor()` overload"]
172 fn ctor(self) -> () {
173 unsafe {
174 let __receiver =
175 <SoundSystem_ResultSoundLoad as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
176 ::unity::il2cpp_call!((::unity::module_base()+0x1d7e0b0usize)as*mut u8,();
177(SoundSystem_ResultSoundLoad)__receiver)
178 }
179 }
180 #[doc = "`SetStatus(crate::app::soundsystem::SoundSystem_ResultSoundLoad_Status)` overload"]
181 fn set_status(self, status: impl ::core::convert::Into<crate::app::soundsystem::SoundSystem_ResultSoundLoad_Status>) -> () {
182 unsafe {
183 let __receiver =
184 <SoundSystem_ResultSoundLoad as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
185 ::unity::il2cpp_call!((::unity::module_base()+0x1d7e0c0usize)as*mut u8,();
186(SoundSystem_ResultSoundLoad)__receiver,(crate::app::soundsystem::SoundSystem_ResultSoundLoad_Status)::core::convert::Into::into(status))
187 }
188 }
189 #[doc = "`IsLoading()` overload"]
190 fn is_loading(self) -> bool {
191 unsafe {
192 let __receiver =
193 <SoundSystem_ResultSoundLoad as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
194 ::unity::il2cpp_call!((::unity::module_base()+0x1d7e0d0usize)as*mut u8,bool;
195(SoundSystem_ResultSoundLoad)__receiver)
196 }
197 }
198 #[doc = "`IsLoadSuccess()` overload"]
199 fn is_load_success(self) -> bool {
200 unsafe {
201 let __receiver =
202 <SoundSystem_ResultSoundLoad as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
203 ::unity::il2cpp_call!((::unity::module_base()+0x1d7e0e0usize)as*mut u8,bool;
204(SoundSystem_ResultSoundLoad)__receiver)
205 }
206 }
207 #[doc = "`IsLoadFault()` overload"]
208 fn is_load_fault(self) -> bool {
209 unsafe {
210 let __receiver =
211 <SoundSystem_ResultSoundLoad as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
212 ::unity::il2cpp_call!((::unity::module_base()+0x1d7e0f0usize)as*mut u8,bool;
213(SoundSystem_ResultSoundLoad)__receiver)
214 }
215 }
216}
217
218#[cfg(feature = "app-soundsystem")]
219impl<__T: ISoundSystem_ResultSoundLoad> ISoundSystem_ResultSoundLoadMethods for __T {}
220
221#[cfg(feature = "app-soundsystem")]
222impl SoundSystem_ResultSoundLoad {
223 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
224 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
225 }
226
227 pub fn set_status_method_info() -> &'static ::unity::il2cpp::MethodInfo {
228 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
229 }
230
231 pub fn is_loading_method_info() -> &'static ::unity::il2cpp::MethodInfo {
232 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
233 }
234
235 pub fn is_load_success_method_info() -> &'static ::unity::il2cpp::MethodInfo {
236 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
237 }
238
239 pub fn is_load_fault_method_info() -> &'static ::unity::il2cpp::MethodInfo {
240 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
241 }
242
243 pub fn load_async_callback_method_info() -> &'static ::unity::il2cpp::MethodInfo {
244 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[5]
245 }
246}
247
248#[cfg(feature = "app-soundsystem")]
249impl SoundSystem_ResultSoundLoad {
250 #[doc = "`.ctor()` — no args"]
251 pub fn new() -> Self {
252 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
253 panic!(
254 "{}
255::{}
256 failed to instantiate",
257 ::core::stringify!(SoundSystem_ResultSoundLoad),
258 ::core::stringify!(new),
259 )
260 });
261 <Self as ISoundSystem_ResultSoundLoadMethods>::ctor(this);
262 this
263 }
264}
265
266#[cfg(feature = "app-soundsystem")]
267pub trait ISoundSystem_ISoundLoadMethods: ISoundSystem_ISoundLoad {
268 #[doc = "`Load(::unity::Il2CppString)` overload"]
269 fn load(self, name: impl ::core::convert::Into<::unity::Il2CppString>) -> () {
270 unsafe {
271 let __receiver =
272 <SoundSystem_ISoundLoad as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
273 {
274 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
275 let __vi = *__vt.get(0usize).unwrap_or_else(|| {
276 panic!(
277 "unity: virtual slot {}
278 out of range (vtable len {}
279) on the runtime class behind {}
280 (method `{}
281`)",
282 0usize,
283 __vt.len(),
284 <SoundSystem_ISoundLoad as ::unity::ClassIdentity>::NAME,
285 "Load",
286 )
287 });
288 let __inner: extern "C" fn(SoundSystem_ISoundLoad, ::unity::Il2CppString, ::unity::OptionalMethod) -> () =
289 ::core::mem::transmute(__vi.method_ptr);
290 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
291 __inner(__receiver, ::core::convert::Into::into(name), __mi)
292 }
293 }
294 }
295 #[doc = "`LoadAsync(::unity::Il2CppString)` overload"]
296 fn load_async(self, name: impl ::core::convert::Into<::unity::Il2CppString>) -> () {
297 unsafe {
298 let __receiver =
299 <SoundSystem_ISoundLoad as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
300 {
301 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
302 let __vi = *__vt.get(1usize).unwrap_or_else(|| {
303 panic!(
304 "unity: virtual slot {}
305 out of range (vtable len {}
306) on the runtime class behind {}
307 (method `{}
308`)",
309 1usize,
310 __vt.len(),
311 <SoundSystem_ISoundLoad as ::unity::ClassIdentity>::NAME,
312 "LoadAsync",
313 )
314 });
315 let __inner: extern "C" fn(SoundSystem_ISoundLoad, ::unity::Il2CppString, ::unity::OptionalMethod) -> () =
316 ::core::mem::transmute(__vi.method_ptr);
317 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
318 __inner(__receiver, ::core::convert::Into::into(name), __mi)
319 }
320 }
321 }
322 #[doc = "`IsLoading()` overload"]
323 fn is_loading(self) -> bool {
324 unsafe {
325 let __receiver =
326 <SoundSystem_ISoundLoad as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
327 {
328 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
329 let __vi = *__vt.get(2usize).unwrap_or_else(|| {
330 panic!(
331 "unity: virtual slot {}
332 out of range (vtable len {}
333) on the runtime class behind {}
334 (method `{}
335`)",
336 2usize,
337 __vt.len(),
338 <SoundSystem_ISoundLoad as ::unity::ClassIdentity>::NAME,
339 "IsLoading",
340 )
341 });
342 let __inner: extern "C" fn(SoundSystem_ISoundLoad, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__vi.method_ptr);
343 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
344 __inner(__receiver, __mi)
345 }
346 }
347 }
348 #[doc = "`IsLoading(::unity::Il2CppString)` overload"]
349 fn is_loading_2(self, name: impl ::core::convert::Into<::unity::Il2CppString>) -> bool {
350 unsafe {
351 let __receiver =
352 <SoundSystem_ISoundLoad as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
353 {
354 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
355 let __vi = *__vt.get(3usize).unwrap_or_else(|| {
356 panic!(
357 "unity: virtual slot {}
358 out of range (vtable len {}
359) on the runtime class behind {}
360 (method `{}
361`)",
362 3usize,
363 __vt.len(),
364 <SoundSystem_ISoundLoad as ::unity::ClassIdentity>::NAME,
365 "IsLoading",
366 )
367 });
368 let __inner: extern "C" fn(SoundSystem_ISoundLoad, ::unity::Il2CppString, ::unity::OptionalMethod) -> bool =
369 ::core::mem::transmute(__vi.method_ptr);
370 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
371 __inner(__receiver, ::core::convert::Into::into(name), __mi)
372 }
373 }
374 }
375 #[doc = "`IsLoaded(::unity::Il2CppString)` overload"]
376 fn is_loaded(self, name: impl ::core::convert::Into<::unity::Il2CppString>) -> bool {
377 unsafe {
378 let __receiver =
379 <SoundSystem_ISoundLoad as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
380 {
381 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
382 let __vi = *__vt.get(4usize).unwrap_or_else(|| {
383 panic!(
384 "unity: virtual slot {}
385 out of range (vtable len {}
386) on the runtime class behind {}
387 (method `{}
388`)",
389 4usize,
390 __vt.len(),
391 <SoundSystem_ISoundLoad as ::unity::ClassIdentity>::NAME,
392 "IsLoaded",
393 )
394 });
395 let __inner: extern "C" fn(SoundSystem_ISoundLoad, ::unity::Il2CppString, ::unity::OptionalMethod) -> bool =
396 ::core::mem::transmute(__vi.method_ptr);
397 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
398 __inner(__receiver, ::core::convert::Into::into(name), __mi)
399 }
400 }
401 }
402 #[doc = "`Unload(::unity::Il2CppString)` overload"]
403 fn unload(self, name: impl ::core::convert::Into<::unity::Il2CppString>) -> () {
404 unsafe {
405 let __receiver =
406 <SoundSystem_ISoundLoad as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
407 {
408 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
409 let __vi = *__vt.get(5usize).unwrap_or_else(|| {
410 panic!(
411 "unity: virtual slot {}
412 out of range (vtable len {}
413) on the runtime class behind {}
414 (method `{}
415`)",
416 5usize,
417 __vt.len(),
418 <SoundSystem_ISoundLoad as ::unity::ClassIdentity>::NAME,
419 "Unload",
420 )
421 });
422 let __inner: extern "C" fn(SoundSystem_ISoundLoad, ::unity::Il2CppString, ::unity::OptionalMethod) -> () =
423 ::core::mem::transmute(__vi.method_ptr);
424 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
425 __inner(__receiver, ::core::convert::Into::into(name), __mi)
426 }
427 }
428 }
429 #[doc = "`UnloadAll()` overload"]
430 fn unload_all(self) -> () {
431 unsafe {
432 let __receiver =
433 <SoundSystem_ISoundLoad as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
434 {
435 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
436 let __vi = *__vt.get(6usize).unwrap_or_else(|| {
437 panic!(
438 "unity: virtual slot {}
439 out of range (vtable len {}
440) on the runtime class behind {}
441 (method `{}
442`)",
443 6usize,
444 __vt.len(),
445 <SoundSystem_ISoundLoad as ::unity::ClassIdentity>::NAME,
446 "UnloadAll",
447 )
448 });
449 let __inner: extern "C" fn(SoundSystem_ISoundLoad, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__vi.method_ptr);
450 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
451 __inner(__receiver, __mi)
452 }
453 }
454 }
455 #[doc = "`ReloadBySetLanguage(crate::app::language::Language_Voices)` overload"]
456 fn reload_by_set_language(self, language: impl ::core::convert::Into<crate::app::language::Language_Voices>) -> () {
457 unsafe {
458 let __receiver =
459 <SoundSystem_ISoundLoad as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
460 {
461 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
462 let __vi = *__vt.get(7usize).unwrap_or_else(|| {
463 panic!(
464 "unity: virtual slot {}
465 out of range (vtable len {}
466) on the runtime class behind {}
467 (method `{}
468`)",
469 7usize,
470 __vt.len(),
471 <SoundSystem_ISoundLoad as ::unity::ClassIdentity>::NAME,
472 "ReloadBySetLanguage",
473 )
474 });
475 let __inner: extern "C" fn(SoundSystem_ISoundLoad, crate::app::language::Language_Voices, ::unity::OptionalMethod) -> () =
476 ::core::mem::transmute(__vi.method_ptr);
477 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
478 __inner(__receiver, ::core::convert::Into::into(language), __mi)
479 }
480 }
481 }
482 #[doc = "`PrepareEvent(::unity::Il2CppString)` overload"]
483 fn prepare_event(self, event_name: impl ::core::convert::Into<::unity::Il2CppString>) -> bool {
484 unsafe {
485 let __receiver =
486 <SoundSystem_ISoundLoad as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
487 {
488 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
489 let __vi = *__vt.get(8usize).unwrap_or_else(|| {
490 panic!(
491 "unity: virtual slot {}
492 out of range (vtable len {}
493) on the runtime class behind {}
494 (method `{}
495`)",
496 8usize,
497 __vt.len(),
498 <SoundSystem_ISoundLoad as ::unity::ClassIdentity>::NAME,
499 "PrepareEvent",
500 )
501 });
502 let __inner: extern "C" fn(SoundSystem_ISoundLoad, ::unity::Il2CppString, ::unity::OptionalMethod) -> bool =
503 ::core::mem::transmute(__vi.method_ptr);
504 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
505 __inner(__receiver, ::core::convert::Into::into(event_name), __mi)
506 }
507 }
508 }
509 #[doc = "`PrepareEvent(::unity::Array<::unity::Il2CppString>)` overload"]
510 fn prepare_event_2(self, event_name_array: impl ::core::convert::Into<::unity::Array<::unity::Il2CppString>>) -> bool {
511 unsafe {
512 let __receiver =
513 <SoundSystem_ISoundLoad as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
514 {
515 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
516 let __vi = *__vt.get(9usize).unwrap_or_else(|| {
517 panic!(
518 "unity: virtual slot {}
519 out of range (vtable len {}
520) on the runtime class behind {}
521 (method `{}
522`)",
523 9usize,
524 __vt.len(),
525 <SoundSystem_ISoundLoad as ::unity::ClassIdentity>::NAME,
526 "PrepareEvent",
527 )
528 });
529 let __inner: extern "C" fn(SoundSystem_ISoundLoad, ::unity::Array<::unity::Il2CppString>, ::unity::OptionalMethod) -> bool =
530 ::core::mem::transmute(__vi.method_ptr);
531 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
532 __inner(__receiver, ::core::convert::Into::into(event_name_array), __mi)
533 }
534 }
535 }
536 #[doc = "`PrepareEventAsync(::unity::Il2CppString, *mutcrate::app::soundsystem::SoundSystem_ResultSoundLoad)` overload"]
537 fn prepare_event_async(
538 self,
539 event_name: impl ::core::convert::Into<::unity::Il2CppString>,
540 ) -> (bool, crate::app::soundsystem::SoundSystem_ResultSoundLoad) {
541 unsafe {
542 let __receiver =
543 <SoundSystem_ISoundLoad as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
544 let mut __out_0 = ::core::mem::MaybeUninit::<crate::app::soundsystem::SoundSystem_ResultSoundLoad>::uninit();
545 let __ret = {
546 {
547 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
548 let __vi = *__vt.get(10usize).unwrap_or_else(|| {
549 panic!(
550 "unity: virtual slot {}
551 out of range (vtable len {}
552) on the runtime class behind {}
553 (method `{}
554`)",
555 10usize,
556 __vt.len(),
557 <SoundSystem_ISoundLoad as ::unity::ClassIdentity>::NAME,
558 "PrepareEventAsync",
559 )
560 });
561 let __inner: extern "C" fn(
562 SoundSystem_ISoundLoad,
563 ::unity::Il2CppString,
564 *mut crate::app::soundsystem::SoundSystem_ResultSoundLoad,
565 ::unity::OptionalMethod,
566 ) -> bool = ::core::mem::transmute(__vi.method_ptr);
567 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
568 __inner(__receiver, ::core::convert::Into::into(event_name), __out_0.as_mut_ptr(), __mi)
569 }
570 };
571 (__ret, __out_0.assume_init())
572 }
573 }
574 #[doc = "`PrepareEventAsync(::unity::Array<::unity::Il2CppString>, *mutcrate::app::soundsystem::SoundSystem_ResultSoundLoad)` overload"]
575 fn prepare_event_async_2(
576 self,
577 event_name_array: impl ::core::convert::Into<::unity::Array<::unity::Il2CppString>>,
578 ) -> (bool, crate::app::soundsystem::SoundSystem_ResultSoundLoad) {
579 unsafe {
580 let __receiver =
581 <SoundSystem_ISoundLoad as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
582 let mut __out_0 = ::core::mem::MaybeUninit::<crate::app::soundsystem::SoundSystem_ResultSoundLoad>::uninit();
583 let __ret = {
584 {
585 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
586 let __vi = *__vt.get(11usize).unwrap_or_else(|| {
587 panic!(
588 "unity: virtual slot {}
589 out of range (vtable len {}
590) on the runtime class behind {}
591 (method `{}
592`)",
593 11usize,
594 __vt.len(),
595 <SoundSystem_ISoundLoad as ::unity::ClassIdentity>::NAME,
596 "PrepareEventAsync",
597 )
598 });
599 let __inner: extern "C" fn(
600 SoundSystem_ISoundLoad,
601 ::unity::Array<::unity::Il2CppString>,
602 *mut crate::app::soundsystem::SoundSystem_ResultSoundLoad,
603 ::unity::OptionalMethod,
604 ) -> bool = ::core::mem::transmute(__vi.method_ptr);
605 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
606 __inner(__receiver, ::core::convert::Into::into(event_name_array), __out_0.as_mut_ptr(), __mi)
607 }
608 };
609 (__ret, __out_0.assume_init())
610 }
611 }
612 #[doc = "`UnprepareEvent(::unity::Il2CppString)` overload"]
613 fn unprepare_event(self, event_name_array: impl ::core::convert::Into<::unity::Il2CppString>) -> () {
614 unsafe {
615 let __receiver =
616 <SoundSystem_ISoundLoad as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
617 {
618 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
619 let __vi = *__vt.get(12usize).unwrap_or_else(|| {
620 panic!(
621 "unity: virtual slot {}
622 out of range (vtable len {}
623) on the runtime class behind {}
624 (method `{}
625`)",
626 12usize,
627 __vt.len(),
628 <SoundSystem_ISoundLoad as ::unity::ClassIdentity>::NAME,
629 "UnprepareEvent",
630 )
631 });
632 let __inner: extern "C" fn(SoundSystem_ISoundLoad, ::unity::Il2CppString, ::unity::OptionalMethod) -> () =
633 ::core::mem::transmute(__vi.method_ptr);
634 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
635 __inner(__receiver, ::core::convert::Into::into(event_name_array), __mi)
636 }
637 }
638 }
639 #[doc = "`UnprepareEvent(::unity::Array<::unity::Il2CppString>)` overload"]
640 fn unprepare_event_2(self, event_name_array: impl ::core::convert::Into<::unity::Array<::unity::Il2CppString>>) -> () {
641 unsafe {
642 let __receiver =
643 <SoundSystem_ISoundLoad as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
644 {
645 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
646 let __vi = *__vt.get(13usize).unwrap_or_else(|| {
647 panic!(
648 "unity: virtual slot {}
649 out of range (vtable len {}
650) on the runtime class behind {}
651 (method `{}
652`)",
653 13usize,
654 __vt.len(),
655 <SoundSystem_ISoundLoad as ::unity::ClassIdentity>::NAME,
656 "UnprepareEvent",
657 )
658 });
659 let __inner: extern "C" fn(SoundSystem_ISoundLoad, ::unity::Array<::unity::Il2CppString>, ::unity::OptionalMethod) -> () =
660 ::core::mem::transmute(__vi.method_ptr);
661 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
662 __inner(__receiver, ::core::convert::Into::into(event_name_array), __mi)
663 }
664 }
665 }
666 #[doc = "`PrepareSwitch(::unity::Il2CppString, ::unity::Il2CppString)` overload"]
667 fn prepare_switch(
668 self,
669 switch_group_name: impl ::core::convert::Into<::unity::Il2CppString>,
670 switch_name: impl ::core::convert::Into<::unity::Il2CppString>,
671 ) -> bool {
672 unsafe {
673 let __receiver =
674 <SoundSystem_ISoundLoad as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
675 {
676 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
677 let __vi = *__vt.get(14usize).unwrap_or_else(|| {
678 panic!(
679 "unity: virtual slot {}
680 out of range (vtable len {}
681) on the runtime class behind {}
682 (method `{}
683`)",
684 14usize,
685 __vt.len(),
686 <SoundSystem_ISoundLoad as ::unity::ClassIdentity>::NAME,
687 "PrepareSwitch",
688 )
689 });
690 let __inner: extern "C" fn(SoundSystem_ISoundLoad, ::unity::Il2CppString, ::unity::Il2CppString, ::unity::OptionalMethod) -> bool =
691 ::core::mem::transmute(__vi.method_ptr);
692 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
693 __inner(
694 __receiver,
695 ::core::convert::Into::into(switch_group_name),
696 ::core::convert::Into::into(switch_name),
697 __mi,
698 )
699 }
700 }
701 }
702 #[doc = "`PrepareSwitch(::unity::Il2CppString, ::unity::Array<::unity::Il2CppString>)` overload"]
703 fn prepare_switch_2(
704 self,
705 switch_group_name: impl ::core::convert::Into<::unity::Il2CppString>,
706 switch_name_array: impl ::core::convert::Into<::unity::Array<::unity::Il2CppString>>,
707 ) -> bool {
708 unsafe {
709 let __receiver =
710 <SoundSystem_ISoundLoad as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
711 {
712 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
713 let __vi = *__vt.get(15usize).unwrap_or_else(|| {
714 panic!(
715 "unity: virtual slot {}
716 out of range (vtable len {}
717) on the runtime class behind {}
718 (method `{}
719`)",
720 15usize,
721 __vt.len(),
722 <SoundSystem_ISoundLoad as ::unity::ClassIdentity>::NAME,
723 "PrepareSwitch",
724 )
725 });
726 let __inner: extern "C" fn(
727 SoundSystem_ISoundLoad,
728 ::unity::Il2CppString,
729 ::unity::Array<::unity::Il2CppString>,
730 ::unity::OptionalMethod,
731 ) -> bool = ::core::mem::transmute(__vi.method_ptr);
732 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
733 __inner(
734 __receiver,
735 ::core::convert::Into::into(switch_group_name),
736 ::core::convert::Into::into(switch_name_array),
737 __mi,
738 )
739 }
740 }
741 }
742 #[doc = "`PrepareSwitchAsync(::unity::Il2CppString, ::unity::Il2CppString, *mutcrate::app::soundsystem::SoundSystem_ResultSoundLoad)` overload"]
743 fn prepare_switch_async(
744 self,
745 switch_group_name: impl ::core::convert::Into<::unity::Il2CppString>,
746 switch_name: impl ::core::convert::Into<::unity::Il2CppString>,
747 ) -> (bool, crate::app::soundsystem::SoundSystem_ResultSoundLoad) {
748 unsafe {
749 let __receiver =
750 <SoundSystem_ISoundLoad as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
751 let mut __out_0 = ::core::mem::MaybeUninit::<crate::app::soundsystem::SoundSystem_ResultSoundLoad>::uninit();
752 let __ret = {
753 {
754 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
755 let __vi = *__vt.get(16usize).unwrap_or_else(|| {
756 panic!(
757 "unity: virtual slot {}
758 out of range (vtable len {}
759) on the runtime class behind {}
760 (method `{}
761`)",
762 16usize,
763 __vt.len(),
764 <SoundSystem_ISoundLoad as ::unity::ClassIdentity>::NAME,
765 "PrepareSwitchAsync",
766 )
767 });
768 let __inner: extern "C" fn(
769 SoundSystem_ISoundLoad,
770 ::unity::Il2CppString,
771 ::unity::Il2CppString,
772 *mut crate::app::soundsystem::SoundSystem_ResultSoundLoad,
773 ::unity::OptionalMethod,
774 ) -> bool = ::core::mem::transmute(__vi.method_ptr);
775 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
776 __inner(
777 __receiver,
778 ::core::convert::Into::into(switch_group_name),
779 ::core::convert::Into::into(switch_name),
780 __out_0.as_mut_ptr(),
781 __mi,
782 )
783 }
784 };
785 (__ret, __out_0.assume_init())
786 }
787 }
788 #[doc = "`PrepareSwitchAsync(::unity::Il2CppString, ::unity::Array<::unity::Il2CppString>, *mutcrate::app::soundsystem::SoundSystem_ResultSoundLoad)` overload"]
789 fn prepare_switch_async_2(
790 self,
791 switch_group_name: impl ::core::convert::Into<::unity::Il2CppString>,
792 switch_name_array: impl ::core::convert::Into<::unity::Array<::unity::Il2CppString>>,
793 ) -> (bool, crate::app::soundsystem::SoundSystem_ResultSoundLoad) {
794 unsafe {
795 let __receiver =
796 <SoundSystem_ISoundLoad as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
797 let mut __out_0 = ::core::mem::MaybeUninit::<crate::app::soundsystem::SoundSystem_ResultSoundLoad>::uninit();
798 let __ret = {
799 {
800 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
801 let __vi = *__vt.get(17usize).unwrap_or_else(|| {
802 panic!(
803 "unity: virtual slot {}
804 out of range (vtable len {}
805) on the runtime class behind {}
806 (method `{}
807`)",
808 17usize,
809 __vt.len(),
810 <SoundSystem_ISoundLoad as ::unity::ClassIdentity>::NAME,
811 "PrepareSwitchAsync",
812 )
813 });
814 let __inner: extern "C" fn(
815 SoundSystem_ISoundLoad,
816 ::unity::Il2CppString,
817 ::unity::Array<::unity::Il2CppString>,
818 *mut crate::app::soundsystem::SoundSystem_ResultSoundLoad,
819 ::unity::OptionalMethod,
820 ) -> bool = ::core::mem::transmute(__vi.method_ptr);
821 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
822 __inner(
823 __receiver,
824 ::core::convert::Into::into(switch_group_name),
825 ::core::convert::Into::into(switch_name_array),
826 __out_0.as_mut_ptr(),
827 __mi,
828 )
829 }
830 };
831 (__ret, __out_0.assume_init())
832 }
833 }
834 #[doc = "`UnprepareSwitch(::unity::Il2CppString, ::unity::Il2CppString)` overload"]
835 fn unprepare_switch(
836 self,
837 switch_group_name: impl ::core::convert::Into<::unity::Il2CppString>,
838 switch_name_array: impl ::core::convert::Into<::unity::Il2CppString>,
839 ) -> () {
840 unsafe {
841 let __receiver =
842 <SoundSystem_ISoundLoad as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
843 {
844 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
845 let __vi = *__vt.get(18usize).unwrap_or_else(|| {
846 panic!(
847 "unity: virtual slot {}
848 out of range (vtable len {}
849) on the runtime class behind {}
850 (method `{}
851`)",
852 18usize,
853 __vt.len(),
854 <SoundSystem_ISoundLoad as ::unity::ClassIdentity>::NAME,
855 "UnprepareSwitch",
856 )
857 });
858 let __inner: extern "C" fn(SoundSystem_ISoundLoad, ::unity::Il2CppString, ::unity::Il2CppString, ::unity::OptionalMethod) -> () =
859 ::core::mem::transmute(__vi.method_ptr);
860 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
861 __inner(
862 __receiver,
863 ::core::convert::Into::into(switch_group_name),
864 ::core::convert::Into::into(switch_name_array),
865 __mi,
866 )
867 }
868 }
869 }
870 #[doc = "`UnprepareSwitch(::unity::Il2CppString, ::unity::Array<::unity::Il2CppString>)` overload"]
871 fn unprepare_switch_2(
872 self,
873 switch_group_name: impl ::core::convert::Into<::unity::Il2CppString>,
874 switch_name_array: impl ::core::convert::Into<::unity::Array<::unity::Il2CppString>>,
875 ) -> () {
876 unsafe {
877 let __receiver =
878 <SoundSystem_ISoundLoad as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
879 {
880 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
881 let __vi = *__vt.get(19usize).unwrap_or_else(|| {
882 panic!(
883 "unity: virtual slot {}
884 out of range (vtable len {}
885) on the runtime class behind {}
886 (method `{}
887`)",
888 19usize,
889 __vt.len(),
890 <SoundSystem_ISoundLoad as ::unity::ClassIdentity>::NAME,
891 "UnprepareSwitch",
892 )
893 });
894 let __inner: extern "C" fn(
895 SoundSystem_ISoundLoad,
896 ::unity::Il2CppString,
897 ::unity::Array<::unity::Il2CppString>,
898 ::unity::OptionalMethod,
899 ) -> () = ::core::mem::transmute(__vi.method_ptr);
900 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
901 __inner(
902 __receiver,
903 ::core::convert::Into::into(switch_group_name),
904 ::core::convert::Into::into(switch_name_array),
905 __mi,
906 )
907 }
908 }
909 }
910 #[doc = "`ClearPrepare()` overload"]
911 fn clear_prepare(self) -> () {
912 unsafe {
913 let __receiver =
914 <SoundSystem_ISoundLoad as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
915 {
916 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
917 let __vi = *__vt.get(20usize).unwrap_or_else(|| {
918 panic!(
919 "unity: virtual slot {}
920 out of range (vtable len {}
921) on the runtime class behind {}
922 (method `{}
923`)",
924 20usize,
925 __vt.len(),
926 <SoundSystem_ISoundLoad as ::unity::ClassIdentity>::NAME,
927 "ClearPrepare",
928 )
929 });
930 let __inner: extern "C" fn(SoundSystem_ISoundLoad, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__vi.method_ptr);
931 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
932 __inner(__receiver, __mi)
933 }
934 }
935 }
936}
937
938#[cfg(feature = "app-soundsystem")]
939impl<__T: ISoundSystem_ISoundLoad> ISoundSystem_ISoundLoadMethods for __T {}
940
941#[cfg(feature = "app-soundsystem")]
942impl SoundSystem_ISoundLoad {
943 pub fn load_method_info() -> &'static ::unity::il2cpp::MethodInfo {
944 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
945 }
946
947 pub fn load_async_method_info() -> &'static ::unity::il2cpp::MethodInfo {
948 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
949 }
950
951 pub fn is_loading_method_info() -> &'static ::unity::il2cpp::MethodInfo {
952 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
953 }
954
955 pub fn is_loading_2_method_info() -> &'static ::unity::il2cpp::MethodInfo {
956 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
957 }
958
959 pub fn is_loaded_method_info() -> &'static ::unity::il2cpp::MethodInfo {
960 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
961 }
962
963 pub fn unload_method_info() -> &'static ::unity::il2cpp::MethodInfo {
964 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[5]
965 }
966
967 pub fn unload_all_method_info() -> &'static ::unity::il2cpp::MethodInfo {
968 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[6]
969 }
970
971 pub fn reload_by_set_language_method_info() -> &'static ::unity::il2cpp::MethodInfo {
972 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[7]
973 }
974
975 pub fn prepare_event_method_info() -> &'static ::unity::il2cpp::MethodInfo {
976 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[8]
977 }
978
979 pub fn prepare_event_2_method_info() -> &'static ::unity::il2cpp::MethodInfo {
980 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[9]
981 }
982
983 pub fn prepare_event_async_method_info() -> &'static ::unity::il2cpp::MethodInfo {
984 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[10]
985 }
986
987 pub fn prepare_event_async_2_method_info() -> &'static ::unity::il2cpp::MethodInfo {
988 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[11]
989 }
990
991 pub fn unprepare_event_method_info() -> &'static ::unity::il2cpp::MethodInfo {
992 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[12]
993 }
994
995 pub fn unprepare_event_2_method_info() -> &'static ::unity::il2cpp::MethodInfo {
996 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[13]
997 }
998
999 pub fn prepare_switch_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1000 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[14]
1001 }
1002
1003 pub fn prepare_switch_2_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1004 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[15]
1005 }
1006
1007 pub fn prepare_switch_async_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1008 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[16]
1009 }
1010
1011 pub fn prepare_switch_async_2_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1012 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[17]
1013 }
1014
1015 pub fn unprepare_switch_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1016 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[18]
1017 }
1018
1019 pub fn unprepare_switch_2_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1020 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[19]
1021 }
1022
1023 pub fn clear_prepare_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1024 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[20]
1025 }
1026}
1027
1028#[cfg(feature = "app-soundsystem")]
1029impl SoundSystem_ISoundLoad {
1030 #[doc = "Direct (non-virtual) call to `SoundSystem_ISoundLoad`'s own `Load`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1031 pub unsafe fn load(this: impl ::core::convert::Into<::unity::IlInstance>, name: ::unity::Il2CppString) -> () {
1032 let __mi = Self::load_method_info();
1033 let __inner: extern "C" fn(::unity::IlInstance, ::unity::Il2CppString, ::unity::OptionalMethod) -> () =
1034 ::core::mem::transmute(__mi.method_ptr);
1035 __inner(this.into(), name, ::core::option::Option::None)
1036 }
1037
1038 #[doc = "Direct (non-virtual) call to `SoundSystem_ISoundLoad`'s own `LoadAsync`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1039 pub unsafe fn load_async(this: impl ::core::convert::Into<::unity::IlInstance>, name: ::unity::Il2CppString) -> () {
1040 let __mi = Self::load_async_method_info();
1041 let __inner: extern "C" fn(::unity::IlInstance, ::unity::Il2CppString, ::unity::OptionalMethod) -> () =
1042 ::core::mem::transmute(__mi.method_ptr);
1043 __inner(this.into(), name, ::core::option::Option::None)
1044 }
1045
1046 #[doc = "Direct (non-virtual) call to `SoundSystem_ISoundLoad`'s own `IsLoading`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1047 pub unsafe fn is_loading(this: impl ::core::convert::Into<::unity::IlInstance>) -> bool {
1048 let __mi = Self::is_loading_method_info();
1049 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__mi.method_ptr);
1050 __inner(this.into(), ::core::option::Option::None)
1051 }
1052
1053 #[doc = "Direct (non-virtual) call to `SoundSystem_ISoundLoad`'s own `IsLoading`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1054 pub unsafe fn is_loading_2(this: impl ::core::convert::Into<::unity::IlInstance>, name: ::unity::Il2CppString) -> bool {
1055 let __mi = Self::is_loading_2_method_info();
1056 let __inner: extern "C" fn(::unity::IlInstance, ::unity::Il2CppString, ::unity::OptionalMethod) -> bool =
1057 ::core::mem::transmute(__mi.method_ptr);
1058 __inner(this.into(), name, ::core::option::Option::None)
1059 }
1060
1061 #[doc = "Direct (non-virtual) call to `SoundSystem_ISoundLoad`'s own `IsLoaded`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1062 pub unsafe fn is_loaded(this: impl ::core::convert::Into<::unity::IlInstance>, name: ::unity::Il2CppString) -> bool {
1063 let __mi = Self::is_loaded_method_info();
1064 let __inner: extern "C" fn(::unity::IlInstance, ::unity::Il2CppString, ::unity::OptionalMethod) -> bool =
1065 ::core::mem::transmute(__mi.method_ptr);
1066 __inner(this.into(), name, ::core::option::Option::None)
1067 }
1068
1069 #[doc = "Direct (non-virtual) call to `SoundSystem_ISoundLoad`'s own `Unload`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1070 pub unsafe fn unload(this: impl ::core::convert::Into<::unity::IlInstance>, name: ::unity::Il2CppString) -> () {
1071 let __mi = Self::unload_method_info();
1072 let __inner: extern "C" fn(::unity::IlInstance, ::unity::Il2CppString, ::unity::OptionalMethod) -> () =
1073 ::core::mem::transmute(__mi.method_ptr);
1074 __inner(this.into(), name, ::core::option::Option::None)
1075 }
1076
1077 #[doc = "Direct (non-virtual) call to `SoundSystem_ISoundLoad`'s own `UnloadAll`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1078 pub unsafe fn unload_all(this: impl ::core::convert::Into<::unity::IlInstance>) -> () {
1079 let __mi = Self::unload_all_method_info();
1080 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
1081 __inner(this.into(), ::core::option::Option::None)
1082 }
1083
1084 #[doc = "Direct (non-virtual) call to `SoundSystem_ISoundLoad`'s own `ReloadBySetLanguage`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1085 pub unsafe fn reload_by_set_language(
1086 this: impl ::core::convert::Into<::unity::IlInstance>,
1087 language: crate::app::language::Language_Voices,
1088 ) -> () {
1089 let __mi = Self::reload_by_set_language_method_info();
1090 let __inner: extern "C" fn(::unity::IlInstance, crate::app::language::Language_Voices, ::unity::OptionalMethod) -> () =
1091 ::core::mem::transmute(__mi.method_ptr);
1092 __inner(this.into(), language, ::core::option::Option::None)
1093 }
1094
1095 #[doc = "Direct (non-virtual) call to `SoundSystem_ISoundLoad`'s own `PrepareEvent`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1096 pub unsafe fn prepare_event(this: impl ::core::convert::Into<::unity::IlInstance>, event_name: ::unity::Il2CppString) -> bool {
1097 let __mi = Self::prepare_event_method_info();
1098 let __inner: extern "C" fn(::unity::IlInstance, ::unity::Il2CppString, ::unity::OptionalMethod) -> bool =
1099 ::core::mem::transmute(__mi.method_ptr);
1100 __inner(this.into(), event_name, ::core::option::Option::None)
1101 }
1102
1103 #[doc = "Direct (non-virtual) call to `SoundSystem_ISoundLoad`'s own `PrepareEvent`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1104 pub unsafe fn prepare_event_2(
1105 this: impl ::core::convert::Into<::unity::IlInstance>,
1106 event_name_array: ::unity::Array<::unity::Il2CppString>,
1107 ) -> bool {
1108 let __mi = Self::prepare_event_2_method_info();
1109 let __inner: extern "C" fn(::unity::IlInstance, ::unity::Array<::unity::Il2CppString>, ::unity::OptionalMethod) -> bool =
1110 ::core::mem::transmute(__mi.method_ptr);
1111 __inner(this.into(), event_name_array, ::core::option::Option::None)
1112 }
1113
1114 #[doc = "Direct (non-virtual) call to `SoundSystem_ISoundLoad`'s own `PrepareEventAsync`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1115 pub unsafe fn prepare_event_async(
1116 this: impl ::core::convert::Into<::unity::IlInstance>,
1117 event_name: ::unity::Il2CppString,
1118 result_sound_load: *mut crate::app::soundsystem::SoundSystem_ResultSoundLoad,
1119 ) -> bool {
1120 let __mi = Self::prepare_event_async_method_info();
1121 let __inner: extern "C" fn(
1122 ::unity::IlInstance,
1123 ::unity::Il2CppString,
1124 *mut crate::app::soundsystem::SoundSystem_ResultSoundLoad,
1125 ::unity::OptionalMethod,
1126 ) -> bool = ::core::mem::transmute(__mi.method_ptr);
1127 __inner(this.into(), event_name, result_sound_load, ::core::option::Option::None)
1128 }
1129
1130 #[doc = "Direct (non-virtual) call to `SoundSystem_ISoundLoad`'s own `PrepareEventAsync`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1131 pub unsafe fn prepare_event_async_2(
1132 this: impl ::core::convert::Into<::unity::IlInstance>,
1133 event_name_array: ::unity::Array<::unity::Il2CppString>,
1134 result_sound_load: *mut crate::app::soundsystem::SoundSystem_ResultSoundLoad,
1135 ) -> bool {
1136 let __mi = Self::prepare_event_async_2_method_info();
1137 let __inner: extern "C" fn(
1138 ::unity::IlInstance,
1139 ::unity::Array<::unity::Il2CppString>,
1140 *mut crate::app::soundsystem::SoundSystem_ResultSoundLoad,
1141 ::unity::OptionalMethod,
1142 ) -> bool = ::core::mem::transmute(__mi.method_ptr);
1143 __inner(this.into(), event_name_array, result_sound_load, ::core::option::Option::None)
1144 }
1145
1146 #[doc = "Direct (non-virtual) call to `SoundSystem_ISoundLoad`'s own `UnprepareEvent`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1147 pub unsafe fn unprepare_event(this: impl ::core::convert::Into<::unity::IlInstance>, event_name_array: ::unity::Il2CppString) -> () {
1148 let __mi = Self::unprepare_event_method_info();
1149 let __inner: extern "C" fn(::unity::IlInstance, ::unity::Il2CppString, ::unity::OptionalMethod) -> () =
1150 ::core::mem::transmute(__mi.method_ptr);
1151 __inner(this.into(), event_name_array, ::core::option::Option::None)
1152 }
1153
1154 #[doc = "Direct (non-virtual) call to `SoundSystem_ISoundLoad`'s own `UnprepareEvent`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1155 pub unsafe fn unprepare_event_2(
1156 this: impl ::core::convert::Into<::unity::IlInstance>,
1157 event_name_array: ::unity::Array<::unity::Il2CppString>,
1158 ) -> () {
1159 let __mi = Self::unprepare_event_2_method_info();
1160 let __inner: extern "C" fn(::unity::IlInstance, ::unity::Array<::unity::Il2CppString>, ::unity::OptionalMethod) -> () =
1161 ::core::mem::transmute(__mi.method_ptr);
1162 __inner(this.into(), event_name_array, ::core::option::Option::None)
1163 }
1164
1165 #[doc = "Direct (non-virtual) call to `SoundSystem_ISoundLoad`'s own `PrepareSwitch`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1166 pub unsafe fn prepare_switch(
1167 this: impl ::core::convert::Into<::unity::IlInstance>,
1168 switch_group_name: ::unity::Il2CppString,
1169 switch_name: ::unity::Il2CppString,
1170 ) -> bool {
1171 let __mi = Self::prepare_switch_method_info();
1172 let __inner: extern "C" fn(::unity::IlInstance, ::unity::Il2CppString, ::unity::Il2CppString, ::unity::OptionalMethod) -> bool =
1173 ::core::mem::transmute(__mi.method_ptr);
1174 __inner(this.into(), switch_group_name, switch_name, ::core::option::Option::None)
1175 }
1176
1177 #[doc = "Direct (non-virtual) call to `SoundSystem_ISoundLoad`'s own `PrepareSwitch`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1178 pub unsafe fn prepare_switch_2(
1179 this: impl ::core::convert::Into<::unity::IlInstance>,
1180 switch_group_name: ::unity::Il2CppString,
1181 switch_name_array: ::unity::Array<::unity::Il2CppString>,
1182 ) -> bool {
1183 let __mi = Self::prepare_switch_2_method_info();
1184 let __inner: extern "C" fn(
1185 ::unity::IlInstance,
1186 ::unity::Il2CppString,
1187 ::unity::Array<::unity::Il2CppString>,
1188 ::unity::OptionalMethod,
1189 ) -> bool = ::core::mem::transmute(__mi.method_ptr);
1190 __inner(this.into(), switch_group_name, switch_name_array, ::core::option::Option::None)
1191 }
1192
1193 #[doc = "Direct (non-virtual) call to `SoundSystem_ISoundLoad`'s own `PrepareSwitchAsync`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1194 pub unsafe fn prepare_switch_async(
1195 this: impl ::core::convert::Into<::unity::IlInstance>,
1196 switch_group_name: ::unity::Il2CppString,
1197 switch_name: ::unity::Il2CppString,
1198 result_sound_load: *mut crate::app::soundsystem::SoundSystem_ResultSoundLoad,
1199 ) -> bool {
1200 let __mi = Self::prepare_switch_async_method_info();
1201 let __inner: extern "C" fn(
1202 ::unity::IlInstance,
1203 ::unity::Il2CppString,
1204 ::unity::Il2CppString,
1205 *mut crate::app::soundsystem::SoundSystem_ResultSoundLoad,
1206 ::unity::OptionalMethod,
1207 ) -> bool = ::core::mem::transmute(__mi.method_ptr);
1208 __inner(
1209 this.into(),
1210 switch_group_name,
1211 switch_name,
1212 result_sound_load,
1213 ::core::option::Option::None,
1214 )
1215 }
1216
1217 #[doc = "Direct (non-virtual) call to `SoundSystem_ISoundLoad`'s own `PrepareSwitchAsync`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1218 pub unsafe fn prepare_switch_async_2(
1219 this: impl ::core::convert::Into<::unity::IlInstance>,
1220 switch_group_name: ::unity::Il2CppString,
1221 switch_name_array: ::unity::Array<::unity::Il2CppString>,
1222 result_sound_load: *mut crate::app::soundsystem::SoundSystem_ResultSoundLoad,
1223 ) -> bool {
1224 let __mi = Self::prepare_switch_async_2_method_info();
1225 let __inner: extern "C" fn(
1226 ::unity::IlInstance,
1227 ::unity::Il2CppString,
1228 ::unity::Array<::unity::Il2CppString>,
1229 *mut crate::app::soundsystem::SoundSystem_ResultSoundLoad,
1230 ::unity::OptionalMethod,
1231 ) -> bool = ::core::mem::transmute(__mi.method_ptr);
1232 __inner(
1233 this.into(),
1234 switch_group_name,
1235 switch_name_array,
1236 result_sound_load,
1237 ::core::option::Option::None,
1238 )
1239 }
1240
1241 #[doc = "Direct (non-virtual) call to `SoundSystem_ISoundLoad`'s own `UnprepareSwitch`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1242 pub unsafe fn unprepare_switch(
1243 this: impl ::core::convert::Into<::unity::IlInstance>,
1244 switch_group_name: ::unity::Il2CppString,
1245 switch_name_array: ::unity::Il2CppString,
1246 ) -> () {
1247 let __mi = Self::unprepare_switch_method_info();
1248 let __inner: extern "C" fn(::unity::IlInstance, ::unity::Il2CppString, ::unity::Il2CppString, ::unity::OptionalMethod) -> () =
1249 ::core::mem::transmute(__mi.method_ptr);
1250 __inner(this.into(), switch_group_name, switch_name_array, ::core::option::Option::None)
1251 }
1252
1253 #[doc = "Direct (non-virtual) call to `SoundSystem_ISoundLoad`'s own `UnprepareSwitch`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1254 pub unsafe fn unprepare_switch_2(
1255 this: impl ::core::convert::Into<::unity::IlInstance>,
1256 switch_group_name: ::unity::Il2CppString,
1257 switch_name_array: ::unity::Array<::unity::Il2CppString>,
1258 ) -> () {
1259 let __mi = Self::unprepare_switch_2_method_info();
1260 let __inner: extern "C" fn(::unity::IlInstance, ::unity::Il2CppString, ::unity::Array<::unity::Il2CppString>, ::unity::OptionalMethod) -> () =
1261 ::core::mem::transmute(__mi.method_ptr);
1262 __inner(this.into(), switch_group_name, switch_name_array, ::core::option::Option::None)
1263 }
1264
1265 #[doc = "Direct (non-virtual) call to `SoundSystem_ISoundLoad`'s own `ClearPrepare`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1266 pub unsafe fn clear_prepare(this: impl ::core::convert::Into<::unity::IlInstance>) -> () {
1267 let __mi = Self::clear_prepare_method_info();
1268 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
1269 __inner(this.into(), ::core::option::Option::None)
1270 }
1271}
1272
1273#[cfg(feature = "app-soundsystem")]
1274pub trait ISoundSystem_SoundHandleMethods: ISoundSystem_SoundHandle {
1275 #[doc = "`.ctor()` overload"]
1276 fn ctor(self) -> () {
1277 unsafe {
1278 let __receiver =
1279 <SoundSystem_SoundHandle as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1280 ::unity::il2cpp_call!((::unity::module_base()+0x1d7e540usize)as*mut u8,();
1281(SoundSystem_SoundHandle)__receiver)
1282 }
1283 }
1284 #[doc = "`Finalize()` overload"]
1285 fn finalize(self) -> () {
1286 unsafe {
1287 let __receiver =
1288 <SoundSystem_SoundHandle as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1289 {
1290 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1291 let __vi = *__vt.get(1usize).unwrap_or_else(|| {
1292 panic!(
1293 "unity: virtual slot {}
1294 out of range (vtable len {}
1295) on the runtime class behind {}
1296 (method `{}
1297`)",
1298 1usize,
1299 __vt.len(),
1300 <SoundSystem_SoundHandle as ::unity::ClassIdentity>::NAME,
1301 "Finalize",
1302 )
1303 });
1304 let __inner: extern "C" fn(SoundSystem_SoundHandle, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__vi.method_ptr);
1305 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1306 __inner(__receiver, __mi)
1307 }
1308 }
1309 }
1310 #[doc = "`GetGameObject()` overload"]
1311 fn get_game_object(self) -> crate::unity_engine::gameobject::GameObject {
1312 unsafe {
1313 let __receiver =
1314 <SoundSystem_SoundHandle as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1315 {
1316 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1317 let __vi = *__vt.get(4usize).unwrap_or_else(|| {
1318 panic!(
1319 "unity: virtual slot {}
1320 out of range (vtable len {}
1321) on the runtime class behind {}
1322 (method `{}
1323`)",
1324 4usize,
1325 __vt.len(),
1326 <SoundSystem_SoundHandle as ::unity::ClassIdentity>::NAME,
1327 "GetGameObject",
1328 )
1329 });
1330 let __inner: extern "C" fn(SoundSystem_SoundHandle, ::unity::OptionalMethod) -> crate::unity_engine::gameobject::GameObject =
1331 ::core::mem::transmute(__vi.method_ptr);
1332 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1333 __inner(__receiver, __mi)
1334 }
1335 }
1336 }
1337 #[doc = "`GetEventName()` overload"]
1338 fn get_event_name(self) -> ::unity::Il2CppString {
1339 unsafe {
1340 let __receiver =
1341 <SoundSystem_SoundHandle as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1342 {
1343 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1344 let __vi = *__vt.get(5usize).unwrap_or_else(|| {
1345 panic!(
1346 "unity: virtual slot {}
1347 out of range (vtable len {}
1348) on the runtime class behind {}
1349 (method `{}
1350`)",
1351 5usize,
1352 __vt.len(),
1353 <SoundSystem_SoundHandle as ::unity::ClassIdentity>::NAME,
1354 "GetEventName",
1355 )
1356 });
1357 let __inner: extern "C" fn(SoundSystem_SoundHandle, ::unity::OptionalMethod) -> ::unity::Il2CppString =
1358 ::core::mem::transmute(__vi.method_ptr);
1359 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1360 __inner(__receiver, __mi)
1361 }
1362 }
1363 }
1364 #[doc = "`GetEventId()` overload"]
1365 fn get_event_id(self) -> u32 {
1366 unsafe {
1367 let __receiver =
1368 <SoundSystem_SoundHandle as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1369 {
1370 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1371 let __vi = *__vt.get(6usize).unwrap_or_else(|| {
1372 panic!(
1373 "unity: virtual slot {}
1374 out of range (vtable len {}
1375) on the runtime class behind {}
1376 (method `{}
1377`)",
1378 6usize,
1379 __vt.len(),
1380 <SoundSystem_SoundHandle as ::unity::ClassIdentity>::NAME,
1381 "GetEventId",
1382 )
1383 });
1384 let __inner: extern "C" fn(SoundSystem_SoundHandle, ::unity::OptionalMethod) -> u32 = ::core::mem::transmute(__vi.method_ptr);
1385 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1386 __inner(__receiver, __mi)
1387 }
1388 }
1389 }
1390 #[doc = "`GetPlayingId()` overload"]
1391 fn get_playing_id(self) -> u32 {
1392 unsafe {
1393 let __receiver =
1394 <SoundSystem_SoundHandle as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1395 {
1396 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1397 let __vi = *__vt.get(7usize).unwrap_or_else(|| {
1398 panic!(
1399 "unity: virtual slot {}
1400 out of range (vtable len {}
1401) on the runtime class behind {}
1402 (method `{}
1403`)",
1404 7usize,
1405 __vt.len(),
1406 <SoundSystem_SoundHandle as ::unity::ClassIdentity>::NAME,
1407 "GetPlayingId",
1408 )
1409 });
1410 let __inner: extern "C" fn(SoundSystem_SoundHandle, ::unity::OptionalMethod) -> u32 = ::core::mem::transmute(__vi.method_ptr);
1411 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1412 __inner(__receiver, __mi)
1413 }
1414 }
1415 }
1416 #[doc = "`IsEnable()` overload"]
1417 fn is_enable(self) -> bool {
1418 unsafe {
1419 let __receiver =
1420 <SoundSystem_SoundHandle as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1421 {
1422 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1423 let __vi = *__vt.get(8usize).unwrap_or_else(|| {
1424 panic!(
1425 "unity: virtual slot {}
1426 out of range (vtable len {}
1427) on the runtime class behind {}
1428 (method `{}
1429`)",
1430 8usize,
1431 __vt.len(),
1432 <SoundSystem_SoundHandle as ::unity::ClassIdentity>::NAME,
1433 "IsEnable",
1434 )
1435 });
1436 let __inner: extern "C" fn(SoundSystem_SoundHandle, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__vi.method_ptr);
1437 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1438 __inner(__receiver, __mi)
1439 }
1440 }
1441 }
1442 #[doc = "`IsPlaying()` overload"]
1443 fn is_playing(self) -> bool {
1444 unsafe {
1445 let __receiver =
1446 <SoundSystem_SoundHandle as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1447 {
1448 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1449 let __vi = *__vt.get(9usize).unwrap_or_else(|| {
1450 panic!(
1451 "unity: virtual slot {}
1452 out of range (vtable len {}
1453) on the runtime class behind {}
1454 (method `{}
1455`)",
1456 9usize,
1457 __vt.len(),
1458 <SoundSystem_SoundHandle as ::unity::ClassIdentity>::NAME,
1459 "IsPlaying",
1460 )
1461 });
1462 let __inner: extern "C" fn(SoundSystem_SoundHandle, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__vi.method_ptr);
1463 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1464 __inner(__receiver, __mi)
1465 }
1466 }
1467 }
1468 #[doc = "`GetCharacter()` overload"]
1469 fn get_character(self) -> crate::combat::character::Character {
1470 unsafe {
1471 let __receiver =
1472 <SoundSystem_SoundHandle as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1473 {
1474 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1475 let __vi = *__vt.get(10usize).unwrap_or_else(|| {
1476 panic!(
1477 "unity: virtual slot {}
1478 out of range (vtable len {}
1479) on the runtime class behind {}
1480 (method `{}
1481`)",
1482 10usize,
1483 __vt.len(),
1484 <SoundSystem_SoundHandle as ::unity::ClassIdentity>::NAME,
1485 "GetCharacter",
1486 )
1487 });
1488 let __inner: extern "C" fn(SoundSystem_SoundHandle, ::unity::OptionalMethod) -> crate::combat::character::Character =
1489 ::core::mem::transmute(__vi.method_ptr);
1490 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1491 __inner(__receiver, __mi)
1492 }
1493 }
1494 }
1495 #[doc = "`GetEventCharacterMouthController()` overload"]
1496 fn get_event_character_mouth_controller(self) -> crate::app::eventcharactermouthcontroller::EventCharacterMouthController {
1497 unsafe {
1498 let __receiver =
1499 <SoundSystem_SoundHandle as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1500 {
1501 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1502 let __vi = *__vt.get(11usize).unwrap_or_else(|| {
1503 panic!(
1504 "unity: virtual slot {}
1505 out of range (vtable len {}
1506) on the runtime class behind {}
1507 (method `{}
1508`)",
1509 11usize,
1510 __vt.len(),
1511 <SoundSystem_SoundHandle as ::unity::ClassIdentity>::NAME,
1512 "GetEventCharacterMouthController",
1513 )
1514 });
1515 let __inner: extern "C" fn(
1516 SoundSystem_SoundHandle,
1517 ::unity::OptionalMethod,
1518 ) -> crate::app::eventcharactermouthcontroller::EventCharacterMouthController = ::core::mem::transmute(__vi.method_ptr);
1519 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1520 __inner(__receiver, __mi)
1521 }
1522 }
1523 }
1524 #[doc = "`GetLipSyncDataFileName()` overload"]
1525 fn get_lip_sync_data_file_name(self) -> ::unity::Il2CppString {
1526 unsafe {
1527 let __receiver =
1528 <SoundSystem_SoundHandle as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1529 {
1530 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1531 let __vi = *__vt.get(12usize).unwrap_or_else(|| {
1532 panic!(
1533 "unity: virtual slot {}
1534 out of range (vtable len {}
1535) on the runtime class behind {}
1536 (method `{}
1537`)",
1538 12usize,
1539 __vt.len(),
1540 <SoundSystem_SoundHandle as ::unity::ClassIdentity>::NAME,
1541 "GetLipSyncDataFileName",
1542 )
1543 });
1544 let __inner: extern "C" fn(SoundSystem_SoundHandle, ::unity::OptionalMethod) -> ::unity::Il2CppString =
1545 ::core::mem::transmute(__vi.method_ptr);
1546 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1547 __inner(__receiver, __mi)
1548 }
1549 }
1550 }
1551 #[doc = "`SetCharacter(crate::combat::character::Character)` overload"]
1552 fn set_character(self, character: impl ::core::convert::Into<crate::combat::character::Character>) -> () {
1553 unsafe {
1554 let __receiver =
1555 <SoundSystem_SoundHandle as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1556 {
1557 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1558 let __vi = *__vt.get(13usize).unwrap_or_else(|| {
1559 panic!(
1560 "unity: virtual slot {}
1561 out of range (vtable len {}
1562) on the runtime class behind {}
1563 (method `{}
1564`)",
1565 13usize,
1566 __vt.len(),
1567 <SoundSystem_SoundHandle as ::unity::ClassIdentity>::NAME,
1568 "SetCharacter",
1569 )
1570 });
1571 let __inner: extern "C" fn(SoundSystem_SoundHandle, crate::combat::character::Character, ::unity::OptionalMethod) -> () =
1572 ::core::mem::transmute(__vi.method_ptr);
1573 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1574 __inner(__receiver, ::core::convert::Into::into(character), __mi)
1575 }
1576 }
1577 }
1578 #[doc = "`SetEventCharacterMouthController(crate::app::eventcharactermouthcontroller::EventCharacterMouthController)` overload"]
1579 fn set_event_character_mouth_controller(
1580 self,
1581 event_character_mouth_controller: impl ::core::convert::Into<crate::app::eventcharactermouthcontroller::EventCharacterMouthController>,
1582 ) -> () {
1583 unsafe {
1584 let __receiver =
1585 <SoundSystem_SoundHandle as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1586 {
1587 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1588 let __vi = *__vt.get(14usize).unwrap_or_else(|| {
1589 panic!(
1590 "unity: virtual slot {}
1591 out of range (vtable len {}
1592) on the runtime class behind {}
1593 (method `{}
1594`)",
1595 14usize,
1596 __vt.len(),
1597 <SoundSystem_SoundHandle as ::unity::ClassIdentity>::NAME,
1598 "SetEventCharacterMouthController",
1599 )
1600 });
1601 let __inner: extern "C" fn(
1602 SoundSystem_SoundHandle,
1603 crate::app::eventcharactermouthcontroller::EventCharacterMouthController,
1604 ::unity::OptionalMethod,
1605 ) -> () = ::core::mem::transmute(__vi.method_ptr);
1606 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1607 __inner(__receiver, ::core::convert::Into::into(event_character_mouth_controller), __mi)
1608 }
1609 }
1610 }
1611 #[doc = "`Stop(i32)` overload"]
1612 fn stop(self, fade_msec: impl ::core::convert::Into<i32>) -> () {
1613 unsafe {
1614 let __receiver =
1615 <SoundSystem_SoundHandle as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1616 {
1617 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1618 let __vi = *__vt.get(15usize).unwrap_or_else(|| {
1619 panic!(
1620 "unity: virtual slot {}
1621 out of range (vtable len {}
1622) on the runtime class behind {}
1623 (method `{}
1624`)",
1625 15usize,
1626 __vt.len(),
1627 <SoundSystem_SoundHandle as ::unity::ClassIdentity>::NAME,
1628 "Stop",
1629 )
1630 });
1631 let __inner: extern "C" fn(SoundSystem_SoundHandle, i32, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__vi.method_ptr);
1632 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1633 __inner(__receiver, ::core::convert::Into::into(fade_msec), __mi)
1634 }
1635 }
1636 }
1637 #[doc = "`Pause(i32)` overload"]
1638 fn pause(self, fade_msec: impl ::core::convert::Into<i32>) -> () {
1639 unsafe {
1640 let __receiver =
1641 <SoundSystem_SoundHandle as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1642 {
1643 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1644 let __vi = *__vt.get(16usize).unwrap_or_else(|| {
1645 panic!(
1646 "unity: virtual slot {}
1647 out of range (vtable len {}
1648) on the runtime class behind {}
1649 (method `{}
1650`)",
1651 16usize,
1652 __vt.len(),
1653 <SoundSystem_SoundHandle as ::unity::ClassIdentity>::NAME,
1654 "Pause",
1655 )
1656 });
1657 let __inner: extern "C" fn(SoundSystem_SoundHandle, i32, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__vi.method_ptr);
1658 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1659 __inner(__receiver, ::core::convert::Into::into(fade_msec), __mi)
1660 }
1661 }
1662 }
1663 #[doc = "`Resume(i32)` overload"]
1664 fn resume(self, fade_msec: impl ::core::convert::Into<i32>) -> () {
1665 unsafe {
1666 let __receiver =
1667 <SoundSystem_SoundHandle as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1668 {
1669 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1670 let __vi = *__vt.get(17usize).unwrap_or_else(|| {
1671 panic!(
1672 "unity: virtual slot {}
1673 out of range (vtable len {}
1674) on the runtime class behind {}
1675 (method `{}
1676`)",
1677 17usize,
1678 __vt.len(),
1679 <SoundSystem_SoundHandle as ::unity::ClassIdentity>::NAME,
1680 "Resume",
1681 )
1682 });
1683 let __inner: extern "C" fn(SoundSystem_SoundHandle, i32, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__vi.method_ptr);
1684 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1685 __inner(__receiver, ::core::convert::Into::into(fade_msec), __mi)
1686 }
1687 }
1688 }
1689}
1690
1691#[cfg(feature = "app-soundsystem")]
1692impl<__T: ISoundSystem_SoundHandle> ISoundSystem_SoundHandleMethods for __T {}
1693
1694#[cfg(feature = "app-soundsystem")]
1695impl SoundSystem_SoundHandle {
1696 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1697 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
1698 }
1699
1700 pub fn finalize_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1701 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
1702 }
1703
1704 pub fn get_game_object_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1705 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
1706 }
1707
1708 pub fn get_event_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1709 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
1710 }
1711
1712 pub fn get_event_id_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1713 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
1714 }
1715
1716 pub fn get_playing_id_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1717 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[5]
1718 }
1719
1720 pub fn is_enable_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1721 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[6]
1722 }
1723
1724 pub fn is_playing_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1725 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[7]
1726 }
1727
1728 pub fn get_character_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1729 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[8]
1730 }
1731
1732 pub fn get_event_character_mouth_controller_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1733 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[9]
1734 }
1735
1736 pub fn get_lip_sync_data_file_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1737 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[10]
1738 }
1739
1740 pub fn set_character_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1741 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[11]
1742 }
1743
1744 pub fn set_event_character_mouth_controller_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1745 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[12]
1746 }
1747
1748 pub fn stop_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1749 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[13]
1750 }
1751
1752 pub fn pause_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1753 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[14]
1754 }
1755
1756 pub fn resume_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1757 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[15]
1758 }
1759}
1760
1761#[cfg(feature = "app-soundsystem")]
1762impl SoundSystem_SoundHandle {
1763 #[doc = "Direct (non-virtual) call to `SoundSystem_SoundHandle`'s own `Finalize`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1764 pub unsafe fn finalize(this: impl ::core::convert::Into<::unity::IlInstance>) -> () {
1765 let __mi = Self::finalize_method_info();
1766 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
1767 __inner(this.into(), ::core::option::Option::None)
1768 }
1769
1770 #[doc = "Direct (non-virtual) call to `SoundSystem_SoundHandle`'s own `GetGameObject`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1771 pub unsafe fn get_game_object(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::unity_engine::gameobject::GameObject {
1772 let __mi = Self::get_game_object_method_info();
1773 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::unity_engine::gameobject::GameObject =
1774 ::core::mem::transmute(__mi.method_ptr);
1775 __inner(this.into(), ::core::option::Option::None)
1776 }
1777
1778 #[doc = "Direct (non-virtual) call to `SoundSystem_SoundHandle`'s own `GetEventName`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1779 pub unsafe fn get_event_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
1780 let __mi = Self::get_event_name_method_info();
1781 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
1782 __inner(this.into(), ::core::option::Option::None)
1783 }
1784
1785 #[doc = "Direct (non-virtual) call to `SoundSystem_SoundHandle`'s own `GetEventId`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1786 pub unsafe fn get_event_id(this: impl ::core::convert::Into<::unity::IlInstance>) -> u32 {
1787 let __mi = Self::get_event_id_method_info();
1788 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> u32 = ::core::mem::transmute(__mi.method_ptr);
1789 __inner(this.into(), ::core::option::Option::None)
1790 }
1791
1792 #[doc = "Direct (non-virtual) call to `SoundSystem_SoundHandle`'s own `GetPlayingId`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1793 pub unsafe fn get_playing_id(this: impl ::core::convert::Into<::unity::IlInstance>) -> u32 {
1794 let __mi = Self::get_playing_id_method_info();
1795 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> u32 = ::core::mem::transmute(__mi.method_ptr);
1796 __inner(this.into(), ::core::option::Option::None)
1797 }
1798
1799 #[doc = "Direct (non-virtual) call to `SoundSystem_SoundHandle`'s own `IsEnable`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1800 pub unsafe fn is_enable(this: impl ::core::convert::Into<::unity::IlInstance>) -> bool {
1801 let __mi = Self::is_enable_method_info();
1802 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__mi.method_ptr);
1803 __inner(this.into(), ::core::option::Option::None)
1804 }
1805
1806 #[doc = "Direct (non-virtual) call to `SoundSystem_SoundHandle`'s own `IsPlaying`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1807 pub unsafe fn is_playing(this: impl ::core::convert::Into<::unity::IlInstance>) -> bool {
1808 let __mi = Self::is_playing_method_info();
1809 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__mi.method_ptr);
1810 __inner(this.into(), ::core::option::Option::None)
1811 }
1812
1813 #[doc = "Direct (non-virtual) call to `SoundSystem_SoundHandle`'s own `GetCharacter`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1814 pub unsafe fn get_character(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::combat::character::Character {
1815 let __mi = Self::get_character_method_info();
1816 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::combat::character::Character =
1817 ::core::mem::transmute(__mi.method_ptr);
1818 __inner(this.into(), ::core::option::Option::None)
1819 }
1820
1821 #[doc = "Direct (non-virtual) call to `SoundSystem_SoundHandle`'s own `GetEventCharacterMouthController`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1822 pub unsafe fn get_event_character_mouth_controller(
1823 this: impl ::core::convert::Into<::unity::IlInstance>,
1824 ) -> crate::app::eventcharactermouthcontroller::EventCharacterMouthController {
1825 let __mi = Self::get_event_character_mouth_controller_method_info();
1826 let __inner: extern "C" fn(
1827 ::unity::IlInstance,
1828 ::unity::OptionalMethod,
1829 ) -> crate::app::eventcharactermouthcontroller::EventCharacterMouthController = ::core::mem::transmute(__mi.method_ptr);
1830 __inner(this.into(), ::core::option::Option::None)
1831 }
1832
1833 #[doc = "Direct (non-virtual) call to `SoundSystem_SoundHandle`'s own `GetLipSyncDataFileName`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1834 pub unsafe fn get_lip_sync_data_file_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
1835 let __mi = Self::get_lip_sync_data_file_name_method_info();
1836 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
1837 __inner(this.into(), ::core::option::Option::None)
1838 }
1839
1840 #[doc = "Direct (non-virtual) call to `SoundSystem_SoundHandle`'s own `SetCharacter`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1841 pub unsafe fn set_character(this: impl ::core::convert::Into<::unity::IlInstance>, character: crate::combat::character::Character) -> () {
1842 let __mi = Self::set_character_method_info();
1843 let __inner: extern "C" fn(::unity::IlInstance, crate::combat::character::Character, ::unity::OptionalMethod) -> () =
1844 ::core::mem::transmute(__mi.method_ptr);
1845 __inner(this.into(), character, ::core::option::Option::None)
1846 }
1847
1848 #[doc = "Direct (non-virtual) call to `SoundSystem_SoundHandle`'s own `SetEventCharacterMouthController`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1849 pub unsafe fn set_event_character_mouth_controller(
1850 this: impl ::core::convert::Into<::unity::IlInstance>,
1851 event_character_mouth_controller: crate::app::eventcharactermouthcontroller::EventCharacterMouthController,
1852 ) -> () {
1853 let __mi = Self::set_event_character_mouth_controller_method_info();
1854 let __inner: extern "C" fn(
1855 ::unity::IlInstance,
1856 crate::app::eventcharactermouthcontroller::EventCharacterMouthController,
1857 ::unity::OptionalMethod,
1858 ) -> () = ::core::mem::transmute(__mi.method_ptr);
1859 __inner(this.into(), event_character_mouth_controller, ::core::option::Option::None)
1860 }
1861
1862 #[doc = "Direct (non-virtual) call to `SoundSystem_SoundHandle`'s own `Stop`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1863 pub unsafe fn stop(this: impl ::core::convert::Into<::unity::IlInstance>, fade_msec: i32) -> () {
1864 let __mi = Self::stop_method_info();
1865 let __inner: extern "C" fn(::unity::IlInstance, i32, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
1866 __inner(this.into(), fade_msec, ::core::option::Option::None)
1867 }
1868
1869 #[doc = "Direct (non-virtual) call to `SoundSystem_SoundHandle`'s own `Pause`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1870 pub unsafe fn pause(this: impl ::core::convert::Into<::unity::IlInstance>, fade_msec: i32) -> () {
1871 let __mi = Self::pause_method_info();
1872 let __inner: extern "C" fn(::unity::IlInstance, i32, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
1873 __inner(this.into(), fade_msec, ::core::option::Option::None)
1874 }
1875
1876 #[doc = "Direct (non-virtual) call to `SoundSystem_SoundHandle`'s own `Resume`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1877 pub unsafe fn resume(this: impl ::core::convert::Into<::unity::IlInstance>, fade_msec: i32) -> () {
1878 let __mi = Self::resume_method_info();
1879 let __inner: extern "C" fn(::unity::IlInstance, i32, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
1880 __inner(this.into(), fade_msec, ::core::option::Option::None)
1881 }
1882}
1883
1884#[cfg(feature = "app-soundsystem")]
1885impl SoundSystem_SoundHandle {
1886 #[doc = "`.ctor()` — no args"]
1887 pub fn new() -> Self {
1888 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
1889 panic!(
1890 "{}
1891::{}
1892 failed to instantiate",
1893 ::core::stringify!(SoundSystem_SoundHandle),
1894 ::core::stringify!(new),
1895 )
1896 });
1897 <Self as ISoundSystem_SoundHandleMethods>::ctor(this);
1898 this
1899 }
1900}
1901
1902#[cfg(feature = "app-soundsystem")]
1903pub trait ISoundSystem_ISoundPlayMethods: ISoundSystem_ISoundPlay {
1904 #[doc = "`PopTemporaryGameObject()` overload"]
1905 fn pop_temporary_game_object(self) -> crate::unity_engine::gameobject::GameObject {
1906 unsafe {
1907 let __receiver =
1908 <SoundSystem_ISoundPlay as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1909 {
1910 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1911 let __vi = *__vt.get(0usize).unwrap_or_else(|| {
1912 panic!(
1913 "unity: virtual slot {}
1914 out of range (vtable len {}
1915) on the runtime class behind {}
1916 (method `{}
1917`)",
1918 0usize,
1919 __vt.len(),
1920 <SoundSystem_ISoundPlay as ::unity::ClassIdentity>::NAME,
1921 "PopTemporaryGameObject",
1922 )
1923 });
1924 let __inner: extern "C" fn(SoundSystem_ISoundPlay, ::unity::OptionalMethod) -> crate::unity_engine::gameobject::GameObject =
1925 ::core::mem::transmute(__vi.method_ptr);
1926 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1927 __inner(__receiver, __mi)
1928 }
1929 }
1930 }
1931 #[doc = "`IsEventLoaded(::unity::Il2CppString)` overload"]
1932 fn is_event_loaded(self, event_name: impl ::core::convert::Into<::unity::Il2CppString>) -> bool {
1933 unsafe {
1934 let __receiver =
1935 <SoundSystem_ISoundPlay as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1936 {
1937 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1938 let __vi = *__vt.get(1usize).unwrap_or_else(|| {
1939 panic!(
1940 "unity: virtual slot {}
1941 out of range (vtable len {}
1942) on the runtime class behind {}
1943 (method `{}
1944`)",
1945 1usize,
1946 __vt.len(),
1947 <SoundSystem_ISoundPlay as ::unity::ClassIdentity>::NAME,
1948 "IsEventLoaded",
1949 )
1950 });
1951 let __inner: extern "C" fn(SoundSystem_ISoundPlay, ::unity::Il2CppString, ::unity::OptionalMethod) -> bool =
1952 ::core::mem::transmute(__vi.method_ptr);
1953 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1954 __inner(__receiver, ::core::convert::Into::into(event_name), __mi)
1955 }
1956 }
1957 }
1958 #[doc = "`PostEvent(::unity::Il2CppString, bool)` overload"]
1959 fn post_event(
1960 self,
1961 name: impl ::core::convert::Into<::unity::Il2CppString>,
1962 is_get_position: impl ::core::convert::Into<bool>,
1963 ) -> crate::app::soundsystem::SoundSystem_SoundHandle {
1964 unsafe {
1965 let __receiver =
1966 <SoundSystem_ISoundPlay as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1967 {
1968 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1969 let __vi = *__vt.get(2usize).unwrap_or_else(|| {
1970 panic!(
1971 "unity: virtual slot {}
1972 out of range (vtable len {}
1973) on the runtime class behind {}
1974 (method `{}
1975`)",
1976 2usize,
1977 __vt.len(),
1978 <SoundSystem_ISoundPlay as ::unity::ClassIdentity>::NAME,
1979 "PostEvent",
1980 )
1981 });
1982 let __inner: extern "C" fn(
1983 SoundSystem_ISoundPlay,
1984 ::unity::Il2CppString,
1985 bool,
1986 ::unity::OptionalMethod,
1987 ) -> crate::app::soundsystem::SoundSystem_SoundHandle = ::core::mem::transmute(__vi.method_ptr);
1988 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1989 __inner(
1990 __receiver,
1991 ::core::convert::Into::into(name),
1992 ::core::convert::Into::into(is_get_position),
1993 __mi,
1994 )
1995 }
1996 }
1997 }
1998 #[doc = "`PostEvent(::unity::Il2CppString, crate::unity_engine::gameobject::GameObject, bool)` overload"]
1999 fn post_event_2(
2000 self,
2001 name: impl ::core::convert::Into<::unity::Il2CppString>,
2002 game_object: impl ::core::convert::Into<crate::unity_engine::gameobject::GameObject>,
2003 is_get_position: impl ::core::convert::Into<bool>,
2004 ) -> crate::app::soundsystem::SoundSystem_SoundHandle {
2005 unsafe {
2006 let __receiver =
2007 <SoundSystem_ISoundPlay as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2008 {
2009 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2010 let __vi = *__vt.get(3usize).unwrap_or_else(|| {
2011 panic!(
2012 "unity: virtual slot {}
2013 out of range (vtable len {}
2014) on the runtime class behind {}
2015 (method `{}
2016`)",
2017 3usize,
2018 __vt.len(),
2019 <SoundSystem_ISoundPlay as ::unity::ClassIdentity>::NAME,
2020 "PostEvent",
2021 )
2022 });
2023 let __inner: extern "C" fn(
2024 SoundSystem_ISoundPlay,
2025 ::unity::Il2CppString,
2026 crate::unity_engine::gameobject::GameObject,
2027 bool,
2028 ::unity::OptionalMethod,
2029 ) -> crate::app::soundsystem::SoundSystem_SoundHandle = ::core::mem::transmute(__vi.method_ptr);
2030 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2031 __inner(
2032 __receiver,
2033 ::core::convert::Into::into(name),
2034 ::core::convert::Into::into(game_object),
2035 ::core::convert::Into::into(is_get_position),
2036 __mi,
2037 )
2038 }
2039 }
2040 }
2041 #[doc = "`PostEventWithTemporaryGameObject(::unity::Il2CppString, crate::unity_engine::gameobject::GameObject, bool)` overload"]
2042 fn post_event_with_temporary_game_object(
2043 self,
2044 name: impl ::core::convert::Into<::unity::Il2CppString>,
2045 temporary_game_object: impl ::core::convert::Into<crate::unity_engine::gameobject::GameObject>,
2046 is_get_position: impl ::core::convert::Into<bool>,
2047 ) -> crate::app::soundsystem::SoundSystem_SoundHandle {
2048 unsafe {
2049 let __receiver =
2050 <SoundSystem_ISoundPlay as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2051 {
2052 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2053 let __vi = *__vt.get(4usize).unwrap_or_else(|| {
2054 panic!(
2055 "unity: virtual slot {}
2056 out of range (vtable len {}
2057) on the runtime class behind {}
2058 (method `{}
2059`)",
2060 4usize,
2061 __vt.len(),
2062 <SoundSystem_ISoundPlay as ::unity::ClassIdentity>::NAME,
2063 "PostEventWithTemporaryGameObject",
2064 )
2065 });
2066 let __inner: extern "C" fn(
2067 SoundSystem_ISoundPlay,
2068 ::unity::Il2CppString,
2069 crate::unity_engine::gameobject::GameObject,
2070 bool,
2071 ::unity::OptionalMethod,
2072 ) -> crate::app::soundsystem::SoundSystem_SoundHandle = ::core::mem::transmute(__vi.method_ptr);
2073 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2074 __inner(
2075 __receiver,
2076 ::core::convert::Into::into(name),
2077 ::core::convert::Into::into(temporary_game_object),
2078 ::core::convert::Into::into(is_get_position),
2079 __mi,
2080 )
2081 }
2082 }
2083 }
2084 #[doc = "`PostEventCallback(crate::system::object::Object, crate::root::akcallbacktype::AkCallbackType, crate::root::akcallbackinfo::AkCallbackInfo)` overload"]
2085 fn post_event_callback(
2086 self,
2087 cookie: impl ::core::convert::Into<crate::system::object::Object>,
2088 r#type: impl ::core::convert::Into<crate::root::akcallbacktype::AkCallbackType>,
2089 callback_info: impl ::core::convert::Into<crate::root::akcallbackinfo::AkCallbackInfo>,
2090 ) -> () {
2091 unsafe {
2092 let __receiver =
2093 <SoundSystem_ISoundPlay as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2094 {
2095 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2096 let __vi = *__vt.get(5usize).unwrap_or_else(|| {
2097 panic!(
2098 "unity: virtual slot {}
2099 out of range (vtable len {}
2100) on the runtime class behind {}
2101 (method `{}
2102`)",
2103 5usize,
2104 __vt.len(),
2105 <SoundSystem_ISoundPlay as ::unity::ClassIdentity>::NAME,
2106 "PostEventCallback",
2107 )
2108 });
2109 let __inner: extern "C" fn(
2110 SoundSystem_ISoundPlay,
2111 crate::system::object::Object,
2112 crate::root::akcallbacktype::AkCallbackType,
2113 crate::root::akcallbackinfo::AkCallbackInfo,
2114 ::unity::OptionalMethod,
2115 ) -> () = ::core::mem::transmute(__vi.method_ptr);
2116 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2117 __inner(
2118 __receiver,
2119 ::core::convert::Into::into(cookie),
2120 ::core::convert::Into::into(r#type),
2121 ::core::convert::Into::into(callback_info),
2122 __mi,
2123 )
2124 }
2125 }
2126 }
2127 #[doc = "`StopSoundOnEvent(::unity::Il2CppString, i32)` overload"]
2128 fn stop_sound_on_event(self, event_name: impl ::core::convert::Into<::unity::Il2CppString>, fade_msec: impl ::core::convert::Into<i32>) -> () {
2129 unsafe {
2130 let __receiver =
2131 <SoundSystem_ISoundPlay as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2132 {
2133 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2134 let __vi = *__vt.get(6usize).unwrap_or_else(|| {
2135 panic!(
2136 "unity: virtual slot {}
2137 out of range (vtable len {}
2138) on the runtime class behind {}
2139 (method `{}
2140`)",
2141 6usize,
2142 __vt.len(),
2143 <SoundSystem_ISoundPlay as ::unity::ClassIdentity>::NAME,
2144 "StopSoundOnEvent",
2145 )
2146 });
2147 let __inner: extern "C" fn(SoundSystem_ISoundPlay, ::unity::Il2CppString, i32, ::unity::OptionalMethod) -> () =
2148 ::core::mem::transmute(__vi.method_ptr);
2149 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2150 __inner(
2151 __receiver,
2152 ::core::convert::Into::into(event_name),
2153 ::core::convert::Into::into(fade_msec),
2154 __mi,
2155 )
2156 }
2157 }
2158 }
2159 #[doc = "`StopSoundOnEvent(::unity::Il2CppString, i32, crate::unity_engine::gameobject::GameObject)` overload"]
2160 fn stop_sound_on_event_2(
2161 self,
2162 event_name: impl ::core::convert::Into<::unity::Il2CppString>,
2163 fade_msec: impl ::core::convert::Into<i32>,
2164 game_object: impl ::core::convert::Into<crate::unity_engine::gameobject::GameObject>,
2165 ) -> () {
2166 unsafe {
2167 let __receiver =
2168 <SoundSystem_ISoundPlay as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2169 {
2170 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2171 let __vi = *__vt.get(7usize).unwrap_or_else(|| {
2172 panic!(
2173 "unity: virtual slot {}
2174 out of range (vtable len {}
2175) on the runtime class behind {}
2176 (method `{}
2177`)",
2178 7usize,
2179 __vt.len(),
2180 <SoundSystem_ISoundPlay as ::unity::ClassIdentity>::NAME,
2181 "StopSoundOnEvent",
2182 )
2183 });
2184 let __inner: extern "C" fn(
2185 SoundSystem_ISoundPlay,
2186 ::unity::Il2CppString,
2187 i32,
2188 crate::unity_engine::gameobject::GameObject,
2189 ::unity::OptionalMethod,
2190 ) -> () = ::core::mem::transmute(__vi.method_ptr);
2191 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2192 __inner(
2193 __receiver,
2194 ::core::convert::Into::into(event_name),
2195 ::core::convert::Into::into(fade_msec),
2196 ::core::convert::Into::into(game_object),
2197 __mi,
2198 )
2199 }
2200 }
2201 }
2202 #[doc = "`PauseSoundOnEvent(::unity::Il2CppString, i32)` overload"]
2203 fn pause_sound_on_event(self, event_name: impl ::core::convert::Into<::unity::Il2CppString>, fade_msec: impl ::core::convert::Into<i32>) -> () {
2204 unsafe {
2205 let __receiver =
2206 <SoundSystem_ISoundPlay as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2207 {
2208 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2209 let __vi = *__vt.get(8usize).unwrap_or_else(|| {
2210 panic!(
2211 "unity: virtual slot {}
2212 out of range (vtable len {}
2213) on the runtime class behind {}
2214 (method `{}
2215`)",
2216 8usize,
2217 __vt.len(),
2218 <SoundSystem_ISoundPlay as ::unity::ClassIdentity>::NAME,
2219 "PauseSoundOnEvent",
2220 )
2221 });
2222 let __inner: extern "C" fn(SoundSystem_ISoundPlay, ::unity::Il2CppString, i32, ::unity::OptionalMethod) -> () =
2223 ::core::mem::transmute(__vi.method_ptr);
2224 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2225 __inner(
2226 __receiver,
2227 ::core::convert::Into::into(event_name),
2228 ::core::convert::Into::into(fade_msec),
2229 __mi,
2230 )
2231 }
2232 }
2233 }
2234 #[doc = "`PauseSoundOnEvent(::unity::Il2CppString, i32, crate::unity_engine::gameobject::GameObject)` overload"]
2235 fn pause_sound_on_event_2(
2236 self,
2237 event_name: impl ::core::convert::Into<::unity::Il2CppString>,
2238 fade_msec: impl ::core::convert::Into<i32>,
2239 game_object: impl ::core::convert::Into<crate::unity_engine::gameobject::GameObject>,
2240 ) -> () {
2241 unsafe {
2242 let __receiver =
2243 <SoundSystem_ISoundPlay as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2244 {
2245 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2246 let __vi = *__vt.get(9usize).unwrap_or_else(|| {
2247 panic!(
2248 "unity: virtual slot {}
2249 out of range (vtable len {}
2250) on the runtime class behind {}
2251 (method `{}
2252`)",
2253 9usize,
2254 __vt.len(),
2255 <SoundSystem_ISoundPlay as ::unity::ClassIdentity>::NAME,
2256 "PauseSoundOnEvent",
2257 )
2258 });
2259 let __inner: extern "C" fn(
2260 SoundSystem_ISoundPlay,
2261 ::unity::Il2CppString,
2262 i32,
2263 crate::unity_engine::gameobject::GameObject,
2264 ::unity::OptionalMethod,
2265 ) -> () = ::core::mem::transmute(__vi.method_ptr);
2266 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2267 __inner(
2268 __receiver,
2269 ::core::convert::Into::into(event_name),
2270 ::core::convert::Into::into(fade_msec),
2271 ::core::convert::Into::into(game_object),
2272 __mi,
2273 )
2274 }
2275 }
2276 }
2277 #[doc = "`ResumeSoundOnEvent(::unity::Il2CppString, i32)` overload"]
2278 fn resume_sound_on_event(self, event_name: impl ::core::convert::Into<::unity::Il2CppString>, fade_msec: impl ::core::convert::Into<i32>) -> () {
2279 unsafe {
2280 let __receiver =
2281 <SoundSystem_ISoundPlay as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2282 {
2283 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2284 let __vi = *__vt.get(10usize).unwrap_or_else(|| {
2285 panic!(
2286 "unity: virtual slot {}
2287 out of range (vtable len {}
2288) on the runtime class behind {}
2289 (method `{}
2290`)",
2291 10usize,
2292 __vt.len(),
2293 <SoundSystem_ISoundPlay as ::unity::ClassIdentity>::NAME,
2294 "ResumeSoundOnEvent",
2295 )
2296 });
2297 let __inner: extern "C" fn(SoundSystem_ISoundPlay, ::unity::Il2CppString, i32, ::unity::OptionalMethod) -> () =
2298 ::core::mem::transmute(__vi.method_ptr);
2299 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2300 __inner(
2301 __receiver,
2302 ::core::convert::Into::into(event_name),
2303 ::core::convert::Into::into(fade_msec),
2304 __mi,
2305 )
2306 }
2307 }
2308 }
2309 #[doc = "`ResumeSoundOnEvent(::unity::Il2CppString, i32, crate::unity_engine::gameobject::GameObject)` overload"]
2310 fn resume_sound_on_event_2(
2311 self,
2312 event_name: impl ::core::convert::Into<::unity::Il2CppString>,
2313 fade_msec: impl ::core::convert::Into<i32>,
2314 game_object: impl ::core::convert::Into<crate::unity_engine::gameobject::GameObject>,
2315 ) -> () {
2316 unsafe {
2317 let __receiver =
2318 <SoundSystem_ISoundPlay as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2319 {
2320 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2321 let __vi = *__vt.get(11usize).unwrap_or_else(|| {
2322 panic!(
2323 "unity: virtual slot {}
2324 out of range (vtable len {}
2325) on the runtime class behind {}
2326 (method `{}
2327`)",
2328 11usize,
2329 __vt.len(),
2330 <SoundSystem_ISoundPlay as ::unity::ClassIdentity>::NAME,
2331 "ResumeSoundOnEvent",
2332 )
2333 });
2334 let __inner: extern "C" fn(
2335 SoundSystem_ISoundPlay,
2336 ::unity::Il2CppString,
2337 i32,
2338 crate::unity_engine::gameobject::GameObject,
2339 ::unity::OptionalMethod,
2340 ) -> () = ::core::mem::transmute(__vi.method_ptr);
2341 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2342 __inner(
2343 __receiver,
2344 ::core::convert::Into::into(event_name),
2345 ::core::convert::Into::into(fade_msec),
2346 ::core::convert::Into::into(game_object),
2347 __mi,
2348 )
2349 }
2350 }
2351 }
2352 #[doc = "`StopByPlayingId(u32, i32)` overload"]
2353 fn stop_by_playing_id(self, playing_id: impl ::core::convert::Into<u32>, fade_msec: impl ::core::convert::Into<i32>) -> () {
2354 unsafe {
2355 let __receiver =
2356 <SoundSystem_ISoundPlay as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2357 {
2358 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2359 let __vi = *__vt.get(12usize).unwrap_or_else(|| {
2360 panic!(
2361 "unity: virtual slot {}
2362 out of range (vtable len {}
2363) on the runtime class behind {}
2364 (method `{}
2365`)",
2366 12usize,
2367 __vt.len(),
2368 <SoundSystem_ISoundPlay as ::unity::ClassIdentity>::NAME,
2369 "StopByPlayingId",
2370 )
2371 });
2372 let __inner: extern "C" fn(SoundSystem_ISoundPlay, u32, i32, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__vi.method_ptr);
2373 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2374 __inner(
2375 __receiver,
2376 ::core::convert::Into::into(playing_id),
2377 ::core::convert::Into::into(fade_msec),
2378 __mi,
2379 )
2380 }
2381 }
2382 }
2383 #[doc = "`GetPlayPosition(u32, i32)` overload"]
2384 fn get_play_position(self, playing_id: impl ::core::convert::Into<u32>, position_offset: impl ::core::convert::Into<i32>) -> i32 {
2385 unsafe {
2386 let __receiver =
2387 <SoundSystem_ISoundPlay as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2388 {
2389 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2390 let __vi = *__vt.get(13usize).unwrap_or_else(|| {
2391 panic!(
2392 "unity: virtual slot {}
2393 out of range (vtable len {}
2394) on the runtime class behind {}
2395 (method `{}
2396`)",
2397 13usize,
2398 __vt.len(),
2399 <SoundSystem_ISoundPlay as ::unity::ClassIdentity>::NAME,
2400 "GetPlayPosition",
2401 )
2402 });
2403 let __inner: extern "C" fn(SoundSystem_ISoundPlay, u32, i32, ::unity::OptionalMethod) -> i32 =
2404 ::core::mem::transmute(__vi.method_ptr);
2405 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2406 __inner(
2407 __receiver,
2408 ::core::convert::Into::into(playing_id),
2409 ::core::convert::Into::into(position_offset),
2410 __mi,
2411 )
2412 }
2413 }
2414 }
2415}
2416
2417#[cfg(feature = "app-soundsystem")]
2418impl<__T: ISoundSystem_ISoundPlay> ISoundSystem_ISoundPlayMethods for __T {}
2419
2420#[cfg(feature = "app-soundsystem")]
2421impl SoundSystem_ISoundPlay {
2422 pub fn pop_temporary_game_object_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2423 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
2424 }
2425
2426 pub fn is_event_loaded_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2427 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
2428 }
2429
2430 pub fn post_event_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2431 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
2432 }
2433
2434 pub fn post_event_2_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2435 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
2436 }
2437
2438 pub fn post_event_with_temporary_game_object_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2439 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
2440 }
2441
2442 pub fn post_event_callback_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2443 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[5]
2444 }
2445
2446 pub fn stop_sound_on_event_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2447 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[6]
2448 }
2449
2450 pub fn stop_sound_on_event_2_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2451 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[7]
2452 }
2453
2454 pub fn pause_sound_on_event_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2455 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[8]
2456 }
2457
2458 pub fn pause_sound_on_event_2_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2459 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[9]
2460 }
2461
2462 pub fn resume_sound_on_event_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2463 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[10]
2464 }
2465
2466 pub fn resume_sound_on_event_2_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2467 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[11]
2468 }
2469
2470 pub fn stop_by_playing_id_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2471 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[12]
2472 }
2473
2474 pub fn get_play_position_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2475 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[13]
2476 }
2477}
2478
2479#[cfg(feature = "app-soundsystem")]
2480impl SoundSystem_ISoundPlay {
2481 #[doc = "Direct (non-virtual) call to `SoundSystem_ISoundPlay`'s own `PopTemporaryGameObject`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2482 pub unsafe fn pop_temporary_game_object(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::unity_engine::gameobject::GameObject {
2483 let __mi = Self::pop_temporary_game_object_method_info();
2484 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::unity_engine::gameobject::GameObject =
2485 ::core::mem::transmute(__mi.method_ptr);
2486 __inner(this.into(), ::core::option::Option::None)
2487 }
2488
2489 #[doc = "Direct (non-virtual) call to `SoundSystem_ISoundPlay`'s own `IsEventLoaded`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2490 pub unsafe fn is_event_loaded(this: impl ::core::convert::Into<::unity::IlInstance>, event_name: ::unity::Il2CppString) -> bool {
2491 let __mi = Self::is_event_loaded_method_info();
2492 let __inner: extern "C" fn(::unity::IlInstance, ::unity::Il2CppString, ::unity::OptionalMethod) -> bool =
2493 ::core::mem::transmute(__mi.method_ptr);
2494 __inner(this.into(), event_name, ::core::option::Option::None)
2495 }
2496
2497 #[doc = "Direct (non-virtual) call to `SoundSystem_ISoundPlay`'s own `PostEvent`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2498 pub unsafe fn post_event(
2499 this: impl ::core::convert::Into<::unity::IlInstance>,
2500 name: ::unity::Il2CppString,
2501 is_get_position: bool,
2502 ) -> crate::app::soundsystem::SoundSystem_SoundHandle {
2503 let __mi = Self::post_event_method_info();
2504 let __inner: extern "C" fn(
2505 ::unity::IlInstance,
2506 ::unity::Il2CppString,
2507 bool,
2508 ::unity::OptionalMethod,
2509 ) -> crate::app::soundsystem::SoundSystem_SoundHandle = ::core::mem::transmute(__mi.method_ptr);
2510 __inner(this.into(), name, is_get_position, ::core::option::Option::None)
2511 }
2512
2513 #[doc = "Direct (non-virtual) call to `SoundSystem_ISoundPlay`'s own `PostEvent`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2514 pub unsafe fn post_event_2(
2515 this: impl ::core::convert::Into<::unity::IlInstance>,
2516 name: ::unity::Il2CppString,
2517 game_object: crate::unity_engine::gameobject::GameObject,
2518 is_get_position: bool,
2519 ) -> crate::app::soundsystem::SoundSystem_SoundHandle {
2520 let __mi = Self::post_event_2_method_info();
2521 let __inner: extern "C" fn(
2522 ::unity::IlInstance,
2523 ::unity::Il2CppString,
2524 crate::unity_engine::gameobject::GameObject,
2525 bool,
2526 ::unity::OptionalMethod,
2527 ) -> crate::app::soundsystem::SoundSystem_SoundHandle = ::core::mem::transmute(__mi.method_ptr);
2528 __inner(this.into(), name, game_object, is_get_position, ::core::option::Option::None)
2529 }
2530
2531 #[doc = "Direct (non-virtual) call to `SoundSystem_ISoundPlay`'s own `PostEventWithTemporaryGameObject`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2532 pub unsafe fn post_event_with_temporary_game_object(
2533 this: impl ::core::convert::Into<::unity::IlInstance>,
2534 name: ::unity::Il2CppString,
2535 temporary_game_object: crate::unity_engine::gameobject::GameObject,
2536 is_get_position: bool,
2537 ) -> crate::app::soundsystem::SoundSystem_SoundHandle {
2538 let __mi = Self::post_event_with_temporary_game_object_method_info();
2539 let __inner: extern "C" fn(
2540 ::unity::IlInstance,
2541 ::unity::Il2CppString,
2542 crate::unity_engine::gameobject::GameObject,
2543 bool,
2544 ::unity::OptionalMethod,
2545 ) -> crate::app::soundsystem::SoundSystem_SoundHandle = ::core::mem::transmute(__mi.method_ptr);
2546 __inner(this.into(), name, temporary_game_object, is_get_position, ::core::option::Option::None)
2547 }
2548
2549 #[doc = "Direct (non-virtual) call to `SoundSystem_ISoundPlay`'s own `PostEventCallback`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2550 pub unsafe fn post_event_callback(
2551 this: impl ::core::convert::Into<::unity::IlInstance>,
2552 cookie: crate::system::object::Object,
2553 r#type: crate::root::akcallbacktype::AkCallbackType,
2554 callback_info: crate::root::akcallbackinfo::AkCallbackInfo,
2555 ) -> () {
2556 let __mi = Self::post_event_callback_method_info();
2557 let __inner: extern "C" fn(
2558 ::unity::IlInstance,
2559 crate::system::object::Object,
2560 crate::root::akcallbacktype::AkCallbackType,
2561 crate::root::akcallbackinfo::AkCallbackInfo,
2562 ::unity::OptionalMethod,
2563 ) -> () = ::core::mem::transmute(__mi.method_ptr);
2564 __inner(this.into(), cookie, r#type, callback_info, ::core::option::Option::None)
2565 }
2566
2567 #[doc = "Direct (non-virtual) call to `SoundSystem_ISoundPlay`'s own `StopSoundOnEvent`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2568 pub unsafe fn stop_sound_on_event(
2569 this: impl ::core::convert::Into<::unity::IlInstance>,
2570 event_name: ::unity::Il2CppString,
2571 fade_msec: i32,
2572 ) -> () {
2573 let __mi = Self::stop_sound_on_event_method_info();
2574 let __inner: extern "C" fn(::unity::IlInstance, ::unity::Il2CppString, i32, ::unity::OptionalMethod) -> () =
2575 ::core::mem::transmute(__mi.method_ptr);
2576 __inner(this.into(), event_name, fade_msec, ::core::option::Option::None)
2577 }
2578
2579 #[doc = "Direct (non-virtual) call to `SoundSystem_ISoundPlay`'s own `StopSoundOnEvent`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2580 pub unsafe fn stop_sound_on_event_2(
2581 this: impl ::core::convert::Into<::unity::IlInstance>,
2582 event_name: ::unity::Il2CppString,
2583 fade_msec: i32,
2584 game_object: crate::unity_engine::gameobject::GameObject,
2585 ) -> () {
2586 let __mi = Self::stop_sound_on_event_2_method_info();
2587 let __inner: extern "C" fn(
2588 ::unity::IlInstance,
2589 ::unity::Il2CppString,
2590 i32,
2591 crate::unity_engine::gameobject::GameObject,
2592 ::unity::OptionalMethod,
2593 ) -> () = ::core::mem::transmute(__mi.method_ptr);
2594 __inner(this.into(), event_name, fade_msec, game_object, ::core::option::Option::None)
2595 }
2596
2597 #[doc = "Direct (non-virtual) call to `SoundSystem_ISoundPlay`'s own `PauseSoundOnEvent`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2598 pub unsafe fn pause_sound_on_event(
2599 this: impl ::core::convert::Into<::unity::IlInstance>,
2600 event_name: ::unity::Il2CppString,
2601 fade_msec: i32,
2602 ) -> () {
2603 let __mi = Self::pause_sound_on_event_method_info();
2604 let __inner: extern "C" fn(::unity::IlInstance, ::unity::Il2CppString, i32, ::unity::OptionalMethod) -> () =
2605 ::core::mem::transmute(__mi.method_ptr);
2606 __inner(this.into(), event_name, fade_msec, ::core::option::Option::None)
2607 }
2608
2609 #[doc = "Direct (non-virtual) call to `SoundSystem_ISoundPlay`'s own `PauseSoundOnEvent`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2610 pub unsafe fn pause_sound_on_event_2(
2611 this: impl ::core::convert::Into<::unity::IlInstance>,
2612 event_name: ::unity::Il2CppString,
2613 fade_msec: i32,
2614 game_object: crate::unity_engine::gameobject::GameObject,
2615 ) -> () {
2616 let __mi = Self::pause_sound_on_event_2_method_info();
2617 let __inner: extern "C" fn(
2618 ::unity::IlInstance,
2619 ::unity::Il2CppString,
2620 i32,
2621 crate::unity_engine::gameobject::GameObject,
2622 ::unity::OptionalMethod,
2623 ) -> () = ::core::mem::transmute(__mi.method_ptr);
2624 __inner(this.into(), event_name, fade_msec, game_object, ::core::option::Option::None)
2625 }
2626
2627 #[doc = "Direct (non-virtual) call to `SoundSystem_ISoundPlay`'s own `ResumeSoundOnEvent`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2628 pub unsafe fn resume_sound_on_event(
2629 this: impl ::core::convert::Into<::unity::IlInstance>,
2630 event_name: ::unity::Il2CppString,
2631 fade_msec: i32,
2632 ) -> () {
2633 let __mi = Self::resume_sound_on_event_method_info();
2634 let __inner: extern "C" fn(::unity::IlInstance, ::unity::Il2CppString, i32, ::unity::OptionalMethod) -> () =
2635 ::core::mem::transmute(__mi.method_ptr);
2636 __inner(this.into(), event_name, fade_msec, ::core::option::Option::None)
2637 }
2638
2639 #[doc = "Direct (non-virtual) call to `SoundSystem_ISoundPlay`'s own `ResumeSoundOnEvent`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2640 pub unsafe fn resume_sound_on_event_2(
2641 this: impl ::core::convert::Into<::unity::IlInstance>,
2642 event_name: ::unity::Il2CppString,
2643 fade_msec: i32,
2644 game_object: crate::unity_engine::gameobject::GameObject,
2645 ) -> () {
2646 let __mi = Self::resume_sound_on_event_2_method_info();
2647 let __inner: extern "C" fn(
2648 ::unity::IlInstance,
2649 ::unity::Il2CppString,
2650 i32,
2651 crate::unity_engine::gameobject::GameObject,
2652 ::unity::OptionalMethod,
2653 ) -> () = ::core::mem::transmute(__mi.method_ptr);
2654 __inner(this.into(), event_name, fade_msec, game_object, ::core::option::Option::None)
2655 }
2656
2657 #[doc = "Direct (non-virtual) call to `SoundSystem_ISoundPlay`'s own `StopByPlayingId`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2658 pub unsafe fn stop_by_playing_id(this: impl ::core::convert::Into<::unity::IlInstance>, playing_id: u32, fade_msec: i32) -> () {
2659 let __mi = Self::stop_by_playing_id_method_info();
2660 let __inner: extern "C" fn(::unity::IlInstance, u32, i32, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
2661 __inner(this.into(), playing_id, fade_msec, ::core::option::Option::None)
2662 }
2663
2664 #[doc = "Direct (non-virtual) call to `SoundSystem_ISoundPlay`'s own `GetPlayPosition`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2665 pub unsafe fn get_play_position(this: impl ::core::convert::Into<::unity::IlInstance>, playing_id: u32, position_offset: i32) -> i32 {
2666 let __mi = Self::get_play_position_method_info();
2667 let __inner: extern "C" fn(::unity::IlInstance, u32, i32, ::unity::OptionalMethod) -> i32 = ::core::mem::transmute(__mi.method_ptr);
2668 __inner(this.into(), playing_id, position_offset, ::core::option::Option::None)
2669 }
2670}
2671
2672#[cfg(feature = "app-soundsystem")]
2673impl SoundSystem_LipSyncDataFile {
2674 #[doc = "`GetLipSyncFilePath(::unity::Il2CppString, i32)` overload"]
2675 pub fn get_lip_sync_file_path(
2676 file_name: impl ::core::convert::Into<::unity::Il2CppString>,
2677 patch_index: impl ::core::convert::Into<i32>,
2678 ) -> ::unity::Il2CppString {
2679 unsafe {
2680 ::unity::il2cpp_call!((::unity::module_base()+0x1d7cf70usize)as*mut u8, ::unity::Il2CppString;
2681(::unity::Il2CppString)::core::convert::Into::into(file_name),(i32)::core::convert::Into::into(patch_index))
2682 }
2683 }
2684
2685 #[doc = "`GetLipSyncFileRelativePath(::unity::Il2CppString)` overload"]
2686 pub fn get_lip_sync_file_relative_path(file_name: impl ::core::convert::Into<::unity::Il2CppString>) -> ::unity::Il2CppString {
2687 unsafe {
2688 ::unity::il2cpp_call!((::unity::module_base()+0x1d7d550usize)as*mut u8, ::unity::Il2CppString;
2689(::unity::Il2CppString)::core::convert::Into::into(file_name))
2690 }
2691 }
2692}
2693
2694#[cfg(feature = "app-soundsystem")]
2695pub trait ISoundSystem_LipSyncDataFileMethods: ISoundSystem_LipSyncDataFile {
2696 #[doc = "`.ctor()` overload"]
2697 fn ctor(self) -> () {
2698 unsafe {
2699 let __receiver =
2700 <SoundSystem_LipSyncDataFile as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2701 ::unity::il2cpp_call!((::unity::module_base()+0x1d7d760usize)as*mut u8,();
2702(SoundSystem_LipSyncDataFile)__receiver)
2703 }
2704 }
2705 #[doc = "`GetLipSyncDataCount()` overload"]
2706 fn get_lip_sync_data_count(self) -> i32 {
2707 unsafe {
2708 let __receiver =
2709 <SoundSystem_LipSyncDataFile as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2710 ::unity::il2cpp_call!((::unity::module_base()+0x1d7d9d0usize)as*mut u8,i32;
2711(SoundSystem_LipSyncDataFile)__receiver)
2712 }
2713 }
2714 #[doc = "`GetLipSyncData(i32)` overload"]
2715 fn get_lip_sync_data(self, index: impl ::core::convert::Into<i32>) -> crate::app::soundsystem::SoundSystem_LipSyncData {
2716 unsafe {
2717 let __receiver =
2718 <SoundSystem_LipSyncDataFile as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2719 ::unity::il2cpp_call!((::unity::module_base()+0x1d7da20usize)as*mut u8,crate::app::soundsystem::SoundSystem_LipSyncData;
2720(SoundSystem_LipSyncDataFile)__receiver,(i32)::core::convert::Into::into(index))
2721 }
2722 }
2723 #[doc = "`LoadAsync(::unity::Il2CppString)` overload"]
2724 fn load_async(self, file_name: impl ::core::convert::Into<::unity::Il2CppString>) -> () {
2725 unsafe {
2726 let __receiver =
2727 <SoundSystem_LipSyncDataFile as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2728 ::unity::il2cpp_call!((::unity::module_base()+0x1d7da90usize)as*mut u8,();
2729(SoundSystem_LipSyncDataFile)__receiver,(::unity::Il2CppString)::core::convert::Into::into(file_name))
2730 }
2731 }
2732 #[doc = "`ExpandFileData()` overload"]
2733 fn expand_file_data(self) -> bool {
2734 unsafe {
2735 let __receiver =
2736 <SoundSystem_LipSyncDataFile as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2737 ::unity::il2cpp_call!((::unity::module_base()+0x1d7dbc0usize)as*mut u8,bool;
2738(SoundSystem_LipSyncDataFile)__receiver)
2739 }
2740 }
2741 #[doc = "`Unload()` overload"]
2742 fn unload(self) -> () {
2743 unsafe {
2744 let __receiver =
2745 <SoundSystem_LipSyncDataFile as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2746 ::unity::il2cpp_call!((::unity::module_base()+0x1d7e050usize)as*mut u8,();
2747(SoundSystem_LipSyncDataFile)__receiver)
2748 }
2749 }
2750}
2751
2752#[cfg(feature = "app-soundsystem")]
2753impl<__T: ISoundSystem_LipSyncDataFile> ISoundSystem_LipSyncDataFileMethods for __T {}
2754
2755#[cfg(feature = "app-soundsystem")]
2756impl SoundSystem_LipSyncDataFile {
2757 pub fn get_lip_sync_file_path_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2758 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
2759 }
2760
2761 pub fn get_lip_sync_file_relative_path_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2762 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
2763 }
2764
2765 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2766 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
2767 }
2768
2769 pub fn get_lip_sync_data_count_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2770 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
2771 }
2772
2773 pub fn get_lip_sync_data_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2774 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
2775 }
2776
2777 pub fn load_async_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2778 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[5]
2779 }
2780
2781 pub fn expand_file_data_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2782 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[6]
2783 }
2784
2785 pub fn unload_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2786 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[7]
2787 }
2788}
2789
2790#[cfg(feature = "app-soundsystem")]
2791impl SoundSystem_LipSyncDataFile {
2792 #[doc = "`.ctor()` — no args"]
2793 pub fn new() -> Self {
2794 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
2795 panic!(
2796 "{}
2797::{}
2798 failed to instantiate",
2799 ::core::stringify!(SoundSystem_LipSyncDataFile),
2800 ::core::stringify!(new),
2801 )
2802 });
2803 <Self as ISoundSystem_LipSyncDataFileMethods>::ctor(this);
2804 this
2805 }
2806}
2807
2808#[cfg(feature = "app-soundsystem")]
2809pub trait ISoundSystem_LipSyncDataMethods: ISoundSystem_LipSyncData {
2810 #[doc = "`get_Msec()` overload"]
2811 fn get_msec(self) -> i32 {
2812 unsafe {
2813 let __receiver =
2814 <SoundSystem_LipSyncData as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2815 ::unity::il2cpp_call!((::unity::module_base()+0x1d7ce00usize)as*mut u8,i32;
2816(SoundSystem_LipSyncData)__receiver)
2817 }
2818 }
2819 #[doc = "`set_Msec(i32)` overload"]
2820 fn set_msec(self, value: impl ::core::convert::Into<i32>) -> () {
2821 unsafe {
2822 let __receiver =
2823 <SoundSystem_LipSyncData as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2824 ::unity::il2cpp_call!((::unity::module_base()+0x1d7ce10usize)as*mut u8,();
2825(SoundSystem_LipSyncData)__receiver,(i32)::core::convert::Into::into(value))
2826 }
2827 }
2828 #[doc = "`get_Width()` overload"]
2829 fn get_width(self) -> f32 {
2830 unsafe {
2831 let __receiver =
2832 <SoundSystem_LipSyncData as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2833 ::unity::il2cpp_call!((::unity::module_base()+0x1d7ce20usize)as*mut u8,f32;
2834(SoundSystem_LipSyncData)__receiver)
2835 }
2836 }
2837 #[doc = "`set_Width(f32)` overload"]
2838 fn set_width(self, value: impl ::core::convert::Into<f32>) -> () {
2839 unsafe {
2840 let __receiver =
2841 <SoundSystem_LipSyncData as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2842 ::unity::il2cpp_call!((::unity::module_base()+0x1d7ce30usize)as*mut u8,();
2843(SoundSystem_LipSyncData)__receiver,(f32)::core::convert::Into::into(value))
2844 }
2845 }
2846 #[doc = "`get_Height()` overload"]
2847 fn get_height(self) -> f32 {
2848 unsafe {
2849 let __receiver =
2850 <SoundSystem_LipSyncData as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2851 ::unity::il2cpp_call!((::unity::module_base()+0x1d7ce40usize)as*mut u8,f32;
2852(SoundSystem_LipSyncData)__receiver)
2853 }
2854 }
2855 #[doc = "`set_Height(f32)` overload"]
2856 fn set_height(self, value: impl ::core::convert::Into<f32>) -> () {
2857 unsafe {
2858 let __receiver =
2859 <SoundSystem_LipSyncData as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2860 ::unity::il2cpp_call!((::unity::module_base()+0x1d7ce50usize)as*mut u8,();
2861(SoundSystem_LipSyncData)__receiver,(f32)::core::convert::Into::into(value))
2862 }
2863 }
2864 #[doc = "`get_Tongue()` overload"]
2865 fn get_tongue(self) -> f32 {
2866 unsafe {
2867 let __receiver =
2868 <SoundSystem_LipSyncData as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2869 ::unity::il2cpp_call!((::unity::module_base()+0x1d7ce60usize)as*mut u8,f32;
2870(SoundSystem_LipSyncData)__receiver)
2871 }
2872 }
2873 #[doc = "`set_Tongue(f32)` overload"]
2874 fn set_tongue(self, value: impl ::core::convert::Into<f32>) -> () {
2875 unsafe {
2876 let __receiver =
2877 <SoundSystem_LipSyncData as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2878 ::unity::il2cpp_call!((::unity::module_base()+0x1d7ce70usize)as*mut u8,();
2879(SoundSystem_LipSyncData)__receiver,(f32)::core::convert::Into::into(value))
2880 }
2881 }
2882 #[doc = "`get_A()` overload"]
2883 fn get_a(self) -> f32 {
2884 unsafe {
2885 let __receiver =
2886 <SoundSystem_LipSyncData as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2887 ::unity::il2cpp_call!((::unity::module_base()+0x1d7ce80usize)as*mut u8,f32;
2888(SoundSystem_LipSyncData)__receiver)
2889 }
2890 }
2891 #[doc = "`set_A(f32)` overload"]
2892 fn set_a(self, value: impl ::core::convert::Into<f32>) -> () {
2893 unsafe {
2894 let __receiver =
2895 <SoundSystem_LipSyncData as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2896 ::unity::il2cpp_call!((::unity::module_base()+0x1d7ce90usize)as*mut u8,();
2897(SoundSystem_LipSyncData)__receiver,(f32)::core::convert::Into::into(value))
2898 }
2899 }
2900 #[doc = "`get_I()` overload"]
2901 fn get_i(self) -> f32 {
2902 unsafe {
2903 let __receiver =
2904 <SoundSystem_LipSyncData as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2905 ::unity::il2cpp_call!((::unity::module_base()+0x1d7cea0usize)as*mut u8,f32;
2906(SoundSystem_LipSyncData)__receiver)
2907 }
2908 }
2909 #[doc = "`set_I(f32)` overload"]
2910 fn set_i(self, value: impl ::core::convert::Into<f32>) -> () {
2911 unsafe {
2912 let __receiver =
2913 <SoundSystem_LipSyncData as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2914 ::unity::il2cpp_call!((::unity::module_base()+0x1d7ceb0usize)as*mut u8,();
2915(SoundSystem_LipSyncData)__receiver,(f32)::core::convert::Into::into(value))
2916 }
2917 }
2918 #[doc = "`get_U()` overload"]
2919 fn get_u(self) -> f32 {
2920 unsafe {
2921 let __receiver =
2922 <SoundSystem_LipSyncData as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2923 ::unity::il2cpp_call!((::unity::module_base()+0x1d7cec0usize)as*mut u8,f32;
2924(SoundSystem_LipSyncData)__receiver)
2925 }
2926 }
2927 #[doc = "`set_U(f32)` overload"]
2928 fn set_u(self, value: impl ::core::convert::Into<f32>) -> () {
2929 unsafe {
2930 let __receiver =
2931 <SoundSystem_LipSyncData as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2932 ::unity::il2cpp_call!((::unity::module_base()+0x1d7ced0usize)as*mut u8,();
2933(SoundSystem_LipSyncData)__receiver,(f32)::core::convert::Into::into(value))
2934 }
2935 }
2936 #[doc = "`get_E()` overload"]
2937 fn get_e(self) -> f32 {
2938 unsafe {
2939 let __receiver =
2940 <SoundSystem_LipSyncData as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2941 ::unity::il2cpp_call!((::unity::module_base()+0x1d7cee0usize)as*mut u8,f32;
2942(SoundSystem_LipSyncData)__receiver)
2943 }
2944 }
2945 #[doc = "`set_E(f32)` overload"]
2946 fn set_e(self, value: impl ::core::convert::Into<f32>) -> () {
2947 unsafe {
2948 let __receiver =
2949 <SoundSystem_LipSyncData as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2950 ::unity::il2cpp_call!((::unity::module_base()+0x1d7cef0usize)as*mut u8,();
2951(SoundSystem_LipSyncData)__receiver,(f32)::core::convert::Into::into(value))
2952 }
2953 }
2954 #[doc = "`get_O()` overload"]
2955 fn get_o(self) -> f32 {
2956 unsafe {
2957 let __receiver =
2958 <SoundSystem_LipSyncData as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2959 ::unity::il2cpp_call!((::unity::module_base()+0x1d7cf00usize)as*mut u8,f32;
2960(SoundSystem_LipSyncData)__receiver)
2961 }
2962 }
2963 #[doc = "`set_O(f32)` overload"]
2964 fn set_o(self, value: impl ::core::convert::Into<f32>) -> () {
2965 unsafe {
2966 let __receiver =
2967 <SoundSystem_LipSyncData as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2968 ::unity::il2cpp_call!((::unity::module_base()+0x1d7cf10usize)as*mut u8,();
2969(SoundSystem_LipSyncData)__receiver,(f32)::core::convert::Into::into(value))
2970 }
2971 }
2972 #[doc = "`get_Vol()` overload"]
2973 fn get_vol(self) -> f32 {
2974 unsafe {
2975 let __receiver =
2976 <SoundSystem_LipSyncData as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2977 ::unity::il2cpp_call!((::unity::module_base()+0x1d7cf20usize)as*mut u8,f32;
2978(SoundSystem_LipSyncData)__receiver)
2979 }
2980 }
2981 #[doc = "`set_Vol(f32)` overload"]
2982 fn set_vol(self, value: impl ::core::convert::Into<f32>) -> () {
2983 unsafe {
2984 let __receiver =
2985 <SoundSystem_LipSyncData as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2986 ::unity::il2cpp_call!((::unity::module_base()+0x1d7cf30usize)as*mut u8,();
2987(SoundSystem_LipSyncData)__receiver,(f32)::core::convert::Into::into(value))
2988 }
2989 }
2990 #[doc = "`SetData(crate::app::soundsystem::SoundSystem_LipSyncStructData)` overload"]
2991 fn set_data(self, data: impl ::core::convert::Into<crate::app::soundsystem::SoundSystem_LipSyncStructData>) -> () {
2992 unsafe {
2993 let __receiver =
2994 <SoundSystem_LipSyncData as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2995 ::unity::il2cpp_call!((::unity::module_base()+0x1d7cf40usize)as*mut u8,();
2996(SoundSystem_LipSyncData)__receiver,(crate::app::soundsystem::SoundSystem_LipSyncStructData)::core::convert::Into::into(data))
2997 }
2998 }
2999 #[doc = "`.ctor()` overload"]
3000 fn ctor(self) -> () {
3001 unsafe {
3002 let __receiver =
3003 <SoundSystem_LipSyncData as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3004 ::unity::il2cpp_call!((::unity::module_base()+0x1d7cf60usize)as*mut u8,();
3005(SoundSystem_LipSyncData)__receiver)
3006 }
3007 }
3008}
3009
3010#[cfg(feature = "app-soundsystem")]
3011impl<__T: ISoundSystem_LipSyncData> ISoundSystem_LipSyncDataMethods for __T {}
3012
3013#[cfg(feature = "app-soundsystem")]
3014impl SoundSystem_LipSyncData {
3015 pub fn get_msec_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3016 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
3017 }
3018
3019 pub fn set_msec_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3020 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
3021 }
3022
3023 pub fn get_width_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3024 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
3025 }
3026
3027 pub fn set_width_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3028 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
3029 }
3030
3031 pub fn get_height_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3032 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
3033 }
3034
3035 pub fn set_height_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3036 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[5]
3037 }
3038
3039 pub fn get_tongue_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3040 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[6]
3041 }
3042
3043 pub fn set_tongue_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3044 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[7]
3045 }
3046
3047 pub fn get_a_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3048 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[8]
3049 }
3050
3051 pub fn set_a_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3052 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[9]
3053 }
3054
3055 pub fn get_i_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3056 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[10]
3057 }
3058
3059 pub fn set_i_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3060 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[11]
3061 }
3062
3063 pub fn get_u_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3064 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[12]
3065 }
3066
3067 pub fn set_u_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3068 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[13]
3069 }
3070
3071 pub fn get_e_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3072 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[14]
3073 }
3074
3075 pub fn set_e_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3076 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[15]
3077 }
3078
3079 pub fn get_o_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3080 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[16]
3081 }
3082
3083 pub fn set_o_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3084 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[17]
3085 }
3086
3087 pub fn get_vol_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3088 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[18]
3089 }
3090
3091 pub fn set_vol_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3092 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[19]
3093 }
3094
3095 pub fn set_data_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3096 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[20]
3097 }
3098
3099 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3100 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[21]
3101 }
3102}
3103
3104#[cfg(feature = "app-soundsystem")]
3105impl SoundSystem_LipSyncData {
3106 #[doc = "`.ctor()` — no args"]
3107 pub fn new() -> Self {
3108 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
3109 panic!(
3110 "{}
3111::{}
3112 failed to instantiate",
3113 ::core::stringify!(SoundSystem_LipSyncData),
3114 ::core::stringify!(new),
3115 )
3116 });
3117 <Self as ISoundSystem_LipSyncDataMethods>::ctor(this);
3118 this
3119 }
3120}
3121
3122#[cfg(feature = "app-soundsystem")]
3123pub trait ISoundSystem_ResultSoundLoadListMethods: ISoundSystem_ResultSoundLoadList {
3124 #[doc = "`.ctor()` overload"]
3125 fn ctor(self) -> () {
3126 unsafe {
3127 let __receiver =
3128 <SoundSystem_ResultSoundLoadList as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3129 ::unity::il2cpp_call!((::unity::module_base()+0x1d7e1a0usize)as*mut u8,();
3130(SoundSystem_ResultSoundLoadList)__receiver)
3131 }
3132 }
3133 #[doc = "`Add(crate::app::soundsystem::SoundSystem_ResultSoundLoad)` overload"]
3134 fn add(self, result: impl ::core::convert::Into<crate::app::soundsystem::SoundSystem_ResultSoundLoad>) -> () {
3135 unsafe {
3136 let __receiver =
3137 <SoundSystem_ResultSoundLoadList as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3138 ::unity::il2cpp_call!((::unity::module_base()+0x1d7e230usize)as*mut u8,();
3139(SoundSystem_ResultSoundLoadList)__receiver,(crate::app::soundsystem::SoundSystem_ResultSoundLoad)::core::convert::Into::into(result))
3140 }
3141 }
3142 #[doc = "`IsLoading()` overload"]
3143 fn is_loading(self) -> bool {
3144 unsafe {
3145 let __receiver =
3146 <SoundSystem_ResultSoundLoadList as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3147 ::unity::il2cpp_call!((::unity::module_base()+0x1d7e290usize)as*mut u8,bool;
3148(SoundSystem_ResultSoundLoadList)__receiver)
3149 }
3150 }
3151 #[doc = "`IsLoadSuccess()` overload"]
3152 fn is_load_success(self) -> bool {
3153 unsafe {
3154 let __receiver =
3155 <SoundSystem_ResultSoundLoadList as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3156 ::unity::il2cpp_call!((::unity::module_base()+0x1d7e3e0usize)as*mut u8,bool;
3157(SoundSystem_ResultSoundLoadList)__receiver)
3158 }
3159 }
3160}
3161
3162#[cfg(feature = "app-soundsystem")]
3163impl<__T: ISoundSystem_ResultSoundLoadList> ISoundSystem_ResultSoundLoadListMethods for __T {}
3164
3165#[cfg(feature = "app-soundsystem")]
3166impl SoundSystem_ResultSoundLoadList {
3167 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3168 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
3169 }
3170
3171 pub fn add_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3172 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
3173 }
3174
3175 pub fn is_loading_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3176 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
3177 }
3178
3179 pub fn is_load_success_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3180 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
3181 }
3182}
3183
3184#[cfg(feature = "app-soundsystem")]
3185impl SoundSystem_ResultSoundLoadList {
3186 #[doc = "`.ctor()` — no args"]
3187 pub fn new() -> Self {
3188 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
3189 panic!(
3190 "{}
3191::{}
3192 failed to instantiate",
3193 ::core::stringify!(SoundSystem_ResultSoundLoadList),
3194 ::core::stringify!(new),
3195 )
3196 });
3197 <Self as ISoundSystem_ResultSoundLoadListMethods>::ctor(this);
3198 this
3199 }
3200}
3201
3202#[cfg(feature = "app-soundsystem")]
3203impl SoundSystem {
3204 #[doc = "`.cctor()` overload"]
3205 pub fn cctor() -> () {
3206 unsafe {
3207 ::unity::il2cpp_call!((::unity::module_base()+0x24fbf90usize)as*mut u8,();
3208 )
3209 }
3210 }
3211}
3212
3213#[cfg(feature = "app-soundsystem")]
3214pub trait ISoundSystemMethods: ISoundSystem {
3215 #[doc = "`.ctor()` overload"]
3216 fn ctor(self) -> () {
3217 unsafe {
3218 let __receiver = <SoundSystem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3219 ::unity::il2cpp_call!((::unity::module_base()+0x24fbf80usize)as*mut u8,();
3220(SoundSystem)__receiver)
3221 }
3222 }
3223}
3224
3225#[cfg(feature = "app-soundsystem")]
3226impl<__T: ISoundSystem> ISoundSystemMethods for __T {}
3227
3228#[cfg(feature = "app-soundsystem")]
3229impl SoundSystem {
3230 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3231 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
3232 }
3233
3234 pub fn cctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3235 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
3236 }
3237}
3238
3239#[cfg(feature = "app-soundsystem")]
3240impl SoundSystem {
3241 #[doc = "`.ctor()` — no args"]
3242 pub fn new() -> Self {
3243 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
3244 panic!(
3245 "{}
3246::{}
3247 failed to instantiate",
3248 ::core::stringify!(SoundSystem),
3249 ::core::stringify!(new),
3250 )
3251 });
3252 <Self as ISoundSystemMethods>::ctor(this);
3253 this
3254 }
3255}
3256
3257#[cfg(feature = "app-soundsystem")]
3258pub trait ISoundSystem_ISoundParamMethods: ISoundSystem_ISoundParam {
3259 #[doc = "`GetMasterBgmVolume()` overload"]
3260 fn get_master_bgm_volume(self) -> f32 {
3261 unsafe {
3262 let __receiver =
3263 <SoundSystem_ISoundParam as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3264 {
3265 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
3266 let __vi = *__vt.get(0usize).unwrap_or_else(|| {
3267 panic!(
3268 "unity: virtual slot {}
3269 out of range (vtable len {}
3270) on the runtime class behind {}
3271 (method `{}
3272`)",
3273 0usize,
3274 __vt.len(),
3275 <SoundSystem_ISoundParam as ::unity::ClassIdentity>::NAME,
3276 "GetMasterBgmVolume",
3277 )
3278 });
3279 let __inner: extern "C" fn(SoundSystem_ISoundParam, ::unity::OptionalMethod) -> f32 = ::core::mem::transmute(__vi.method_ptr);
3280 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
3281 __inner(__receiver, __mi)
3282 }
3283 }
3284 }
3285 #[doc = "`GetMasterSeVolume()` overload"]
3286 fn get_master_se_volume(self) -> f32 {
3287 unsafe {
3288 let __receiver =
3289 <SoundSystem_ISoundParam as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3290 {
3291 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
3292 let __vi = *__vt.get(1usize).unwrap_or_else(|| {
3293 panic!(
3294 "unity: virtual slot {}
3295 out of range (vtable len {}
3296) on the runtime class behind {}
3297 (method `{}
3298`)",
3299 1usize,
3300 __vt.len(),
3301 <SoundSystem_ISoundParam as ::unity::ClassIdentity>::NAME,
3302 "GetMasterSeVolume",
3303 )
3304 });
3305 let __inner: extern "C" fn(SoundSystem_ISoundParam, ::unity::OptionalMethod) -> f32 = ::core::mem::transmute(__vi.method_ptr);
3306 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
3307 __inner(__receiver, __mi)
3308 }
3309 }
3310 }
3311 #[doc = "`GetMasterEnvVolume()` overload"]
3312 fn get_master_env_volume(self) -> f32 {
3313 unsafe {
3314 let __receiver =
3315 <SoundSystem_ISoundParam as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3316 {
3317 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
3318 let __vi = *__vt.get(2usize).unwrap_or_else(|| {
3319 panic!(
3320 "unity: virtual slot {}
3321 out of range (vtable len {}
3322) on the runtime class behind {}
3323 (method `{}
3324`)",
3325 2usize,
3326 __vt.len(),
3327 <SoundSystem_ISoundParam as ::unity::ClassIdentity>::NAME,
3328 "GetMasterEnvVolume",
3329 )
3330 });
3331 let __inner: extern "C" fn(SoundSystem_ISoundParam, ::unity::OptionalMethod) -> f32 = ::core::mem::transmute(__vi.method_ptr);
3332 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
3333 __inner(__receiver, __mi)
3334 }
3335 }
3336 }
3337 #[doc = "`GetMasterVoiceVolume()` overload"]
3338 fn get_master_voice_volume(self) -> f32 {
3339 unsafe {
3340 let __receiver =
3341 <SoundSystem_ISoundParam as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3342 {
3343 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
3344 let __vi = *__vt.get(3usize).unwrap_or_else(|| {
3345 panic!(
3346 "unity: virtual slot {}
3347 out of range (vtable len {}
3348) on the runtime class behind {}
3349 (method `{}
3350`)",
3351 3usize,
3352 __vt.len(),
3353 <SoundSystem_ISoundParam as ::unity::ClassIdentity>::NAME,
3354 "GetMasterVoiceVolume",
3355 )
3356 });
3357 let __inner: extern "C" fn(SoundSystem_ISoundParam, ::unity::OptionalMethod) -> f32 = ::core::mem::transmute(__vi.method_ptr);
3358 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
3359 __inner(__receiver, __mi)
3360 }
3361 }
3362 }
3363 #[doc = "`SetMasterBgmVolume(f32, i32)` overload"]
3364 fn set_master_bgm_volume(self, vol: impl ::core::convert::Into<f32>, fade_msec: impl ::core::convert::Into<i32>) -> () {
3365 unsafe {
3366 let __receiver =
3367 <SoundSystem_ISoundParam as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3368 {
3369 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
3370 let __vi = *__vt.get(4usize).unwrap_or_else(|| {
3371 panic!(
3372 "unity: virtual slot {}
3373 out of range (vtable len {}
3374) on the runtime class behind {}
3375 (method `{}
3376`)",
3377 4usize,
3378 __vt.len(),
3379 <SoundSystem_ISoundParam as ::unity::ClassIdentity>::NAME,
3380 "SetMasterBgmVolume",
3381 )
3382 });
3383 let __inner: extern "C" fn(SoundSystem_ISoundParam, f32, i32, ::unity::OptionalMethod) -> () =
3384 ::core::mem::transmute(__vi.method_ptr);
3385 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
3386 __inner(__receiver, ::core::convert::Into::into(vol), ::core::convert::Into::into(fade_msec), __mi)
3387 }
3388 }
3389 }
3390 #[doc = "`SetMasterSeVolume(f32, i32)` overload"]
3391 fn set_master_se_volume(self, vol: impl ::core::convert::Into<f32>, fade_msec: impl ::core::convert::Into<i32>) -> () {
3392 unsafe {
3393 let __receiver =
3394 <SoundSystem_ISoundParam as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3395 {
3396 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
3397 let __vi = *__vt.get(5usize).unwrap_or_else(|| {
3398 panic!(
3399 "unity: virtual slot {}
3400 out of range (vtable len {}
3401) on the runtime class behind {}
3402 (method `{}
3403`)",
3404 5usize,
3405 __vt.len(),
3406 <SoundSystem_ISoundParam as ::unity::ClassIdentity>::NAME,
3407 "SetMasterSeVolume",
3408 )
3409 });
3410 let __inner: extern "C" fn(SoundSystem_ISoundParam, f32, i32, ::unity::OptionalMethod) -> () =
3411 ::core::mem::transmute(__vi.method_ptr);
3412 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
3413 __inner(__receiver, ::core::convert::Into::into(vol), ::core::convert::Into::into(fade_msec), __mi)
3414 }
3415 }
3416 }
3417 #[doc = "`SetMasterEnvVolume(f32, i32)` overload"]
3418 fn set_master_env_volume(self, vol: impl ::core::convert::Into<f32>, fade_msec: impl ::core::convert::Into<i32>) -> () {
3419 unsafe {
3420 let __receiver =
3421 <SoundSystem_ISoundParam as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3422 {
3423 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
3424 let __vi = *__vt.get(6usize).unwrap_or_else(|| {
3425 panic!(
3426 "unity: virtual slot {}
3427 out of range (vtable len {}
3428) on the runtime class behind {}
3429 (method `{}
3430`)",
3431 6usize,
3432 __vt.len(),
3433 <SoundSystem_ISoundParam as ::unity::ClassIdentity>::NAME,
3434 "SetMasterEnvVolume",
3435 )
3436 });
3437 let __inner: extern "C" fn(SoundSystem_ISoundParam, f32, i32, ::unity::OptionalMethod) -> () =
3438 ::core::mem::transmute(__vi.method_ptr);
3439 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
3440 __inner(__receiver, ::core::convert::Into::into(vol), ::core::convert::Into::into(fade_msec), __mi)
3441 }
3442 }
3443 }
3444 #[doc = "`SetMasterVoiceVolume(f32, i32)` overload"]
3445 fn set_master_voice_volume(self, vol: impl ::core::convert::Into<f32>, fade_msec: impl ::core::convert::Into<i32>) -> () {
3446 unsafe {
3447 let __receiver =
3448 <SoundSystem_ISoundParam as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3449 {
3450 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
3451 let __vi = *__vt.get(7usize).unwrap_or_else(|| {
3452 panic!(
3453 "unity: virtual slot {}
3454 out of range (vtable len {}
3455) on the runtime class behind {}
3456 (method `{}
3457`)",
3458 7usize,
3459 __vt.len(),
3460 <SoundSystem_ISoundParam as ::unity::ClassIdentity>::NAME,
3461 "SetMasterVoiceVolume",
3462 )
3463 });
3464 let __inner: extern "C" fn(SoundSystem_ISoundParam, f32, i32, ::unity::OptionalMethod) -> () =
3465 ::core::mem::transmute(__vi.method_ptr);
3466 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
3467 __inner(__receiver, ::core::convert::Into::into(vol), ::core::convert::Into::into(fade_msec), __mi)
3468 }
3469 }
3470 }
3471 #[doc = "`ResetMasterBgmVolume(i32)` overload"]
3472 fn reset_master_bgm_volume(self, fade_msec: impl ::core::convert::Into<i32>) -> () {
3473 unsafe {
3474 let __receiver =
3475 <SoundSystem_ISoundParam as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3476 {
3477 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
3478 let __vi = *__vt.get(8usize).unwrap_or_else(|| {
3479 panic!(
3480 "unity: virtual slot {}
3481 out of range (vtable len {}
3482) on the runtime class behind {}
3483 (method `{}
3484`)",
3485 8usize,
3486 __vt.len(),
3487 <SoundSystem_ISoundParam as ::unity::ClassIdentity>::NAME,
3488 "ResetMasterBgmVolume",
3489 )
3490 });
3491 let __inner: extern "C" fn(SoundSystem_ISoundParam, i32, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__vi.method_ptr);
3492 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
3493 __inner(__receiver, ::core::convert::Into::into(fade_msec), __mi)
3494 }
3495 }
3496 }
3497 #[doc = "`ResetMasterSeVolume(i32)` overload"]
3498 fn reset_master_se_volume(self, fade_msec: impl ::core::convert::Into<i32>) -> () {
3499 unsafe {
3500 let __receiver =
3501 <SoundSystem_ISoundParam as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3502 {
3503 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
3504 let __vi = *__vt.get(9usize).unwrap_or_else(|| {
3505 panic!(
3506 "unity: virtual slot {}
3507 out of range (vtable len {}
3508) on the runtime class behind {}
3509 (method `{}
3510`)",
3511 9usize,
3512 __vt.len(),
3513 <SoundSystem_ISoundParam as ::unity::ClassIdentity>::NAME,
3514 "ResetMasterSeVolume",
3515 )
3516 });
3517 let __inner: extern "C" fn(SoundSystem_ISoundParam, i32, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__vi.method_ptr);
3518 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
3519 __inner(__receiver, ::core::convert::Into::into(fade_msec), __mi)
3520 }
3521 }
3522 }
3523 #[doc = "`ResetMasterEnvVolume(i32)` overload"]
3524 fn reset_master_env_volume(self, fade_msec: impl ::core::convert::Into<i32>) -> () {
3525 unsafe {
3526 let __receiver =
3527 <SoundSystem_ISoundParam as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3528 {
3529 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
3530 let __vi = *__vt.get(10usize).unwrap_or_else(|| {
3531 panic!(
3532 "unity: virtual slot {}
3533 out of range (vtable len {}
3534) on the runtime class behind {}
3535 (method `{}
3536`)",
3537 10usize,
3538 __vt.len(),
3539 <SoundSystem_ISoundParam as ::unity::ClassIdentity>::NAME,
3540 "ResetMasterEnvVolume",
3541 )
3542 });
3543 let __inner: extern "C" fn(SoundSystem_ISoundParam, i32, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__vi.method_ptr);
3544 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
3545 __inner(__receiver, ::core::convert::Into::into(fade_msec), __mi)
3546 }
3547 }
3548 }
3549 #[doc = "`ResetMasterVoiceVolume(i32)` overload"]
3550 fn reset_master_voice_volume(self, fade_msec: impl ::core::convert::Into<i32>) -> () {
3551 unsafe {
3552 let __receiver =
3553 <SoundSystem_ISoundParam as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3554 {
3555 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
3556 let __vi = *__vt.get(11usize).unwrap_or_else(|| {
3557 panic!(
3558 "unity: virtual slot {}
3559 out of range (vtable len {}
3560) on the runtime class behind {}
3561 (method `{}
3562`)",
3563 11usize,
3564 __vt.len(),
3565 <SoundSystem_ISoundParam as ::unity::ClassIdentity>::NAME,
3566 "ResetMasterVoiceVolume",
3567 )
3568 });
3569 let __inner: extern "C" fn(SoundSystem_ISoundParam, i32, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__vi.method_ptr);
3570 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
3571 __inner(__receiver, ::core::convert::Into::into(fade_msec), __mi)
3572 }
3573 }
3574 }
3575 #[doc = "`GetConfigBgmVolume()` overload"]
3576 fn get_config_bgm_volume(self) -> f32 {
3577 unsafe {
3578 let __receiver =
3579 <SoundSystem_ISoundParam as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3580 {
3581 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
3582 let __vi = *__vt.get(12usize).unwrap_or_else(|| {
3583 panic!(
3584 "unity: virtual slot {}
3585 out of range (vtable len {}
3586) on the runtime class behind {}
3587 (method `{}
3588`)",
3589 12usize,
3590 __vt.len(),
3591 <SoundSystem_ISoundParam as ::unity::ClassIdentity>::NAME,
3592 "GetConfigBgmVolume",
3593 )
3594 });
3595 let __inner: extern "C" fn(SoundSystem_ISoundParam, ::unity::OptionalMethod) -> f32 = ::core::mem::transmute(__vi.method_ptr);
3596 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
3597 __inner(__receiver, __mi)
3598 }
3599 }
3600 }
3601 #[doc = "`GetConfigSeVolume()` overload"]
3602 fn get_config_se_volume(self) -> f32 {
3603 unsafe {
3604 let __receiver =
3605 <SoundSystem_ISoundParam as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3606 {
3607 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
3608 let __vi = *__vt.get(13usize).unwrap_or_else(|| {
3609 panic!(
3610 "unity: virtual slot {}
3611 out of range (vtable len {}
3612) on the runtime class behind {}
3613 (method `{}
3614`)",
3615 13usize,
3616 __vt.len(),
3617 <SoundSystem_ISoundParam as ::unity::ClassIdentity>::NAME,
3618 "GetConfigSeVolume",
3619 )
3620 });
3621 let __inner: extern "C" fn(SoundSystem_ISoundParam, ::unity::OptionalMethod) -> f32 = ::core::mem::transmute(__vi.method_ptr);
3622 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
3623 __inner(__receiver, __mi)
3624 }
3625 }
3626 }
3627 #[doc = "`GetConfigEnvVolume()` overload"]
3628 fn get_config_env_volume(self) -> f32 {
3629 unsafe {
3630 let __receiver =
3631 <SoundSystem_ISoundParam as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3632 {
3633 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
3634 let __vi = *__vt.get(14usize).unwrap_or_else(|| {
3635 panic!(
3636 "unity: virtual slot {}
3637 out of range (vtable len {}
3638) on the runtime class behind {}
3639 (method `{}
3640`)",
3641 14usize,
3642 __vt.len(),
3643 <SoundSystem_ISoundParam as ::unity::ClassIdentity>::NAME,
3644 "GetConfigEnvVolume",
3645 )
3646 });
3647 let __inner: extern "C" fn(SoundSystem_ISoundParam, ::unity::OptionalMethod) -> f32 = ::core::mem::transmute(__vi.method_ptr);
3648 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
3649 __inner(__receiver, __mi)
3650 }
3651 }
3652 }
3653 #[doc = "`GetConfigVoiceVolume()` overload"]
3654 fn get_config_voice_volume(self) -> f32 {
3655 unsafe {
3656 let __receiver =
3657 <SoundSystem_ISoundParam as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3658 {
3659 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
3660 let __vi = *__vt.get(15usize).unwrap_or_else(|| {
3661 panic!(
3662 "unity: virtual slot {}
3663 out of range (vtable len {}
3664) on the runtime class behind {}
3665 (method `{}
3666`)",
3667 15usize,
3668 __vt.len(),
3669 <SoundSystem_ISoundParam as ::unity::ClassIdentity>::NAME,
3670 "GetConfigVoiceVolume",
3671 )
3672 });
3673 let __inner: extern "C" fn(SoundSystem_ISoundParam, ::unity::OptionalMethod) -> f32 = ::core::mem::transmute(__vi.method_ptr);
3674 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
3675 __inner(__receiver, __mi)
3676 }
3677 }
3678 }
3679 #[doc = "`SetConfigBgmVolume(f32, i32)` overload"]
3680 fn set_config_bgm_volume(self, vol: impl ::core::convert::Into<f32>, fade_msec: impl ::core::convert::Into<i32>) -> () {
3681 unsafe {
3682 let __receiver =
3683 <SoundSystem_ISoundParam as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3684 {
3685 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
3686 let __vi = *__vt.get(16usize).unwrap_or_else(|| {
3687 panic!(
3688 "unity: virtual slot {}
3689 out of range (vtable len {}
3690) on the runtime class behind {}
3691 (method `{}
3692`)",
3693 16usize,
3694 __vt.len(),
3695 <SoundSystem_ISoundParam as ::unity::ClassIdentity>::NAME,
3696 "SetConfigBgmVolume",
3697 )
3698 });
3699 let __inner: extern "C" fn(SoundSystem_ISoundParam, f32, i32, ::unity::OptionalMethod) -> () =
3700 ::core::mem::transmute(__vi.method_ptr);
3701 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
3702 __inner(__receiver, ::core::convert::Into::into(vol), ::core::convert::Into::into(fade_msec), __mi)
3703 }
3704 }
3705 }
3706 #[doc = "`SetConfigSeVolume(f32, i32)` overload"]
3707 fn set_config_se_volume(self, vol: impl ::core::convert::Into<f32>, fade_msec: impl ::core::convert::Into<i32>) -> () {
3708 unsafe {
3709 let __receiver =
3710 <SoundSystem_ISoundParam as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3711 {
3712 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
3713 let __vi = *__vt.get(17usize).unwrap_or_else(|| {
3714 panic!(
3715 "unity: virtual slot {}
3716 out of range (vtable len {}
3717) on the runtime class behind {}
3718 (method `{}
3719`)",
3720 17usize,
3721 __vt.len(),
3722 <SoundSystem_ISoundParam as ::unity::ClassIdentity>::NAME,
3723 "SetConfigSeVolume",
3724 )
3725 });
3726 let __inner: extern "C" fn(SoundSystem_ISoundParam, f32, i32, ::unity::OptionalMethod) -> () =
3727 ::core::mem::transmute(__vi.method_ptr);
3728 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
3729 __inner(__receiver, ::core::convert::Into::into(vol), ::core::convert::Into::into(fade_msec), __mi)
3730 }
3731 }
3732 }
3733 #[doc = "`SetConfigEnvVolume(f32, i32)` overload"]
3734 fn set_config_env_volume(self, vol: impl ::core::convert::Into<f32>, fade_msec: impl ::core::convert::Into<i32>) -> () {
3735 unsafe {
3736 let __receiver =
3737 <SoundSystem_ISoundParam as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3738 {
3739 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
3740 let __vi = *__vt.get(18usize).unwrap_or_else(|| {
3741 panic!(
3742 "unity: virtual slot {}
3743 out of range (vtable len {}
3744) on the runtime class behind {}
3745 (method `{}
3746`)",
3747 18usize,
3748 __vt.len(),
3749 <SoundSystem_ISoundParam as ::unity::ClassIdentity>::NAME,
3750 "SetConfigEnvVolume",
3751 )
3752 });
3753 let __inner: extern "C" fn(SoundSystem_ISoundParam, f32, i32, ::unity::OptionalMethod) -> () =
3754 ::core::mem::transmute(__vi.method_ptr);
3755 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
3756 __inner(__receiver, ::core::convert::Into::into(vol), ::core::convert::Into::into(fade_msec), __mi)
3757 }
3758 }
3759 }
3760 #[doc = "`SetConfigVoiceVolume(f32, i32)` overload"]
3761 fn set_config_voice_volume(self, vol: impl ::core::convert::Into<f32>, fade_msec: impl ::core::convert::Into<i32>) -> () {
3762 unsafe {
3763 let __receiver =
3764 <SoundSystem_ISoundParam as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3765 {
3766 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
3767 let __vi = *__vt.get(19usize).unwrap_or_else(|| {
3768 panic!(
3769 "unity: virtual slot {}
3770 out of range (vtable len {}
3771) on the runtime class behind {}
3772 (method `{}
3773`)",
3774 19usize,
3775 __vt.len(),
3776 <SoundSystem_ISoundParam as ::unity::ClassIdentity>::NAME,
3777 "SetConfigVoiceVolume",
3778 )
3779 });
3780 let __inner: extern "C" fn(SoundSystem_ISoundParam, f32, i32, ::unity::OptionalMethod) -> () =
3781 ::core::mem::transmute(__vi.method_ptr);
3782 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
3783 __inner(__receiver, ::core::convert::Into::into(vol), ::core::convert::Into::into(fade_msec), __mi)
3784 }
3785 }
3786 }
3787 #[doc = "`SetVolume(f32, crate::unity_engine::gameobject::GameObject)` overload"]
3788 fn set_volume(
3789 self,
3790 vol: impl ::core::convert::Into<f32>,
3791 game_object: impl ::core::convert::Into<crate::unity_engine::gameobject::GameObject>,
3792 ) -> () {
3793 unsafe {
3794 let __receiver =
3795 <SoundSystem_ISoundParam as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3796 {
3797 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
3798 let __vi = *__vt.get(20usize).unwrap_or_else(|| {
3799 panic!(
3800 "unity: virtual slot {}
3801 out of range (vtable len {}
3802) on the runtime class behind {}
3803 (method `{}
3804`)",
3805 20usize,
3806 __vt.len(),
3807 <SoundSystem_ISoundParam as ::unity::ClassIdentity>::NAME,
3808 "SetVolume",
3809 )
3810 });
3811 let __inner: extern "C" fn(SoundSystem_ISoundParam, f32, crate::unity_engine::gameobject::GameObject, ::unity::OptionalMethod) -> () =
3812 ::core::mem::transmute(__vi.method_ptr);
3813 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
3814 __inner(
3815 __receiver,
3816 ::core::convert::Into::into(vol),
3817 ::core::convert::Into::into(game_object),
3818 __mi,
3819 )
3820 }
3821 }
3822 }
3823 #[doc = "`GetValue(::unity::Il2CppString, bool, *mutu32)` overload"]
3824 fn get_value(self, value_name: impl ::core::convert::Into<::unity::Il2CppString>, is_global: impl ::core::convert::Into<bool>) -> (bool, u32) {
3825 unsafe {
3826 let __receiver =
3827 <SoundSystem_ISoundParam as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3828 let mut __out_0 = ::core::mem::MaybeUninit::<u32>::uninit();
3829 let __ret = {
3830 {
3831 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
3832 let __vi = *__vt.get(21usize).unwrap_or_else(|| {
3833 panic!(
3834 "unity: virtual slot {}
3835 out of range (vtable len {}
3836) on the runtime class behind {}
3837 (method `{}
3838`)",
3839 21usize,
3840 __vt.len(),
3841 <SoundSystem_ISoundParam as ::unity::ClassIdentity>::NAME,
3842 "GetValue",
3843 )
3844 });
3845 let __inner: extern "C" fn(SoundSystem_ISoundParam, ::unity::Il2CppString, bool, *mut u32, ::unity::OptionalMethod) -> bool =
3846 ::core::mem::transmute(__vi.method_ptr);
3847 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
3848 __inner(
3849 __receiver,
3850 ::core::convert::Into::into(value_name),
3851 ::core::convert::Into::into(is_global),
3852 __out_0.as_mut_ptr(),
3853 __mi,
3854 )
3855 }
3856 };
3857 (__ret, __out_0.assume_init())
3858 }
3859 }
3860 #[doc = "`GetValue(::unity::Il2CppString, crate::unity_engine::gameobject::GameObject, bool, *mutu32)` overload"]
3861 fn get_value_2(
3862 self,
3863 value_name: impl ::core::convert::Into<::unity::Il2CppString>,
3864 game_object: impl ::core::convert::Into<crate::unity_engine::gameobject::GameObject>,
3865 is_global: impl ::core::convert::Into<bool>,
3866 ) -> (bool, u32) {
3867 unsafe {
3868 let __receiver =
3869 <SoundSystem_ISoundParam as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3870 let mut __out_0 = ::core::mem::MaybeUninit::<u32>::uninit();
3871 let __ret = {
3872 {
3873 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
3874 let __vi = *__vt.get(22usize).unwrap_or_else(|| {
3875 panic!(
3876 "unity: virtual slot {}
3877 out of range (vtable len {}
3878) on the runtime class behind {}
3879 (method `{}
3880`)",
3881 22usize,
3882 __vt.len(),
3883 <SoundSystem_ISoundParam as ::unity::ClassIdentity>::NAME,
3884 "GetValue",
3885 )
3886 });
3887 let __inner: extern "C" fn(
3888 SoundSystem_ISoundParam,
3889 ::unity::Il2CppString,
3890 crate::unity_engine::gameobject::GameObject,
3891 bool,
3892 *mut u32,
3893 ::unity::OptionalMethod,
3894 ) -> bool = ::core::mem::transmute(__vi.method_ptr);
3895 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
3896 __inner(
3897 __receiver,
3898 ::core::convert::Into::into(value_name),
3899 ::core::convert::Into::into(game_object),
3900 ::core::convert::Into::into(is_global),
3901 __out_0.as_mut_ptr(),
3902 __mi,
3903 )
3904 }
3905 };
3906 (__ret, __out_0.assume_init())
3907 }
3908 }
3909 #[doc = "`GetValue(::unity::Il2CppString, *mutf32)` overload"]
3910 fn get_value_3(self, value_name: impl ::core::convert::Into<::unity::Il2CppString>) -> (bool, f32) {
3911 unsafe {
3912 let __receiver =
3913 <SoundSystem_ISoundParam as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3914 let mut __out_0 = ::core::mem::MaybeUninit::<f32>::uninit();
3915 let __ret = {
3916 {
3917 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
3918 let __vi = *__vt.get(23usize).unwrap_or_else(|| {
3919 panic!(
3920 "unity: virtual slot {}
3921 out of range (vtable len {}
3922) on the runtime class behind {}
3923 (method `{}
3924`)",
3925 23usize,
3926 __vt.len(),
3927 <SoundSystem_ISoundParam as ::unity::ClassIdentity>::NAME,
3928 "GetValue",
3929 )
3930 });
3931 let __inner: extern "C" fn(SoundSystem_ISoundParam, ::unity::Il2CppString, *mut f32, ::unity::OptionalMethod) -> bool =
3932 ::core::mem::transmute(__vi.method_ptr);
3933 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
3934 __inner(__receiver, ::core::convert::Into::into(value_name), __out_0.as_mut_ptr(), __mi)
3935 }
3936 };
3937 (__ret, __out_0.assume_init())
3938 }
3939 }
3940 #[doc = "`GetValue(::unity::Il2CppString, crate::unity_engine::gameobject::GameObject, *mutf32)` overload"]
3941 fn get_value_4(
3942 self,
3943 value_name: impl ::core::convert::Into<::unity::Il2CppString>,
3944 game_object: impl ::core::convert::Into<crate::unity_engine::gameobject::GameObject>,
3945 ) -> (bool, f32) {
3946 unsafe {
3947 let __receiver =
3948 <SoundSystem_ISoundParam as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3949 let mut __out_0 = ::core::mem::MaybeUninit::<f32>::uninit();
3950 let __ret = {
3951 {
3952 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
3953 let __vi = *__vt.get(24usize).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 24usize,
3961 __vt.len(),
3962 <SoundSystem_ISoundParam as ::unity::ClassIdentity>::NAME,
3963 "GetValue",
3964 )
3965 });
3966 let __inner: extern "C" fn(
3967 SoundSystem_ISoundParam,
3968 ::unity::Il2CppString,
3969 crate::unity_engine::gameobject::GameObject,
3970 *mut f32,
3971 ::unity::OptionalMethod,
3972 ) -> bool = ::core::mem::transmute(__vi.method_ptr);
3973 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
3974 __inner(
3975 __receiver,
3976 ::core::convert::Into::into(value_name),
3977 ::core::convert::Into::into(game_object),
3978 __out_0.as_mut_ptr(),
3979 __mi,
3980 )
3981 }
3982 };
3983 (__ret, __out_0.assume_init())
3984 }
3985 }
3986 #[doc = "`SetValue(::unity::Il2CppString, bool, ::unity::Il2CppString)` overload"]
3987 fn set_value(
3988 self,
3989 value_name: impl ::core::convert::Into<::unity::Il2CppString>,
3990 is_global: impl ::core::convert::Into<bool>,
3991 value: impl ::core::convert::Into<::unity::Il2CppString>,
3992 ) -> bool {
3993 unsafe {
3994 let __receiver =
3995 <SoundSystem_ISoundParam as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3996 {
3997 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
3998 let __vi = *__vt.get(25usize).unwrap_or_else(|| {
3999 panic!(
4000 "unity: virtual slot {}
4001 out of range (vtable len {}
4002) on the runtime class behind {}
4003 (method `{}
4004`)",
4005 25usize,
4006 __vt.len(),
4007 <SoundSystem_ISoundParam as ::unity::ClassIdentity>::NAME,
4008 "SetValue",
4009 )
4010 });
4011 let __inner: extern "C" fn(
4012 SoundSystem_ISoundParam,
4013 ::unity::Il2CppString,
4014 bool,
4015 ::unity::Il2CppString,
4016 ::unity::OptionalMethod,
4017 ) -> bool = ::core::mem::transmute(__vi.method_ptr);
4018 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
4019 __inner(
4020 __receiver,
4021 ::core::convert::Into::into(value_name),
4022 ::core::convert::Into::into(is_global),
4023 ::core::convert::Into::into(value),
4024 __mi,
4025 )
4026 }
4027 }
4028 }
4029 #[doc = "`SetValue(::unity::Il2CppString, bool, u32)` overload"]
4030 fn set_value_2(
4031 self,
4032 value_name: impl ::core::convert::Into<::unity::Il2CppString>,
4033 is_global: impl ::core::convert::Into<bool>,
4034 value: impl ::core::convert::Into<u32>,
4035 ) -> bool {
4036 unsafe {
4037 let __receiver =
4038 <SoundSystem_ISoundParam as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
4039 {
4040 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
4041 let __vi = *__vt.get(26usize).unwrap_or_else(|| {
4042 panic!(
4043 "unity: virtual slot {}
4044 out of range (vtable len {}
4045) on the runtime class behind {}
4046 (method `{}
4047`)",
4048 26usize,
4049 __vt.len(),
4050 <SoundSystem_ISoundParam as ::unity::ClassIdentity>::NAME,
4051 "SetValue",
4052 )
4053 });
4054 let __inner: extern "C" fn(SoundSystem_ISoundParam, ::unity::Il2CppString, bool, u32, ::unity::OptionalMethod) -> bool =
4055 ::core::mem::transmute(__vi.method_ptr);
4056 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
4057 __inner(
4058 __receiver,
4059 ::core::convert::Into::into(value_name),
4060 ::core::convert::Into::into(is_global),
4061 ::core::convert::Into::into(value),
4062 __mi,
4063 )
4064 }
4065 }
4066 }
4067 #[doc = "`SetValue(::unity::Il2CppString, bool, ::unity::Il2CppString, crate::unity_engine::gameobject::GameObject)` overload"]
4068 fn set_value_3(
4069 self,
4070 value_name: impl ::core::convert::Into<::unity::Il2CppString>,
4071 is_global: impl ::core::convert::Into<bool>,
4072 value: impl ::core::convert::Into<::unity::Il2CppString>,
4073 game_object: impl ::core::convert::Into<crate::unity_engine::gameobject::GameObject>,
4074 ) -> bool {
4075 unsafe {
4076 let __receiver =
4077 <SoundSystem_ISoundParam as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
4078 {
4079 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
4080 let __vi = *__vt.get(27usize).unwrap_or_else(|| {
4081 panic!(
4082 "unity: virtual slot {}
4083 out of range (vtable len {}
4084) on the runtime class behind {}
4085 (method `{}
4086`)",
4087 27usize,
4088 __vt.len(),
4089 <SoundSystem_ISoundParam as ::unity::ClassIdentity>::NAME,
4090 "SetValue",
4091 )
4092 });
4093 let __inner: extern "C" fn(
4094 SoundSystem_ISoundParam,
4095 ::unity::Il2CppString,
4096 bool,
4097 ::unity::Il2CppString,
4098 crate::unity_engine::gameobject::GameObject,
4099 ::unity::OptionalMethod,
4100 ) -> bool = ::core::mem::transmute(__vi.method_ptr);
4101 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
4102 __inner(
4103 __receiver,
4104 ::core::convert::Into::into(value_name),
4105 ::core::convert::Into::into(is_global),
4106 ::core::convert::Into::into(value),
4107 ::core::convert::Into::into(game_object),
4108 __mi,
4109 )
4110 }
4111 }
4112 }
4113 #[doc = "`SetValue(::unity::Il2CppString, bool, u32, crate::unity_engine::gameobject::GameObject)` overload"]
4114 fn set_value_4(
4115 self,
4116 value_name: impl ::core::convert::Into<::unity::Il2CppString>,
4117 is_global: impl ::core::convert::Into<bool>,
4118 value: impl ::core::convert::Into<u32>,
4119 game_object: impl ::core::convert::Into<crate::unity_engine::gameobject::GameObject>,
4120 ) -> bool {
4121 unsafe {
4122 let __receiver =
4123 <SoundSystem_ISoundParam as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
4124 {
4125 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
4126 let __vi = *__vt.get(28usize).unwrap_or_else(|| {
4127 panic!(
4128 "unity: virtual slot {}
4129 out of range (vtable len {}
4130) on the runtime class behind {}
4131 (method `{}
4132`)",
4133 28usize,
4134 __vt.len(),
4135 <SoundSystem_ISoundParam as ::unity::ClassIdentity>::NAME,
4136 "SetValue",
4137 )
4138 });
4139 let __inner: extern "C" fn(
4140 SoundSystem_ISoundParam,
4141 ::unity::Il2CppString,
4142 bool,
4143 u32,
4144 crate::unity_engine::gameobject::GameObject,
4145 ::unity::OptionalMethod,
4146 ) -> bool = ::core::mem::transmute(__vi.method_ptr);
4147 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
4148 __inner(
4149 __receiver,
4150 ::core::convert::Into::into(value_name),
4151 ::core::convert::Into::into(is_global),
4152 ::core::convert::Into::into(value),
4153 ::core::convert::Into::into(game_object),
4154 __mi,
4155 )
4156 }
4157 }
4158 }
4159 #[doc = "`SetValue(::unity::Il2CppString, f32)` overload"]
4160 fn set_value_5(self, value_name: impl ::core::convert::Into<::unity::Il2CppString>, value: impl ::core::convert::Into<f32>) -> bool {
4161 unsafe {
4162 let __receiver =
4163 <SoundSystem_ISoundParam as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
4164 {
4165 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
4166 let __vi = *__vt.get(29usize).unwrap_or_else(|| {
4167 panic!(
4168 "unity: virtual slot {}
4169 out of range (vtable len {}
4170) on the runtime class behind {}
4171 (method `{}
4172`)",
4173 29usize,
4174 __vt.len(),
4175 <SoundSystem_ISoundParam as ::unity::ClassIdentity>::NAME,
4176 "SetValue",
4177 )
4178 });
4179 let __inner: extern "C" fn(SoundSystem_ISoundParam, ::unity::Il2CppString, f32, ::unity::OptionalMethod) -> bool =
4180 ::core::mem::transmute(__vi.method_ptr);
4181 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
4182 __inner(
4183 __receiver,
4184 ::core::convert::Into::into(value_name),
4185 ::core::convert::Into::into(value),
4186 __mi,
4187 )
4188 }
4189 }
4190 }
4191 #[doc = "`SetValue(::unity::Il2CppString, f32, crate::unity_engine::gameobject::GameObject)` overload"]
4192 fn set_value_6(
4193 self,
4194 value_name: impl ::core::convert::Into<::unity::Il2CppString>,
4195 value: impl ::core::convert::Into<f32>,
4196 game_object: impl ::core::convert::Into<crate::unity_engine::gameobject::GameObject>,
4197 ) -> bool {
4198 unsafe {
4199 let __receiver =
4200 <SoundSystem_ISoundParam as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
4201 {
4202 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
4203 let __vi = *__vt.get(30usize).unwrap_or_else(|| {
4204 panic!(
4205 "unity: virtual slot {}
4206 out of range (vtable len {}
4207) on the runtime class behind {}
4208 (method `{}
4209`)",
4210 30usize,
4211 __vt.len(),
4212 <SoundSystem_ISoundParam as ::unity::ClassIdentity>::NAME,
4213 "SetValue",
4214 )
4215 });
4216 let __inner: extern "C" fn(
4217 SoundSystem_ISoundParam,
4218 ::unity::Il2CppString,
4219 f32,
4220 crate::unity_engine::gameobject::GameObject,
4221 ::unity::OptionalMethod,
4222 ) -> bool = ::core::mem::transmute(__vi.method_ptr);
4223 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
4224 __inner(
4225 __receiver,
4226 ::core::convert::Into::into(value_name),
4227 ::core::convert::Into::into(value),
4228 ::core::convert::Into::into(game_object),
4229 __mi,
4230 )
4231 }
4232 }
4233 }
4234 #[doc = "`SetPosition(crate::unity_engine::vector3::Vector3, crate::unity_engine::vector3::Vector3, crate::unity_engine::vector3::Vector3, crate::unity_engine::gameobject::GameObject)` overload"]
4235 fn set_position(
4236 self,
4237 pos: impl ::core::convert::Into<crate::unity_engine::vector3::Vector3>,
4238 foward: impl ::core::convert::Into<crate::unity_engine::vector3::Vector3>,
4239 up: impl ::core::convert::Into<crate::unity_engine::vector3::Vector3>,
4240 game_object: impl ::core::convert::Into<crate::unity_engine::gameobject::GameObject>,
4241 ) -> bool {
4242 unsafe {
4243 let __receiver =
4244 <SoundSystem_ISoundParam as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
4245 {
4246 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
4247 let __vi = *__vt.get(31usize).unwrap_or_else(|| {
4248 panic!(
4249 "unity: virtual slot {}
4250 out of range (vtable len {}
4251) on the runtime class behind {}
4252 (method `{}
4253`)",
4254 31usize,
4255 __vt.len(),
4256 <SoundSystem_ISoundParam as ::unity::ClassIdentity>::NAME,
4257 "SetPosition",
4258 )
4259 });
4260 let __inner: extern "C" fn(
4261 SoundSystem_ISoundParam,
4262 crate::unity_engine::vector3::Vector3,
4263 crate::unity_engine::vector3::Vector3,
4264 crate::unity_engine::vector3::Vector3,
4265 crate::unity_engine::gameobject::GameObject,
4266 ::unity::OptionalMethod,
4267 ) -> bool = ::core::mem::transmute(__vi.method_ptr);
4268 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
4269 __inner(
4270 __receiver,
4271 ::core::convert::Into::into(pos),
4272 ::core::convert::Into::into(foward),
4273 ::core::convert::Into::into(up),
4274 ::core::convert::Into::into(game_object),
4275 __mi,
4276 )
4277 }
4278 }
4279 }
4280 #[doc = "`GetAudioListenerObject()` overload"]
4281 fn get_audio_listener_object(self) -> crate::unity_engine::gameobject::GameObject {
4282 unsafe {
4283 let __receiver =
4284 <SoundSystem_ISoundParam as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
4285 {
4286 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
4287 let __vi = *__vt.get(32usize).unwrap_or_else(|| {
4288 panic!(
4289 "unity: virtual slot {}
4290 out of range (vtable len {}
4291) on the runtime class behind {}
4292 (method `{}
4293`)",
4294 32usize,
4295 __vt.len(),
4296 <SoundSystem_ISoundParam as ::unity::ClassIdentity>::NAME,
4297 "GetAudioListenerObject",
4298 )
4299 });
4300 let __inner: extern "C" fn(SoundSystem_ISoundParam, ::unity::OptionalMethod) -> crate::unity_engine::gameobject::GameObject =
4301 ::core::mem::transmute(__vi.method_ptr);
4302 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
4303 __inner(__receiver, __mi)
4304 }
4305 }
4306 }
4307 #[doc = "`GetAudioListenerPosistion()` overload"]
4308 fn get_audio_listener_posistion(self) -> crate::unity_engine::vector3::Vector3 {
4309 unsafe {
4310 let __receiver =
4311 <SoundSystem_ISoundParam as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
4312 {
4313 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
4314 let __vi = *__vt.get(33usize).unwrap_or_else(|| {
4315 panic!(
4316 "unity: virtual slot {}
4317 out of range (vtable len {}
4318) on the runtime class behind {}
4319 (method `{}
4320`)",
4321 33usize,
4322 __vt.len(),
4323 <SoundSystem_ISoundParam as ::unity::ClassIdentity>::NAME,
4324 "GetAudioListenerPosistion",
4325 )
4326 });
4327 let __inner: extern "C" fn(SoundSystem_ISoundParam, ::unity::OptionalMethod) -> crate::unity_engine::vector3::Vector3 =
4328 ::core::mem::transmute(__vi.method_ptr);
4329 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
4330 __inner(__receiver, __mi)
4331 }
4332 }
4333 }
4334 #[doc = "`GetAudioListenerRotation()` overload"]
4335 fn get_audio_listener_rotation(self) -> crate::unity_engine::quaternion::Quaternion {
4336 unsafe {
4337 let __receiver =
4338 <SoundSystem_ISoundParam as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
4339 {
4340 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
4341 let __vi = *__vt.get(34usize).unwrap_or_else(|| {
4342 panic!(
4343 "unity: virtual slot {}
4344 out of range (vtable len {}
4345) on the runtime class behind {}
4346 (method `{}
4347`)",
4348 34usize,
4349 __vt.len(),
4350 <SoundSystem_ISoundParam as ::unity::ClassIdentity>::NAME,
4351 "GetAudioListenerRotation",
4352 )
4353 });
4354 let __inner: extern "C" fn(SoundSystem_ISoundParam, ::unity::OptionalMethod) -> crate::unity_engine::quaternion::Quaternion =
4355 ::core::mem::transmute(__vi.method_ptr);
4356 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
4357 __inner(__receiver, __mi)
4358 }
4359 }
4360 }
4361 #[doc = "`SetAudioListenerPosition(crate::unity_engine::vector3::Vector3)` overload"]
4362 fn set_audio_listener_position(self, listener_pos: impl ::core::convert::Into<crate::unity_engine::vector3::Vector3>) -> () {
4363 unsafe {
4364 let __receiver =
4365 <SoundSystem_ISoundParam as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
4366 {
4367 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
4368 let __vi = *__vt.get(35usize).unwrap_or_else(|| {
4369 panic!(
4370 "unity: virtual slot {}
4371 out of range (vtable len {}
4372) on the runtime class behind {}
4373 (method `{}
4374`)",
4375 35usize,
4376 __vt.len(),
4377 <SoundSystem_ISoundParam as ::unity::ClassIdentity>::NAME,
4378 "SetAudioListenerPosition",
4379 )
4380 });
4381 let __inner: extern "C" fn(SoundSystem_ISoundParam, crate::unity_engine::vector3::Vector3, ::unity::OptionalMethod) -> () =
4382 ::core::mem::transmute(__vi.method_ptr);
4383 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
4384 __inner(__receiver, ::core::convert::Into::into(listener_pos), __mi)
4385 }
4386 }
4387 }
4388 #[doc = "`SetAudioListenerRotation(crate::unity_engine::quaternion::Quaternion)` overload"]
4389 fn set_audio_listener_rotation(self, listener_rot: impl ::core::convert::Into<crate::unity_engine::quaternion::Quaternion>) -> () {
4390 unsafe {
4391 let __receiver =
4392 <SoundSystem_ISoundParam as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
4393 {
4394 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
4395 let __vi = *__vt.get(36usize).unwrap_or_else(|| {
4396 panic!(
4397 "unity: virtual slot {}
4398 out of range (vtable len {}
4399) on the runtime class behind {}
4400 (method `{}
4401`)",
4402 36usize,
4403 __vt.len(),
4404 <SoundSystem_ISoundParam as ::unity::ClassIdentity>::NAME,
4405 "SetAudioListenerRotation",
4406 )
4407 });
4408 let __inner: extern "C" fn(SoundSystem_ISoundParam, crate::unity_engine::quaternion::Quaternion, ::unity::OptionalMethod) -> () =
4409 ::core::mem::transmute(__vi.method_ptr);
4410 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
4411 __inner(__receiver, ::core::convert::Into::into(listener_rot), __mi)
4412 }
4413 }
4414 }
4415}
4416
4417#[cfg(feature = "app-soundsystem")]
4418impl<__T: ISoundSystem_ISoundParam> ISoundSystem_ISoundParamMethods for __T {}
4419
4420#[cfg(feature = "app-soundsystem")]
4421impl SoundSystem_ISoundParam {
4422 pub fn get_master_bgm_volume_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4423 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
4424 }
4425
4426 pub fn get_master_se_volume_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4427 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
4428 }
4429
4430 pub fn get_master_env_volume_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4431 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
4432 }
4433
4434 pub fn get_master_voice_volume_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4435 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
4436 }
4437
4438 pub fn set_master_bgm_volume_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4439 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
4440 }
4441
4442 pub fn set_master_se_volume_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4443 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[5]
4444 }
4445
4446 pub fn set_master_env_volume_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4447 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[6]
4448 }
4449
4450 pub fn set_master_voice_volume_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4451 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[7]
4452 }
4453
4454 pub fn reset_master_bgm_volume_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4455 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[8]
4456 }
4457
4458 pub fn reset_master_se_volume_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4459 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[9]
4460 }
4461
4462 pub fn reset_master_env_volume_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4463 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[10]
4464 }
4465
4466 pub fn reset_master_voice_volume_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4467 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[11]
4468 }
4469
4470 pub fn get_config_bgm_volume_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4471 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[12]
4472 }
4473
4474 pub fn get_config_se_volume_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4475 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[13]
4476 }
4477
4478 pub fn get_config_env_volume_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4479 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[14]
4480 }
4481
4482 pub fn get_config_voice_volume_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4483 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[15]
4484 }
4485
4486 pub fn set_config_bgm_volume_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4487 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[16]
4488 }
4489
4490 pub fn set_config_se_volume_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4491 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[17]
4492 }
4493
4494 pub fn set_config_env_volume_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4495 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[18]
4496 }
4497
4498 pub fn set_config_voice_volume_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4499 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[19]
4500 }
4501
4502 pub fn set_volume_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4503 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[20]
4504 }
4505
4506 pub fn get_value_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4507 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[21]
4508 }
4509
4510 pub fn get_value_2_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4511 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[22]
4512 }
4513
4514 pub fn get_value_3_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4515 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[23]
4516 }
4517
4518 pub fn get_value_4_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4519 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[24]
4520 }
4521
4522 pub fn set_value_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4523 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[25]
4524 }
4525
4526 pub fn set_value_2_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4527 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[26]
4528 }
4529
4530 pub fn set_value_3_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4531 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[27]
4532 }
4533
4534 pub fn set_value_4_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4535 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[28]
4536 }
4537
4538 pub fn set_value_5_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4539 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[29]
4540 }
4541
4542 pub fn set_value_6_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4543 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[30]
4544 }
4545
4546 pub fn set_position_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4547 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[31]
4548 }
4549
4550 pub fn get_audio_listener_object_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4551 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[32]
4552 }
4553
4554 pub fn get_audio_listener_posistion_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4555 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[33]
4556 }
4557
4558 pub fn get_audio_listener_rotation_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4559 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[34]
4560 }
4561
4562 pub fn set_audio_listener_position_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4563 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[35]
4564 }
4565
4566 pub fn set_audio_listener_rotation_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4567 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[36]
4568 }
4569}
4570
4571#[cfg(feature = "app-soundsystem")]
4572impl SoundSystem_ISoundParam {
4573 #[doc = "Direct (non-virtual) call to `SoundSystem_ISoundParam`'s own `GetMasterBgmVolume`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
4574 pub unsafe fn get_master_bgm_volume(this: impl ::core::convert::Into<::unity::IlInstance>) -> f32 {
4575 let __mi = Self::get_master_bgm_volume_method_info();
4576 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> f32 = ::core::mem::transmute(__mi.method_ptr);
4577 __inner(this.into(), ::core::option::Option::None)
4578 }
4579
4580 #[doc = "Direct (non-virtual) call to `SoundSystem_ISoundParam`'s own `GetMasterSeVolume`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
4581 pub unsafe fn get_master_se_volume(this: impl ::core::convert::Into<::unity::IlInstance>) -> f32 {
4582 let __mi = Self::get_master_se_volume_method_info();
4583 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> f32 = ::core::mem::transmute(__mi.method_ptr);
4584 __inner(this.into(), ::core::option::Option::None)
4585 }
4586
4587 #[doc = "Direct (non-virtual) call to `SoundSystem_ISoundParam`'s own `GetMasterEnvVolume`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
4588 pub unsafe fn get_master_env_volume(this: impl ::core::convert::Into<::unity::IlInstance>) -> f32 {
4589 let __mi = Self::get_master_env_volume_method_info();
4590 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> f32 = ::core::mem::transmute(__mi.method_ptr);
4591 __inner(this.into(), ::core::option::Option::None)
4592 }
4593
4594 #[doc = "Direct (non-virtual) call to `SoundSystem_ISoundParam`'s own `GetMasterVoiceVolume`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
4595 pub unsafe fn get_master_voice_volume(this: impl ::core::convert::Into<::unity::IlInstance>) -> f32 {
4596 let __mi = Self::get_master_voice_volume_method_info();
4597 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> f32 = ::core::mem::transmute(__mi.method_ptr);
4598 __inner(this.into(), ::core::option::Option::None)
4599 }
4600
4601 #[doc = "Direct (non-virtual) call to `SoundSystem_ISoundParam`'s own `SetMasterBgmVolume`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
4602 pub unsafe fn set_master_bgm_volume(this: impl ::core::convert::Into<::unity::IlInstance>, vol: f32, fade_msec: i32) -> () {
4603 let __mi = Self::set_master_bgm_volume_method_info();
4604 let __inner: extern "C" fn(::unity::IlInstance, f32, i32, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
4605 __inner(this.into(), vol, fade_msec, ::core::option::Option::None)
4606 }
4607
4608 #[doc = "Direct (non-virtual) call to `SoundSystem_ISoundParam`'s own `SetMasterSeVolume`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
4609 pub unsafe fn set_master_se_volume(this: impl ::core::convert::Into<::unity::IlInstance>, vol: f32, fade_msec: i32) -> () {
4610 let __mi = Self::set_master_se_volume_method_info();
4611 let __inner: extern "C" fn(::unity::IlInstance, f32, i32, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
4612 __inner(this.into(), vol, fade_msec, ::core::option::Option::None)
4613 }
4614
4615 #[doc = "Direct (non-virtual) call to `SoundSystem_ISoundParam`'s own `SetMasterEnvVolume`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
4616 pub unsafe fn set_master_env_volume(this: impl ::core::convert::Into<::unity::IlInstance>, vol: f32, fade_msec: i32) -> () {
4617 let __mi = Self::set_master_env_volume_method_info();
4618 let __inner: extern "C" fn(::unity::IlInstance, f32, i32, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
4619 __inner(this.into(), vol, fade_msec, ::core::option::Option::None)
4620 }
4621
4622 #[doc = "Direct (non-virtual) call to `SoundSystem_ISoundParam`'s own `SetMasterVoiceVolume`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
4623 pub unsafe fn set_master_voice_volume(this: impl ::core::convert::Into<::unity::IlInstance>, vol: f32, fade_msec: i32) -> () {
4624 let __mi = Self::set_master_voice_volume_method_info();
4625 let __inner: extern "C" fn(::unity::IlInstance, f32, i32, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
4626 __inner(this.into(), vol, fade_msec, ::core::option::Option::None)
4627 }
4628
4629 #[doc = "Direct (non-virtual) call to `SoundSystem_ISoundParam`'s own `ResetMasterBgmVolume`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
4630 pub unsafe fn reset_master_bgm_volume(this: impl ::core::convert::Into<::unity::IlInstance>, fade_msec: i32) -> () {
4631 let __mi = Self::reset_master_bgm_volume_method_info();
4632 let __inner: extern "C" fn(::unity::IlInstance, i32, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
4633 __inner(this.into(), fade_msec, ::core::option::Option::None)
4634 }
4635
4636 #[doc = "Direct (non-virtual) call to `SoundSystem_ISoundParam`'s own `ResetMasterSeVolume`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
4637 pub unsafe fn reset_master_se_volume(this: impl ::core::convert::Into<::unity::IlInstance>, fade_msec: i32) -> () {
4638 let __mi = Self::reset_master_se_volume_method_info();
4639 let __inner: extern "C" fn(::unity::IlInstance, i32, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
4640 __inner(this.into(), fade_msec, ::core::option::Option::None)
4641 }
4642
4643 #[doc = "Direct (non-virtual) call to `SoundSystem_ISoundParam`'s own `ResetMasterEnvVolume`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
4644 pub unsafe fn reset_master_env_volume(this: impl ::core::convert::Into<::unity::IlInstance>, fade_msec: i32) -> () {
4645 let __mi = Self::reset_master_env_volume_method_info();
4646 let __inner: extern "C" fn(::unity::IlInstance, i32, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
4647 __inner(this.into(), fade_msec, ::core::option::Option::None)
4648 }
4649
4650 #[doc = "Direct (non-virtual) call to `SoundSystem_ISoundParam`'s own `ResetMasterVoiceVolume`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
4651 pub unsafe fn reset_master_voice_volume(this: impl ::core::convert::Into<::unity::IlInstance>, fade_msec: i32) -> () {
4652 let __mi = Self::reset_master_voice_volume_method_info();
4653 let __inner: extern "C" fn(::unity::IlInstance, i32, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
4654 __inner(this.into(), fade_msec, ::core::option::Option::None)
4655 }
4656
4657 #[doc = "Direct (non-virtual) call to `SoundSystem_ISoundParam`'s own `GetConfigBgmVolume`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
4658 pub unsafe fn get_config_bgm_volume(this: impl ::core::convert::Into<::unity::IlInstance>) -> f32 {
4659 let __mi = Self::get_config_bgm_volume_method_info();
4660 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> f32 = ::core::mem::transmute(__mi.method_ptr);
4661 __inner(this.into(), ::core::option::Option::None)
4662 }
4663
4664 #[doc = "Direct (non-virtual) call to `SoundSystem_ISoundParam`'s own `GetConfigSeVolume`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
4665 pub unsafe fn get_config_se_volume(this: impl ::core::convert::Into<::unity::IlInstance>) -> f32 {
4666 let __mi = Self::get_config_se_volume_method_info();
4667 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> f32 = ::core::mem::transmute(__mi.method_ptr);
4668 __inner(this.into(), ::core::option::Option::None)
4669 }
4670
4671 #[doc = "Direct (non-virtual) call to `SoundSystem_ISoundParam`'s own `GetConfigEnvVolume`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
4672 pub unsafe fn get_config_env_volume(this: impl ::core::convert::Into<::unity::IlInstance>) -> f32 {
4673 let __mi = Self::get_config_env_volume_method_info();
4674 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> f32 = ::core::mem::transmute(__mi.method_ptr);
4675 __inner(this.into(), ::core::option::Option::None)
4676 }
4677
4678 #[doc = "Direct (non-virtual) call to `SoundSystem_ISoundParam`'s own `GetConfigVoiceVolume`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
4679 pub unsafe fn get_config_voice_volume(this: impl ::core::convert::Into<::unity::IlInstance>) -> f32 {
4680 let __mi = Self::get_config_voice_volume_method_info();
4681 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> f32 = ::core::mem::transmute(__mi.method_ptr);
4682 __inner(this.into(), ::core::option::Option::None)
4683 }
4684
4685 #[doc = "Direct (non-virtual) call to `SoundSystem_ISoundParam`'s own `SetConfigBgmVolume`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
4686 pub unsafe fn set_config_bgm_volume(this: impl ::core::convert::Into<::unity::IlInstance>, vol: f32, fade_msec: i32) -> () {
4687 let __mi = Self::set_config_bgm_volume_method_info();
4688 let __inner: extern "C" fn(::unity::IlInstance, f32, i32, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
4689 __inner(this.into(), vol, fade_msec, ::core::option::Option::None)
4690 }
4691
4692 #[doc = "Direct (non-virtual) call to `SoundSystem_ISoundParam`'s own `SetConfigSeVolume`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
4693 pub unsafe fn set_config_se_volume(this: impl ::core::convert::Into<::unity::IlInstance>, vol: f32, fade_msec: i32) -> () {
4694 let __mi = Self::set_config_se_volume_method_info();
4695 let __inner: extern "C" fn(::unity::IlInstance, f32, i32, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
4696 __inner(this.into(), vol, fade_msec, ::core::option::Option::None)
4697 }
4698
4699 #[doc = "Direct (non-virtual) call to `SoundSystem_ISoundParam`'s own `SetConfigEnvVolume`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
4700 pub unsafe fn set_config_env_volume(this: impl ::core::convert::Into<::unity::IlInstance>, vol: f32, fade_msec: i32) -> () {
4701 let __mi = Self::set_config_env_volume_method_info();
4702 let __inner: extern "C" fn(::unity::IlInstance, f32, i32, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
4703 __inner(this.into(), vol, fade_msec, ::core::option::Option::None)
4704 }
4705
4706 #[doc = "Direct (non-virtual) call to `SoundSystem_ISoundParam`'s own `SetConfigVoiceVolume`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
4707 pub unsafe fn set_config_voice_volume(this: impl ::core::convert::Into<::unity::IlInstance>, vol: f32, fade_msec: i32) -> () {
4708 let __mi = Self::set_config_voice_volume_method_info();
4709 let __inner: extern "C" fn(::unity::IlInstance, f32, i32, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
4710 __inner(this.into(), vol, fade_msec, ::core::option::Option::None)
4711 }
4712
4713 #[doc = "Direct (non-virtual) call to `SoundSystem_ISoundParam`'s own `SetVolume`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
4714 pub unsafe fn set_volume(
4715 this: impl ::core::convert::Into<::unity::IlInstance>,
4716 vol: f32,
4717 game_object: crate::unity_engine::gameobject::GameObject,
4718 ) -> () {
4719 let __mi = Self::set_volume_method_info();
4720 let __inner: extern "C" fn(::unity::IlInstance, f32, crate::unity_engine::gameobject::GameObject, ::unity::OptionalMethod) -> () =
4721 ::core::mem::transmute(__mi.method_ptr);
4722 __inner(this.into(), vol, game_object, ::core::option::Option::None)
4723 }
4724
4725 #[doc = "Direct (non-virtual) call to `SoundSystem_ISoundParam`'s own `GetValue`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
4726 pub unsafe fn get_value(
4727 this: impl ::core::convert::Into<::unity::IlInstance>,
4728 value_name: ::unity::Il2CppString,
4729 is_global: bool,
4730 value: *mut u32,
4731 ) -> bool {
4732 let __mi = Self::get_value_method_info();
4733 let __inner: extern "C" fn(::unity::IlInstance, ::unity::Il2CppString, bool, *mut u32, ::unity::OptionalMethod) -> bool =
4734 ::core::mem::transmute(__mi.method_ptr);
4735 __inner(this.into(), value_name, is_global, value, ::core::option::Option::None)
4736 }
4737
4738 #[doc = "Direct (non-virtual) call to `SoundSystem_ISoundParam`'s own `GetValue`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
4739 pub unsafe fn get_value_2(
4740 this: impl ::core::convert::Into<::unity::IlInstance>,
4741 value_name: ::unity::Il2CppString,
4742 game_object: crate::unity_engine::gameobject::GameObject,
4743 is_global: bool,
4744 value: *mut u32,
4745 ) -> bool {
4746 let __mi = Self::get_value_2_method_info();
4747 let __inner: extern "C" fn(
4748 ::unity::IlInstance,
4749 ::unity::Il2CppString,
4750 crate::unity_engine::gameobject::GameObject,
4751 bool,
4752 *mut u32,
4753 ::unity::OptionalMethod,
4754 ) -> bool = ::core::mem::transmute(__mi.method_ptr);
4755 __inner(this.into(), value_name, game_object, is_global, value, ::core::option::Option::None)
4756 }
4757
4758 #[doc = "Direct (non-virtual) call to `SoundSystem_ISoundParam`'s own `GetValue`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
4759 pub unsafe fn get_value_3(this: impl ::core::convert::Into<::unity::IlInstance>, value_name: ::unity::Il2CppString, value: *mut f32) -> bool {
4760 let __mi = Self::get_value_3_method_info();
4761 let __inner: extern "C" fn(::unity::IlInstance, ::unity::Il2CppString, *mut f32, ::unity::OptionalMethod) -> bool =
4762 ::core::mem::transmute(__mi.method_ptr);
4763 __inner(this.into(), value_name, value, ::core::option::Option::None)
4764 }
4765
4766 #[doc = "Direct (non-virtual) call to `SoundSystem_ISoundParam`'s own `GetValue`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
4767 pub unsafe fn get_value_4(
4768 this: impl ::core::convert::Into<::unity::IlInstance>,
4769 value_name: ::unity::Il2CppString,
4770 game_object: crate::unity_engine::gameobject::GameObject,
4771 value: *mut f32,
4772 ) -> bool {
4773 let __mi = Self::get_value_4_method_info();
4774 let __inner: extern "C" fn(
4775 ::unity::IlInstance,
4776 ::unity::Il2CppString,
4777 crate::unity_engine::gameobject::GameObject,
4778 *mut f32,
4779 ::unity::OptionalMethod,
4780 ) -> bool = ::core::mem::transmute(__mi.method_ptr);
4781 __inner(this.into(), value_name, game_object, value, ::core::option::Option::None)
4782 }
4783
4784 #[doc = "Direct (non-virtual) call to `SoundSystem_ISoundParam`'s own `SetValue`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
4785 pub unsafe fn set_value(
4786 this: impl ::core::convert::Into<::unity::IlInstance>,
4787 value_name: ::unity::Il2CppString,
4788 is_global: bool,
4789 value: ::unity::Il2CppString,
4790 ) -> bool {
4791 let __mi = Self::set_value_method_info();
4792 let __inner: extern "C" fn(::unity::IlInstance, ::unity::Il2CppString, bool, ::unity::Il2CppString, ::unity::OptionalMethod) -> bool =
4793 ::core::mem::transmute(__mi.method_ptr);
4794 __inner(this.into(), value_name, is_global, value, ::core::option::Option::None)
4795 }
4796
4797 #[doc = "Direct (non-virtual) call to `SoundSystem_ISoundParam`'s own `SetValue`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
4798 pub unsafe fn set_value_2(
4799 this: impl ::core::convert::Into<::unity::IlInstance>,
4800 value_name: ::unity::Il2CppString,
4801 is_global: bool,
4802 value: u32,
4803 ) -> bool {
4804 let __mi = Self::set_value_2_method_info();
4805 let __inner: extern "C" fn(::unity::IlInstance, ::unity::Il2CppString, bool, u32, ::unity::OptionalMethod) -> bool =
4806 ::core::mem::transmute(__mi.method_ptr);
4807 __inner(this.into(), value_name, is_global, value, ::core::option::Option::None)
4808 }
4809
4810 #[doc = "Direct (non-virtual) call to `SoundSystem_ISoundParam`'s own `SetValue`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
4811 pub unsafe fn set_value_3(
4812 this: impl ::core::convert::Into<::unity::IlInstance>,
4813 value_name: ::unity::Il2CppString,
4814 is_global: bool,
4815 value: ::unity::Il2CppString,
4816 game_object: crate::unity_engine::gameobject::GameObject,
4817 ) -> bool {
4818 let __mi = Self::set_value_3_method_info();
4819 let __inner: extern "C" fn(
4820 ::unity::IlInstance,
4821 ::unity::Il2CppString,
4822 bool,
4823 ::unity::Il2CppString,
4824 crate::unity_engine::gameobject::GameObject,
4825 ::unity::OptionalMethod,
4826 ) -> bool = ::core::mem::transmute(__mi.method_ptr);
4827 __inner(this.into(), value_name, is_global, value, game_object, ::core::option::Option::None)
4828 }
4829
4830 #[doc = "Direct (non-virtual) call to `SoundSystem_ISoundParam`'s own `SetValue`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
4831 pub unsafe fn set_value_4(
4832 this: impl ::core::convert::Into<::unity::IlInstance>,
4833 value_name: ::unity::Il2CppString,
4834 is_global: bool,
4835 value: u32,
4836 game_object: crate::unity_engine::gameobject::GameObject,
4837 ) -> bool {
4838 let __mi = Self::set_value_4_method_info();
4839 let __inner: extern "C" fn(
4840 ::unity::IlInstance,
4841 ::unity::Il2CppString,
4842 bool,
4843 u32,
4844 crate::unity_engine::gameobject::GameObject,
4845 ::unity::OptionalMethod,
4846 ) -> bool = ::core::mem::transmute(__mi.method_ptr);
4847 __inner(this.into(), value_name, is_global, value, game_object, ::core::option::Option::None)
4848 }
4849
4850 #[doc = "Direct (non-virtual) call to `SoundSystem_ISoundParam`'s own `SetValue`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
4851 pub unsafe fn set_value_5(this: impl ::core::convert::Into<::unity::IlInstance>, value_name: ::unity::Il2CppString, value: f32) -> bool {
4852 let __mi = Self::set_value_5_method_info();
4853 let __inner: extern "C" fn(::unity::IlInstance, ::unity::Il2CppString, f32, ::unity::OptionalMethod) -> bool =
4854 ::core::mem::transmute(__mi.method_ptr);
4855 __inner(this.into(), value_name, value, ::core::option::Option::None)
4856 }
4857
4858 #[doc = "Direct (non-virtual) call to `SoundSystem_ISoundParam`'s own `SetValue`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
4859 pub unsafe fn set_value_6(
4860 this: impl ::core::convert::Into<::unity::IlInstance>,
4861 value_name: ::unity::Il2CppString,
4862 value: f32,
4863 game_object: crate::unity_engine::gameobject::GameObject,
4864 ) -> bool {
4865 let __mi = Self::set_value_6_method_info();
4866 let __inner: extern "C" fn(
4867 ::unity::IlInstance,
4868 ::unity::Il2CppString,
4869 f32,
4870 crate::unity_engine::gameobject::GameObject,
4871 ::unity::OptionalMethod,
4872 ) -> bool = ::core::mem::transmute(__mi.method_ptr);
4873 __inner(this.into(), value_name, value, game_object, ::core::option::Option::None)
4874 }
4875
4876 #[doc = "Direct (non-virtual) call to `SoundSystem_ISoundParam`'s own `SetPosition`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
4877 pub unsafe fn set_position(
4878 this: impl ::core::convert::Into<::unity::IlInstance>,
4879 pos: crate::unity_engine::vector3::Vector3,
4880 foward: crate::unity_engine::vector3::Vector3,
4881 up: crate::unity_engine::vector3::Vector3,
4882 game_object: crate::unity_engine::gameobject::GameObject,
4883 ) -> bool {
4884 let __mi = Self::set_position_method_info();
4885 let __inner: extern "C" fn(
4886 ::unity::IlInstance,
4887 crate::unity_engine::vector3::Vector3,
4888 crate::unity_engine::vector3::Vector3,
4889 crate::unity_engine::vector3::Vector3,
4890 crate::unity_engine::gameobject::GameObject,
4891 ::unity::OptionalMethod,
4892 ) -> bool = ::core::mem::transmute(__mi.method_ptr);
4893 __inner(this.into(), pos, foward, up, game_object, ::core::option::Option::None)
4894 }
4895
4896 #[doc = "Direct (non-virtual) call to `SoundSystem_ISoundParam`'s own `GetAudioListenerObject`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
4897 pub unsafe fn get_audio_listener_object(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::unity_engine::gameobject::GameObject {
4898 let __mi = Self::get_audio_listener_object_method_info();
4899 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::unity_engine::gameobject::GameObject =
4900 ::core::mem::transmute(__mi.method_ptr);
4901 __inner(this.into(), ::core::option::Option::None)
4902 }
4903
4904 #[doc = "Direct (non-virtual) call to `SoundSystem_ISoundParam`'s own `GetAudioListenerPosistion`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
4905 pub unsafe fn get_audio_listener_posistion(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::unity_engine::vector3::Vector3 {
4906 let __mi = Self::get_audio_listener_posistion_method_info();
4907 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::unity_engine::vector3::Vector3 =
4908 ::core::mem::transmute(__mi.method_ptr);
4909 __inner(this.into(), ::core::option::Option::None)
4910 }
4911
4912 #[doc = "Direct (non-virtual) call to `SoundSystem_ISoundParam`'s own `GetAudioListenerRotation`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
4913 pub unsafe fn get_audio_listener_rotation(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::unity_engine::quaternion::Quaternion {
4914 let __mi = Self::get_audio_listener_rotation_method_info();
4915 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::unity_engine::quaternion::Quaternion =
4916 ::core::mem::transmute(__mi.method_ptr);
4917 __inner(this.into(), ::core::option::Option::None)
4918 }
4919
4920 #[doc = "Direct (non-virtual) call to `SoundSystem_ISoundParam`'s own `SetAudioListenerPosition`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
4921 pub unsafe fn set_audio_listener_position(
4922 this: impl ::core::convert::Into<::unity::IlInstance>,
4923 listener_pos: crate::unity_engine::vector3::Vector3,
4924 ) -> () {
4925 let __mi = Self::set_audio_listener_position_method_info();
4926 let __inner: extern "C" fn(::unity::IlInstance, crate::unity_engine::vector3::Vector3, ::unity::OptionalMethod) -> () =
4927 ::core::mem::transmute(__mi.method_ptr);
4928 __inner(this.into(), listener_pos, ::core::option::Option::None)
4929 }
4930
4931 #[doc = "Direct (non-virtual) call to `SoundSystem_ISoundParam`'s own `SetAudioListenerRotation`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
4932 pub unsafe fn set_audio_listener_rotation(
4933 this: impl ::core::convert::Into<::unity::IlInstance>,
4934 listener_rot: crate::unity_engine::quaternion::Quaternion,
4935 ) -> () {
4936 let __mi = Self::set_audio_listener_rotation_method_info();
4937 let __inner: extern "C" fn(::unity::IlInstance, crate::unity_engine::quaternion::Quaternion, ::unity::OptionalMethod) -> () =
4938 ::core::mem::transmute(__mi.method_ptr);
4939 __inner(this.into(), listener_rot, ::core::option::Option::None)
4940 }
4941}
4942
4943#[cfg(feature = "app-soundsystem")]
4944#[doc(hidden)]
4945pub mod prelude {
4946 pub use super::{
4947 ISoundSystem, ISoundSystemMethods, ISoundSystem_ISoundLoad, ISoundSystem_ISoundLoadMethods, ISoundSystem_ISoundParam,
4948 ISoundSystem_ISoundParamMethods, ISoundSystem_ISoundPlay, ISoundSystem_ISoundPlayMethods, ISoundSystem_LipSyncData,
4949 ISoundSystem_LipSyncDataFile, ISoundSystem_LipSyncDataFileMethods, ISoundSystem_LipSyncDataMethods, ISoundSystem_ResultSoundLoad,
4950 ISoundSystem_ResultSoundLoadList, ISoundSystem_ResultSoundLoadListMethods, ISoundSystem_ResultSoundLoadMethods, ISoundSystem_SoundHandle,
4951 ISoundSystem_SoundHandleMethods, SoundSystem, SoundSystem_ISoundLoad, SoundSystem_ISoundParam, SoundSystem_ISoundPlay,
4952 SoundSystem_LipSyncData, SoundSystem_LipSyncDataFile, SoundSystem_LipSyncStructData, SoundSystem_ResultSoundLoad,
4953 SoundSystem_ResultSoundLoadList, SoundSystem_ResultSoundLoad_Status, SoundSystem_SoundHandle,
4954 };
4955 #[cfg(feature = "system-object")]
4956 pub use crate::system::object::IObjectMethods;
4957 #[cfg(feature = "system-enum")]
4958 pub use crate::system::r#enum::IEnumMethods;
4959 #[cfg(feature = "system-valuetype")]
4960 pub use crate::system::valuetype::IValueTypeMethods;
4961 pub use crate::system::{object::IObject, r#enum::IEnum, valuetype::IValueType};
4962}