Eveldee/NobetaSource
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Add v1.0.3.1

Browse Source
This commit is contained in:
Eveldee
2023-09-06 22:00:49 +02:00
commit 3aebbbf8f0
2051 changed files with 757425 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

13
Interop/Assembly-CSharp/AmplifyColor/Quality.cs Normal file
View File

@@ -0,0 +1,13 @@
using System;
namespace AmplifyColor
{
// Token: 0x02000635 RID: 1589
public enum Quality
{
// Token: 0x04006CE0 RID: 27872
Mobile,
// Token: 0x04006CE1 RID: 27873
Standard
}
}

66
Interop/Assembly-CSharp/AmplifyColor/RenderLayer.cs Normal file
View File

@@ -0,0 +1,66 @@
using System;
using System.Runtime.InteropServices;
using Il2CppInterop.Common.Attributes;
using Il2CppInterop.Runtime;
using Il2CppSystem;
using UnityEngine;
namespace AmplifyColor
{
// Token: 0x02000637 RID: 1591
[Serializable]
[StructLayout(LayoutKind.Explicit)]
public struct RenderLayer
{
// Token: 0x0600A1D9 RID: 41433 RVA: 0x00299604 File Offset: 0x00297804
[CallerCount(4)]
[CachedScanResults(RefRangeStart = 421650, RefRangeEnd = 421654, XrefRangeStart = 421650, XrefRangeEnd = 421654, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
public unsafe RenderLayer(LayerMask mask, Color color)
{
IntPtr* ptr;
checked
{
ptr = stackalloc IntPtr[unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)];
*ptr = ref mask;
}
ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref color;
IntPtr intPtr2;
IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(RenderLayer.NativeMethodInfoPtr__ctor_Public_Void_LayerMask_Color_0, ref this, (void**)ptr, ref intPtr2);
Il2CppException.RaiseExceptionIfNecessary(intPtr2);
}
// Token: 0x0600A1DA RID: 41434 RVA: 0x0029965C File Offset: 0x0029785C
// Note: this type is marked as 'beforefieldinit'.
static RenderLayer()
{
Il2CppClassPointerStore<RenderLayer>.NativeClassPtr = IL2CPP.GetIl2CppClass("Assembly-CSharp.dll", "AmplifyColor", "RenderLayer");
IL2CPP.il2cpp_runtime_class_init(Il2CppClassPointerStore<RenderLayer>.NativeClassPtr);
RenderLayer.NativeFieldInfoPtr_mask = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<RenderLayer>.NativeClassPtr, "mask");
RenderLayer.NativeFieldInfoPtr_color = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<RenderLayer>.NativeClassPtr, "color");
RenderLayer.NativeMethodInfoPtr__ctor_Public_Void_LayerMask_Color_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<RenderLayer>.NativeClassPtr, 100675863);
}
// Token: 0x0600A1DB RID: 41435 RVA: 0x002996C8 File Offset: 0x002978C8
public Il2CppSystem.Object BoxIl2CppObject()
{
return new Il2CppSystem.Object(IL2CPP.il2cpp_value_box(Il2CppClassPointerStore<RenderLayer>.NativeClassPtr, ref this));
}
// Token: 0x04006CE7 RID: 27879
private static readonly IntPtr NativeFieldInfoPtr_mask;
// Token: 0x04006CE8 RID: 27880
private static readonly IntPtr NativeFieldInfoPtr_color;
// Token: 0x04006CE9 RID: 27881
private static readonly IntPtr NativeMethodInfoPtr__ctor_Public_Void_LayerMask_Color_0;
// Token: 0x04006CEA RID: 27882
[FieldOffset(0)]
public LayerMask mask;
// Token: 0x04006CEB RID: 27883
[FieldOffset(4)]
public Color color;
}
}

17
Interop/Assembly-CSharp/AmplifyColor/Tonemapping.cs Normal file
View File

@@ -0,0 +1,17 @@
using System;
namespace AmplifyColor
{
// Token: 0x02000636 RID: 1590
public enum Tonemapping
{
// Token: 0x04006CE3 RID: 27875
Disabled,
// Token: 0x04006CE4 RID: 27876
Photographic,
// Token: 0x04006CE5 RID: 27877
FilmicHable,
// Token: 0x04006CE6 RID: 27878
FilmicACES
}
}

319
Interop/Assembly-CSharp/AmplifyColor/VersionInfo.cs Normal file
View File

@@ -0,0 +1,319 @@
using System;
using Il2CppInterop.Common.Attributes;
using Il2CppInterop.Runtime;
using Il2CppSystem;
namespace AmplifyColor
{
// Token: 0x02000638 RID: 1592
[Serializable]
public class VersionInfo : Object
{
// Token: 0x0600A1DC RID: 41436 RVA: 0x002996DC File Offset: 0x002978DC
[CallerCount(0)]
[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 626433, XrefRangeEnd = 626448, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
public unsafe static string StaticToString()
{
IntPtr* ptr = null;
IntPtr intPtr2;
IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(VersionInfo.NativeMethodInfoPtr_StaticToString_Public_Static_String_0, 0, (void**)ptr, ref intPtr2);
Il2CppException.RaiseExceptionIfNecessary(intPtr2);
return IL2CPP.Il2CppStringToManaged(intPtr);
}
// Token: 0x0600A1DD RID: 41437 RVA: 0x00299718 File Offset: 0x00297918
[CallerCount(0)]
[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 626448, XrefRangeEnd = 626463, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
public unsafe override string ToString()
{
IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
IntPtr* ptr = null;
IntPtr intPtr2;
IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(IL2CPP.il2cpp_object_get_virtual_method(IL2CPP.Il2CppObjectBaseToPtr(this), VersionInfo.NativeMethodInfoPtr_ToString_Public_Virtual_String_0), IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
Il2CppException.RaiseExceptionIfNecessary(intPtr2);
return IL2CPP.Il2CppStringToManaged(intPtr);
}
// Token: 0x170036D0 RID: 14032
// (get) Token: 0x0600A1DE RID: 41438 RVA: 0x00299770 File Offset: 0x00297970
public unsafe int Number
{
[CallerCount(0)]
get
{
IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
IntPtr* ptr = null;
IntPtr intPtr2;
IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(VersionInfo.NativeMethodInfoPtr_get_Number_Public_get_Int32_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
Il2CppException.RaiseExceptionIfNecessary(intPtr2);
return *IL2CPP.il2cpp_object_unbox(intPtr);
}
}
// Token: 0x0600A1DF RID: 41439 RVA: 0x002997C0 File Offset: 0x002979C0
[CallerCount(0)]
[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 626463, XrefRangeEnd = 626464, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
public unsafe VersionInfo()
: this(IL2CPP.il2cpp_object_new(Il2CppClassPointerStore<VersionInfo>.NativeClassPtr))
{
IntPtr* ptr = null;
IntPtr intPtr2;
IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(VersionInfo.NativeMethodInfoPtr__ctor_Private_Void_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
Il2CppException.RaiseExceptionIfNecessary(intPtr2);
}
// Token: 0x0600A1E0 RID: 41440 RVA: 0x0029980C File Offset: 0x00297A0C
[CallerCount(0)]
[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 626464, XrefRangeEnd = 626465, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
public unsafe VersionInfo(byte major, byte minor, byte release)
: this(IL2CPP.il2cpp_object_new(Il2CppClassPointerStore<VersionInfo>.NativeClassPtr))
{
IntPtr* ptr;
checked
{
ptr = stackalloc IntPtr[unchecked((UIntPtr)3) * (UIntPtr)sizeof(IntPtr)];
*ptr = ref major;
}
ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref minor;
ptr[checked(unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref release;
IntPtr intPtr2;
IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(VersionInfo.NativeMethodInfoPtr__ctor_Private_Void_Byte_Byte_Byte_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
Il2CppException.RaiseExceptionIfNecessary(intPtr2);
}
// Token: 0x0600A1E1 RID: 41441 RVA: 0x00299890 File Offset: 0x00297A90
[CallerCount(0)]
[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 626465, XrefRangeEnd = 626469, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
public unsafe static VersionInfo Current()
{
IntPtr* ptr = null;
IntPtr intPtr2;
IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(VersionInfo.NativeMethodInfoPtr_Current_Public_Static_VersionInfo_0, 0, (void**)ptr, ref intPtr2);
Il2CppException.RaiseExceptionIfNecessary(intPtr2);
IntPtr intPtr3 = intPtr;
return (intPtr3 != 0) ? new VersionInfo(intPtr3) : null;
}
// Token: 0x0600A1E2 RID: 41442 RVA: 0x002998D8 File Offset: 0x00297AD8
[CallerCount(0)]
public unsafe static bool Matches(VersionInfo version)
{
checked
{
IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
*ptr = IL2CPP.Il2CppObjectBaseToPtr(version);
IntPtr intPtr2;
IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(VersionInfo.NativeMethodInfoPtr_Matches_Public_Static_Boolean_VersionInfo_0, 0, (void**)ptr, ref intPtr2);
Il2CppException.RaiseExceptionIfNecessary(intPtr2);
return *IL2CPP.il2cpp_object_unbox(intPtr);
}
}
// Token: 0x0600A1E3 RID: 41443 RVA: 0x00299930 File Offset: 0x00297B30
// Note: this type is marked as 'beforefieldinit'.
static VersionInfo()
{
Il2CppClassPointerStore<VersionInfo>.NativeClassPtr = IL2CPP.GetIl2CppClass("Assembly-CSharp.dll", "AmplifyColor", "VersionInfo");
IL2CPP.il2cpp_runtime_class_init(Il2CppClassPointerStore<VersionInfo>.NativeClassPtr);
VersionInfo.NativeFieldInfoPtr_Major = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<VersionInfo>.NativeClassPtr, "Major");
VersionInfo.NativeFieldInfoPtr_Minor = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<VersionInfo>.NativeClassPtr, "Minor");
VersionInfo.NativeFieldInfoPtr_Release = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<VersionInfo>.NativeClassPtr, "Release");
VersionInfo.NativeFieldInfoPtr_StageSuffix = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<VersionInfo>.NativeClassPtr, "StageSuffix");
VersionInfo.NativeFieldInfoPtr_TrialSuffix = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<VersionInfo>.NativeClassPtr, "TrialSuffix");
VersionInfo.NativeFieldInfoPtr_m_major = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<VersionInfo>.NativeClassPtr, "m_major");
VersionInfo.NativeFieldInfoPtr_m_minor = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<VersionInfo>.NativeClassPtr, "m_minor");
VersionInfo.NativeFieldInfoPtr_m_release = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<VersionInfo>.NativeClassPtr, "m_release");
VersionInfo.NativeMethodInfoPtr_StaticToString_Public_Static_String_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<VersionInfo>.NativeClassPtr, 100675864);
VersionInfo.NativeMethodInfoPtr_ToString_Public_Virtual_String_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<VersionInfo>.NativeClassPtr, 100675865);
VersionInfo.NativeMethodInfoPtr_get_Number_Public_get_Int32_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<VersionInfo>.NativeClassPtr, 100675866);
VersionInfo.NativeMethodInfoPtr__ctor_Private_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<VersionInfo>.NativeClassPtr, 100675867);
VersionInfo.NativeMethodInfoPtr__ctor_Private_Void_Byte_Byte_Byte_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<VersionInfo>.NativeClassPtr, 100675868);
VersionInfo.NativeMethodInfoPtr_Current_Public_Static_VersionInfo_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<VersionInfo>.NativeClassPtr, 100675869);
VersionInfo.NativeMethodInfoPtr_Matches_Public_Static_Boolean_VersionInfo_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<VersionInfo>.NativeClassPtr, 100675870);
}
// Token: 0x0600A1E4 RID: 41444 RVA: 0x0000A688 File Offset: 0x00008888
public VersionInfo(IntPtr pointer)
: base(pointer)
{
}
// Token: 0x170036C8 RID: 14024
// (get) Token: 0x0600A1E5 RID: 41445 RVA: 0x00299A8C File Offset: 0x00297C8C
// (set) Token: 0x0600A1E6 RID: 41446 RVA: 0x00299AAA File Offset: 0x00297CAA
public unsafe static byte Major
{
get
{
byte b;
IL2CPP.il2cpp_field_static_get_value(VersionInfo.NativeFieldInfoPtr_Major, (void*)(&b));
return b;
}
set
{
IL2CPP.il2cpp_field_static_set_value(VersionInfo.NativeFieldInfoPtr_Major, (void*)(&value));
}
}
// Token: 0x170036C9 RID: 14025
// (get) Token: 0x0600A1E7 RID: 41447 RVA: 0x00299ABC File Offset: 0x00297CBC
// (set) Token: 0x0600A1E8 RID: 41448 RVA: 0x00299ADA File Offset: 0x00297CDA
public unsafe static byte Minor
{
get
{
byte b;
IL2CPP.il2cpp_field_static_get_value(VersionInfo.NativeFieldInfoPtr_Minor, (void*)(&b));
return b;
}
set
{
IL2CPP.il2cpp_field_static_set_value(VersionInfo.NativeFieldInfoPtr_Minor, (void*)(&value));
}
}
// Token: 0x170036CA RID: 14026
// (get) Token: 0x0600A1E9 RID: 41449 RVA: 0x00299AEC File Offset: 0x00297CEC
// (set) Token: 0x0600A1EA RID: 41450 RVA: 0x00299B0A File Offset: 0x00297D0A
public unsafe static byte Release
{
get
{
byte b;
IL2CPP.il2cpp_field_static_get_value(VersionInfo.NativeFieldInfoPtr_Release, (void*)(&b));
return b;
}
set
{
IL2CPP.il2cpp_field_static_set_value(VersionInfo.NativeFieldInfoPtr_Release, (void*)(&value));
}
}
// Token: 0x170036CB RID: 14027
// (get) Token: 0x0600A1EB RID: 41451 RVA: 0x00299B1C File Offset: 0x00297D1C
// (set) Token: 0x0600A1EC RID: 41452 RVA: 0x00299B3C File Offset: 0x00297D3C
public unsafe static string StageSuffix
{
get
{
IntPtr intPtr;
IL2CPP.il2cpp_field_static_get_value(VersionInfo.NativeFieldInfoPtr_StageSuffix, (void*)(&intPtr));
return IL2CPP.Il2CppStringToManaged(intPtr);
}
set
{
IL2CPP.il2cpp_field_static_set_value(VersionInfo.NativeFieldInfoPtr_StageSuffix, IL2CPP.ManagedStringToIl2Cpp(value));
}
}
// Token: 0x170036CC RID: 14028
// (get) Token: 0x0600A1ED RID: 41453 RVA: 0x00299B54 File Offset: 0x00297D54
// (set) Token: 0x0600A1EE RID: 41454 RVA: 0x00299B74 File Offset: 0x00297D74
public unsafe static string TrialSuffix
{
get
{
IntPtr intPtr;
IL2CPP.il2cpp_field_static_get_value(VersionInfo.NativeFieldInfoPtr_TrialSuffix, (void*)(&intPtr));
return IL2CPP.Il2CppStringToManaged(intPtr);
}
set
{
IL2CPP.il2cpp_field_static_set_value(VersionInfo.NativeFieldInfoPtr_TrialSuffix, IL2CPP.ManagedStringToIl2Cpp(value));
}
}
// Token: 0x170036CD RID: 14029
// (get) Token: 0x0600A1EF RID: 41455 RVA: 0x00299B8C File Offset: 0x00297D8C
// (set) Token: 0x0600A1F0 RID: 41456 RVA: 0x00299BB4 File Offset: 0x00297DB4
public unsafe int m_major
{
get
{
IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(VersionInfo.NativeFieldInfoPtr_m_major);
return *intPtr;
}
set
{
*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(VersionInfo.NativeFieldInfoPtr_m_major)) = value;
}
}
// Token: 0x170036CE RID: 14030
// (get) Token: 0x0600A1F1 RID: 41457 RVA: 0x00299BD8 File Offset: 0x00297DD8
// (set) Token: 0x0600A1F2 RID: 41458 RVA: 0x00299C00 File Offset: 0x00297E00
public unsafe int m_minor
{
get
{
IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(VersionInfo.NativeFieldInfoPtr_m_minor);
return *intPtr;
}
set
{
*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(VersionInfo.NativeFieldInfoPtr_m_minor)) = value;
}
}
// Token: 0x170036CF RID: 14031
// (get) Token: 0x0600A1F3 RID: 41459 RVA: 0x00299C24 File Offset: 0x00297E24
// (set) Token: 0x0600A1F4 RID: 41460 RVA: 0x00299C4C File Offset: 0x00297E4C
public unsafe int m_release
{
get
{
IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(VersionInfo.NativeFieldInfoPtr_m_release);
return *intPtr;
}
set
{
*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(VersionInfo.NativeFieldInfoPtr_m_release)) = value;
}
}
// Token: 0x04006CEC RID: 27884
private static readonly IntPtr NativeFieldInfoPtr_Major;
// Token: 0x04006CED RID: 27885
private static readonly IntPtr NativeFieldInfoPtr_Minor;
// Token: 0x04006CEE RID: 27886
private static readonly IntPtr NativeFieldInfoPtr_Release;
// Token: 0x04006CEF RID: 27887
private static readonly IntPtr NativeFieldInfoPtr_StageSuffix;
// Token: 0x04006CF0 RID: 27888
private static readonly IntPtr NativeFieldInfoPtr_TrialSuffix;
// Token: 0x04006CF1 RID: 27889
private static readonly IntPtr NativeFieldInfoPtr_m_major;
// Token: 0x04006CF2 RID: 27890
private static readonly IntPtr NativeFieldInfoPtr_m_minor;
// Token: 0x04006CF3 RID: 27891
private static readonly IntPtr NativeFieldInfoPtr_m_release;
// Token: 0x04006CF4 RID: 27892
private static readonly IntPtr NativeMethodInfoPtr_StaticToString_Public_Static_String_0;
// Token: 0x04006CF5 RID: 27893
private static readonly IntPtr NativeMethodInfoPtr_ToString_Public_Virtual_String_0;
// Token: 0x04006CF6 RID: 27894
private static readonly IntPtr NativeMethodInfoPtr_get_Number_Public_get_Int32_0;
// Token: 0x04006CF7 RID: 27895
private static readonly IntPtr NativeMethodInfoPtr__ctor_Private_Void_0;
// Token: 0x04006CF8 RID: 27896
private static readonly IntPtr NativeMethodInfoPtr__ctor_Private_Void_Byte_Byte_Byte_0;
// Token: 0x04006CF9 RID: 27897
private static readonly IntPtr NativeMethodInfoPtr_Current_Public_Static_VersionInfo_0;
// Token: 0x04006CFA RID: 27898
private static readonly IntPtr NativeMethodInfoPtr_Matches_Public_Static_Boolean_VersionInfo_0;
}
}

425
Interop/Assembly-CSharp/AmplifyColor/VolumeEffect.cs Normal file
View File

@@ -0,0 +1,425 @@
using System;
using Il2CppInterop.Common.Attributes;
using Il2CppInterop.Runtime;
using Il2CppInterop.Runtime.InteropTypes.Arrays;
using Il2CppSystem;
using Il2CppSystem.Collections.Generic;
using UnityEngine;
namespace AmplifyColor
{
// Token: 0x0200063D RID: 1597
[Serializable]
public class VolumeEffect : Il2CppSystem.Object
{
// Token: 0x0600A22B RID: 41515 RVA: 0x0029AB48 File Offset: 0x00298D48
[CallerCount(4)]
[CachedScanResults(RefRangeStart = 626719, RefRangeEnd = 626723, XrefRangeStart = 626710, XrefRangeEnd = 626719, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
public unsafe VolumeEffect(AmplifyColorBase effect)
: this(IL2CPP.il2cpp_object_new(Il2CppClassPointerStore<VolumeEffect>.NativeClassPtr))
{
checked
{
IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
*ptr = IL2CPP.Il2CppObjectBaseToPtr(effect);
IntPtr intPtr2;
IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(VolumeEffect.NativeMethodInfoPtr__ctor_Public_Void_AmplifyColorBase_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
Il2CppException.RaiseExceptionIfNecessary(intPtr2);
}
}
// Token: 0x0600A22C RID: 41516 RVA: 0x0029ABAC File Offset: 0x00298DAC
[CallerCount(2)]
[CachedScanResults(RefRangeStart = 626799, RefRangeEnd = 626801, XrefRangeStart = 626723, XrefRangeEnd = 626799, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
public unsafe static VolumeEffect BlendValuesToVolumeEffect(VolumeEffectFlags flags, VolumeEffect volume1, VolumeEffect volume2, float blend)
{
IntPtr* ptr;
checked
{
ptr = stackalloc IntPtr[unchecked((UIntPtr)4) * (UIntPtr)sizeof(IntPtr)];
*ptr = IL2CPP.Il2CppObjectBaseToPtr(flags);
}
ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = IL2CPP.Il2CppObjectBaseToPtr(volume1);
ptr[checked(unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = IL2CPP.Il2CppObjectBaseToPtr(volume2);
ptr[checked(unchecked((UIntPtr)3) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref blend;
IntPtr intPtr2;
IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(VolumeEffect.NativeMethodInfoPtr_BlendValuesToVolumeEffect_Public_Static_VolumeEffect_VolumeEffectFlags_VolumeEffect_VolumeEffect_Single_0, 0, (void**)ptr, ref intPtr2);
Il2CppException.RaiseExceptionIfNecessary(intPtr2);
IntPtr intPtr3 = intPtr;
return (intPtr3 != 0) ? new VolumeEffect(intPtr3) : null;
}
// Token: 0x0600A22D RID: 41517 RVA: 0x0029AC50 File Offset: 0x00298E50
[CallerCount(2)]
[CachedScanResults(RefRangeStart = 626812, RefRangeEnd = 626814, XrefRangeStart = 626801, XrefRangeEnd = 626812, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
public unsafe VolumeEffectComponent AddComponent(Component c, VolumeEffectComponentFlags compFlags)
{
IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
IntPtr* ptr;
checked
{
ptr = stackalloc IntPtr[unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)];
*ptr = IL2CPP.Il2CppObjectBaseToPtr(c);
}
ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = IL2CPP.Il2CppObjectBaseToPtr(compFlags);
IntPtr intPtr2;
IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(VolumeEffect.NativeMethodInfoPtr_AddComponent_Public_VolumeEffectComponent_Component_VolumeEffectComponentFlags_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
Il2CppException.RaiseExceptionIfNecessary(intPtr2);
IntPtr intPtr3 = intPtr;
return (intPtr3 != 0) ? new VolumeEffectComponent(intPtr3) : null;
}
// Token: 0x0600A22E RID: 41518 RVA: 0x0029ACD8 File Offset: 0x00298ED8
[CallerCount(0)]
[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 626814, XrefRangeEnd = 626818, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
public unsafe void RemoveEffectComponent(VolumeEffectComponent comp)
{
IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
checked
{
IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
*ptr = IL2CPP.Il2CppObjectBaseToPtr(comp);
IntPtr intPtr2;
IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(VolumeEffect.NativeMethodInfoPtr_RemoveEffectComponent_Public_Void_VolumeEffectComponent_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
Il2CppException.RaiseExceptionIfNecessary(intPtr2);
}
}
// Token: 0x0600A22F RID: 41519 RVA: 0x0029AD34 File Offset: 0x00298F34
[CallerCount(2)]
[CachedScanResults(RefRangeStart = 626841, RefRangeEnd = 626843, XrefRangeStart = 626818, XrefRangeEnd = 626841, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
public unsafe void UpdateVolume()
{
IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
IntPtr* ptr = null;
IntPtr intPtr2;
IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(VolumeEffect.NativeMethodInfoPtr_UpdateVolume_Public_Void_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
Il2CppException.RaiseExceptionIfNecessary(intPtr2);
}
// Token: 0x0600A230 RID: 41520 RVA: 0x0029AD78 File Offset: 0x00298F78
[CallerCount(1)]
[CachedScanResults(RefRangeStart = 626915, RefRangeEnd = 626916, XrefRangeStart = 626843, XrefRangeEnd = 626915, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
public unsafe void SetValues(AmplifyColorBase targetColor)
{
IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
checked
{
IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
*ptr = IL2CPP.Il2CppObjectBaseToPtr(targetColor);
IntPtr intPtr2;
IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(VolumeEffect.NativeMethodInfoPtr_SetValues_Public_Void_AmplifyColorBase_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
Il2CppException.RaiseExceptionIfNecessary(intPtr2);
}
}
// Token: 0x0600A231 RID: 41521 RVA: 0x0029ADD4 File Offset: 0x00298FD4
[CallerCount(1)]
[CachedScanResults(RefRangeStart = 626980, RefRangeEnd = 626981, XrefRangeStart = 626916, XrefRangeEnd = 626980, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
public unsafe void BlendValues(AmplifyColorBase targetColor, VolumeEffect other, float blendAmount)
{
IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
IntPtr* ptr;
checked
{
ptr = stackalloc IntPtr[unchecked((UIntPtr)3) * (UIntPtr)sizeof(IntPtr)];
*ptr = IL2CPP.Il2CppObjectBaseToPtr(targetColor);
}
ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = IL2CPP.Il2CppObjectBaseToPtr(other);
ptr[checked(unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref blendAmount;
IntPtr intPtr2;
IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(VolumeEffect.NativeMethodInfoPtr_BlendValues_Public_Void_AmplifyColorBase_VolumeEffect_Single_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
Il2CppException.RaiseExceptionIfNecessary(intPtr2);
}
// Token: 0x0600A232 RID: 41522 RVA: 0x0029AE58 File Offset: 0x00299058
[CallerCount(6)]
[CachedScanResults(RefRangeStart = 626988, RefRangeEnd = 626994, XrefRangeStart = 626981, XrefRangeEnd = 626988, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
public unsafe VolumeEffectComponent FindEffectComponent(string compName)
{
IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
checked
{
IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
*ptr = IL2CPP.ManagedStringToIl2Cpp(compName);
IntPtr intPtr2;
IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(VolumeEffect.NativeMethodInfoPtr_FindEffectComponent_Public_VolumeEffectComponent_String_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
Il2CppException.RaiseExceptionIfNecessary(intPtr2);
IntPtr intPtr3 = intPtr;
return (intPtr3 != 0) ? new VolumeEffectComponent(intPtr3) : null;
}
}
// Token: 0x0600A233 RID: 41523 RVA: 0x0029AEC8 File Offset: 0x002990C8
[CallerCount(0)]
[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 626994, XrefRangeEnd = 627031, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
public unsafe static Il2CppReferenceArray<Component> ListAcceptableComponents(AmplifyColorBase go)
{
checked
{
IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
*ptr = IL2CPP.Il2CppObjectBaseToPtr(go);
IntPtr intPtr2;
IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(VolumeEffect.NativeMethodInfoPtr_ListAcceptableComponents_Public_Static_Il2CppReferenceArray_1_Component_AmplifyColorBase_0, 0, (void**)ptr, ref intPtr2);
Il2CppException.RaiseExceptionIfNecessary(intPtr2);
IntPtr intPtr3 = intPtr;
return (intPtr3 != 0) ? new Il2CppReferenceArray<Component>(intPtr3) : null;
}
}
// Token: 0x0600A234 RID: 41524 RVA: 0x0029AF28 File Offset: 0x00299128
[CallerCount(0)]
[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 627031, XrefRangeEnd = 627053, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
public unsafe Il2CppStringArray GetComponentNames()
{
IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
IntPtr* ptr = null;
IntPtr intPtr2;
IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(VolumeEffect.NativeMethodInfoPtr_GetComponentNames_Public_Il2CppStringArray_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
Il2CppException.RaiseExceptionIfNecessary(intPtr2);
IntPtr intPtr3 = intPtr;
return (intPtr3 != 0) ? new Il2CppStringArray(intPtr3) : null;
}
// Token: 0x0600A235 RID: 41525 RVA: 0x0029AF80 File Offset: 0x00299180
// Note: this type is marked as 'beforefieldinit'.
static VolumeEffect()
{
Il2CppClassPointerStore<VolumeEffect>.NativeClassPtr = IL2CPP.GetIl2CppClass("Assembly-CSharp.dll", "AmplifyColor", "VolumeEffect");
IL2CPP.il2cpp_runtime_class_init(Il2CppClassPointerStore<VolumeEffect>.NativeClassPtr);
VolumeEffect.NativeFieldInfoPtr_gameObject = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<VolumeEffect>.NativeClassPtr, "gameObject");
VolumeEffect.NativeFieldInfoPtr_components = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<VolumeEffect>.NativeClassPtr, "components");
VolumeEffect.NativeMethodInfoPtr__ctor_Public_Void_AmplifyColorBase_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<VolumeEffect>.NativeClassPtr, 100675891);
VolumeEffect.NativeMethodInfoPtr_BlendValuesToVolumeEffect_Public_Static_VolumeEffect_VolumeEffectFlags_VolumeEffect_VolumeEffect_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<VolumeEffect>.NativeClassPtr, 100675892);
VolumeEffect.NativeMethodInfoPtr_AddComponent_Public_VolumeEffectComponent_Component_VolumeEffectComponentFlags_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<VolumeEffect>.NativeClassPtr, 100675893);
VolumeEffect.NativeMethodInfoPtr_RemoveEffectComponent_Public_Void_VolumeEffectComponent_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<VolumeEffect>.NativeClassPtr, 100675894);
VolumeEffect.NativeMethodInfoPtr_UpdateVolume_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<VolumeEffect>.NativeClassPtr, 100675895);
VolumeEffect.NativeMethodInfoPtr_SetValues_Public_Void_AmplifyColorBase_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<VolumeEffect>.NativeClassPtr, 100675896);
VolumeEffect.NativeMethodInfoPtr_BlendValues_Public_Void_AmplifyColorBase_VolumeEffect_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<VolumeEffect>.NativeClassPtr, 100675897);
VolumeEffect.NativeMethodInfoPtr_FindEffectComponent_Public_VolumeEffectComponent_String_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<VolumeEffect>.NativeClassPtr, 100675898);
VolumeEffect.NativeMethodInfoPtr_ListAcceptableComponents_Public_Static_Il2CppReferenceArray_1_Component_AmplifyColorBase_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<VolumeEffect>.NativeClassPtr, 100675899);
VolumeEffect.NativeMethodInfoPtr_GetComponentNames_Public_Il2CppStringArray_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<VolumeEffect>.NativeClassPtr, 100675900);
}
// Token: 0x0600A236 RID: 41526 RVA: 0x0000A688 File Offset: 0x00008888
public VolumeEffect(IntPtr pointer)
: base(pointer)
{
}
// Token: 0x170036DF RID: 14047
// (get) Token: 0x0600A237 RID: 41527 RVA: 0x0029B0A0 File Offset: 0x002992A0
// (set) Token: 0x0600A238 RID: 41528 RVA: 0x0029B0D4 File Offset: 0x002992D4
public unsafe AmplifyColorBase gameObject
{
get
{
IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(VolumeEffect.NativeFieldInfoPtr_gameObject);
IntPtr intPtr2 = *intPtr;
return (intPtr2 != 0) ? new AmplifyColorBase(intPtr2) : null;
}
set
{
IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
IL2CPP.il2cpp_gc_wbarrier_set_field(intPtr, intPtr + (IntPtr)IL2CPP.il2cpp_field_get_offset(VolumeEffect.NativeFieldInfoPtr_gameObject), IL2CPP.Il2CppObjectBaseToPtr(value));
}
}
// Token: 0x170036E0 RID: 14048
// (get) Token: 0x0600A239 RID: 41529 RVA: 0x0029B0FC File Offset: 0x002992FC
// (set) Token: 0x0600A23A RID: 41530 RVA: 0x0029B130 File Offset: 0x00299330
public unsafe List<VolumeEffectComponent> components
{
get
{
IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(VolumeEffect.NativeFieldInfoPtr_components);
IntPtr intPtr2 = *intPtr;
return (intPtr2 != 0) ? new List<VolumeEffectComponent>(intPtr2) : null;
}
set
{
IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
IL2CPP.il2cpp_gc_wbarrier_set_field(intPtr, intPtr + (IntPtr)IL2CPP.il2cpp_field_get_offset(VolumeEffect.NativeFieldInfoPtr_components), IL2CPP.Il2CppObjectBaseToPtr(value));
}
}
// Token: 0x04006D1B RID: 27931
private static readonly IntPtr NativeFieldInfoPtr_gameObject;
// Token: 0x04006D1C RID: 27932
private static readonly IntPtr NativeFieldInfoPtr_components;
// Token: 0x04006D1D RID: 27933
private static readonly IntPtr NativeMethodInfoPtr__ctor_Public_Void_AmplifyColorBase_0;
// Token: 0x04006D1E RID: 27934
private static readonly IntPtr NativeMethodInfoPtr_BlendValuesToVolumeEffect_Public_Static_VolumeEffect_VolumeEffectFlags_VolumeEffect_VolumeEffect_Single_0;
// Token: 0x04006D1F RID: 27935
private static readonly IntPtr NativeMethodInfoPtr_AddComponent_Public_VolumeEffectComponent_Component_VolumeEffectComponentFlags_0;
// Token: 0x04006D20 RID: 27936
private static readonly IntPtr NativeMethodInfoPtr_RemoveEffectComponent_Public_Void_VolumeEffectComponent_0;
// Token: 0x04006D21 RID: 27937
private static readonly IntPtr NativeMethodInfoPtr_UpdateVolume_Public_Void_0;
// Token: 0x04006D22 RID: 27938
private static readonly IntPtr NativeMethodInfoPtr_SetValues_Public_Void_AmplifyColorBase_0;
// Token: 0x04006D23 RID: 27939
private static readonly IntPtr NativeMethodInfoPtr_BlendValues_Public_Void_AmplifyColorBase_VolumeEffect_Single_0;
// Token: 0x04006D24 RID: 27940
private static readonly IntPtr NativeMethodInfoPtr_FindEffectComponent_Public_VolumeEffectComponent_String_0;
// Token: 0x04006D25 RID: 27941
private static readonly IntPtr NativeMethodInfoPtr_ListAcceptableComponents_Public_Static_Il2CppReferenceArray_1_Component_AmplifyColorBase_0;
// Token: 0x04006D26 RID: 27942
private static readonly IntPtr NativeMethodInfoPtr_GetComponentNames_Public_Il2CppStringArray_0;
// Token: 0x0200063E RID: 1598
[ObfuscatedName("AmplifyColor.VolumeEffect/<>c")]
[Serializable]
public sealed class __c : Il2CppSystem.Object
{
// Token: 0x0600A23B RID: 41531 RVA: 0x0029B158 File Offset: 0x00299358
[CallerCount(1642)]
[CachedScanResults(RefRangeStart = 7417, RefRangeEnd = 9059, XrefRangeStart = 7417, XrefRangeEnd = 9059, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
public unsafe __c()
: this(IL2CPP.il2cpp_object_new(Il2CppClassPointerStore<VolumeEffect.__c>.NativeClassPtr))
{
IntPtr* ptr = null;
IntPtr intPtr2;
IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(VolumeEffect.__c.NativeMethodInfoPtr__ctor_Public_Void_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
Il2CppException.RaiseExceptionIfNecessary(intPtr2);
}
// Token: 0x0600A23C RID: 41532 RVA: 0x0029B1A4 File Offset: 0x002993A4
[CallerCount(0)]
[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 626698, XrefRangeEnd = 626710, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
public unsafe bool _ListAcceptableComponents_b__10_0(Component comp)
{
IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
checked
{
IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
*ptr = IL2CPP.Il2CppObjectBaseToPtr(comp);
IntPtr intPtr2;
IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(VolumeEffect.__c.NativeMethodInfoPtr__ListAcceptableComponents_b__10_0_Internal_Boolean_Component_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
Il2CppException.RaiseExceptionIfNecessary(intPtr2);
return *IL2CPP.il2cpp_object_unbox(intPtr);
}
}
// Token: 0x0600A23D RID: 41533 RVA: 0x0029B20C File Offset: 0x0029940C
[CallerCount(0)]
public unsafe string _GetComponentNames_b__11_0(VolumeEffectComponent r)
{
IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
checked
{
IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
*ptr = IL2CPP.Il2CppObjectBaseToPtr(r);
IntPtr intPtr2;
IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(VolumeEffect.__c.NativeMethodInfoPtr__GetComponentNames_b__11_0_Internal_String_VolumeEffectComponent_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
Il2CppException.RaiseExceptionIfNecessary(intPtr2);
return IL2CPP.Il2CppStringToManaged(intPtr);
}
}
// Token: 0x0600A23E RID: 41534 RVA: 0x0029B270 File Offset: 0x00299470
// Note: this type is marked as 'beforefieldinit'.
static __c()
{
Il2CppClassPointerStore<VolumeEffect.__c>.NativeClassPtr = IL2CPP.GetIl2CppNestedType(Il2CppClassPointerStore<VolumeEffect>.NativeClassPtr, "<>c");
IL2CPP.il2cpp_runtime_class_init(Il2CppClassPointerStore<VolumeEffect.__c>.NativeClassPtr);
VolumeEffect.__c.NativeFieldInfoPtr___9 = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<VolumeEffect.__c>.NativeClassPtr, "<>9");
VolumeEffect.__c.NativeFieldInfoPtr___9__10_0 = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<VolumeEffect.__c>.NativeClassPtr, "<>9__10_0");
VolumeEffect.__c.NativeFieldInfoPtr___9__11_0 = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<VolumeEffect.__c>.NativeClassPtr, "<>9__11_0");
VolumeEffect.__c.NativeMethodInfoPtr__ctor_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<VolumeEffect.__c>.NativeClassPtr, 100675902);
VolumeEffect.__c.NativeMethodInfoPtr__ListAcceptableComponents_b__10_0_Internal_Boolean_Component_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<VolumeEffect.__c>.NativeClassPtr, 100675903);
VolumeEffect.__c.NativeMethodInfoPtr__GetComponentNames_b__11_0_Internal_String_VolumeEffectComponent_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<VolumeEffect.__c>.NativeClassPtr, 100675904);
}
// Token: 0x0600A23F RID: 41535 RVA: 0x0000A688 File Offset: 0x00008888
public __c(IntPtr pointer)
: base(pointer)
{
}
// Token: 0x170036E1 RID: 14049
// (get) Token: 0x0600A240 RID: 41536 RVA: 0x0029B314 File Offset: 0x00299514
// (set) Token: 0x0600A241 RID: 41537 RVA: 0x0029B33F File Offset: 0x0029953F
public unsafe static VolumeEffect.__c __9
{
get
{
IntPtr intPtr;
IL2CPP.il2cpp_field_static_get_value(VolumeEffect.__c.NativeFieldInfoPtr___9, (void*)(&intPtr));
IntPtr intPtr2 = intPtr;
return (intPtr2 != 0) ? new VolumeEffect.__c(intPtr2) : null;
}
set
{
IL2CPP.il2cpp_field_static_set_value(VolumeEffect.__c.NativeFieldInfoPtr___9, IL2CPP.Il2CppObjectBaseToPtr(value));
}
}
// Token: 0x170036E2 RID: 14050
// (get) Token: 0x0600A242 RID: 41538 RVA: 0x0029B354 File Offset: 0x00299554
// (set) Token: 0x0600A243 RID: 41539 RVA: 0x0029B37F File Offset: 0x0029957F
public unsafe static Func<Component, bool> __9__10_0
{
get
{
IntPtr intPtr;
IL2CPP.il2cpp_field_static_get_value(VolumeEffect.__c.NativeFieldInfoPtr___9__10_0, (void*)(&intPtr));
IntPtr intPtr2 = intPtr;
return (intPtr2 != 0) ? new Func<Component, bool>(intPtr2) : null;
}
set
{
IL2CPP.il2cpp_field_static_set_value(VolumeEffect.__c.NativeFieldInfoPtr___9__10_0, IL2CPP.Il2CppObjectBaseToPtr(value));
}
}
// Token: 0x170036E3 RID: 14051
// (get) Token: 0x0600A244 RID: 41540 RVA: 0x0029B394 File Offset: 0x00299594
// (set) Token: 0x0600A245 RID: 41541 RVA: 0x0029B3BF File Offset: 0x002995BF
public unsafe static Func<VolumeEffectComponent, string> __9__11_0
{
get
{
IntPtr intPtr;
IL2CPP.il2cpp_field_static_get_value(VolumeEffect.__c.NativeFieldInfoPtr___9__11_0, (void*)(&intPtr));
IntPtr intPtr2 = intPtr;
return (intPtr2 != 0) ? new Func<VolumeEffectComponent, string>(intPtr2) : null;
}
set
{
IL2CPP.il2cpp_field_static_set_value(VolumeEffect.__c.NativeFieldInfoPtr___9__11_0, IL2CPP.Il2CppObjectBaseToPtr(value));
}
}
// Token: 0x04006D27 RID: 27943
private static readonly IntPtr NativeFieldInfoPtr___9;
// Token: 0x04006D28 RID: 27944
private static readonly IntPtr NativeFieldInfoPtr___9__10_0;
// Token: 0x04006D29 RID: 27945
private static readonly IntPtr NativeFieldInfoPtr___9__11_0;
// Token: 0x04006D2A RID: 27946
private static readonly IntPtr NativeMethodInfoPtr__ctor_Public_Void_0;
// Token: 0x04006D2B RID: 27947
private static readonly IntPtr NativeMethodInfoPtr__ListAcceptableComponents_b__10_0_Internal_Boolean_Component_0;
// Token: 0x04006D2C RID: 27948
private static readonly IntPtr NativeMethodInfoPtr__GetComponentNames_b__11_0_Internal_String_VolumeEffectComponent_0;
}
}
}

488
Interop/Assembly-CSharp/AmplifyColor/VolumeEffectComponent.cs Normal file
View File

@@ -0,0 +1,488 @@
using System;
using Il2CppInterop.Common.Attributes;
using Il2CppInterop.Runtime;
using Il2CppInterop.Runtime.InteropTypes.Arrays;
using Il2CppSystem;
using Il2CppSystem.Collections.Generic;
using Il2CppSystem.Reflection;
using UnityEngine;
namespace AmplifyColor
{
// Token: 0x0200063A RID: 1594
[Serializable]
public class VolumeEffectComponent : Il2CppSystem.Object
{
// Token: 0x0600A20B RID: 41483 RVA: 0x0029A1A4 File Offset: 0x002983A4
[CallerCount(2)]
[CachedScanResults(RefRangeStart = 626535, RefRangeEnd = 626537, XrefRangeStart = 626526, XrefRangeEnd = 626535, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
public unsafe VolumeEffectComponent(string name)
: this(IL2CPP.il2cpp_object_new(Il2CppClassPointerStore<VolumeEffectComponent>.NativeClassPtr))
{
checked
{
IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
*ptr = IL2CPP.ManagedStringToIl2Cpp(name);
IntPtr intPtr2;
IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(VolumeEffectComponent.NativeMethodInfoPtr__ctor_Public_Void_String_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
Il2CppException.RaiseExceptionIfNecessary(intPtr2);
}
}
// Token: 0x0600A20C RID: 41484 RVA: 0x0029A208 File Offset: 0x00298408
[CallerCount(0)]
[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 626537, XrefRangeEnd = 626548, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
public unsafe VolumeEffectField AddField(FieldInfo pi, Component c)
{
IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
IntPtr* ptr;
checked
{
ptr = stackalloc IntPtr[unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)];
*ptr = IL2CPP.Il2CppObjectBaseToPtr(pi);
}
ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = IL2CPP.Il2CppObjectBaseToPtr(c);
IntPtr intPtr2;
IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(VolumeEffectComponent.NativeMethodInfoPtr_AddField_Public_VolumeEffectField_FieldInfo_Component_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
Il2CppException.RaiseExceptionIfNecessary(intPtr2);
IntPtr intPtr3 = intPtr;
return (intPtr3 != 0) ? new VolumeEffectField(intPtr3) : null;
}
// Token: 0x0600A20D RID: 41485 RVA: 0x0029A290 File Offset: 0x00298490
[CallerCount(0)]
[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 626548, XrefRangeEnd = 626562, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
public unsafe VolumeEffectField AddField(FieldInfo pi, Component c, int position)
{
IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
IntPtr* ptr;
checked
{
ptr = stackalloc IntPtr[unchecked((UIntPtr)3) * (UIntPtr)sizeof(IntPtr)];
*ptr = IL2CPP.Il2CppObjectBaseToPtr(pi);
}
ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = IL2CPP.Il2CppObjectBaseToPtr(c);
ptr[checked(unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref position;
IntPtr intPtr2;
IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(VolumeEffectComponent.NativeMethodInfoPtr_AddField_Public_VolumeEffectField_FieldInfo_Component_Int32_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
Il2CppException.RaiseExceptionIfNecessary(intPtr2);
IntPtr intPtr3 = intPtr;
return (intPtr3 != 0) ? new VolumeEffectField(intPtr3) : null;
}
// Token: 0x0600A20E RID: 41486 RVA: 0x0029A328 File Offset: 0x00298528
[CallerCount(0)]
[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 626562, XrefRangeEnd = 626566, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
public unsafe void RemoveEffectField(VolumeEffectField field)
{
IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
checked
{
IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
*ptr = IL2CPP.Il2CppObjectBaseToPtr(field);
IntPtr intPtr2;
IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(VolumeEffectComponent.NativeMethodInfoPtr_RemoveEffectField_Public_Void_VolumeEffectField_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
Il2CppException.RaiseExceptionIfNecessary(intPtr2);
}
}
// Token: 0x0600A20F RID: 41487 RVA: 0x0029A384 File Offset: 0x00298584
[CallerCount(1)]
[CachedScanResults(RefRangeStart = 626591, RefRangeEnd = 626592, XrefRangeStart = 626566, XrefRangeEnd = 626591, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
public unsafe VolumeEffectComponent(Component c, VolumeEffectComponentFlags compFlags)
: this(IL2CPP.il2cpp_object_new(Il2CppClassPointerStore<VolumeEffectComponent>.NativeClassPtr))
{
IntPtr* ptr;
checked
{
ptr = stackalloc IntPtr[unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)];
*ptr = IL2CPP.Il2CppObjectBaseToPtr(c);
}
ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = IL2CPP.Il2CppObjectBaseToPtr(compFlags);
IntPtr intPtr2;
IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(VolumeEffectComponent.NativeMethodInfoPtr__ctor_Public_Void_Component_VolumeEffectComponentFlags_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
Il2CppException.RaiseExceptionIfNecessary(intPtr2);
}
// Token: 0x0600A210 RID: 41488 RVA: 0x0029A400 File Offset: 0x00298600
[CallerCount(0)]
[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 626592, XrefRangeEnd = 626632, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
public unsafe void UpdateComponent(Component c, VolumeEffectComponentFlags compFlags)
{
IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
IntPtr* ptr;
checked
{
ptr = stackalloc IntPtr[unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)];
*ptr = IL2CPP.Il2CppObjectBaseToPtr(c);
}
ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = IL2CPP.Il2CppObjectBaseToPtr(compFlags);
IntPtr intPtr2;
IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(VolumeEffectComponent.NativeMethodInfoPtr_UpdateComponent_Public_Void_Component_VolumeEffectComponentFlags_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
Il2CppException.RaiseExceptionIfNecessary(intPtr2);
}
// Token: 0x0600A211 RID: 41489 RVA: 0x0029A474 File Offset: 0x00298674
[CallerCount(5)]
[CachedScanResults(RefRangeStart = 626639, RefRangeEnd = 626644, XrefRangeStart = 626632, XrefRangeEnd = 626639, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
public unsafe VolumeEffectField FindEffectField(string fieldName)
{
IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
checked
{
IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
*ptr = IL2CPP.ManagedStringToIl2Cpp(fieldName);
IntPtr intPtr2;
IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(VolumeEffectComponent.NativeMethodInfoPtr_FindEffectField_Public_VolumeEffectField_String_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
Il2CppException.RaiseExceptionIfNecessary(intPtr2);
IntPtr intPtr3 = intPtr;
return (intPtr3 != 0) ? new VolumeEffectField(intPtr3) : null;
}
}
// Token: 0x0600A212 RID: 41490 RVA: 0x0029A4E4 File Offset: 0x002986E4
[CallerCount(0)]
[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 626644, XrefRangeEnd = 626676, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
public unsafe static Il2CppReferenceArray<FieldInfo> ListAcceptableFields(Component c)
{
checked
{
IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
*ptr = IL2CPP.Il2CppObjectBaseToPtr(c);
IntPtr intPtr2;
IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(VolumeEffectComponent.NativeMethodInfoPtr_ListAcceptableFields_Public_Static_Il2CppReferenceArray_1_FieldInfo_Component_0, 0, (void**)ptr, ref intPtr2);
Il2CppException.RaiseExceptionIfNecessary(intPtr2);
IntPtr intPtr3 = intPtr;
return (intPtr3 != 0) ? new Il2CppReferenceArray<FieldInfo>(intPtr3) : null;
}
}
// Token: 0x0600A213 RID: 41491 RVA: 0x0029A544 File Offset: 0x00298744
[CallerCount(0)]
[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 626676, XrefRangeEnd = 626698, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
public unsafe Il2CppStringArray GetFieldNames()
{
IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
IntPtr* ptr = null;
IntPtr intPtr2;
IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(VolumeEffectComponent.NativeMethodInfoPtr_GetFieldNames_Public_Il2CppStringArray_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
Il2CppException.RaiseExceptionIfNecessary(intPtr2);
IntPtr intPtr3 = intPtr;
return (intPtr3 != 0) ? new Il2CppStringArray(intPtr3) : null;
}
// Token: 0x0600A214 RID: 41492 RVA: 0x0029A59C File Offset: 0x0029879C
// Note: this type is marked as 'beforefieldinit'.
static VolumeEffectComponent()
{
Il2CppClassPointerStore<VolumeEffectComponent>.NativeClassPtr = IL2CPP.GetIl2CppClass("Assembly-CSharp.dll", "AmplifyColor", "VolumeEffectComponent");
IL2CPP.il2cpp_runtime_class_init(Il2CppClassPointerStore<VolumeEffectComponent>.NativeClassPtr);
VolumeEffectComponent.NativeFieldInfoPtr_componentName = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<VolumeEffectComponent>.NativeClassPtr, "componentName");
VolumeEffectComponent.NativeFieldInfoPtr_fields = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<VolumeEffectComponent>.NativeClassPtr, "fields");
VolumeEffectComponent.NativeMethodInfoPtr__ctor_Public_Void_String_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<VolumeEffectComponent>.NativeClassPtr, 100675876);
VolumeEffectComponent.NativeMethodInfoPtr_AddField_Public_VolumeEffectField_FieldInfo_Component_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<VolumeEffectComponent>.NativeClassPtr, 100675877);
VolumeEffectComponent.NativeMethodInfoPtr_AddField_Public_VolumeEffectField_FieldInfo_Component_Int32_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<VolumeEffectComponent>.NativeClassPtr, 100675878);
VolumeEffectComponent.NativeMethodInfoPtr_RemoveEffectField_Public_Void_VolumeEffectField_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<VolumeEffectComponent>.NativeClassPtr, 100675879);
VolumeEffectComponent.NativeMethodInfoPtr__ctor_Public_Void_Component_VolumeEffectComponentFlags_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<VolumeEffectComponent>.NativeClassPtr, 100675880);
VolumeEffectComponent.NativeMethodInfoPtr_UpdateComponent_Public_Void_Component_VolumeEffectComponentFlags_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<VolumeEffectComponent>.NativeClassPtr, 100675881);
VolumeEffectComponent.NativeMethodInfoPtr_FindEffectField_Public_VolumeEffectField_String_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<VolumeEffectComponent>.NativeClassPtr, 100675882);
VolumeEffectComponent.NativeMethodInfoPtr_ListAcceptableFields_Public_Static_Il2CppReferenceArray_1_FieldInfo_Component_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<VolumeEffectComponent>.NativeClassPtr, 100675883);
VolumeEffectComponent.NativeMethodInfoPtr_GetFieldNames_Public_Il2CppStringArray_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<VolumeEffectComponent>.NativeClassPtr, 100675884);
}
// Token: 0x0600A215 RID: 41493 RVA: 0x0000A688 File Offset: 0x00008888
public VolumeEffectComponent(IntPtr pointer)
: base(pointer)
{
}
// Token: 0x170036D9 RID: 14041
// (get) Token: 0x0600A216 RID: 41494 RVA: 0x0029A6A8 File Offset: 0x002988A8
// (set) Token: 0x0600A217 RID: 41495 RVA: 0x0029A6D1 File Offset: 0x002988D1
public unsafe string componentName
{
get
{
IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(VolumeEffectComponent.NativeFieldInfoPtr_componentName);
return IL2CPP.Il2CppStringToManaged(*intPtr);
}
set
{
IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
IL2CPP.il2cpp_gc_wbarrier_set_field(intPtr, intPtr + (IntPtr)IL2CPP.il2cpp_field_get_offset(VolumeEffectComponent.NativeFieldInfoPtr_componentName), IL2CPP.ManagedStringToIl2Cpp(value));
}
}
// Token: 0x170036DA RID: 14042
// (get) Token: 0x0600A218 RID: 41496 RVA: 0x0029A6F8 File Offset: 0x002988F8
// (set) Token: 0x0600A219 RID: 41497 RVA: 0x0029A72C File Offset: 0x0029892C
public unsafe List<VolumeEffectField> fields
{
get
{
IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(VolumeEffectComponent.NativeFieldInfoPtr_fields);
IntPtr intPtr2 = *intPtr;
return (intPtr2 != 0) ? new List<VolumeEffectField>(intPtr2) : null;
}
set
{
IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
IL2CPP.il2cpp_gc_wbarrier_set_field(intPtr, intPtr + (IntPtr)IL2CPP.il2cpp_field_get_offset(VolumeEffectComponent.NativeFieldInfoPtr_fields), IL2CPP.Il2CppObjectBaseToPtr(value));
}
}
// Token: 0x04006D07 RID: 27911
private static readonly IntPtr NativeFieldInfoPtr_componentName;
// Token: 0x04006D08 RID: 27912
private static readonly IntPtr NativeFieldInfoPtr_fields;
// Token: 0x04006D09 RID: 27913
private static readonly IntPtr NativeMethodInfoPtr__ctor_Public_Void_String_0;
// Token: 0x04006D0A RID: 27914
private static readonly IntPtr NativeMethodInfoPtr_AddField_Public_VolumeEffectField_FieldInfo_Component_0;
// Token: 0x04006D0B RID: 27915
private static readonly IntPtr NativeMethodInfoPtr_AddField_Public_VolumeEffectField_FieldInfo_Component_Int32_0;
// Token: 0x04006D0C RID: 27916
private static readonly IntPtr NativeMethodInfoPtr_RemoveEffectField_Public_Void_VolumeEffectField_0;
// Token: 0x04006D0D RID: 27917
private static readonly IntPtr NativeMethodInfoPtr__ctor_Public_Void_Component_VolumeEffectComponentFlags_0;
// Token: 0x04006D0E RID: 27918
private static readonly IntPtr NativeMethodInfoPtr_UpdateComponent_Public_Void_Component_VolumeEffectComponentFlags_0;
// Token: 0x04006D0F RID: 27919
private static readonly IntPtr NativeMethodInfoPtr_FindEffectField_Public_VolumeEffectField_String_0;
// Token: 0x04006D10 RID: 27920
private static readonly IntPtr NativeMethodInfoPtr_ListAcceptableFields_Public_Static_Il2CppReferenceArray_1_FieldInfo_Component_0;
// Token: 0x04006D11 RID: 27921
private static readonly IntPtr NativeMethodInfoPtr_GetFieldNames_Public_Il2CppStringArray_0;
// Token: 0x0200063B RID: 1595
[ObfuscatedName("AmplifyColor.VolumeEffectComponent/<>c__DisplayClass7_0")]
public sealed class __c__DisplayClass7_0 : Il2CppSystem.Object
{
// Token: 0x0600A21A RID: 41498 RVA: 0x0029A754 File Offset: 0x00298954
[CallerCount(1642)]
[CachedScanResults(RefRangeStart = 7417, RefRangeEnd = 9059, XrefRangeStart = 7417, XrefRangeEnd = 9059, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
public unsafe __c__DisplayClass7_0()
: this(IL2CPP.il2cpp_object_new(Il2CppClassPointerStore<VolumeEffectComponent.__c__DisplayClass7_0>.NativeClassPtr))
{
IntPtr* ptr = null;
IntPtr intPtr2;
IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(VolumeEffectComponent.__c__DisplayClass7_0.NativeMethodInfoPtr__ctor_Public_Void_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
Il2CppException.RaiseExceptionIfNecessary(intPtr2);
}
// Token: 0x0600A21B RID: 41499 RVA: 0x0029A7A0 File Offset: 0x002989A0
[CallerCount(0)]
[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 626522, XrefRangeEnd = 626524, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
public unsafe bool _UpdateComponent_b__0(VolumeEffectField s)
{
IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
checked
{
IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
*ptr = IL2CPP.Il2CppObjectBaseToPtr(s);
IntPtr intPtr2;
IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(VolumeEffectComponent.__c__DisplayClass7_0.NativeMethodInfoPtr__UpdateComponent_b__0_Internal_Boolean_VolumeEffectField_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
Il2CppException.RaiseExceptionIfNecessary(intPtr2);
return *IL2CPP.il2cpp_object_unbox(intPtr);
}
}
// Token: 0x0600A21C RID: 41500 RVA: 0x0029A808 File Offset: 0x00298A08
// Note: this type is marked as 'beforefieldinit'.
static __c__DisplayClass7_0()
{
Il2CppClassPointerStore<VolumeEffectComponent.__c__DisplayClass7_0>.NativeClassPtr = IL2CPP.GetIl2CppNestedType(Il2CppClassPointerStore<VolumeEffectComponent>.NativeClassPtr, "<>c__DisplayClass7_0");
IL2CPP.il2cpp_runtime_class_init(Il2CppClassPointerStore<VolumeEffectComponent.__c__DisplayClass7_0>.NativeClassPtr);
VolumeEffectComponent.__c__DisplayClass7_0.NativeFieldInfoPtr_fieldFlags = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<VolumeEffectComponent.__c__DisplayClass7_0>.NativeClassPtr, "fieldFlags");
VolumeEffectComponent.__c__DisplayClass7_0.NativeMethodInfoPtr__ctor_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<VolumeEffectComponent.__c__DisplayClass7_0>.NativeClassPtr, 100675885);
VolumeEffectComponent.__c__DisplayClass7_0.NativeMethodInfoPtr__UpdateComponent_b__0_Internal_Boolean_VolumeEffectField_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<VolumeEffectComponent.__c__DisplayClass7_0>.NativeClassPtr, 100675886);
}
// Token: 0x0600A21D RID: 41501 RVA: 0x0000A688 File Offset: 0x00008888
public __c__DisplayClass7_0(IntPtr pointer)
: base(pointer)
{
}
// Token: 0x170036DB RID: 14043
// (get) Token: 0x0600A21E RID: 41502 RVA: 0x0029A870 File Offset: 0x00298A70
// (set) Token: 0x0600A21F RID: 41503 RVA: 0x0029A8A4 File Offset: 0x00298AA4
public unsafe VolumeEffectFieldFlags fieldFlags
{
get
{
IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(VolumeEffectComponent.__c__DisplayClass7_0.NativeFieldInfoPtr_fieldFlags);
IntPtr intPtr2 = *intPtr;
return (intPtr2 != 0) ? new VolumeEffectFieldFlags(intPtr2) : null;
}
set
{
IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
IL2CPP.il2cpp_gc_wbarrier_set_field(intPtr, intPtr + (IntPtr)IL2CPP.il2cpp_field_get_offset(VolumeEffectComponent.__c__DisplayClass7_0.NativeFieldInfoPtr_fieldFlags), IL2CPP.Il2CppObjectBaseToPtr(value));
}
}
// Token: 0x04006D12 RID: 27922
private static readonly IntPtr NativeFieldInfoPtr_fieldFlags;
// Token: 0x04006D13 RID: 27923
private static readonly IntPtr NativeMethodInfoPtr__ctor_Public_Void_0;
// Token: 0x04006D14 RID: 27924
private static readonly IntPtr NativeMethodInfoPtr__UpdateComponent_b__0_Internal_Boolean_VolumeEffectField_0;
}
// Token: 0x0200063C RID: 1596
[ObfuscatedName("AmplifyColor.VolumeEffectComponent/<>c")]
[Serializable]
public sealed class __c : Il2CppSystem.Object
{
// Token: 0x0600A220 RID: 41504 RVA: 0x0029A8CC File Offset: 0x00298ACC
[CallerCount(1642)]
[CachedScanResults(RefRangeStart = 7417, RefRangeEnd = 9059, XrefRangeStart = 7417, XrefRangeEnd = 9059, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
public unsafe __c()
: this(IL2CPP.il2cpp_object_new(Il2CppClassPointerStore<VolumeEffectComponent.__c>.NativeClassPtr))
{
IntPtr* ptr = null;
IntPtr intPtr2;
IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(VolumeEffectComponent.__c.NativeMethodInfoPtr__ctor_Public_Void_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
Il2CppException.RaiseExceptionIfNecessary(intPtr2);
}
// Token: 0x0600A221 RID: 41505 RVA: 0x0029A918 File Offset: 0x00298B18
[CallerCount(0)]
[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 626524, XrefRangeEnd = 626526, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
public unsafe bool _ListAcceptableFields_b__9_0(FieldInfo f)
{
IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
checked
{
IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
*ptr = IL2CPP.Il2CppObjectBaseToPtr(f);
IntPtr intPtr2;
IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(VolumeEffectComponent.__c.NativeMethodInfoPtr__ListAcceptableFields_b__9_0_Internal_Boolean_FieldInfo_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
Il2CppException.RaiseExceptionIfNecessary(intPtr2);
return *IL2CPP.il2cpp_object_unbox(intPtr);
}
}
// Token: 0x0600A222 RID: 41506 RVA: 0x0029A980 File Offset: 0x00298B80
[CallerCount(0)]
public unsafe string _GetFieldNames_b__10_0(VolumeEffectField r)
{
IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
checked
{
IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
*ptr = IL2CPP.Il2CppObjectBaseToPtr(r);
IntPtr intPtr2;
IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(VolumeEffectComponent.__c.NativeMethodInfoPtr__GetFieldNames_b__10_0_Internal_String_VolumeEffectField_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
Il2CppException.RaiseExceptionIfNecessary(intPtr2);
return IL2CPP.Il2CppStringToManaged(intPtr);
}
}
// Token: 0x0600A223 RID: 41507 RVA: 0x0029A9E4 File Offset: 0x00298BE4
// Note: this type is marked as 'beforefieldinit'.
static __c()
{
Il2CppClassPointerStore<VolumeEffectComponent.__c>.NativeClassPtr = IL2CPP.GetIl2CppNestedType(Il2CppClassPointerStore<VolumeEffectComponent>.NativeClassPtr, "<>c");
IL2CPP.il2cpp_runtime_class_init(Il2CppClassPointerStore<VolumeEffectComponent.__c>.NativeClassPtr);
VolumeEffectComponent.__c.NativeFieldInfoPtr___9 = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<VolumeEffectComponent.__c>.NativeClassPtr, "<>9");
VolumeEffectComponent.__c.NativeFieldInfoPtr___9__9_0 = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<VolumeEffectComponent.__c>.NativeClassPtr, "<>9__9_0");
VolumeEffectComponent.__c.NativeFieldInfoPtr___9__10_0 = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<VolumeEffectComponent.__c>.NativeClassPtr, "<>9__10_0");
VolumeEffectComponent.__c.NativeMethodInfoPtr__ctor_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<VolumeEffectComponent.__c>.NativeClassPtr, 100675888);
VolumeEffectComponent.__c.NativeMethodInfoPtr__ListAcceptableFields_b__9_0_Internal_Boolean_FieldInfo_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<VolumeEffectComponent.__c>.NativeClassPtr, 100675889);
VolumeEffectComponent.__c.NativeMethodInfoPtr__GetFieldNames_b__10_0_Internal_String_VolumeEffectField_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<VolumeEffectComponent.__c>.NativeClassPtr, 100675890);
}
// Token: 0x0600A224 RID: 41508 RVA: 0x0000A688 File Offset: 0x00008888
public __c(IntPtr pointer)
: base(pointer)
{
}
// Token: 0x170036DC RID: 14044
// (get) Token: 0x0600A225 RID: 41509 RVA: 0x0029AA88 File Offset: 0x00298C88
// (set) Token: 0x0600A226 RID: 41510 RVA: 0x0029AAB3 File Offset: 0x00298CB3
public unsafe static VolumeEffectComponent.__c __9
{
get
{
IntPtr intPtr;
IL2CPP.il2cpp_field_static_get_value(VolumeEffectComponent.__c.NativeFieldInfoPtr___9, (void*)(&intPtr));
IntPtr intPtr2 = intPtr;
return (intPtr2 != 0) ? new VolumeEffectComponent.__c(intPtr2) : null;
}
set
{
IL2CPP.il2cpp_field_static_set_value(VolumeEffectComponent.__c.NativeFieldInfoPtr___9, IL2CPP.Il2CppObjectBaseToPtr(value));
}
}
// Token: 0x170036DD RID: 14045
// (get) Token: 0x0600A227 RID: 41511 RVA: 0x0029AAC8 File Offset: 0x00298CC8
// (set) Token: 0x0600A228 RID: 41512 RVA: 0x0029AAF3 File Offset: 0x00298CF3
public unsafe static Func<FieldInfo, bool> __9__9_0
{
get
{
IntPtr intPtr;
IL2CPP.il2cpp_field_static_get_value(VolumeEffectComponent.__c.NativeFieldInfoPtr___9__9_0, (void*)(&intPtr));
IntPtr intPtr2 = intPtr;
return (intPtr2 != 0) ? new Func<FieldInfo, bool>(intPtr2) : null;
}
set
{
IL2CPP.il2cpp_field_static_set_value(VolumeEffectComponent.__c.NativeFieldInfoPtr___9__9_0, IL2CPP.Il2CppObjectBaseToPtr(value));
}
}
// Token: 0x170036DE RID: 14046
// (get) Token: 0x0600A229 RID: 41513 RVA: 0x0029AB08 File Offset: 0x00298D08
// (set) Token: 0x0600A22A RID: 41514 RVA: 0x0029AB33 File Offset: 0x00298D33
public unsafe static Func<VolumeEffectField, string> __9__10_0
{
get
{
IntPtr intPtr;
IL2CPP.il2cpp_field_static_get_value(VolumeEffectComponent.__c.NativeFieldInfoPtr___9__10_0, (void*)(&intPtr));
IntPtr intPtr2 = intPtr;
return (intPtr2 != 0) ? new Func<VolumeEffectField, string>(intPtr2) : null;
}
set
{
IL2CPP.il2cpp_field_static_set_value(VolumeEffectComponent.__c.NativeFieldInfoPtr___9__10_0, IL2CPP.Il2CppObjectBaseToPtr(value));
}
}
// Token: 0x04006D15 RID: 27925
private static readonly IntPtr NativeFieldInfoPtr___9;
// Token: 0x04006D16 RID: 27926
private static readonly IntPtr NativeFieldInfoPtr___9__9_0;
// Token: 0x04006D17 RID: 27927
private static readonly IntPtr NativeFieldInfoPtr___9__10_0;
// Token: 0x04006D18 RID: 27928
private static readonly IntPtr NativeMethodInfoPtr__ctor_Public_Void_0;
// Token: 0x04006D19 RID: 27929
private static readonly IntPtr NativeMethodInfoPtr__ListAcceptableFields_b__9_0_Internal_Boolean_FieldInfo_0;
// Token: 0x04006D1A RID: 27930
private static readonly IntPtr NativeMethodInfoPtr__GetFieldNames_b__10_0_Internal_String_VolumeEffectField_0;
}
}
}

509
Interop/Assembly-CSharp/AmplifyColor/VolumeEffectComponentFlags.cs Normal file
View File

@@ -0,0 +1,509 @@
using System;
using Il2CppInterop.Common.Attributes;
using Il2CppInterop.Runtime;
using Il2CppInterop.Runtime.InteropTypes.Arrays;
using Il2CppSystem;
using Il2CppSystem.Collections.Generic;
using Il2CppSystem.Reflection;
using UnityEngine;
namespace AmplifyColor
{
// Token: 0x02000642 RID: 1602
[Serializable]
public class VolumeEffectComponentFlags : Il2CppSystem.Object
{
// Token: 0x0600A262 RID: 41570 RVA: 0x0029BB28 File Offset: 0x00299D28
[CallerCount(2)]
[CachedScanResults(RefRangeStart = 627139, RefRangeEnd = 627141, XrefRangeStart = 627130, XrefRangeEnd = 627139, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
public unsafe VolumeEffectComponentFlags(string name)
: this(IL2CPP.il2cpp_object_new(Il2CppClassPointerStore<VolumeEffectComponentFlags>.NativeClassPtr))
{
checked
{
IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
*ptr = IL2CPP.ManagedStringToIl2Cpp(name);
IntPtr intPtr2;
IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(VolumeEffectComponentFlags.NativeMethodInfoPtr__ctor_Public_Void_String_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
Il2CppException.RaiseExceptionIfNecessary(intPtr2);
}
}
// Token: 0x0600A263 RID: 41571 RVA: 0x0029BB8C File Offset: 0x00299D8C
[CallerCount(1)]
[CachedScanResults(RefRangeStart = 627166, RefRangeEnd = 627167, XrefRangeStart = 627141, XrefRangeEnd = 627166, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
public unsafe VolumeEffectComponentFlags(VolumeEffectComponent comp)
: this(IL2CPP.il2cpp_object_new(Il2CppClassPointerStore<VolumeEffectComponentFlags>.NativeClassPtr))
{
checked
{
IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
*ptr = IL2CPP.Il2CppObjectBaseToPtr(comp);
IntPtr intPtr2;
IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(VolumeEffectComponentFlags.NativeMethodInfoPtr__ctor_Public_Void_VolumeEffectComponent_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
Il2CppException.RaiseExceptionIfNecessary(intPtr2);
}
}
// Token: 0x0600A264 RID: 41572 RVA: 0x0029BBF0 File Offset: 0x00299DF0
[CallerCount(1)]
[CachedScanResults(RefRangeStart = 627182, RefRangeEnd = 627183, XrefRangeStart = 627167, XrefRangeEnd = 627182, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
public unsafe VolumeEffectComponentFlags(Component c)
: this(IL2CPP.il2cpp_object_new(Il2CppClassPointerStore<VolumeEffectComponentFlags>.NativeClassPtr))
{
checked
{
IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
*ptr = IL2CPP.Il2CppObjectBaseToPtr(c);
IntPtr intPtr2;
IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(VolumeEffectComponentFlags.NativeMethodInfoPtr__ctor_Public_Void_Component_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
Il2CppException.RaiseExceptionIfNecessary(intPtr2);
}
}
// Token: 0x0600A265 RID: 41573 RVA: 0x0029BC54 File Offset: 0x00299E54
[CallerCount(1)]
[CachedScanResults(RefRangeStart = 627223, RefRangeEnd = 627224, XrefRangeStart = 627183, XrefRangeEnd = 627223, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
public unsafe void UpdateComponentFlags(VolumeEffectComponent comp)
{
IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
checked
{
IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
*ptr = IL2CPP.Il2CppObjectBaseToPtr(comp);
IntPtr intPtr2;
IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(VolumeEffectComponentFlags.NativeMethodInfoPtr_UpdateComponentFlags_Public_Void_VolumeEffectComponent_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
Il2CppException.RaiseExceptionIfNecessary(intPtr2);
}
}
// Token: 0x0600A266 RID: 41574 RVA: 0x0029BCB0 File Offset: 0x00299EB0
[CallerCount(0)]
[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 627224, XrefRangeEnd = 627251, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
public unsafe void UpdateComponentFlags(Component c)
{
IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
checked
{
IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
*ptr = IL2CPP.Il2CppObjectBaseToPtr(c);
IntPtr intPtr2;
IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(VolumeEffectComponentFlags.NativeMethodInfoPtr_UpdateComponentFlags_Public_Void_Component_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
Il2CppException.RaiseExceptionIfNecessary(intPtr2);
}
}
// Token: 0x0600A267 RID: 41575 RVA: 0x0029BD0C File Offset: 0x00299F0C
[CallerCount(0)]
[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 627251, XrefRangeEnd = 627291, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
public unsafe Il2CppStringArray GetFieldNames()
{
IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
IntPtr* ptr = null;
IntPtr intPtr2;
IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(VolumeEffectComponentFlags.NativeMethodInfoPtr_GetFieldNames_Public_Il2CppStringArray_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
Il2CppException.RaiseExceptionIfNecessary(intPtr2);
IntPtr intPtr3 = intPtr;
return (intPtr3 != 0) ? new Il2CppStringArray(intPtr3) : null;
}
// Token: 0x0600A268 RID: 41576 RVA: 0x0029BD64 File Offset: 0x00299F64
// Note: this type is marked as 'beforefieldinit'.
static VolumeEffectComponentFlags()
{
Il2CppClassPointerStore<VolumeEffectComponentFlags>.NativeClassPtr = IL2CPP.GetIl2CppClass("Assembly-CSharp.dll", "AmplifyColor", "VolumeEffectComponentFlags");
IL2CPP.il2cpp_runtime_class_init(Il2CppClassPointerStore<VolumeEffectComponentFlags>.NativeClassPtr);
VolumeEffectComponentFlags.NativeFieldInfoPtr_componentName = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<VolumeEffectComponentFlags>.NativeClassPtr, "componentName");
VolumeEffectComponentFlags.NativeFieldInfoPtr_componentFields = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<VolumeEffectComponentFlags>.NativeClassPtr, "componentFields");
VolumeEffectComponentFlags.NativeFieldInfoPtr_blendFlag = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<VolumeEffectComponentFlags>.NativeClassPtr, "blendFlag");
VolumeEffectComponentFlags.NativeMethodInfoPtr__ctor_Public_Void_String_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<VolumeEffectComponentFlags>.NativeClassPtr, 100675916);
VolumeEffectComponentFlags.NativeMethodInfoPtr__ctor_Public_Void_VolumeEffectComponent_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<VolumeEffectComponentFlags>.NativeClassPtr, 100675917);
VolumeEffectComponentFlags.NativeMethodInfoPtr__ctor_Public_Void_Component_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<VolumeEffectComponentFlags>.NativeClassPtr, 100675918);
VolumeEffectComponentFlags.NativeMethodInfoPtr_UpdateComponentFlags_Public_Void_VolumeEffectComponent_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<VolumeEffectComponentFlags>.NativeClassPtr, 100675919);
VolumeEffectComponentFlags.NativeMethodInfoPtr_UpdateComponentFlags_Public_Void_Component_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<VolumeEffectComponentFlags>.NativeClassPtr, 100675920);
VolumeEffectComponentFlags.NativeMethodInfoPtr_GetFieldNames_Public_Il2CppStringArray_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<VolumeEffectComponentFlags>.NativeClassPtr, 100675921);
}
// Token: 0x0600A269 RID: 41577 RVA: 0x0000A688 File Offset: 0x00008888
public VolumeEffectComponentFlags(IntPtr pointer)
: base(pointer)
{
}
// Token: 0x170036EA RID: 14058
// (get) Token: 0x0600A26A RID: 41578 RVA: 0x0029BE48 File Offset: 0x0029A048
// (set) Token: 0x0600A26B RID: 41579 RVA: 0x0029BE71 File Offset: 0x0029A071
public unsafe string componentName
{
get
{
IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(VolumeEffectComponentFlags.NativeFieldInfoPtr_componentName);
return IL2CPP.Il2CppStringToManaged(*intPtr);
}
set
{
IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
IL2CPP.il2cpp_gc_wbarrier_set_field(intPtr, intPtr + (IntPtr)IL2CPP.il2cpp_field_get_offset(VolumeEffectComponentFlags.NativeFieldInfoPtr_componentName), IL2CPP.ManagedStringToIl2Cpp(value));
}
}
// Token: 0x170036EB RID: 14059
// (get) Token: 0x0600A26C RID: 41580 RVA: 0x0029BE98 File Offset: 0x0029A098
// (set) Token: 0x0600A26D RID: 41581 RVA: 0x0029BECC File Offset: 0x0029A0CC
public unsafe List<VolumeEffectFieldFlags> componentFields
{
get
{
IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(VolumeEffectComponentFlags.NativeFieldInfoPtr_componentFields);
IntPtr intPtr2 = *intPtr;
return (intPtr2 != 0) ? new List<VolumeEffectFieldFlags>(intPtr2) : null;
}
set
{
IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
IL2CPP.il2cpp_gc_wbarrier_set_field(intPtr, intPtr + (IntPtr)IL2CPP.il2cpp_field_get_offset(VolumeEffectComponentFlags.NativeFieldInfoPtr_componentFields), IL2CPP.Il2CppObjectBaseToPtr(value));
}
}
// Token: 0x170036EC RID: 14060
// (get) Token: 0x0600A26E RID: 41582 RVA: 0x0029BEF4 File Offset: 0x0029A0F4
// (set) Token: 0x0600A26F RID: 41583 RVA: 0x0029BF1C File Offset: 0x0029A11C
public unsafe bool blendFlag
{
get
{
IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(VolumeEffectComponentFlags.NativeFieldInfoPtr_blendFlag);
return *intPtr;
}
set
{
*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(VolumeEffectComponentFlags.NativeFieldInfoPtr_blendFlag)) = value;
}
}
// Token: 0x04006D3D RID: 27965
private static readonly IntPtr NativeFieldInfoPtr_componentName;
// Token: 0x04006D3E RID: 27966
private static readonly IntPtr NativeFieldInfoPtr_componentFields;
// Token: 0x04006D3F RID: 27967
private static readonly IntPtr NativeFieldInfoPtr_blendFlag;
// Token: 0x04006D40 RID: 27968
private static readonly IntPtr NativeMethodInfoPtr__ctor_Public_Void_String_0;
// Token: 0x04006D41 RID: 27969
private static readonly IntPtr NativeMethodInfoPtr__ctor_Public_Void_VolumeEffectComponent_0;
// Token: 0x04006D42 RID: 27970
private static readonly IntPtr NativeMethodInfoPtr__ctor_Public_Void_Component_0;
// Token: 0x04006D43 RID: 27971
private static readonly IntPtr NativeMethodInfoPtr_UpdateComponentFlags_Public_Void_VolumeEffectComponent_0;
// Token: 0x04006D44 RID: 27972
private static readonly IntPtr NativeMethodInfoPtr_UpdateComponentFlags_Public_Void_Component_0;
// Token: 0x04006D45 RID: 27973
private static readonly IntPtr NativeMethodInfoPtr_GetFieldNames_Public_Il2CppStringArray_0;
// Token: 0x02000643 RID: 1603
[ObfuscatedName("AmplifyColor.VolumeEffectComponentFlags/<>c__DisplayClass6_0")]
public sealed class __c__DisplayClass6_0 : Il2CppSystem.Object
{
// Token: 0x0600A270 RID: 41584 RVA: 0x0029BF40 File Offset: 0x0029A140
[CallerCount(1642)]
[CachedScanResults(RefRangeStart = 7417, RefRangeEnd = 9059, XrefRangeStart = 7417, XrefRangeEnd = 9059, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
public unsafe __c__DisplayClass6_0()
: this(IL2CPP.il2cpp_object_new(Il2CppClassPointerStore<VolumeEffectComponentFlags.__c__DisplayClass6_0>.NativeClassPtr))
{
IntPtr* ptr = null;
IntPtr intPtr2;
IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(VolumeEffectComponentFlags.__c__DisplayClass6_0.NativeMethodInfoPtr__ctor_Public_Void_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
Il2CppException.RaiseExceptionIfNecessary(intPtr2);
}
// Token: 0x0600A271 RID: 41585 RVA: 0x0029BF8C File Offset: 0x0029A18C
[CallerCount(0)]
[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 0, XrefRangeEnd = 0, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
public unsafe bool _UpdateComponentFlags_b__0(VolumeEffectFieldFlags s)
{
IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
checked
{
IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
*ptr = IL2CPP.Il2CppObjectBaseToPtr(s);
IntPtr intPtr2;
IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(VolumeEffectComponentFlags.__c__DisplayClass6_0.NativeMethodInfoPtr__UpdateComponentFlags_b__0_Internal_Boolean_VolumeEffectFieldFlags_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
Il2CppException.RaiseExceptionIfNecessary(intPtr2);
return *IL2CPP.il2cpp_object_unbox(intPtr);
}
}
// Token: 0x0600A272 RID: 41586 RVA: 0x0029BFF4 File Offset: 0x0029A1F4
// Note: this type is marked as 'beforefieldinit'.
static __c__DisplayClass6_0()
{
Il2CppClassPointerStore<VolumeEffectComponentFlags.__c__DisplayClass6_0>.NativeClassPtr = IL2CPP.GetIl2CppNestedType(Il2CppClassPointerStore<VolumeEffectComponentFlags>.NativeClassPtr, "<>c__DisplayClass6_0");
IL2CPP.il2cpp_runtime_class_init(Il2CppClassPointerStore<VolumeEffectComponentFlags.__c__DisplayClass6_0>.NativeClassPtr);
VolumeEffectComponentFlags.__c__DisplayClass6_0.NativeFieldInfoPtr_field = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<VolumeEffectComponentFlags.__c__DisplayClass6_0>.NativeClassPtr, "field");
VolumeEffectComponentFlags.__c__DisplayClass6_0.NativeMethodInfoPtr__ctor_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<VolumeEffectComponentFlags.__c__DisplayClass6_0>.NativeClassPtr, 100675922);
VolumeEffectComponentFlags.__c__DisplayClass6_0.NativeMethodInfoPtr__UpdateComponentFlags_b__0_Internal_Boolean_VolumeEffectFieldFlags_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<VolumeEffectComponentFlags.__c__DisplayClass6_0>.NativeClassPtr, 100675923);
}
// Token: 0x0600A273 RID: 41587 RVA: 0x0000A688 File Offset: 0x00008888
public __c__DisplayClass6_0(IntPtr pointer)
: base(pointer)
{
}
// Token: 0x170036ED RID: 14061
// (get) Token: 0x0600A274 RID: 41588 RVA: 0x0029C05C File Offset: 0x0029A25C
// (set) Token: 0x0600A275 RID: 41589 RVA: 0x0029C090 File Offset: 0x0029A290
public unsafe VolumeEffectField field
{
get
{
IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(VolumeEffectComponentFlags.__c__DisplayClass6_0.NativeFieldInfoPtr_field);
IntPtr intPtr2 = *intPtr;
return (intPtr2 != 0) ? new VolumeEffectField(intPtr2) : null;
}
set
{
IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
IL2CPP.il2cpp_gc_wbarrier_set_field(intPtr, intPtr + (IntPtr)IL2CPP.il2cpp_field_get_offset(VolumeEffectComponentFlags.__c__DisplayClass6_0.NativeFieldInfoPtr_field), IL2CPP.Il2CppObjectBaseToPtr(value));
}
}
// Token: 0x04006D46 RID: 27974
private static readonly IntPtr NativeFieldInfoPtr_field;
// Token: 0x04006D47 RID: 27975
private static readonly IntPtr NativeMethodInfoPtr__ctor_Public_Void_0;
// Token: 0x04006D48 RID: 27976
private static readonly IntPtr NativeMethodInfoPtr__UpdateComponentFlags_b__0_Internal_Boolean_VolumeEffectFieldFlags_0;
}
// Token: 0x02000644 RID: 1604
[ObfuscatedName("AmplifyColor.VolumeEffectComponentFlags/<>c__DisplayClass7_0")]
public sealed class __c__DisplayClass7_0 : Il2CppSystem.Object
{
// Token: 0x0600A276 RID: 41590 RVA: 0x0029C0B8 File Offset: 0x0029A2B8
[CallerCount(1642)]
[CachedScanResults(RefRangeStart = 7417, RefRangeEnd = 9059, XrefRangeStart = 7417, XrefRangeEnd = 9059, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
public unsafe __c__DisplayClass7_0()
: this(IL2CPP.il2cpp_object_new(Il2CppClassPointerStore<VolumeEffectComponentFlags.__c__DisplayClass7_0>.NativeClassPtr))
{
IntPtr* ptr = null;
IntPtr intPtr2;
IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(VolumeEffectComponentFlags.__c__DisplayClass7_0.NativeMethodInfoPtr__ctor_Public_Void_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
Il2CppException.RaiseExceptionIfNecessary(intPtr2);
}
// Token: 0x0600A277 RID: 41591 RVA: 0x0029C104 File Offset: 0x0029A304
[CallerCount(0)]
[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 627128, XrefRangeEnd = 627130, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
public unsafe bool _UpdateComponentFlags_b__0(VolumeEffectFieldFlags s)
{
IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
checked
{
IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
*ptr = IL2CPP.Il2CppObjectBaseToPtr(s);
IntPtr intPtr2;
IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(VolumeEffectComponentFlags.__c__DisplayClass7_0.NativeMethodInfoPtr__UpdateComponentFlags_b__0_Internal_Boolean_VolumeEffectFieldFlags_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
Il2CppException.RaiseExceptionIfNecessary(intPtr2);
return *IL2CPP.il2cpp_object_unbox(intPtr);
}
}
// Token: 0x0600A278 RID: 41592 RVA: 0x0029C16C File Offset: 0x0029A36C
// Note: this type is marked as 'beforefieldinit'.
static __c__DisplayClass7_0()
{
Il2CppClassPointerStore<VolumeEffectComponentFlags.__c__DisplayClass7_0>.NativeClassPtr = IL2CPP.GetIl2CppNestedType(Il2CppClassPointerStore<VolumeEffectComponentFlags>.NativeClassPtr, "<>c__DisplayClass7_0");
IL2CPP.il2cpp_runtime_class_init(Il2CppClassPointerStore<VolumeEffectComponentFlags.__c__DisplayClass7_0>.NativeClassPtr);
VolumeEffectComponentFlags.__c__DisplayClass7_0.NativeFieldInfoPtr_pi = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<VolumeEffectComponentFlags.__c__DisplayClass7_0>.NativeClassPtr, "pi");
VolumeEffectComponentFlags.__c__DisplayClass7_0.NativeMethodInfoPtr__ctor_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<VolumeEffectComponentFlags.__c__DisplayClass7_0>.NativeClassPtr, 100675924);
VolumeEffectComponentFlags.__c__DisplayClass7_0.NativeMethodInfoPtr__UpdateComponentFlags_b__0_Internal_Boolean_VolumeEffectFieldFlags_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<VolumeEffectComponentFlags.__c__DisplayClass7_0>.NativeClassPtr, 100675925);
}
// Token: 0x0600A279 RID: 41593 RVA: 0x0000A688 File Offset: 0x00008888
public __c__DisplayClass7_0(IntPtr pointer)
: base(pointer)
{
}
// Token: 0x170036EE RID: 14062
// (get) Token: 0x0600A27A RID: 41594 RVA: 0x0029C1D4 File Offset: 0x0029A3D4
// (set) Token: 0x0600A27B RID: 41595 RVA: 0x0029C208 File Offset: 0x0029A408
public unsafe FieldInfo pi
{
get
{
IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(VolumeEffectComponentFlags.__c__DisplayClass7_0.NativeFieldInfoPtr_pi);
IntPtr intPtr2 = *intPtr;
return (intPtr2 != 0) ? new FieldInfo(intPtr2) : null;
}
set
{
IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
IL2CPP.il2cpp_gc_wbarrier_set_field(intPtr, intPtr + (IntPtr)IL2CPP.il2cpp_field_get_offset(VolumeEffectComponentFlags.__c__DisplayClass7_0.NativeFieldInfoPtr_pi), IL2CPP.Il2CppObjectBaseToPtr(value));
}
}
// Token: 0x04006D49 RID: 27977
private static readonly IntPtr NativeFieldInfoPtr_pi;
// Token: 0x04006D4A RID: 27978
private static readonly IntPtr NativeMethodInfoPtr__ctor_Public_Void_0;
// Token: 0x04006D4B RID: 27979
private static readonly IntPtr NativeMethodInfoPtr__UpdateComponentFlags_b__0_Internal_Boolean_VolumeEffectFieldFlags_0;
}
// Token: 0x02000645 RID: 1605
[ObfuscatedName("AmplifyColor.VolumeEffectComponentFlags/<>c")]
[Serializable]
public sealed class __c : Il2CppSystem.Object
{
// Token: 0x0600A27C RID: 41596 RVA: 0x0029C230 File Offset: 0x0029A430
[CallerCount(1642)]
[CachedScanResults(RefRangeStart = 7417, RefRangeEnd = 9059, XrefRangeStart = 7417, XrefRangeEnd = 9059, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
public unsafe __c()
: this(IL2CPP.il2cpp_object_new(Il2CppClassPointerStore<VolumeEffectComponentFlags.__c>.NativeClassPtr))
{
IntPtr* ptr = null;
IntPtr intPtr2;
IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(VolumeEffectComponentFlags.__c.NativeMethodInfoPtr__ctor_Public_Void_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
Il2CppException.RaiseExceptionIfNecessary(intPtr2);
}
// Token: 0x0600A27D RID: 41597 RVA: 0x0029C27C File Offset: 0x0029A47C
[CallerCount(0)]
public unsafe bool _GetFieldNames_b__8_0(VolumeEffectFieldFlags r)
{
IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
checked
{
IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
*ptr = IL2CPP.Il2CppObjectBaseToPtr(r);
IntPtr intPtr2;
IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(VolumeEffectComponentFlags.__c.NativeMethodInfoPtr__GetFieldNames_b__8_0_Internal_Boolean_VolumeEffectFieldFlags_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
Il2CppException.RaiseExceptionIfNecessary(intPtr2);
return *IL2CPP.il2cpp_object_unbox(intPtr);
}
}
// Token: 0x0600A27E RID: 41598 RVA: 0x0029C2E4 File Offset: 0x0029A4E4
[CallerCount(0)]
public unsafe string _GetFieldNames_b__8_1(VolumeEffectFieldFlags r)
{
IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
checked
{
IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
*ptr = IL2CPP.Il2CppObjectBaseToPtr(r);
IntPtr intPtr2;
IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(VolumeEffectComponentFlags.__c.NativeMethodInfoPtr__GetFieldNames_b__8_1_Internal_String_VolumeEffectFieldFlags_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
Il2CppException.RaiseExceptionIfNecessary(intPtr2);
return IL2CPP.Il2CppStringToManaged(intPtr);
}
}
// Token: 0x0600A27F RID: 41599 RVA: 0x0029C348 File Offset: 0x0029A548
// Note: this type is marked as 'beforefieldinit'.
static __c()
{
Il2CppClassPointerStore<VolumeEffectComponentFlags.__c>.NativeClassPtr = IL2CPP.GetIl2CppNestedType(Il2CppClassPointerStore<VolumeEffectComponentFlags>.NativeClassPtr, "<>c");
IL2CPP.il2cpp_runtime_class_init(Il2CppClassPointerStore<VolumeEffectComponentFlags.__c>.NativeClassPtr);
VolumeEffectComponentFlags.__c.NativeFieldInfoPtr___9 = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<VolumeEffectComponentFlags.__c>.NativeClassPtr, "<>9");
VolumeEffectComponentFlags.__c.NativeFieldInfoPtr___9__8_0 = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<VolumeEffectComponentFlags.__c>.NativeClassPtr, "<>9__8_0");
VolumeEffectComponentFlags.__c.NativeFieldInfoPtr___9__8_1 = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<VolumeEffectComponentFlags.__c>.NativeClassPtr, "<>9__8_1");
VolumeEffectComponentFlags.__c.NativeMethodInfoPtr__ctor_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<VolumeEffectComponentFlags.__c>.NativeClassPtr, 100675927);
VolumeEffectComponentFlags.__c.NativeMethodInfoPtr__GetFieldNames_b__8_0_Internal_Boolean_VolumeEffectFieldFlags_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<VolumeEffectComponentFlags.__c>.NativeClassPtr, 100675928);
VolumeEffectComponentFlags.__c.NativeMethodInfoPtr__GetFieldNames_b__8_1_Internal_String_VolumeEffectFieldFlags_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<VolumeEffectComponentFlags.__c>.NativeClassPtr, 100675929);
}
// Token: 0x0600A280 RID: 41600 RVA: 0x0000A688 File Offset: 0x00008888
public __c(IntPtr pointer)
: base(pointer)
{
}
// Token: 0x170036EF RID: 14063
// (get) Token: 0x0600A281 RID: 41601 RVA: 0x0029C3EC File Offset: 0x0029A5EC
// (set) Token: 0x0600A282 RID: 41602 RVA: 0x0029C417 File Offset: 0x0029A617
public unsafe static VolumeEffectComponentFlags.__c __9
{
get
{
IntPtr intPtr;
IL2CPP.il2cpp_field_static_get_value(VolumeEffectComponentFlags.__c.NativeFieldInfoPtr___9, (void*)(&intPtr));
IntPtr intPtr2 = intPtr;
return (intPtr2 != 0) ? new VolumeEffectComponentFlags.__c(intPtr2) : null;
}
set
{
IL2CPP.il2cpp_field_static_set_value(VolumeEffectComponentFlags.__c.NativeFieldInfoPtr___9, IL2CPP.Il2CppObjectBaseToPtr(value));
}
}
// Token: 0x170036F0 RID: 14064
// (get) Token: 0x0600A283 RID: 41603 RVA: 0x0029C42C File Offset: 0x0029A62C
// (set) Token: 0x0600A284 RID: 41604 RVA: 0x0029C457 File Offset: 0x0029A657
public unsafe static Func<VolumeEffectFieldFlags, bool> __9__8_0
{
get
{
IntPtr intPtr;
IL2CPP.il2cpp_field_static_get_value(VolumeEffectComponentFlags.__c.NativeFieldInfoPtr___9__8_0, (void*)(&intPtr));
IntPtr intPtr2 = intPtr;
return (intPtr2 != 0) ? new Func<VolumeEffectFieldFlags, bool>(intPtr2) : null;
}
set
{
IL2CPP.il2cpp_field_static_set_value(VolumeEffectComponentFlags.__c.NativeFieldInfoPtr___9__8_0, IL2CPP.Il2CppObjectBaseToPtr(value));
}
}
// Token: 0x170036F1 RID: 14065
// (get) Token: 0x0600A285 RID: 41605 RVA: 0x0029C46C File Offset: 0x0029A66C
// (set) Token: 0x0600A286 RID: 41606 RVA: 0x0029C497 File Offset: 0x0029A697
public unsafe static Func<VolumeEffectFieldFlags, string> __9__8_1
{
get
{
IntPtr intPtr;
IL2CPP.il2cpp_field_static_get_value(VolumeEffectComponentFlags.__c.NativeFieldInfoPtr___9__8_1, (void*)(&intPtr));
IntPtr intPtr2 = intPtr;
return (intPtr2 != 0) ? new Func<VolumeEffectFieldFlags, string>(intPtr2) : null;
}
set
{
IL2CPP.il2cpp_field_static_set_value(VolumeEffectComponentFlags.__c.NativeFieldInfoPtr___9__8_1, IL2CPP.Il2CppObjectBaseToPtr(value));
}
}
// Token: 0x04006D4C RID: 27980
private static readonly IntPtr NativeFieldInfoPtr___9;
// Token: 0x04006D4D RID: 27981
private static readonly IntPtr NativeFieldInfoPtr___9__8_0;
// Token: 0x04006D4E RID: 27982
private static readonly IntPtr NativeFieldInfoPtr___9__8_1;
// Token: 0x04006D4F RID: 27983
private static readonly IntPtr NativeMethodInfoPtr__ctor_Public_Void_0;
// Token: 0x04006D50 RID: 27984
private static readonly IntPtr NativeMethodInfoPtr__GetFieldNames_b__8_0_Internal_Boolean_VolumeEffectFieldFlags_0;
// Token: 0x04006D51 RID: 27985
private static readonly IntPtr NativeMethodInfoPtr__GetFieldNames_b__8_1_Internal_String_VolumeEffectFieldFlags_0;
}
}
}

269
Interop/Assembly-CSharp/AmplifyColor/VolumeEffectContainer.cs Normal file
View File

@@ -0,0 +1,269 @@
using System;
using Il2CppInterop.Common.Attributes;
using Il2CppInterop.Runtime;
using Il2CppInterop.Runtime.InteropTypes.Arrays;
using Il2CppSystem;
using Il2CppSystem.Collections.Generic;
namespace AmplifyColor
{
// Token: 0x0200063F RID: 1599
[Serializable]
public class VolumeEffectContainer : Object
{
// Token: 0x0600A246 RID: 41542 RVA: 0x0029B3D4 File Offset: 0x002995D4
[CallerCount(1)]
[CachedScanResults(RefRangeStart = 627061, RefRangeEnd = 627062, XrefRangeStart = 627053, XrefRangeEnd = 627061, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
public unsafe VolumeEffectContainer()
: this(IL2CPP.il2cpp_object_new(Il2CppClassPointerStore<VolumeEffectContainer>.NativeClassPtr))
{
IntPtr* ptr = null;
IntPtr intPtr2;
IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(VolumeEffectContainer.NativeMethodInfoPtr__ctor_Public_Void_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
Il2CppException.RaiseExceptionIfNecessary(intPtr2);
}
// Token: 0x0600A247 RID: 41543 RVA: 0x0029B420 File Offset: 0x00299620
[CallerCount(0)]
[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 627062, XrefRangeEnd = 627073, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
public unsafe void AddColorEffect(AmplifyColorBase colorEffect)
{
IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
checked
{
IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
*ptr = IL2CPP.Il2CppObjectBaseToPtr(colorEffect);
IntPtr intPtr2;
IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(VolumeEffectContainer.NativeMethodInfoPtr_AddColorEffect_Public_Void_AmplifyColorBase_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
Il2CppException.RaiseExceptionIfNecessary(intPtr2);
}
}
// Token: 0x0600A248 RID: 41544 RVA: 0x0029B47C File Offset: 0x0029967C
[CallerCount(0)]
[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 627073, XrefRangeEnd = 627080, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
public unsafe VolumeEffect AddJustColorEffect(AmplifyColorBase colorEffect)
{
IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
checked
{
IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
*ptr = IL2CPP.Il2CppObjectBaseToPtr(colorEffect);
IntPtr intPtr2;
IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(VolumeEffectContainer.NativeMethodInfoPtr_AddJustColorEffect_Public_VolumeEffect_AmplifyColorBase_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
Il2CppException.RaiseExceptionIfNecessary(intPtr2);
IntPtr intPtr3 = intPtr;
return (intPtr3 != 0) ? new VolumeEffect(intPtr3) : null;
}
}
// Token: 0x0600A249 RID: 41545 RVA: 0x0029B4EC File Offset: 0x002996EC
[CallerCount(3)]
[CachedScanResults(RefRangeStart = 627090, RefRangeEnd = 627093, XrefRangeStart = 627080, XrefRangeEnd = 627090, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
public unsafe VolumeEffect FindVolumeEffect(AmplifyColorBase colorEffect)
{
IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
checked
{
IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
*ptr = IL2CPP.Il2CppObjectBaseToPtr(colorEffect);
IntPtr intPtr2;
IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(VolumeEffectContainer.NativeMethodInfoPtr_FindVolumeEffect_Public_VolumeEffect_AmplifyColorBase_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
Il2CppException.RaiseExceptionIfNecessary(intPtr2);
IntPtr intPtr3 = intPtr;
return (intPtr3 != 0) ? new VolumeEffect(intPtr3) : null;
}
}
// Token: 0x0600A24A RID: 41546 RVA: 0x0029B55C File Offset: 0x0029975C
[CallerCount(0)]
[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 627093, XrefRangeEnd = 627097, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
public unsafe void RemoveVolumeEffect(VolumeEffect volume)
{
IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
checked
{
IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
*ptr = IL2CPP.Il2CppObjectBaseToPtr(volume);
IntPtr intPtr2;
IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(VolumeEffectContainer.NativeMethodInfoPtr_RemoveVolumeEffect_Public_Void_VolumeEffect_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
Il2CppException.RaiseExceptionIfNecessary(intPtr2);
}
}
// Token: 0x0600A24B RID: 41547 RVA: 0x0029B5B8 File Offset: 0x002997B8
[CallerCount(0)]
[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 627097, XrefRangeEnd = 627119, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
public unsafe Il2CppReferenceArray<AmplifyColorBase> GetStoredEffects()
{
IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
IntPtr* ptr = null;
IntPtr intPtr2;
IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(VolumeEffectContainer.NativeMethodInfoPtr_GetStoredEffects_Public_Il2CppReferenceArray_1_AmplifyColorBase_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
Il2CppException.RaiseExceptionIfNecessary(intPtr2);
IntPtr intPtr3 = intPtr;
return (intPtr3 != 0) ? new Il2CppReferenceArray<AmplifyColorBase>(intPtr3) : null;
}
// Token: 0x0600A24C RID: 41548 RVA: 0x0029B610 File Offset: 0x00299810
// Note: this type is marked as 'beforefieldinit'.
static VolumeEffectContainer()
{
Il2CppClassPointerStore<VolumeEffectContainer>.NativeClassPtr = IL2CPP.GetIl2CppClass("Assembly-CSharp.dll", "AmplifyColor", "VolumeEffectContainer");
IL2CPP.il2cpp_runtime_class_init(Il2CppClassPointerStore<VolumeEffectContainer>.NativeClassPtr);
VolumeEffectContainer.NativeFieldInfoPtr_volumes = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<VolumeEffectContainer>.NativeClassPtr, "volumes");
VolumeEffectContainer.NativeMethodInfoPtr__ctor_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<VolumeEffectContainer>.NativeClassPtr, 100675905);
VolumeEffectContainer.NativeMethodInfoPtr_AddColorEffect_Public_Void_AmplifyColorBase_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<VolumeEffectContainer>.NativeClassPtr, 100675906);
VolumeEffectContainer.NativeMethodInfoPtr_AddJustColorEffect_Public_VolumeEffect_AmplifyColorBase_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<VolumeEffectContainer>.NativeClassPtr, 100675907);
VolumeEffectContainer.NativeMethodInfoPtr_FindVolumeEffect_Public_VolumeEffect_AmplifyColorBase_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<VolumeEffectContainer>.NativeClassPtr, 100675908);
VolumeEffectContainer.NativeMethodInfoPtr_RemoveVolumeEffect_Public_Void_VolumeEffect_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<VolumeEffectContainer>.NativeClassPtr, 100675909);
VolumeEffectContainer.NativeMethodInfoPtr_GetStoredEffects_Public_Il2CppReferenceArray_1_AmplifyColorBase_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<VolumeEffectContainer>.NativeClassPtr, 100675910);
}
// Token: 0x0600A24D RID: 41549 RVA: 0x0000A688 File Offset: 0x00008888
public VolumeEffectContainer(IntPtr pointer)
: base(pointer)
{
}
// Token: 0x170036E4 RID: 14052
// (get) Token: 0x0600A24E RID: 41550 RVA: 0x0029B6CC File Offset: 0x002998CC
// (set) Token: 0x0600A24F RID: 41551 RVA: 0x0029B700 File Offset: 0x00299900
public unsafe List<VolumeEffect> volumes
{
get
{
IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(VolumeEffectContainer.NativeFieldInfoPtr_volumes);
IntPtr intPtr2 = *intPtr;
return (intPtr2 != 0) ? new List<VolumeEffect>(intPtr2) : null;
}
set
{
IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
IL2CPP.il2cpp_gc_wbarrier_set_field(intPtr, intPtr + (IntPtr)IL2CPP.il2cpp_field_get_offset(VolumeEffectContainer.NativeFieldInfoPtr_volumes), IL2CPP.Il2CppObjectBaseToPtr(value));
}
}
// Token: 0x04006D2D RID: 27949
private static readonly IntPtr NativeFieldInfoPtr_volumes;
// Token: 0x04006D2E RID: 27950
private static readonly IntPtr NativeMethodInfoPtr__ctor_Public_Void_0;
// Token: 0x04006D2F RID: 27951
private static readonly IntPtr NativeMethodInfoPtr_AddColorEffect_Public_Void_AmplifyColorBase_0;
// Token: 0x04006D30 RID: 27952
private static readonly IntPtr NativeMethodInfoPtr_AddJustColorEffect_Public_VolumeEffect_AmplifyColorBase_0;
// Token: 0x04006D31 RID: 27953
private static readonly IntPtr NativeMethodInfoPtr_FindVolumeEffect_Public_VolumeEffect_AmplifyColorBase_0;
// Token: 0x04006D32 RID: 27954
private static readonly IntPtr NativeMethodInfoPtr_RemoveVolumeEffect_Public_Void_VolumeEffect_0;
// Token: 0x04006D33 RID: 27955
private static readonly IntPtr NativeMethodInfoPtr_GetStoredEffects_Public_Il2CppReferenceArray_1_AmplifyColorBase_0;
// Token: 0x02000640 RID: 1600
[ObfuscatedName("AmplifyColor.VolumeEffectContainer/<>c")]
[Serializable]
public sealed class __c : Object
{
// Token: 0x0600A250 RID: 41552 RVA: 0x0029B728 File Offset: 0x00299928
[CallerCount(1642)]
[CachedScanResults(RefRangeStart = 7417, RefRangeEnd = 9059, XrefRangeStart = 7417, XrefRangeEnd = 9059, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
public unsafe __c()
: this(IL2CPP.il2cpp_object_new(Il2CppClassPointerStore<VolumeEffectContainer.__c>.NativeClassPtr))
{
IntPtr* ptr = null;
IntPtr intPtr2;
IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(VolumeEffectContainer.__c.NativeMethodInfoPtr__ctor_Public_Void_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
Il2CppException.RaiseExceptionIfNecessary(intPtr2);
}
// Token: 0x0600A251 RID: 41553 RVA: 0x0029B774 File Offset: 0x00299974
[CallerCount(0)]
public unsafe AmplifyColorBase _GetStoredEffects_b__6_0(VolumeEffect r)
{
IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
checked
{
IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
*ptr = IL2CPP.Il2CppObjectBaseToPtr(r);
IntPtr intPtr2;
IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(VolumeEffectContainer.__c.NativeMethodInfoPtr__GetStoredEffects_b__6_0_Internal_AmplifyColorBase_VolumeEffect_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
Il2CppException.RaiseExceptionIfNecessary(intPtr2);
IntPtr intPtr3 = intPtr;
return (intPtr3 != 0) ? new AmplifyColorBase(intPtr3) : null;
}
}
// Token: 0x0600A252 RID: 41554 RVA: 0x0029B7E4 File Offset: 0x002999E4
// Note: this type is marked as 'beforefieldinit'.
static __c()
{
Il2CppClassPointerStore<VolumeEffectContainer.__c>.NativeClassPtr = IL2CPP.GetIl2CppNestedType(Il2CppClassPointerStore<VolumeEffectContainer>.NativeClassPtr, "<>c");
IL2CPP.il2cpp_runtime_class_init(Il2CppClassPointerStore<VolumeEffectContainer.__c>.NativeClassPtr);
VolumeEffectContainer.__c.NativeFieldInfoPtr___9 = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<VolumeEffectContainer.__c>.NativeClassPtr, "<>9");
VolumeEffectContainer.__c.NativeFieldInfoPtr___9__6_0 = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<VolumeEffectContainer.__c>.NativeClassPtr, "<>9__6_0");
VolumeEffectContainer.__c.NativeMethodInfoPtr__ctor_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<VolumeEffectContainer.__c>.NativeClassPtr, 100675912);
VolumeEffectContainer.__c.NativeMethodInfoPtr__GetStoredEffects_b__6_0_Internal_AmplifyColorBase_VolumeEffect_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<VolumeEffectContainer.__c>.NativeClassPtr, 100675913);
}
// Token: 0x0600A253 RID: 41555 RVA: 0x0000A688 File Offset: 0x00008888
public __c(IntPtr pointer)
: base(pointer)
{
}
// Token: 0x170036E5 RID: 14053
// (get) Token: 0x0600A254 RID: 41556 RVA: 0x0029B860 File Offset: 0x00299A60
// (set) Token: 0x0600A255 RID: 41557 RVA: 0x0029B88B File Offset: 0x00299A8B
public unsafe static VolumeEffectContainer.__c __9
{
get
{
IntPtr intPtr;
IL2CPP.il2cpp_field_static_get_value(VolumeEffectContainer.__c.NativeFieldInfoPtr___9, (void*)(&intPtr));
IntPtr intPtr2 = intPtr;
return (intPtr2 != 0) ? new VolumeEffectContainer.__c(intPtr2) : null;
}
set
{
IL2CPP.il2cpp_field_static_set_value(VolumeEffectContainer.__c.NativeFieldInfoPtr___9, IL2CPP.Il2CppObjectBaseToPtr(value));
}
}
// Token: 0x170036E6 RID: 14054
// (get) Token: 0x0600A256 RID: 41558 RVA: 0x0029B8A0 File Offset: 0x00299AA0
// (set) Token: 0x0600A257 RID: 41559 RVA: 0x0029B8CB File Offset: 0x00299ACB
public unsafe static Func<VolumeEffect, AmplifyColorBase> __9__6_0
{
get
{
IntPtr intPtr;
IL2CPP.il2cpp_field_static_get_value(VolumeEffectContainer.__c.NativeFieldInfoPtr___9__6_0, (void*)(&intPtr));
IntPtr intPtr2 = intPtr;
return (intPtr2 != 0) ? new Func<VolumeEffect, AmplifyColorBase>(intPtr2) : null;
}
set
{
IL2CPP.il2cpp_field_static_set_value(VolumeEffectContainer.__c.NativeFieldInfoPtr___9__6_0, IL2CPP.Il2CppObjectBaseToPtr(value));
}
}
// Token: 0x04006D34 RID: 27956
private static readonly IntPtr NativeFieldInfoPtr___9;
// Token: 0x04006D35 RID: 27957
private static readonly IntPtr NativeFieldInfoPtr___9__6_0;
// Token: 0x04006D36 RID: 27958
private static readonly IntPtr NativeMethodInfoPtr__ctor_Public_Void_0;
// Token: 0x04006D37 RID: 27959
private static readonly IntPtr NativeMethodInfoPtr__GetStoredEffects_b__6_0_Internal_AmplifyColorBase_VolumeEffect_0;
}
}
}

274
Interop/Assembly-CSharp/AmplifyColor/VolumeEffectField.cs Normal file
View File

@@ -0,0 +1,274 @@
using System;
using Il2CppInterop.Common.Attributes;
using Il2CppInterop.Runtime;
using Il2CppSystem;
using Il2CppSystem.Reflection;
using UnityEngine;
namespace AmplifyColor
{
// Token: 0x02000639 RID: 1593
[Serializable]
public class VolumeEffectField : Il2CppSystem.Object
{
// Token: 0x0600A1F5 RID: 41461 RVA: 0x00299C70 File Offset: 0x00297E70
[CallerCount(87)]
[CachedScanResults(RefRangeStart = 7329, RefRangeEnd = 7416, XrefRangeStart = 7329, XrefRangeEnd = 7416, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
public unsafe VolumeEffectField(string fieldName, string fieldType)
: this(IL2CPP.il2cpp_object_new(Il2CppClassPointerStore<VolumeEffectField>.NativeClassPtr))
{
IntPtr* ptr;
checked
{
ptr = stackalloc IntPtr[unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)];
*ptr = IL2CPP.ManagedStringToIl2Cpp(fieldName);
}
ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = IL2CPP.ManagedStringToIl2Cpp(fieldType);
IntPtr intPtr2;
IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(VolumeEffectField.NativeMethodInfoPtr__ctor_Public_Void_String_String_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
Il2CppException.RaiseExceptionIfNecessary(intPtr2);
}
// Token: 0x0600A1F6 RID: 41462 RVA: 0x00299CEC File Offset: 0x00297EEC
[CallerCount(4)]
[CachedScanResults(RefRangeStart = 626474, RefRangeEnd = 626478, XrefRangeStart = 626469, XrefRangeEnd = 626474, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
public unsafe VolumeEffectField(FieldInfo pi, Component c)
: this(IL2CPP.il2cpp_object_new(Il2CppClassPointerStore<VolumeEffectField>.NativeClassPtr))
{
IntPtr* ptr;
checked
{
ptr = stackalloc IntPtr[unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)];
*ptr = IL2CPP.Il2CppObjectBaseToPtr(pi);
}
ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = IL2CPP.Il2CppObjectBaseToPtr(c);
IntPtr intPtr2;
IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(VolumeEffectField.NativeMethodInfoPtr__ctor_Public_Void_FieldInfo_Component_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
Il2CppException.RaiseExceptionIfNecessary(intPtr2);
}
// Token: 0x0600A1F7 RID: 41463 RVA: 0x00299D68 File Offset: 0x00297F68
[CallerCount(9)]
[CachedScanResults(RefRangeStart = 626496, RefRangeEnd = 626505, XrefRangeStart = 626478, XrefRangeEnd = 626496, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
public unsafe static bool IsValidType(string type)
{
checked
{
IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
*ptr = IL2CPP.ManagedStringToIl2Cpp(type);
IntPtr intPtr2;
IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(VolumeEffectField.NativeMethodInfoPtr_IsValidType_Public_Static_Boolean_String_0, 0, (void**)ptr, ref intPtr2);
Il2CppException.RaiseExceptionIfNecessary(intPtr2);
return *IL2CPP.il2cpp_object_unbox(intPtr);
}
}
// Token: 0x0600A1F8 RID: 41464 RVA: 0x00299DC0 File Offset: 0x00297FC0
[CallerCount(1)]
[CachedScanResults(RefRangeStart = 626521, RefRangeEnd = 626522, XrefRangeStart = 626505, XrefRangeEnd = 626521, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
public unsafe void UpdateValue(Il2CppSystem.Object val)
{
IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
checked
{
IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
*ptr = IL2CPP.Il2CppObjectBaseToPtr(val);
IntPtr intPtr2;
IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(VolumeEffectField.NativeMethodInfoPtr_UpdateValue_Public_Void_Object_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
Il2CppException.RaiseExceptionIfNecessary(intPtr2);
}
}
// Token: 0x0600A1F9 RID: 41465 RVA: 0x00299E1C File Offset: 0x0029801C
// Note: this type is marked as 'beforefieldinit'.
static VolumeEffectField()
{
Il2CppClassPointerStore<VolumeEffectField>.NativeClassPtr = IL2CPP.GetIl2CppClass("Assembly-CSharp.dll", "AmplifyColor", "VolumeEffectField");
IL2CPP.il2cpp_runtime_class_init(Il2CppClassPointerStore<VolumeEffectField>.NativeClassPtr);
VolumeEffectField.NativeFieldInfoPtr_fieldName = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<VolumeEffectField>.NativeClassPtr, "fieldName");
VolumeEffectField.NativeFieldInfoPtr_fieldType = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<VolumeEffectField>.NativeClassPtr, "fieldType");
VolumeEffectField.NativeFieldInfoPtr_valueSingle = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<VolumeEffectField>.NativeClassPtr, "valueSingle");
VolumeEffectField.NativeFieldInfoPtr_valueColor = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<VolumeEffectField>.NativeClassPtr, "valueColor");
VolumeEffectField.NativeFieldInfoPtr_valueBoolean = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<VolumeEffectField>.NativeClassPtr, "valueBoolean");
VolumeEffectField.NativeFieldInfoPtr_valueVector2 = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<VolumeEffectField>.NativeClassPtr, "valueVector2");
VolumeEffectField.NativeFieldInfoPtr_valueVector3 = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<VolumeEffectField>.NativeClassPtr, "valueVector3");
VolumeEffectField.NativeFieldInfoPtr_valueVector4 = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<VolumeEffectField>.NativeClassPtr, "valueVector4");
VolumeEffectField.NativeMethodInfoPtr__ctor_Public_Void_String_String_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<VolumeEffectField>.NativeClassPtr, 100675872);
VolumeEffectField.NativeMethodInfoPtr__ctor_Public_Void_FieldInfo_Component_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<VolumeEffectField>.NativeClassPtr, 100675873);
VolumeEffectField.NativeMethodInfoPtr_IsValidType_Public_Static_Boolean_String_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<VolumeEffectField>.NativeClassPtr, 100675874);
VolumeEffectField.NativeMethodInfoPtr_UpdateValue_Public_Void_Object_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<VolumeEffectField>.NativeClassPtr, 100675875);
}
// Token: 0x0600A1FA RID: 41466 RVA: 0x0000A688 File Offset: 0x00008888
public VolumeEffectField(IntPtr pointer)
: base(pointer)
{
}
// Token: 0x170036D1 RID: 14033
// (get) Token: 0x0600A1FB RID: 41467 RVA: 0x00299F3C File Offset: 0x0029813C
// (set) Token: 0x0600A1FC RID: 41468 RVA: 0x00299F65 File Offset: 0x00298165
public unsafe string fieldName
{
get
{
IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(VolumeEffectField.NativeFieldInfoPtr_fieldName);
return IL2CPP.Il2CppStringToManaged(*intPtr);
}
set
{
IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
IL2CPP.il2cpp_gc_wbarrier_set_field(intPtr, intPtr + (IntPtr)IL2CPP.il2cpp_field_get_offset(VolumeEffectField.NativeFieldInfoPtr_fieldName), IL2CPP.ManagedStringToIl2Cpp(value));
}
}
// Token: 0x170036D2 RID: 14034
// (get) Token: 0x0600A1FD RID: 41469 RVA: 0x00299F8C File Offset: 0x0029818C
// (set) Token: 0x0600A1FE RID: 41470 RVA: 0x00299FB5 File Offset: 0x002981B5
public unsafe string fieldType
{
get
{
IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(VolumeEffectField.NativeFieldInfoPtr_fieldType);
return IL2CPP.Il2CppStringToManaged(*intPtr);
}
set
{
IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
IL2CPP.il2cpp_gc_wbarrier_set_field(intPtr, intPtr + (IntPtr)IL2CPP.il2cpp_field_get_offset(VolumeEffectField.NativeFieldInfoPtr_fieldType), IL2CPP.ManagedStringToIl2Cpp(value));
}
}
// Token: 0x170036D3 RID: 14035
// (get) Token: 0x0600A1FF RID: 41471 RVA: 0x00299FDC File Offset: 0x002981DC
// (set) Token: 0x0600A200 RID: 41472 RVA: 0x0029A004 File Offset: 0x00298204
public unsafe float valueSingle
{
get
{
IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(VolumeEffectField.NativeFieldInfoPtr_valueSingle);
return *intPtr;
}
set
{
*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(VolumeEffectField.NativeFieldInfoPtr_valueSingle)) = value;
}
}
// Token: 0x170036D4 RID: 14036
// (get) Token: 0x0600A201 RID: 41473 RVA: 0x0029A028 File Offset: 0x00298228
// (set) Token: 0x0600A202 RID: 41474 RVA: 0x0029A050 File Offset: 0x00298250
public unsafe Color valueColor
{
get
{
IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(VolumeEffectField.NativeFieldInfoPtr_valueColor);
return *intPtr;
}
set
{
*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(VolumeEffectField.NativeFieldInfoPtr_valueColor)) = value;
}
}
// Token: 0x170036D5 RID: 14037
// (get) Token: 0x0600A203 RID: 41475 RVA: 0x0029A074 File Offset: 0x00298274
// (set) Token: 0x0600A204 RID: 41476 RVA: 0x0029A09C File Offset: 0x0029829C
public unsafe bool valueBoolean
{
get
{
IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(VolumeEffectField.NativeFieldInfoPtr_valueBoolean);
return *intPtr;
}
set
{
*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(VolumeEffectField.NativeFieldInfoPtr_valueBoolean)) = value;
}
}
// Token: 0x170036D6 RID: 14038
// (get) Token: 0x0600A205 RID: 41477 RVA: 0x0029A0C0 File Offset: 0x002982C0
// (set) Token: 0x0600A206 RID: 41478 RVA: 0x0029A0E8 File Offset: 0x002982E8
public unsafe Vector2 valueVector2
{
get
{
IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(VolumeEffectField.NativeFieldInfoPtr_valueVector2);
return *intPtr;
}
set
{
*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(VolumeEffectField.NativeFieldInfoPtr_valueVector2)) = value;
}
}
// Token: 0x170036D7 RID: 14039
// (get) Token: 0x0600A207 RID: 41479 RVA: 0x0029A10C File Offset: 0x0029830C
// (set) Token: 0x0600A208 RID: 41480 RVA: 0x0029A134 File Offset: 0x00298334
public unsafe Vector3 valueVector3
{
get
{
IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(VolumeEffectField.NativeFieldInfoPtr_valueVector3);
return *intPtr;
}
set
{
*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(VolumeEffectField.NativeFieldInfoPtr_valueVector3)) = value;
}
}
// Token: 0x170036D8 RID: 14040
// (get) Token: 0x0600A209 RID: 41481 RVA: 0x0029A158 File Offset: 0x00298358
// (set) Token: 0x0600A20A RID: 41482 RVA: 0x0029A180 File Offset: 0x00298380
public unsafe Vector4 valueVector4
{
get
{
IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(VolumeEffectField.NativeFieldInfoPtr_valueVector4);
return *intPtr;
}
set
{
*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(VolumeEffectField.NativeFieldInfoPtr_valueVector4)) = value;
}
}
// Token: 0x04006CFB RID: 27899
private static readonly IntPtr NativeFieldInfoPtr_fieldName;
// Token: 0x04006CFC RID: 27900
private static readonly IntPtr NativeFieldInfoPtr_fieldType;
// Token: 0x04006CFD RID: 27901
private static readonly IntPtr NativeFieldInfoPtr_valueSingle;
// Token: 0x04006CFE RID: 27902
private static readonly IntPtr NativeFieldInfoPtr_valueColor;
// Token: 0x04006CFF RID: 27903
private static readonly IntPtr NativeFieldInfoPtr_valueBoolean;
// Token: 0x04006D00 RID: 27904
private static readonly IntPtr NativeFieldInfoPtr_valueVector2;
// Token: 0x04006D01 RID: 27905
private static readonly IntPtr NativeFieldInfoPtr_valueVector3;
// Token: 0x04006D02 RID: 27906
private static readonly IntPtr NativeFieldInfoPtr_valueVector4;
// Token: 0x04006D03 RID: 27907
private static readonly IntPtr NativeMethodInfoPtr__ctor_Public_Void_String_String_0;
// Token: 0x04006D04 RID: 27908
private static readonly IntPtr NativeMethodInfoPtr__ctor_Public_Void_FieldInfo_Component_0;
// Token: 0x04006D05 RID: 27909
private static readonly IntPtr NativeMethodInfoPtr_IsValidType_Public_Static_Boolean_String_0;
// Token: 0x04006D06 RID: 27910
private static readonly IntPtr NativeMethodInfoPtr_UpdateValue_Public_Void_Object_0;
}
}

129
Interop/Assembly-CSharp/AmplifyColor/VolumeEffectFieldFlags.cs Normal file
View File

@@ -0,0 +1,129 @@
using System;
using Il2CppInterop.Common.Attributes;
using Il2CppInterop.Runtime;
using Il2CppSystem;
using Il2CppSystem.Reflection;
namespace AmplifyColor
{
// Token: 0x02000641 RID: 1601
[Serializable]
public class VolumeEffectFieldFlags : Object
{
// Token: 0x0600A258 RID: 41560 RVA: 0x0029B8E0 File Offset: 0x00299AE0
[CallerCount(2)]
[CachedScanResults(RefRangeStart = 627123, RefRangeEnd = 627125, XrefRangeStart = 627119, XrefRangeEnd = 627123, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
public unsafe VolumeEffectFieldFlags(FieldInfo pi)
: this(IL2CPP.il2cpp_object_new(Il2CppClassPointerStore<VolumeEffectFieldFlags>.NativeClassPtr))
{
checked
{
IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
*ptr = IL2CPP.Il2CppObjectBaseToPtr(pi);
IntPtr intPtr2;
IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(VolumeEffectFieldFlags.NativeMethodInfoPtr__ctor_Public_Void_FieldInfo_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
Il2CppException.RaiseExceptionIfNecessary(intPtr2);
}
}
// Token: 0x0600A259 RID: 41561 RVA: 0x0029B944 File Offset: 0x00299B44
[CallerCount(0)]
[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 627125, XrefRangeEnd = 627128, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
public unsafe VolumeEffectFieldFlags(VolumeEffectField field)
: this(IL2CPP.il2cpp_object_new(Il2CppClassPointerStore<VolumeEffectFieldFlags>.NativeClassPtr))
{
checked
{
IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
*ptr = IL2CPP.Il2CppObjectBaseToPtr(field);
IntPtr intPtr2;
IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(VolumeEffectFieldFlags.NativeMethodInfoPtr__ctor_Public_Void_VolumeEffectField_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
Il2CppException.RaiseExceptionIfNecessary(intPtr2);
}
}
// Token: 0x0600A25A RID: 41562 RVA: 0x0029B9A8 File Offset: 0x00299BA8
// Note: this type is marked as 'beforefieldinit'.
static VolumeEffectFieldFlags()
{
Il2CppClassPointerStore<VolumeEffectFieldFlags>.NativeClassPtr = IL2CPP.GetIl2CppClass("Assembly-CSharp.dll", "AmplifyColor", "VolumeEffectFieldFlags");
IL2CPP.il2cpp_runtime_class_init(Il2CppClassPointerStore<VolumeEffectFieldFlags>.NativeClassPtr);
VolumeEffectFieldFlags.NativeFieldInfoPtr_fieldName = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<VolumeEffectFieldFlags>.NativeClassPtr, "fieldName");
VolumeEffectFieldFlags.NativeFieldInfoPtr_fieldType = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<VolumeEffectFieldFlags>.NativeClassPtr, "fieldType");
VolumeEffectFieldFlags.NativeFieldInfoPtr_blendFlag = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<VolumeEffectFieldFlags>.NativeClassPtr, "blendFlag");
VolumeEffectFieldFlags.NativeMethodInfoPtr__ctor_Public_Void_FieldInfo_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<VolumeEffectFieldFlags>.NativeClassPtr, 100675914);
VolumeEffectFieldFlags.NativeMethodInfoPtr__ctor_Public_Void_VolumeEffectField_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<VolumeEffectFieldFlags>.NativeClassPtr, 100675915);
}
// Token: 0x0600A25B RID: 41563 RVA: 0x0000A688 File Offset: 0x00008888
public VolumeEffectFieldFlags(IntPtr pointer)
: base(pointer)
{
}
// Token: 0x170036E7 RID: 14055
// (get) Token: 0x0600A25C RID: 41564 RVA: 0x0029BA3C File Offset: 0x00299C3C
// (set) Token: 0x0600A25D RID: 41565 RVA: 0x0029BA65 File Offset: 0x00299C65
public unsafe string fieldName
{
get
{
IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(VolumeEffectFieldFlags.NativeFieldInfoPtr_fieldName);
return IL2CPP.Il2CppStringToManaged(*intPtr);
}
set
{
IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
IL2CPP.il2cpp_gc_wbarrier_set_field(intPtr, intPtr + (IntPtr)IL2CPP.il2cpp_field_get_offset(VolumeEffectFieldFlags.NativeFieldInfoPtr_fieldName), IL2CPP.ManagedStringToIl2Cpp(value));
}
}
// Token: 0x170036E8 RID: 14056
// (get) Token: 0x0600A25E RID: 41566 RVA: 0x0029BA8C File Offset: 0x00299C8C
// (set) Token: 0x0600A25F RID: 41567 RVA: 0x0029BAB5 File Offset: 0x00299CB5
public unsafe string fieldType
{
get
{
IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(VolumeEffectFieldFlags.NativeFieldInfoPtr_fieldType);
return IL2CPP.Il2CppStringToManaged(*intPtr);
}
set
{
IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
IL2CPP.il2cpp_gc_wbarrier_set_field(intPtr, intPtr + (IntPtr)IL2CPP.il2cpp_field_get_offset(VolumeEffectFieldFlags.NativeFieldInfoPtr_fieldType), IL2CPP.ManagedStringToIl2Cpp(value));
}
}
// Token: 0x170036E9 RID: 14057
// (get) Token: 0x0600A260 RID: 41568 RVA: 0x0029BADC File Offset: 0x00299CDC
// (set) Token: 0x0600A261 RID: 41569 RVA: 0x0029BB04 File Offset: 0x00299D04
public unsafe bool blendFlag
{
get
{
IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(VolumeEffectFieldFlags.NativeFieldInfoPtr_blendFlag);
return *intPtr;
}
set
{
*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(VolumeEffectFieldFlags.NativeFieldInfoPtr_blendFlag)) = value;
}
}
// Token: 0x04006D38 RID: 27960
private static readonly IntPtr NativeFieldInfoPtr_fieldName;
// Token: 0x04006D39 RID: 27961
private static readonly IntPtr NativeFieldInfoPtr_fieldType;
// Token: 0x04006D3A RID: 27962
private static readonly IntPtr NativeFieldInfoPtr_blendFlag;
// Token: 0x04006D3B RID: 27963
private static readonly IntPtr NativeMethodInfoPtr__ctor_Public_Void_FieldInfo_0;
// Token: 0x04006D3C RID: 27964
private static readonly IntPtr NativeMethodInfoPtr__ctor_Public_Void_VolumeEffectField_0;
}
}

488
Interop/Assembly-CSharp/AmplifyColor/VolumeEffectFlags.cs Normal file
View File

@@ -0,0 +1,488 @@
using System;
using Il2CppInterop.Common.Attributes;
using Il2CppInterop.Runtime;
using Il2CppInterop.Runtime.InteropTypes.Arrays;
using Il2CppSystem;
using Il2CppSystem.Collections.Generic;
using UnityEngine;
namespace AmplifyColor
{
// Token: 0x02000646 RID: 1606
[Serializable]
public class VolumeEffectFlags : Il2CppSystem.Object
{
// Token: 0x0600A287 RID: 41607 RVA: 0x0029C4AC File Offset: 0x0029A6AC
[CallerCount(1)]
[CachedScanResults(RefRangeStart = 627304, RefRangeEnd = 627305, XrefRangeStart = 627296, XrefRangeEnd = 627304, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
public unsafe VolumeEffectFlags()
: this(IL2CPP.il2cpp_object_new(Il2CppClassPointerStore<VolumeEffectFlags>.NativeClassPtr))
{
IntPtr* ptr = null;
IntPtr intPtr2;
IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(VolumeEffectFlags.NativeMethodInfoPtr__ctor_Public_Void_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
Il2CppException.RaiseExceptionIfNecessary(intPtr2);
}
// Token: 0x0600A288 RID: 41608 RVA: 0x0029C4F8 File Offset: 0x0029A6F8
[CallerCount(0)]
[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 627305, XrefRangeEnd = 627328, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
public unsafe void AddComponent(Component c)
{
IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
checked
{
IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
*ptr = IL2CPP.Il2CppObjectBaseToPtr(c);
IntPtr intPtr2;
IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(VolumeEffectFlags.NativeMethodInfoPtr_AddComponent_Public_Void_Component_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
Il2CppException.RaiseExceptionIfNecessary(intPtr2);
}
}
// Token: 0x0600A289 RID: 41609 RVA: 0x0029C554 File Offset: 0x0029A754
[CallerCount(1)]
[CachedScanResults(RefRangeStart = 627367, RefRangeEnd = 627368, XrefRangeStart = 627328, XrefRangeEnd = 627367, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
public unsafe void UpdateFlags(VolumeEffect effectVol)
{
IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
checked
{
IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
*ptr = IL2CPP.Il2CppObjectBaseToPtr(effectVol);
IntPtr intPtr2;
IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(VolumeEffectFlags.NativeMethodInfoPtr_UpdateFlags_Public_Void_VolumeEffect_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
Il2CppException.RaiseExceptionIfNecessary(intPtr2);
}
}
// Token: 0x0600A28A RID: 41610 RVA: 0x0029C5B0 File Offset: 0x0029A7B0
[CallerCount(0)]
[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 627368, XrefRangeEnd = 627384, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
public unsafe static void UpdateCamFlags(Il2CppReferenceArray<AmplifyColorBase> effects, Il2CppReferenceArray<AmplifyColorVolumeBase> volumes)
{
IntPtr* ptr;
checked
{
ptr = stackalloc IntPtr[unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)];
*ptr = IL2CPP.Il2CppObjectBaseToPtr(effects);
}
ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = IL2CPP.Il2CppObjectBaseToPtr(volumes);
IntPtr intPtr2;
IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(VolumeEffectFlags.NativeMethodInfoPtr_UpdateCamFlags_Public_Static_Void_Il2CppReferenceArray_1_AmplifyColorBase_Il2CppReferenceArray_1_AmplifyColorVolumeBase_0, 0, (void**)ptr, ref intPtr2);
Il2CppException.RaiseExceptionIfNecessary(intPtr2);
}
// Token: 0x0600A28B RID: 41611 RVA: 0x0029C614 File Offset: 0x0029A814
[CallerCount(1)]
[CachedScanResults(RefRangeStart = 627408, RefRangeEnd = 627409, XrefRangeStart = 627384, XrefRangeEnd = 627408, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
public unsafe VolumeEffect GenerateEffectData(AmplifyColorBase go)
{
IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
checked
{
IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
*ptr = IL2CPP.Il2CppObjectBaseToPtr(go);
IntPtr intPtr2;
IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(VolumeEffectFlags.NativeMethodInfoPtr_GenerateEffectData_Public_VolumeEffect_AmplifyColorBase_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
Il2CppException.RaiseExceptionIfNecessary(intPtr2);
IntPtr intPtr3 = intPtr;
return (intPtr3 != 0) ? new VolumeEffect(intPtr3) : null;
}
}
// Token: 0x0600A28C RID: 41612 RVA: 0x0029C684 File Offset: 0x0029A884
[CallerCount(0)]
[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 627409, XrefRangeEnd = 627416, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
public unsafe VolumeEffectComponentFlags FindComponentFlags(string compName)
{
IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
checked
{
IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
*ptr = IL2CPP.ManagedStringToIl2Cpp(compName);
IntPtr intPtr2;
IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(VolumeEffectFlags.NativeMethodInfoPtr_FindComponentFlags_Public_VolumeEffectComponentFlags_String_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
Il2CppException.RaiseExceptionIfNecessary(intPtr2);
IntPtr intPtr3 = intPtr;
return (intPtr3 != 0) ? new VolumeEffectComponentFlags(intPtr3) : null;
}
}
// Token: 0x0600A28D RID: 41613 RVA: 0x0029C6F4 File Offset: 0x0029A8F4
[CallerCount(0)]
[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 627416, XrefRangeEnd = 627456, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
public unsafe Il2CppStringArray GetComponentNames()
{
IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
IntPtr* ptr = null;
IntPtr intPtr2;
IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(VolumeEffectFlags.NativeMethodInfoPtr_GetComponentNames_Public_Il2CppStringArray_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
Il2CppException.RaiseExceptionIfNecessary(intPtr2);
IntPtr intPtr3 = intPtr;
return (intPtr3 != 0) ? new Il2CppStringArray(intPtr3) : null;
}
// Token: 0x0600A28E RID: 41614 RVA: 0x0029C74C File Offset: 0x0029A94C
// Note: this type is marked as 'beforefieldinit'.
static VolumeEffectFlags()
{
Il2CppClassPointerStore<VolumeEffectFlags>.NativeClassPtr = IL2CPP.GetIl2CppClass("Assembly-CSharp.dll", "AmplifyColor", "VolumeEffectFlags");
IL2CPP.il2cpp_runtime_class_init(Il2CppClassPointerStore<VolumeEffectFlags>.NativeClassPtr);
VolumeEffectFlags.NativeFieldInfoPtr_components = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<VolumeEffectFlags>.NativeClassPtr, "components");
VolumeEffectFlags.NativeMethodInfoPtr__ctor_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<VolumeEffectFlags>.NativeClassPtr, 100675930);
VolumeEffectFlags.NativeMethodInfoPtr_AddComponent_Public_Void_Component_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<VolumeEffectFlags>.NativeClassPtr, 100675931);
VolumeEffectFlags.NativeMethodInfoPtr_UpdateFlags_Public_Void_VolumeEffect_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<VolumeEffectFlags>.NativeClassPtr, 100675932);
VolumeEffectFlags.NativeMethodInfoPtr_UpdateCamFlags_Public_Static_Void_Il2CppReferenceArray_1_AmplifyColorBase_Il2CppReferenceArray_1_AmplifyColorVolumeBase_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<VolumeEffectFlags>.NativeClassPtr, 100675933);
VolumeEffectFlags.NativeMethodInfoPtr_GenerateEffectData_Public_VolumeEffect_AmplifyColorBase_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<VolumeEffectFlags>.NativeClassPtr, 100675934);
VolumeEffectFlags.NativeMethodInfoPtr_FindComponentFlags_Public_VolumeEffectComponentFlags_String_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<VolumeEffectFlags>.NativeClassPtr, 100675935);
VolumeEffectFlags.NativeMethodInfoPtr_GetComponentNames_Public_Il2CppStringArray_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<VolumeEffectFlags>.NativeClassPtr, 100675936);
}
// Token: 0x0600A28F RID: 41615 RVA: 0x0000A688 File Offset: 0x00008888
public VolumeEffectFlags(IntPtr pointer)
: base(pointer)
{
}
// Token: 0x170036F2 RID: 14066
// (get) Token: 0x0600A290 RID: 41616 RVA: 0x0029C81C File Offset: 0x0029AA1C
// (set) Token: 0x0600A291 RID: 41617 RVA: 0x0029C850 File Offset: 0x0029AA50
public unsafe List<VolumeEffectComponentFlags> components
{
get
{
IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(VolumeEffectFlags.NativeFieldInfoPtr_components);
IntPtr intPtr2 = *intPtr;
return (intPtr2 != 0) ? new List<VolumeEffectComponentFlags>(intPtr2) : null;
}
set
{
IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
IL2CPP.il2cpp_gc_wbarrier_set_field(intPtr, intPtr + (IntPtr)IL2CPP.il2cpp_field_get_offset(VolumeEffectFlags.NativeFieldInfoPtr_components), IL2CPP.Il2CppObjectBaseToPtr(value));
}
}
// Token: 0x04006D52 RID: 27986
private static readonly IntPtr NativeFieldInfoPtr_components;
// Token: 0x04006D53 RID: 27987
private static readonly IntPtr NativeMethodInfoPtr__ctor_Public_Void_0;
// Token: 0x04006D54 RID: 27988
private static readonly IntPtr NativeMethodInfoPtr_AddComponent_Public_Void_Component_0;
// Token: 0x04006D55 RID: 27989
private static readonly IntPtr NativeMethodInfoPtr_UpdateFlags_Public_Void_VolumeEffect_0;
// Token: 0x04006D56 RID: 27990
private static readonly IntPtr NativeMethodInfoPtr_UpdateCamFlags_Public_Static_Void_Il2CppReferenceArray_1_AmplifyColorBase_Il2CppReferenceArray_1_AmplifyColorVolumeBase_0;
// Token: 0x04006D57 RID: 27991
private static readonly IntPtr NativeMethodInfoPtr_GenerateEffectData_Public_VolumeEffect_AmplifyColorBase_0;
// Token: 0x04006D58 RID: 27992
private static readonly IntPtr NativeMethodInfoPtr_FindComponentFlags_Public_VolumeEffectComponentFlags_String_0;
// Token: 0x04006D59 RID: 27993
private static readonly IntPtr NativeMethodInfoPtr_GetComponentNames_Public_Il2CppStringArray_0;
// Token: 0x02000647 RID: 1607
[ObfuscatedName("AmplifyColor.VolumeEffectFlags/<>c__DisplayClass2_0")]
public sealed class __c__DisplayClass2_0 : Il2CppSystem.Object
{
// Token: 0x0600A292 RID: 41618 RVA: 0x0029C878 File Offset: 0x0029AA78
[CallerCount(1642)]
[CachedScanResults(RefRangeStart = 7417, RefRangeEnd = 9059, XrefRangeStart = 7417, XrefRangeEnd = 9059, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
public unsafe __c__DisplayClass2_0()
: this(IL2CPP.il2cpp_object_new(Il2CppClassPointerStore<VolumeEffectFlags.__c__DisplayClass2_0>.NativeClassPtr))
{
IntPtr* ptr = null;
IntPtr intPtr2;
IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(VolumeEffectFlags.__c__DisplayClass2_0.NativeMethodInfoPtr__ctor_Public_Void_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
Il2CppException.RaiseExceptionIfNecessary(intPtr2);
}
// Token: 0x0600A293 RID: 41619 RVA: 0x0029C8C4 File Offset: 0x0029AAC4
[CallerCount(0)]
[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 627291, XrefRangeEnd = 627296, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
public unsafe bool _AddComponent_b__0(VolumeEffectComponentFlags s)
{
IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
checked
{
IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
*ptr = IL2CPP.Il2CppObjectBaseToPtr(s);
IntPtr intPtr2;
IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(VolumeEffectFlags.__c__DisplayClass2_0.NativeMethodInfoPtr__AddComponent_b__0_Internal_Boolean_VolumeEffectComponentFlags_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
Il2CppException.RaiseExceptionIfNecessary(intPtr2);
return *IL2CPP.il2cpp_object_unbox(intPtr);
}
}
// Token: 0x0600A294 RID: 41620 RVA: 0x0029C92C File Offset: 0x0029AB2C
// Note: this type is marked as 'beforefieldinit'.
static __c__DisplayClass2_0()
{
Il2CppClassPointerStore<VolumeEffectFlags.__c__DisplayClass2_0>.NativeClassPtr = IL2CPP.GetIl2CppNestedType(Il2CppClassPointerStore<VolumeEffectFlags>.NativeClassPtr, "<>c__DisplayClass2_0");
IL2CPP.il2cpp_runtime_class_init(Il2CppClassPointerStore<VolumeEffectFlags.__c__DisplayClass2_0>.NativeClassPtr);
VolumeEffectFlags.__c__DisplayClass2_0.NativeFieldInfoPtr_c = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<VolumeEffectFlags.__c__DisplayClass2_0>.NativeClassPtr, "c");
VolumeEffectFlags.__c__DisplayClass2_0.NativeMethodInfoPtr__ctor_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<VolumeEffectFlags.__c__DisplayClass2_0>.NativeClassPtr, 100675937);
VolumeEffectFlags.__c__DisplayClass2_0.NativeMethodInfoPtr__AddComponent_b__0_Internal_Boolean_VolumeEffectComponentFlags_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<VolumeEffectFlags.__c__DisplayClass2_0>.NativeClassPtr, 100675938);
}
// Token: 0x0600A295 RID: 41621 RVA: 0x0000A688 File Offset: 0x00008888
public __c__DisplayClass2_0(IntPtr pointer)
: base(pointer)
{
}
// Token: 0x170036F3 RID: 14067
// (get) Token: 0x0600A296 RID: 41622 RVA: 0x0029C994 File Offset: 0x0029AB94
// (set) Token: 0x0600A297 RID: 41623 RVA: 0x0029C9C8 File Offset: 0x0029ABC8
public unsafe Component c
{
get
{
IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(VolumeEffectFlags.__c__DisplayClass2_0.NativeFieldInfoPtr_c);
IntPtr intPtr2 = *intPtr;
return (intPtr2 != 0) ? new Component(intPtr2) : null;
}
set
{
IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
IL2CPP.il2cpp_gc_wbarrier_set_field(intPtr, intPtr + (IntPtr)IL2CPP.il2cpp_field_get_offset(VolumeEffectFlags.__c__DisplayClass2_0.NativeFieldInfoPtr_c), IL2CPP.Il2CppObjectBaseToPtr(value));
}
}
// Token: 0x04006D5A RID: 27994
private static readonly IntPtr NativeFieldInfoPtr_c;
// Token: 0x04006D5B RID: 27995
private static readonly IntPtr NativeMethodInfoPtr__ctor_Public_Void_0;
// Token: 0x04006D5C RID: 27996
private static readonly IntPtr NativeMethodInfoPtr__AddComponent_b__0_Internal_Boolean_VolumeEffectComponentFlags_0;
}
// Token: 0x02000648 RID: 1608
[ObfuscatedName("AmplifyColor.VolumeEffectFlags/<>c__DisplayClass3_0")]
public sealed class __c__DisplayClass3_0 : Il2CppSystem.Object
{
// Token: 0x0600A298 RID: 41624 RVA: 0x0029C9F0 File Offset: 0x0029ABF0
[CallerCount(1642)]
[CachedScanResults(RefRangeStart = 7417, RefRangeEnd = 9059, XrefRangeStart = 7417, XrefRangeEnd = 9059, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
public unsafe __c__DisplayClass3_0()
: this(IL2CPP.il2cpp_object_new(Il2CppClassPointerStore<VolumeEffectFlags.__c__DisplayClass3_0>.NativeClassPtr))
{
IntPtr* ptr = null;
IntPtr intPtr2;
IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(VolumeEffectFlags.__c__DisplayClass3_0.NativeMethodInfoPtr__ctor_Public_Void_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
Il2CppException.RaiseExceptionIfNecessary(intPtr2);
}
// Token: 0x0600A299 RID: 41625 RVA: 0x0029CA3C File Offset: 0x0029AC3C
[CallerCount(0)]
[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 0, XrefRangeEnd = 0, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
public unsafe bool _UpdateFlags_b__0(VolumeEffectComponentFlags s)
{
IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
checked
{
IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
*ptr = IL2CPP.Il2CppObjectBaseToPtr(s);
IntPtr intPtr2;
IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(VolumeEffectFlags.__c__DisplayClass3_0.NativeMethodInfoPtr__UpdateFlags_b__0_Internal_Boolean_VolumeEffectComponentFlags_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
Il2CppException.RaiseExceptionIfNecessary(intPtr2);
return *IL2CPP.il2cpp_object_unbox(intPtr);
}
}
// Token: 0x0600A29A RID: 41626 RVA: 0x0029CAA4 File Offset: 0x0029ACA4
// Note: this type is marked as 'beforefieldinit'.
static __c__DisplayClass3_0()
{
Il2CppClassPointerStore<VolumeEffectFlags.__c__DisplayClass3_0>.NativeClassPtr = IL2CPP.GetIl2CppNestedType(Il2CppClassPointerStore<VolumeEffectFlags>.NativeClassPtr, "<>c__DisplayClass3_0");
IL2CPP.il2cpp_runtime_class_init(Il2CppClassPointerStore<VolumeEffectFlags.__c__DisplayClass3_0>.NativeClassPtr);
VolumeEffectFlags.__c__DisplayClass3_0.NativeFieldInfoPtr_comp = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<VolumeEffectFlags.__c__DisplayClass3_0>.NativeClassPtr, "comp");
VolumeEffectFlags.__c__DisplayClass3_0.NativeMethodInfoPtr__ctor_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<VolumeEffectFlags.__c__DisplayClass3_0>.NativeClassPtr, 100675939);
VolumeEffectFlags.__c__DisplayClass3_0.NativeMethodInfoPtr__UpdateFlags_b__0_Internal_Boolean_VolumeEffectComponentFlags_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<VolumeEffectFlags.__c__DisplayClass3_0>.NativeClassPtr, 100675940);
}
// Token: 0x0600A29B RID: 41627 RVA: 0x0000A688 File Offset: 0x00008888
public __c__DisplayClass3_0(IntPtr pointer)
: base(pointer)
{
}
// Token: 0x170036F4 RID: 14068
// (get) Token: 0x0600A29C RID: 41628 RVA: 0x0029CB0C File Offset: 0x0029AD0C
// (set) Token: 0x0600A29D RID: 41629 RVA: 0x0029CB40 File Offset: 0x0029AD40
public unsafe VolumeEffectComponent comp
{
get
{
IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(VolumeEffectFlags.__c__DisplayClass3_0.NativeFieldInfoPtr_comp);
IntPtr intPtr2 = *intPtr;
return (intPtr2 != 0) ? new VolumeEffectComponent(intPtr2) : null;
}
set
{
IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
IL2CPP.il2cpp_gc_wbarrier_set_field(intPtr, intPtr + (IntPtr)IL2CPP.il2cpp_field_get_offset(VolumeEffectFlags.__c__DisplayClass3_0.NativeFieldInfoPtr_comp), IL2CPP.Il2CppObjectBaseToPtr(value));
}
}
// Token: 0x04006D5D RID: 27997
private static readonly IntPtr NativeFieldInfoPtr_comp;
// Token: 0x04006D5E RID: 27998
private static readonly IntPtr NativeMethodInfoPtr__ctor_Public_Void_0;
// Token: 0x04006D5F RID: 27999
private static readonly IntPtr NativeMethodInfoPtr__UpdateFlags_b__0_Internal_Boolean_VolumeEffectComponentFlags_0;
}
// Token: 0x02000649 RID: 1609
[ObfuscatedName("AmplifyColor.VolumeEffectFlags/<>c")]
[Serializable]
public sealed class __c : Il2CppSystem.Object
{
// Token: 0x0600A29E RID: 41630 RVA: 0x0029CB68 File Offset: 0x0029AD68
[CallerCount(1642)]
[CachedScanResults(RefRangeStart = 7417, RefRangeEnd = 9059, XrefRangeStart = 7417, XrefRangeEnd = 9059, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
public unsafe __c()
: this(IL2CPP.il2cpp_object_new(Il2CppClassPointerStore<VolumeEffectFlags.__c>.NativeClassPtr))
{
IntPtr* ptr = null;
IntPtr intPtr2;
IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(VolumeEffectFlags.__c.NativeMethodInfoPtr__ctor_Public_Void_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
Il2CppException.RaiseExceptionIfNecessary(intPtr2);
}
// Token: 0x0600A29F RID: 41631 RVA: 0x0029CBB4 File Offset: 0x0029ADB4
[CallerCount(0)]
public unsafe bool _GetComponentNames_b__7_0(VolumeEffectComponentFlags r)
{
IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
checked
{
IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
*ptr = IL2CPP.Il2CppObjectBaseToPtr(r);
IntPtr intPtr2;
IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(VolumeEffectFlags.__c.NativeMethodInfoPtr__GetComponentNames_b__7_0_Internal_Boolean_VolumeEffectComponentFlags_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
Il2CppException.RaiseExceptionIfNecessary(intPtr2);
return *IL2CPP.il2cpp_object_unbox(intPtr);
}
}
// Token: 0x0600A2A0 RID: 41632 RVA: 0x0029CC1C File Offset: 0x0029AE1C
[CallerCount(0)]
public unsafe string _GetComponentNames_b__7_1(VolumeEffectComponentFlags r)
{
IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
checked
{
IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
*ptr = IL2CPP.Il2CppObjectBaseToPtr(r);
IntPtr intPtr2;
IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(VolumeEffectFlags.__c.NativeMethodInfoPtr__GetComponentNames_b__7_1_Internal_String_VolumeEffectComponentFlags_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
Il2CppException.RaiseExceptionIfNecessary(intPtr2);
return IL2CPP.Il2CppStringToManaged(intPtr);
}
}
// Token: 0x0600A2A1 RID: 41633 RVA: 0x0029CC80 File Offset: 0x0029AE80
// Note: this type is marked as 'beforefieldinit'.
static __c()
{
Il2CppClassPointerStore<VolumeEffectFlags.__c>.NativeClassPtr = IL2CPP.GetIl2CppNestedType(Il2CppClassPointerStore<VolumeEffectFlags>.NativeClassPtr, "<>c");
IL2CPP.il2cpp_runtime_class_init(Il2CppClassPointerStore<VolumeEffectFlags.__c>.NativeClassPtr);
VolumeEffectFlags.__c.NativeFieldInfoPtr___9 = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<VolumeEffectFlags.__c>.NativeClassPtr, "<>9");
VolumeEffectFlags.__c.NativeFieldInfoPtr___9__7_0 = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<VolumeEffectFlags.__c>.NativeClassPtr, "<>9__7_0");
VolumeEffectFlags.__c.NativeFieldInfoPtr___9__7_1 = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<VolumeEffectFlags.__c>.NativeClassPtr, "<>9__7_1");
VolumeEffectFlags.__c.NativeMethodInfoPtr__ctor_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<VolumeEffectFlags.__c>.NativeClassPtr, 100675942);
VolumeEffectFlags.__c.NativeMethodInfoPtr__GetComponentNames_b__7_0_Internal_Boolean_VolumeEffectComponentFlags_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<VolumeEffectFlags.__c>.NativeClassPtr, 100675943);
VolumeEffectFlags.__c.NativeMethodInfoPtr__GetComponentNames_b__7_1_Internal_String_VolumeEffectComponentFlags_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<VolumeEffectFlags.__c>.NativeClassPtr, 100675944);
}
// Token: 0x0600A2A2 RID: 41634 RVA: 0x0000A688 File Offset: 0x00008888
public __c(IntPtr pointer)
: base(pointer)
{
}
// Token: 0x170036F5 RID: 14069
// (get) Token: 0x0600A2A3 RID: 41635 RVA: 0x0029CD24 File Offset: 0x0029AF24
// (set) Token: 0x0600A2A4 RID: 41636 RVA: 0x0029CD4F File Offset: 0x0029AF4F
public unsafe static VolumeEffectFlags.__c __9
{
get
{
IntPtr intPtr;
IL2CPP.il2cpp_field_static_get_value(VolumeEffectFlags.__c.NativeFieldInfoPtr___9, (void*)(&intPtr));
IntPtr intPtr2 = intPtr;
return (intPtr2 != 0) ? new VolumeEffectFlags.__c(intPtr2) : null;
}
set
{
IL2CPP.il2cpp_field_static_set_value(VolumeEffectFlags.__c.NativeFieldInfoPtr___9, IL2CPP.Il2CppObjectBaseToPtr(value));
}
}
// Token: 0x170036F6 RID: 14070
// (get) Token: 0x0600A2A5 RID: 41637 RVA: 0x0029CD64 File Offset: 0x0029AF64
// (set) Token: 0x0600A2A6 RID: 41638 RVA: 0x0029CD8F File Offset: 0x0029AF8F
public unsafe static Func<VolumeEffectComponentFlags, bool> __9__7_0
{
get
{
IntPtr intPtr;
IL2CPP.il2cpp_field_static_get_value(VolumeEffectFlags.__c.NativeFieldInfoPtr___9__7_0, (void*)(&intPtr));
IntPtr intPtr2 = intPtr;
return (intPtr2 != 0) ? new Func<VolumeEffectComponentFlags, bool>(intPtr2) : null;
}
set
{
IL2CPP.il2cpp_field_static_set_value(VolumeEffectFlags.__c.NativeFieldInfoPtr___9__7_0, IL2CPP.Il2CppObjectBaseToPtr(value));
}
}
// Token: 0x170036F7 RID: 14071
// (get) Token: 0x0600A2A7 RID: 41639 RVA: 0x0029CDA4 File Offset: 0x0029AFA4
// (set) Token: 0x0600A2A8 RID: 41640 RVA: 0x0029CDCF File Offset: 0x0029AFCF
public unsafe static Func<VolumeEffectComponentFlags, string> __9__7_1
{
get
{
IntPtr intPtr;
IL2CPP.il2cpp_field_static_get_value(VolumeEffectFlags.__c.NativeFieldInfoPtr___9__7_1, (void*)(&intPtr));
IntPtr intPtr2 = intPtr;
return (intPtr2 != 0) ? new Func<VolumeEffectComponentFlags, string>(intPtr2) : null;
}
set
{
IL2CPP.il2cpp_field_static_set_value(VolumeEffectFlags.__c.NativeFieldInfoPtr___9__7_1, IL2CPP.Il2CppObjectBaseToPtr(value));
}
}
// Token: 0x04006D60 RID: 28000
private static readonly IntPtr NativeFieldInfoPtr___9;
// Token: 0x04006D61 RID: 28001
private static readonly IntPtr NativeFieldInfoPtr___9__7_0;
// Token: 0x04006D62 RID: 28002
private static readonly IntPtr NativeFieldInfoPtr___9__7_1;
// Token: 0x04006D63 RID: 28003
private static readonly IntPtr NativeMethodInfoPtr__ctor_Public_Void_0;
// Token: 0x04006D64 RID: 28004
private static readonly IntPtr NativeMethodInfoPtr__GetComponentNames_b__7_0_Internal_Boolean_VolumeEffectComponentFlags_0;
// Token: 0x04006D65 RID: 28005
private static readonly IntPtr NativeMethodInfoPtr__GetComponentNames_b__7_1_Internal_String_VolumeEffectComponentFlags_0;
}
}
}