using System;
using System.Runtime.InteropServices;
using Il2CppInterop.Common.Attributes;
using Il2CppInterop.Runtime;
using Il2CppSystem;

namespace UnityEngine.PostProcessing
{
	// Token: 0x020005B3 RID: 1459
	[Serializable]
	public class ColorGradingModel : PostProcessingModel
	{
		// Token: 0x17003572 RID: 13682
		// (get) Token: 0x06009E79 RID: 40569 RVA: 0x0028B6D8 File Offset: 0x002898D8
		// (set) Token: 0x06009E7A RID: 40570 RVA: 0x0028B724 File Offset: 0x00289924
		public unsafe ColorGradingModel.Settings settings
		{
			[CallerCount(0)]
			get
			{
				IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
				IntPtr* ptr = null;
				IntPtr intPtr2;
				IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(ColorGradingModel.NativeMethodInfoPtr_get_settings_Public_get_Settings_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
				return new ColorGradingModel.Settings(intPtr);
			}
			[CallerCount(0)]
			[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 648834, XrefRangeEnd = 648835, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
			set
			{
				IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
				checked
				{
					IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
					*ptr = IL2CPP.il2cpp_object_unbox(IL2CPP.Il2CppObjectBaseToPtrNotNull(value));
					IntPtr intPtr2;
					IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(ColorGradingModel.NativeMethodInfoPtr_set_settings_Public_set_Void_Settings_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
					Il2CppException.RaiseExceptionIfNecessary(intPtr2);
				}
			}
		}

		// Token: 0x17003573 RID: 13683
		// (get) Token: 0x06009E7B RID: 40571 RVA: 0x0028B784 File Offset: 0x00289984
		// (set) Token: 0x06009E7C RID: 40572 RVA: 0x0028B7D4 File Offset: 0x002899D4
		public unsafe bool isDirty
		{
			[CallerCount(0)]
			get
			{
				IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
				IntPtr* ptr = null;
				IntPtr intPtr2;
				IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(ColorGradingModel.NativeMethodInfoPtr_get_isDirty_Public_get_Boolean_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
				return *IL2CPP.il2cpp_object_unbox(intPtr);
			}
			[CallerCount(0)]
			set
			{
				IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
				checked
				{
					IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
					*ptr = ref value;
					IntPtr intPtr2;
					IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(ColorGradingModel.NativeMethodInfoPtr_set_isDirty_Internal_set_Void_Boolean_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
					Il2CppException.RaiseExceptionIfNecessary(intPtr2);
				}
			}
		}

		// Token: 0x17003574 RID: 13684
		// (get) Token: 0x06009E7D RID: 40573 RVA: 0x0028B828 File Offset: 0x00289A28
		// (set) Token: 0x06009E7E RID: 40574 RVA: 0x0028B880 File Offset: 0x00289A80
		public unsafe RenderTexture bakedLut
		{
			[CallerCount(0)]
			get
			{
				IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
				IntPtr* ptr = null;
				IntPtr intPtr2;
				IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(ColorGradingModel.NativeMethodInfoPtr_get_bakedLut_Public_get_RenderTexture_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
				IntPtr intPtr3 = intPtr;
				return (intPtr3 != 0) ? new RenderTexture(intPtr3) : null;
			}
			[CallerCount(0)]
			[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 0, XrefRangeEnd = 0, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
			set
			{
				IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
				checked
				{
					IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
					*ptr = IL2CPP.Il2CppObjectBaseToPtr(value);
					IntPtr intPtr2;
					IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(ColorGradingModel.NativeMethodInfoPtr_set_bakedLut_Internal_set_Void_RenderTexture_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
					Il2CppException.RaiseExceptionIfNecessary(intPtr2);
				}
			}
		}

		// Token: 0x06009E7F RID: 40575 RVA: 0x0028B8DC File Offset: 0x00289ADC
		[CallerCount(0)]
		[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 648835, XrefRangeEnd = 648837, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
		public unsafe override void Reset()
		{
			IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			IntPtr* ptr = null;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(IL2CPP.il2cpp_object_get_virtual_method(IL2CPP.Il2CppObjectBaseToPtr(this), ColorGradingModel.NativeMethodInfoPtr_Reset_Public_Virtual_Void_0), IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		}

		// Token: 0x06009E80 RID: 40576 RVA: 0x0028B92C File Offset: 0x00289B2C
		[CallerCount(0)]
		public unsafe override void OnValidate()
		{
			IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			IntPtr* ptr = null;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(IL2CPP.il2cpp_object_get_virtual_method(IL2CPP.Il2CppObjectBaseToPtr(this), ColorGradingModel.NativeMethodInfoPtr_OnValidate_Public_Virtual_Void_0), IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		}

		// Token: 0x06009E81 RID: 40577 RVA: 0x0028B97C File Offset: 0x00289B7C
		[CallerCount(1)]
		[CachedScanResults(RefRangeStart = 648840, RefRangeEnd = 648841, XrefRangeStart = 648837, XrefRangeEnd = 648840, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
		public unsafe ColorGradingModel()
			: this(IL2CPP.il2cpp_object_new(Il2CppClassPointerStore<ColorGradingModel>.NativeClassPtr))
		{
			IntPtr* ptr = null;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(ColorGradingModel.NativeMethodInfoPtr__ctor_Public_Void_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		}

		// Token: 0x06009E82 RID: 40578 RVA: 0x0028B9C8 File Offset: 0x00289BC8
		// Note: this type is marked as 'beforefieldinit'.
		static ColorGradingModel()
		{
			Il2CppClassPointerStore<ColorGradingModel>.NativeClassPtr = IL2CPP.GetIl2CppClass("Assembly-CSharp.dll", "UnityEngine.PostProcessing", "ColorGradingModel");
			IL2CPP.il2cpp_runtime_class_init(Il2CppClassPointerStore<ColorGradingModel>.NativeClassPtr);
			ColorGradingModel.NativeFieldInfoPtr_m_Settings = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<ColorGradingModel>.NativeClassPtr, "m_Settings");
			ColorGradingModel.NativeFieldInfoPtr__isDirty_k__BackingField = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<ColorGradingModel>.NativeClassPtr, "<isDirty>k__BackingField");
			ColorGradingModel.NativeFieldInfoPtr__bakedLut_k__BackingField = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<ColorGradingModel>.NativeClassPtr, "<bakedLut>k__BackingField");
			ColorGradingModel.NativeMethodInfoPtr_get_settings_Public_get_Settings_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<ColorGradingModel>.NativeClassPtr, 100675693);
			ColorGradingModel.NativeMethodInfoPtr_set_settings_Public_set_Void_Settings_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<ColorGradingModel>.NativeClassPtr, 100675694);
			ColorGradingModel.NativeMethodInfoPtr_get_isDirty_Public_get_Boolean_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<ColorGradingModel>.NativeClassPtr, 100675695);
			ColorGradingModel.NativeMethodInfoPtr_set_isDirty_Internal_set_Void_Boolean_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<ColorGradingModel>.NativeClassPtr, 100675696);
			ColorGradingModel.NativeMethodInfoPtr_get_bakedLut_Public_get_RenderTexture_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<ColorGradingModel>.NativeClassPtr, 100675697);
			ColorGradingModel.NativeMethodInfoPtr_set_bakedLut_Internal_set_Void_RenderTexture_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<ColorGradingModel>.NativeClassPtr, 100675698);
			ColorGradingModel.NativeMethodInfoPtr_Reset_Public_Virtual_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<ColorGradingModel>.NativeClassPtr, 100675699);
			ColorGradingModel.NativeMethodInfoPtr_OnValidate_Public_Virtual_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<ColorGradingModel>.NativeClassPtr, 100675700);
			ColorGradingModel.NativeMethodInfoPtr__ctor_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<ColorGradingModel>.NativeClassPtr, 100675701);
		}

		// Token: 0x06009E83 RID: 40579 RVA: 0x00289EDC File Offset: 0x002880DC
		public ColorGradingModel(IntPtr pointer)
			: base(pointer)
		{
		}

		// Token: 0x1700356F RID: 13679
		// (get) Token: 0x06009E84 RID: 40580 RVA: 0x0028BAE8 File Offset: 0x00289CE8
		// (set) Token: 0x06009E85 RID: 40581 RVA: 0x0028BB1A File Offset: 0x00289D1A
		public ColorGradingModel.Settings m_Settings
		{
			get
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(ColorGradingModel.NativeFieldInfoPtr_m_Settings);
				return new ColorGradingModel.Settings(IL2CPP.il2cpp_value_box(Il2CppClassPointerStore<ColorGradingModel.Settings>.NativeClassPtr, intPtr));
			}
			set
			{
				cpblk(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(ColorGradingModel.NativeFieldInfoPtr_m_Settings), IL2CPP.il2cpp_object_unbox(IL2CPP.Il2CppObjectBaseToPtr(value)), IL2CPP.il2cpp_class_value_size(Il2CppClassPointerStore<ColorGradingModel.Settings>.NativeClassPtr, (UIntPtr)0));
			}
		}

		// Token: 0x17003570 RID: 13680
		// (get) Token: 0x06009E86 RID: 40582 RVA: 0x0028BB50 File Offset: 0x00289D50
		// (set) Token: 0x06009E87 RID: 40583 RVA: 0x0028BB78 File Offset: 0x00289D78
		public unsafe bool _isDirty_k__BackingField
		{
			get
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(ColorGradingModel.NativeFieldInfoPtr__isDirty_k__BackingField);
				return *intPtr;
			}
			set
			{
				*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(ColorGradingModel.NativeFieldInfoPtr__isDirty_k__BackingField)) = value;
			}
		}

		// Token: 0x17003571 RID: 13681
		// (get) Token: 0x06009E88 RID: 40584 RVA: 0x0028BB9C File Offset: 0x00289D9C
		// (set) Token: 0x06009E89 RID: 40585 RVA: 0x0028BBD0 File Offset: 0x00289DD0
		public unsafe RenderTexture _bakedLut_k__BackingField
		{
			get
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(ColorGradingModel.NativeFieldInfoPtr__bakedLut_k__BackingField);
				IntPtr intPtr2 = *intPtr;
				return (intPtr2 != 0) ? new RenderTexture(intPtr2) : null;
			}
			set
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
				IL2CPP.il2cpp_gc_wbarrier_set_field(intPtr, intPtr + (IntPtr)IL2CPP.il2cpp_field_get_offset(ColorGradingModel.NativeFieldInfoPtr__bakedLut_k__BackingField), IL2CPP.Il2CppObjectBaseToPtr(value));
			}
		}

		// Token: 0x040069FF RID: 27135
		private static readonly IntPtr NativeFieldInfoPtr_m_Settings;

		// Token: 0x04006A00 RID: 27136
		private static readonly IntPtr NativeFieldInfoPtr__isDirty_k__BackingField;

		// Token: 0x04006A01 RID: 27137
		private static readonly IntPtr NativeFieldInfoPtr__bakedLut_k__BackingField;

		// Token: 0x04006A02 RID: 27138
		private static readonly IntPtr NativeMethodInfoPtr_get_settings_Public_get_Settings_0;

		// Token: 0x04006A03 RID: 27139
		private static readonly IntPtr NativeMethodInfoPtr_set_settings_Public_set_Void_Settings_0;

		// Token: 0x04006A04 RID: 27140
		private static readonly IntPtr NativeMethodInfoPtr_get_isDirty_Public_get_Boolean_0;

		// Token: 0x04006A05 RID: 27141
		private static readonly IntPtr NativeMethodInfoPtr_set_isDirty_Internal_set_Void_Boolean_0;

		// Token: 0x04006A06 RID: 27142
		private static readonly IntPtr NativeMethodInfoPtr_get_bakedLut_Public_get_RenderTexture_0;

		// Token: 0x04006A07 RID: 27143
		private static readonly IntPtr NativeMethodInfoPtr_set_bakedLut_Internal_set_Void_RenderTexture_0;

		// Token: 0x04006A08 RID: 27144
		private static readonly IntPtr NativeMethodInfoPtr_Reset_Public_Virtual_Void_0;

		// Token: 0x04006A09 RID: 27145
		private static readonly IntPtr NativeMethodInfoPtr_OnValidate_Public_Virtual_Void_0;

		// Token: 0x04006A0A RID: 27146
		private static readonly IntPtr NativeMethodInfoPtr__ctor_Public_Void_0;

		// Token: 0x020005B4 RID: 1460
		public enum Tonemapper
		{
			// Token: 0x04006A0C RID: 27148
			None,
			// Token: 0x04006A0D RID: 27149
			ACES,
			// Token: 0x04006A0E RID: 27150
			Neutral
		}

		// Token: 0x020005B5 RID: 1461
		[Serializable]
		[StructLayout(2)]
		public struct TonemappingSettings
		{
			// Token: 0x17003575 RID: 13685
			// (get) Token: 0x06009E8A RID: 40586 RVA: 0x0028BBF8 File Offset: 0x00289DF8
			public unsafe static ColorGradingModel.TonemappingSettings defaultSettings
			{
				[CallerCount(0)]
				get
				{
					IntPtr* ptr = null;
					IntPtr intPtr2;
					IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(ColorGradingModel.TonemappingSettings.NativeMethodInfoPtr_get_defaultSettings_Public_Static_get_TonemappingSettings_0, 0, (void**)ptr, ref intPtr2);
					Il2CppException.RaiseExceptionIfNecessary(intPtr2);
					return *IL2CPP.il2cpp_object_unbox(intPtr);
				}
			}

			// Token: 0x06009E8B RID: 40587 RVA: 0x0028BC3C File Offset: 0x00289E3C
			// Note: this type is marked as 'beforefieldinit'.
			static TonemappingSettings()
			{
				Il2CppClassPointerStore<ColorGradingModel.TonemappingSettings>.NativeClassPtr = IL2CPP.GetIl2CppNestedType(Il2CppClassPointerStore<ColorGradingModel>.NativeClassPtr, "TonemappingSettings");
				IL2CPP.il2cpp_runtime_class_init(Il2CppClassPointerStore<ColorGradingModel.TonemappingSettings>.NativeClassPtr);
				ColorGradingModel.TonemappingSettings.NativeFieldInfoPtr_tonemapper = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<ColorGradingModel.TonemappingSettings>.NativeClassPtr, "tonemapper");
				ColorGradingModel.TonemappingSettings.NativeFieldInfoPtr_neutralBlackIn = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<ColorGradingModel.TonemappingSettings>.NativeClassPtr, "neutralBlackIn");
				ColorGradingModel.TonemappingSettings.NativeFieldInfoPtr_neutralWhiteIn = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<ColorGradingModel.TonemappingSettings>.NativeClassPtr, "neutralWhiteIn");
				ColorGradingModel.TonemappingSettings.NativeFieldInfoPtr_neutralBlackOut = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<ColorGradingModel.TonemappingSettings>.NativeClassPtr, "neutralBlackOut");
				ColorGradingModel.TonemappingSettings.NativeFieldInfoPtr_neutralWhiteOut = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<ColorGradingModel.TonemappingSettings>.NativeClassPtr, "neutralWhiteOut");
				ColorGradingModel.TonemappingSettings.NativeFieldInfoPtr_neutralWhiteLevel = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<ColorGradingModel.TonemappingSettings>.NativeClassPtr, "neutralWhiteLevel");
				ColorGradingModel.TonemappingSettings.NativeFieldInfoPtr_neutralWhiteClip = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<ColorGradingModel.TonemappingSettings>.NativeClassPtr, "neutralWhiteClip");
				ColorGradingModel.TonemappingSettings.NativeMethodInfoPtr_get_defaultSettings_Public_Static_get_TonemappingSettings_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<ColorGradingModel.TonemappingSettings>.NativeClassPtr, 100675702);
			}

			// Token: 0x06009E8C RID: 40588 RVA: 0x0028BD07 File Offset: 0x00289F07
			public Object BoxIl2CppObject()
			{
				return new Object(IL2CPP.il2cpp_value_box(Il2CppClassPointerStore<ColorGradingModel.TonemappingSettings>.NativeClassPtr, ref this));
			}

			// Token: 0x04006A0F RID: 27151
			private static readonly IntPtr NativeFieldInfoPtr_tonemapper;

			// Token: 0x04006A10 RID: 27152
			private static readonly IntPtr NativeFieldInfoPtr_neutralBlackIn;

			// Token: 0x04006A11 RID: 27153
			private static readonly IntPtr NativeFieldInfoPtr_neutralWhiteIn;

			// Token: 0x04006A12 RID: 27154
			private static readonly IntPtr NativeFieldInfoPtr_neutralBlackOut;

			// Token: 0x04006A13 RID: 27155
			private static readonly IntPtr NativeFieldInfoPtr_neutralWhiteOut;

			// Token: 0x04006A14 RID: 27156
			private static readonly IntPtr NativeFieldInfoPtr_neutralWhiteLevel;

			// Token: 0x04006A15 RID: 27157
			private static readonly IntPtr NativeFieldInfoPtr_neutralWhiteClip;

			// Token: 0x04006A16 RID: 27158
			private static readonly IntPtr NativeMethodInfoPtr_get_defaultSettings_Public_Static_get_TonemappingSettings_0;

			// Token: 0x04006A17 RID: 27159
			[FieldOffset(0)]
			public ColorGradingModel.Tonemapper tonemapper;

			// Token: 0x04006A18 RID: 27160
			[FieldOffset(4)]
			public float neutralBlackIn;

			// Token: 0x04006A19 RID: 27161
			[FieldOffset(8)]
			public float neutralWhiteIn;

			// Token: 0x04006A1A RID: 27162
			[FieldOffset(12)]
			public float neutralBlackOut;

			// Token: 0x04006A1B RID: 27163
			[FieldOffset(16)]
			public float neutralWhiteOut;

			// Token: 0x04006A1C RID: 27164
			[FieldOffset(20)]
			public float neutralWhiteLevel;

			// Token: 0x04006A1D RID: 27165
			[FieldOffset(24)]
			public float neutralWhiteClip;
		}

		// Token: 0x020005B6 RID: 1462
		[Serializable]
		[StructLayout(2)]
		public struct BasicSettings
		{
			// Token: 0x17003576 RID: 13686
			// (get) Token: 0x06009E8D RID: 40589 RVA: 0x0028BD1C File Offset: 0x00289F1C
			public unsafe static ColorGradingModel.BasicSettings defaultSettings
			{
				[CallerCount(0)]
				get
				{
					IntPtr* ptr = null;
					IntPtr intPtr2;
					IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(ColorGradingModel.BasicSettings.NativeMethodInfoPtr_get_defaultSettings_Public_Static_get_BasicSettings_0, 0, (void**)ptr, ref intPtr2);
					Il2CppException.RaiseExceptionIfNecessary(intPtr2);
					return *IL2CPP.il2cpp_object_unbox(intPtr);
				}
			}

			// Token: 0x06009E8E RID: 40590 RVA: 0x0028BD60 File Offset: 0x00289F60
			// Note: this type is marked as 'beforefieldinit'.
			static BasicSettings()
			{
				Il2CppClassPointerStore<ColorGradingModel.BasicSettings>.NativeClassPtr = IL2CPP.GetIl2CppNestedType(Il2CppClassPointerStore<ColorGradingModel>.NativeClassPtr, "BasicSettings");
				IL2CPP.il2cpp_runtime_class_init(Il2CppClassPointerStore<ColorGradingModel.BasicSettings>.NativeClassPtr);
				ColorGradingModel.BasicSettings.NativeFieldInfoPtr_postExposure = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<ColorGradingModel.BasicSettings>.NativeClassPtr, "postExposure");
				ColorGradingModel.BasicSettings.NativeFieldInfoPtr_temperature = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<ColorGradingModel.BasicSettings>.NativeClassPtr, "temperature");
				ColorGradingModel.BasicSettings.NativeFieldInfoPtr_tint = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<ColorGradingModel.BasicSettings>.NativeClassPtr, "tint");
				ColorGradingModel.BasicSettings.NativeFieldInfoPtr_hueShift = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<ColorGradingModel.BasicSettings>.NativeClassPtr, "hueShift");
				ColorGradingModel.BasicSettings.NativeFieldInfoPtr_saturation = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<ColorGradingModel.BasicSettings>.NativeClassPtr, "saturation");
				ColorGradingModel.BasicSettings.NativeFieldInfoPtr_contrast = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<ColorGradingModel.BasicSettings>.NativeClassPtr, "contrast");
				ColorGradingModel.BasicSettings.NativeMethodInfoPtr_get_defaultSettings_Public_Static_get_BasicSettings_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<ColorGradingModel.BasicSettings>.NativeClassPtr, 100675703);
			}

			// Token: 0x06009E8F RID: 40591 RVA: 0x0028BE17 File Offset: 0x0028A017
			public Object BoxIl2CppObject()
			{
				return new Object(IL2CPP.il2cpp_value_box(Il2CppClassPointerStore<ColorGradingModel.BasicSettings>.NativeClassPtr, ref this));
			}

			// Token: 0x04006A1E RID: 27166
			private static readonly IntPtr NativeFieldInfoPtr_postExposure;

			// Token: 0x04006A1F RID: 27167
			private static readonly IntPtr NativeFieldInfoPtr_temperature;

			// Token: 0x04006A20 RID: 27168
			private static readonly IntPtr NativeFieldInfoPtr_tint;

			// Token: 0x04006A21 RID: 27169
			private static readonly IntPtr NativeFieldInfoPtr_hueShift;

			// Token: 0x04006A22 RID: 27170
			private static readonly IntPtr NativeFieldInfoPtr_saturation;

			// Token: 0x04006A23 RID: 27171
			private static readonly IntPtr NativeFieldInfoPtr_contrast;

			// Token: 0x04006A24 RID: 27172
			private static readonly IntPtr NativeMethodInfoPtr_get_defaultSettings_Public_Static_get_BasicSettings_0;

			// Token: 0x04006A25 RID: 27173
			[FieldOffset(0)]
			public float postExposure;

			// Token: 0x04006A26 RID: 27174
			[FieldOffset(4)]
			public float temperature;

			// Token: 0x04006A27 RID: 27175
			[FieldOffset(8)]
			public float tint;

			// Token: 0x04006A28 RID: 27176
			[FieldOffset(12)]
			public float hueShift;

			// Token: 0x04006A29 RID: 27177
			[FieldOffset(16)]
			public float saturation;

			// Token: 0x04006A2A RID: 27178
			[FieldOffset(20)]
			public float contrast;
		}

		// Token: 0x020005B7 RID: 1463
		[Serializable]
		[StructLayout(2)]
		public struct ChannelMixerSettings
		{
			// Token: 0x17003577 RID: 13687
			// (get) Token: 0x06009E90 RID: 40592 RVA: 0x0028BE2C File Offset: 0x0028A02C
			public unsafe static ColorGradingModel.ChannelMixerSettings defaultSettings
			{
				[CallerCount(0)]
				get
				{
					IntPtr* ptr = null;
					IntPtr intPtr2;
					IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(ColorGradingModel.ChannelMixerSettings.NativeMethodInfoPtr_get_defaultSettings_Public_Static_get_ChannelMixerSettings_0, 0, (void**)ptr, ref intPtr2);
					Il2CppException.RaiseExceptionIfNecessary(intPtr2);
					return *IL2CPP.il2cpp_object_unbox(intPtr);
				}
			}

			// Token: 0x06009E91 RID: 40593 RVA: 0x0028BE70 File Offset: 0x0028A070
			// Note: this type is marked as 'beforefieldinit'.
			static ChannelMixerSettings()
			{
				Il2CppClassPointerStore<ColorGradingModel.ChannelMixerSettings>.NativeClassPtr = IL2CPP.GetIl2CppNestedType(Il2CppClassPointerStore<ColorGradingModel>.NativeClassPtr, "ChannelMixerSettings");
				IL2CPP.il2cpp_runtime_class_init(Il2CppClassPointerStore<ColorGradingModel.ChannelMixerSettings>.NativeClassPtr);
				ColorGradingModel.ChannelMixerSettings.NativeFieldInfoPtr_red = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<ColorGradingModel.ChannelMixerSettings>.NativeClassPtr, "red");
				ColorGradingModel.ChannelMixerSettings.NativeFieldInfoPtr_green = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<ColorGradingModel.ChannelMixerSettings>.NativeClassPtr, "green");
				ColorGradingModel.ChannelMixerSettings.NativeFieldInfoPtr_blue = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<ColorGradingModel.ChannelMixerSettings>.NativeClassPtr, "blue");
				ColorGradingModel.ChannelMixerSettings.NativeFieldInfoPtr_currentEditingChannel = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<ColorGradingModel.ChannelMixerSettings>.NativeClassPtr, "currentEditingChannel");
				ColorGradingModel.ChannelMixerSettings.NativeMethodInfoPtr_get_defaultSettings_Public_Static_get_ChannelMixerSettings_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<ColorGradingModel.ChannelMixerSettings>.NativeClassPtr, 100675704);
			}

			// Token: 0x06009E92 RID: 40594 RVA: 0x0028BEFF File Offset: 0x0028A0FF
			public Object BoxIl2CppObject()
			{
				return new Object(IL2CPP.il2cpp_value_box(Il2CppClassPointerStore<ColorGradingModel.ChannelMixerSettings>.NativeClassPtr, ref this));
			}

			// Token: 0x04006A2B RID: 27179
			private static readonly IntPtr NativeFieldInfoPtr_red;

			// Token: 0x04006A2C RID: 27180
			private static readonly IntPtr NativeFieldInfoPtr_green;

			// Token: 0x04006A2D RID: 27181
			private static readonly IntPtr NativeFieldInfoPtr_blue;

			// Token: 0x04006A2E RID: 27182
			private static readonly IntPtr NativeFieldInfoPtr_currentEditingChannel;

			// Token: 0x04006A2F RID: 27183
			private static readonly IntPtr NativeMethodInfoPtr_get_defaultSettings_Public_Static_get_ChannelMixerSettings_0;

			// Token: 0x04006A30 RID: 27184
			[FieldOffset(0)]
			public Vector3 red;

			// Token: 0x04006A31 RID: 27185
			[FieldOffset(12)]
			public Vector3 green;

			// Token: 0x04006A32 RID: 27186
			[FieldOffset(24)]
			public Vector3 blue;

			// Token: 0x04006A33 RID: 27187
			[FieldOffset(36)]
			public int currentEditingChannel;
		}

		// Token: 0x020005B8 RID: 1464
		[Serializable]
		[StructLayout(2)]
		public struct LogWheelsSettings
		{
			// Token: 0x17003578 RID: 13688
			// (get) Token: 0x06009E93 RID: 40595 RVA: 0x0028BF14 File Offset: 0x0028A114
			public unsafe static ColorGradingModel.LogWheelsSettings defaultSettings
			{
				[CallerCount(0)]
				[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 648738, XrefRangeEnd = 648741, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
				get
				{
					IntPtr* ptr = null;
					IntPtr intPtr2;
					IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(ColorGradingModel.LogWheelsSettings.NativeMethodInfoPtr_get_defaultSettings_Public_Static_get_LogWheelsSettings_0, 0, (void**)ptr, ref intPtr2);
					Il2CppException.RaiseExceptionIfNecessary(intPtr2);
					return *IL2CPP.il2cpp_object_unbox(intPtr);
				}
			}

			// Token: 0x06009E94 RID: 40596 RVA: 0x0028BF58 File Offset: 0x0028A158
			// Note: this type is marked as 'beforefieldinit'.
			static LogWheelsSettings()
			{
				Il2CppClassPointerStore<ColorGradingModel.LogWheelsSettings>.NativeClassPtr = IL2CPP.GetIl2CppNestedType(Il2CppClassPointerStore<ColorGradingModel>.NativeClassPtr, "LogWheelsSettings");
				IL2CPP.il2cpp_runtime_class_init(Il2CppClassPointerStore<ColorGradingModel.LogWheelsSettings>.NativeClassPtr);
				ColorGradingModel.LogWheelsSettings.NativeFieldInfoPtr_slope = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<ColorGradingModel.LogWheelsSettings>.NativeClassPtr, "slope");
				ColorGradingModel.LogWheelsSettings.NativeFieldInfoPtr_power = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<ColorGradingModel.LogWheelsSettings>.NativeClassPtr, "power");
				ColorGradingModel.LogWheelsSettings.NativeFieldInfoPtr_offset = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<ColorGradingModel.LogWheelsSettings>.NativeClassPtr, "offset");
				ColorGradingModel.LogWheelsSettings.NativeMethodInfoPtr_get_defaultSettings_Public_Static_get_LogWheelsSettings_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<ColorGradingModel.LogWheelsSettings>.NativeClassPtr, 100675705);
			}

			// Token: 0x06009E95 RID: 40597 RVA: 0x0028BFD3 File Offset: 0x0028A1D3
			public Object BoxIl2CppObject()
			{
				return new Object(IL2CPP.il2cpp_value_box(Il2CppClassPointerStore<ColorGradingModel.LogWheelsSettings>.NativeClassPtr, ref this));
			}

			// Token: 0x04006A34 RID: 27188
			private static readonly IntPtr NativeFieldInfoPtr_slope;

			// Token: 0x04006A35 RID: 27189
			private static readonly IntPtr NativeFieldInfoPtr_power;

			// Token: 0x04006A36 RID: 27190
			private static readonly IntPtr NativeFieldInfoPtr_offset;

			// Token: 0x04006A37 RID: 27191
			private static readonly IntPtr NativeMethodInfoPtr_get_defaultSettings_Public_Static_get_LogWheelsSettings_0;

			// Token: 0x04006A38 RID: 27192
			[FieldOffset(0)]
			public Color slope;

			// Token: 0x04006A39 RID: 27193
			[FieldOffset(16)]
			public Color power;

			// Token: 0x04006A3A RID: 27194
			[FieldOffset(32)]
			public Color offset;
		}

		// Token: 0x020005B9 RID: 1465
		[Serializable]
		[StructLayout(2)]
		public struct LinearWheelsSettings
		{
			// Token: 0x17003579 RID: 13689
			// (get) Token: 0x06009E96 RID: 40598 RVA: 0x0028BFE8 File Offset: 0x0028A1E8
			public unsafe static ColorGradingModel.LinearWheelsSettings defaultSettings
			{
				[CallerCount(0)]
				[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 0, XrefRangeEnd = 0, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
				get
				{
					IntPtr* ptr = null;
					IntPtr intPtr2;
					IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(ColorGradingModel.LinearWheelsSettings.NativeMethodInfoPtr_get_defaultSettings_Public_Static_get_LinearWheelsSettings_0, 0, (void**)ptr, ref intPtr2);
					Il2CppException.RaiseExceptionIfNecessary(intPtr2);
					return *IL2CPP.il2cpp_object_unbox(intPtr);
				}
			}

			// Token: 0x06009E97 RID: 40599 RVA: 0x0028C02C File Offset: 0x0028A22C
			// Note: this type is marked as 'beforefieldinit'.
			static LinearWheelsSettings()
			{
				Il2CppClassPointerStore<ColorGradingModel.LinearWheelsSettings>.NativeClassPtr = IL2CPP.GetIl2CppNestedType(Il2CppClassPointerStore<ColorGradingModel>.NativeClassPtr, "LinearWheelsSettings");
				IL2CPP.il2cpp_runtime_class_init(Il2CppClassPointerStore<ColorGradingModel.LinearWheelsSettings>.NativeClassPtr);
				ColorGradingModel.LinearWheelsSettings.NativeFieldInfoPtr_lift = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<ColorGradingModel.LinearWheelsSettings>.NativeClassPtr, "lift");
				ColorGradingModel.LinearWheelsSettings.NativeFieldInfoPtr_gamma = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<ColorGradingModel.LinearWheelsSettings>.NativeClassPtr, "gamma");
				ColorGradingModel.LinearWheelsSettings.NativeFieldInfoPtr_gain = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<ColorGradingModel.LinearWheelsSettings>.NativeClassPtr, "gain");
				ColorGradingModel.LinearWheelsSettings.NativeMethodInfoPtr_get_defaultSettings_Public_Static_get_LinearWheelsSettings_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<ColorGradingModel.LinearWheelsSettings>.NativeClassPtr, 100675706);
			}

			// Token: 0x06009E98 RID: 40600 RVA: 0x0028C0A7 File Offset: 0x0028A2A7
			public Object BoxIl2CppObject()
			{
				return new Object(IL2CPP.il2cpp_value_box(Il2CppClassPointerStore<ColorGradingModel.LinearWheelsSettings>.NativeClassPtr, ref this));
			}

			// Token: 0x04006A3B RID: 27195
			private static readonly IntPtr NativeFieldInfoPtr_lift;

			// Token: 0x04006A3C RID: 27196
			private static readonly IntPtr NativeFieldInfoPtr_gamma;

			// Token: 0x04006A3D RID: 27197
			private static readonly IntPtr NativeFieldInfoPtr_gain;

			// Token: 0x04006A3E RID: 27198
			private static readonly IntPtr NativeMethodInfoPtr_get_defaultSettings_Public_Static_get_LinearWheelsSettings_0;

			// Token: 0x04006A3F RID: 27199
			[FieldOffset(0)]
			public Color lift;

			// Token: 0x04006A40 RID: 27200
			[FieldOffset(16)]
			public Color gamma;

			// Token: 0x04006A41 RID: 27201
			[FieldOffset(32)]
			public Color gain;
		}

		// Token: 0x020005BA RID: 1466
		public enum ColorWheelMode
		{
			// Token: 0x04006A43 RID: 27203
			Linear,
			// Token: 0x04006A44 RID: 27204
			Log
		}

		// Token: 0x020005BB RID: 1467
		[Serializable]
		[StructLayout(2)]
		public struct ColorWheelsSettings
		{
			// Token: 0x1700357A RID: 13690
			// (get) Token: 0x06009E99 RID: 40601 RVA: 0x0028C0BC File Offset: 0x0028A2BC
			public unsafe static ColorGradingModel.ColorWheelsSettings defaultSettings
			{
				[CallerCount(0)]
				[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 648741, XrefRangeEnd = 648747, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
				get
				{
					IntPtr* ptr = null;
					IntPtr intPtr2;
					IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(ColorGradingModel.ColorWheelsSettings.NativeMethodInfoPtr_get_defaultSettings_Public_Static_get_ColorWheelsSettings_0, 0, (void**)ptr, ref intPtr2);
					Il2CppException.RaiseExceptionIfNecessary(intPtr2);
					return *IL2CPP.il2cpp_object_unbox(intPtr);
				}
			}

			// Token: 0x06009E9A RID: 40602 RVA: 0x0028C100 File Offset: 0x0028A300
			// Note: this type is marked as 'beforefieldinit'.
			static ColorWheelsSettings()
			{
				Il2CppClassPointerStore<ColorGradingModel.ColorWheelsSettings>.NativeClassPtr = IL2CPP.GetIl2CppNestedType(Il2CppClassPointerStore<ColorGradingModel>.NativeClassPtr, "ColorWheelsSettings");
				IL2CPP.il2cpp_runtime_class_init(Il2CppClassPointerStore<ColorGradingModel.ColorWheelsSettings>.NativeClassPtr);
				ColorGradingModel.ColorWheelsSettings.NativeFieldInfoPtr_mode = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<ColorGradingModel.ColorWheelsSettings>.NativeClassPtr, "mode");
				ColorGradingModel.ColorWheelsSettings.NativeFieldInfoPtr_log = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<ColorGradingModel.ColorWheelsSettings>.NativeClassPtr, "log");
				ColorGradingModel.ColorWheelsSettings.NativeFieldInfoPtr_linear = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<ColorGradingModel.ColorWheelsSettings>.NativeClassPtr, "linear");
				ColorGradingModel.ColorWheelsSettings.NativeMethodInfoPtr_get_defaultSettings_Public_Static_get_ColorWheelsSettings_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<ColorGradingModel.ColorWheelsSettings>.NativeClassPtr, 100675707);
			}

			// Token: 0x06009E9B RID: 40603 RVA: 0x0028C17B File Offset: 0x0028A37B
			public Object BoxIl2CppObject()
			{
				return new Object(IL2CPP.il2cpp_value_box(Il2CppClassPointerStore<ColorGradingModel.ColorWheelsSettings>.NativeClassPtr, ref this));
			}

			// Token: 0x04006A45 RID: 27205
			private static readonly IntPtr NativeFieldInfoPtr_mode;

			// Token: 0x04006A46 RID: 27206
			private static readonly IntPtr NativeFieldInfoPtr_log;

			// Token: 0x04006A47 RID: 27207
			private static readonly IntPtr NativeFieldInfoPtr_linear;

			// Token: 0x04006A48 RID: 27208
			private static readonly IntPtr NativeMethodInfoPtr_get_defaultSettings_Public_Static_get_ColorWheelsSettings_0;

			// Token: 0x04006A49 RID: 27209
			[FieldOffset(0)]
			public ColorGradingModel.ColorWheelMode mode;

			// Token: 0x04006A4A RID: 27210
			[FieldOffset(4)]
			public ColorGradingModel.LogWheelsSettings log;

			// Token: 0x04006A4B RID: 27211
			[FieldOffset(52)]
			public ColorGradingModel.LinearWheelsSettings linear;
		}

		// Token: 0x020005BC RID: 1468
		[Serializable]
		public sealed class CurvesSettings : ValueType
		{
			// Token: 0x17003588 RID: 13704
			// (get) Token: 0x06009E9C RID: 40604 RVA: 0x0028C190 File Offset: 0x0028A390
			public unsafe static ColorGradingModel.CurvesSettings defaultSettings
			{
				[CallerCount(1)]
				[CachedScanResults(RefRangeStart = 648822, RefRangeEnd = 648823, XrefRangeStart = 648747, XrefRangeEnd = 648822, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
				get
				{
					IntPtr* ptr = null;
					IntPtr intPtr2;
					IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(ColorGradingModel.CurvesSettings.NativeMethodInfoPtr_get_defaultSettings_Public_Static_get_CurvesSettings_0, 0, (void**)ptr, ref intPtr2);
					Il2CppException.RaiseExceptionIfNecessary(intPtr2);
					return new ColorGradingModel.CurvesSettings(intPtr);
				}
			}

			// Token: 0x06009E9D RID: 40605 RVA: 0x0028C1CC File Offset: 0x0028A3CC
			// Note: this type is marked as 'beforefieldinit'.
			static CurvesSettings()
			{
				Il2CppClassPointerStore<ColorGradingModel.CurvesSettings>.NativeClassPtr = IL2CPP.GetIl2CppNestedType(Il2CppClassPointerStore<ColorGradingModel>.NativeClassPtr, "CurvesSettings");
				IL2CPP.il2cpp_runtime_class_init(Il2CppClassPointerStore<ColorGradingModel.CurvesSettings>.NativeClassPtr);
				ColorGradingModel.CurvesSettings.NativeFieldInfoPtr_master = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<ColorGradingModel.CurvesSettings>.NativeClassPtr, "master");
				ColorGradingModel.CurvesSettings.NativeFieldInfoPtr_red = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<ColorGradingModel.CurvesSettings>.NativeClassPtr, "red");
				ColorGradingModel.CurvesSettings.NativeFieldInfoPtr_green = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<ColorGradingModel.CurvesSettings>.NativeClassPtr, "green");
				ColorGradingModel.CurvesSettings.NativeFieldInfoPtr_blue = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<ColorGradingModel.CurvesSettings>.NativeClassPtr, "blue");
				ColorGradingModel.CurvesSettings.NativeFieldInfoPtr_hueVShue = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<ColorGradingModel.CurvesSettings>.NativeClassPtr, "hueVShue");
				ColorGradingModel.CurvesSettings.NativeFieldInfoPtr_hueVSsat = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<ColorGradingModel.CurvesSettings>.NativeClassPtr, "hueVSsat");
				ColorGradingModel.CurvesSettings.NativeFieldInfoPtr_satVSsat = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<ColorGradingModel.CurvesSettings>.NativeClassPtr, "satVSsat");
				ColorGradingModel.CurvesSettings.NativeFieldInfoPtr_lumVSsat = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<ColorGradingModel.CurvesSettings>.NativeClassPtr, "lumVSsat");
				ColorGradingModel.CurvesSettings.NativeFieldInfoPtr_e_CurrentEditingCurve = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<ColorGradingModel.CurvesSettings>.NativeClassPtr, "e_CurrentEditingCurve");
				ColorGradingModel.CurvesSettings.NativeFieldInfoPtr_e_CurveY = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<ColorGradingModel.CurvesSettings>.NativeClassPtr, "e_CurveY");
				ColorGradingModel.CurvesSettings.NativeFieldInfoPtr_e_CurveR = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<ColorGradingModel.CurvesSettings>.NativeClassPtr, "e_CurveR");
				ColorGradingModel.CurvesSettings.NativeFieldInfoPtr_e_CurveG = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<ColorGradingModel.CurvesSettings>.NativeClassPtr, "e_CurveG");
				ColorGradingModel.CurvesSettings.NativeFieldInfoPtr_e_CurveB = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<ColorGradingModel.CurvesSettings>.NativeClassPtr, "e_CurveB");
				ColorGradingModel.CurvesSettings.NativeMethodInfoPtr_get_defaultSettings_Public_Static_get_CurvesSettings_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<ColorGradingModel.CurvesSettings>.NativeClassPtr, 100675708);
			}

			// Token: 0x06009E9E RID: 40606 RVA: 0x001295E7 File Offset: 0x001277E7
			public CurvesSettings(IntPtr pointer)
				: base(pointer)
			{
			}

			// Token: 0x06009E9F RID: 40607 RVA: 0x0028C310 File Offset: 0x0028A510
			public unsafe CurvesSettings()
			{
				IntPtr intPtr = stackalloc byte[(UIntPtr)IL2CPP.il2cpp_class_value_size(Il2CppClassPointerStore<ColorGradingModel.CurvesSettings>.NativeClassPtr, (UIntPtr)0)];
				base..ctor(IL2CPP.il2cpp_value_box(Il2CppClassPointerStore<ColorGradingModel.CurvesSettings>.NativeClassPtr, intPtr));
			}

			// Token: 0x1700357B RID: 13691
			// (get) Token: 0x06009EA0 RID: 40608 RVA: 0x0028C340 File Offset: 0x0028A540
			// (set) Token: 0x06009EA1 RID: 40609 RVA: 0x0028C374 File Offset: 0x0028A574
			public unsafe ColorGradingCurve master
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(ColorGradingModel.CurvesSettings.NativeFieldInfoPtr_master);
					IntPtr intPtr2 = *intPtr;
					return (intPtr2 != 0) ? new ColorGradingCurve(intPtr2) : null;
				}
				set
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
					IL2CPP.il2cpp_gc_wbarrier_set_field(intPtr, intPtr + (IntPtr)IL2CPP.il2cpp_field_get_offset(ColorGradingModel.CurvesSettings.NativeFieldInfoPtr_master), IL2CPP.Il2CppObjectBaseToPtr(value));
				}
			}

			// Token: 0x1700357C RID: 13692
			// (get) Token: 0x06009EA2 RID: 40610 RVA: 0x0028C39C File Offset: 0x0028A59C
			// (set) Token: 0x06009EA3 RID: 40611 RVA: 0x0028C3D0 File Offset: 0x0028A5D0
			public unsafe ColorGradingCurve red
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(ColorGradingModel.CurvesSettings.NativeFieldInfoPtr_red);
					IntPtr intPtr2 = *intPtr;
					return (intPtr2 != 0) ? new ColorGradingCurve(intPtr2) : null;
				}
				set
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
					IL2CPP.il2cpp_gc_wbarrier_set_field(intPtr, intPtr + (IntPtr)IL2CPP.il2cpp_field_get_offset(ColorGradingModel.CurvesSettings.NativeFieldInfoPtr_red), IL2CPP.Il2CppObjectBaseToPtr(value));
				}
			}

			// Token: 0x1700357D RID: 13693
			// (get) Token: 0x06009EA4 RID: 40612 RVA: 0x0028C3F8 File Offset: 0x0028A5F8
			// (set) Token: 0x06009EA5 RID: 40613 RVA: 0x0028C42C File Offset: 0x0028A62C
			public unsafe ColorGradingCurve green
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(ColorGradingModel.CurvesSettings.NativeFieldInfoPtr_green);
					IntPtr intPtr2 = *intPtr;
					return (intPtr2 != 0) ? new ColorGradingCurve(intPtr2) : null;
				}
				set
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
					IL2CPP.il2cpp_gc_wbarrier_set_field(intPtr, intPtr + (IntPtr)IL2CPP.il2cpp_field_get_offset(ColorGradingModel.CurvesSettings.NativeFieldInfoPtr_green), IL2CPP.Il2CppObjectBaseToPtr(value));
				}
			}

			// Token: 0x1700357E RID: 13694
			// (get) Token: 0x06009EA6 RID: 40614 RVA: 0x0028C454 File Offset: 0x0028A654
			// (set) Token: 0x06009EA7 RID: 40615 RVA: 0x0028C488 File Offset: 0x0028A688
			public unsafe ColorGradingCurve blue
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(ColorGradingModel.CurvesSettings.NativeFieldInfoPtr_blue);
					IntPtr intPtr2 = *intPtr;
					return (intPtr2 != 0) ? new ColorGradingCurve(intPtr2) : null;
				}
				set
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
					IL2CPP.il2cpp_gc_wbarrier_set_field(intPtr, intPtr + (IntPtr)IL2CPP.il2cpp_field_get_offset(ColorGradingModel.CurvesSettings.NativeFieldInfoPtr_blue), IL2CPP.Il2CppObjectBaseToPtr(value));
				}
			}

			// Token: 0x1700357F RID: 13695
			// (get) Token: 0x06009EA8 RID: 40616 RVA: 0x0028C4B0 File Offset: 0x0028A6B0
			// (set) Token: 0x06009EA9 RID: 40617 RVA: 0x0028C4E4 File Offset: 0x0028A6E4
			public unsafe ColorGradingCurve hueVShue
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(ColorGradingModel.CurvesSettings.NativeFieldInfoPtr_hueVShue);
					IntPtr intPtr2 = *intPtr;
					return (intPtr2 != 0) ? new ColorGradingCurve(intPtr2) : null;
				}
				set
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
					IL2CPP.il2cpp_gc_wbarrier_set_field(intPtr, intPtr + (IntPtr)IL2CPP.il2cpp_field_get_offset(ColorGradingModel.CurvesSettings.NativeFieldInfoPtr_hueVShue), IL2CPP.Il2CppObjectBaseToPtr(value));
				}
			}

			// Token: 0x17003580 RID: 13696
			// (get) Token: 0x06009EAA RID: 40618 RVA: 0x0028C50C File Offset: 0x0028A70C
			// (set) Token: 0x06009EAB RID: 40619 RVA: 0x0028C540 File Offset: 0x0028A740
			public unsafe ColorGradingCurve hueVSsat
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(ColorGradingModel.CurvesSettings.NativeFieldInfoPtr_hueVSsat);
					IntPtr intPtr2 = *intPtr;
					return (intPtr2 != 0) ? new ColorGradingCurve(intPtr2) : null;
				}
				set
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
					IL2CPP.il2cpp_gc_wbarrier_set_field(intPtr, intPtr + (IntPtr)IL2CPP.il2cpp_field_get_offset(ColorGradingModel.CurvesSettings.NativeFieldInfoPtr_hueVSsat), IL2CPP.Il2CppObjectBaseToPtr(value));
				}
			}

			// Token: 0x17003581 RID: 13697
			// (get) Token: 0x06009EAC RID: 40620 RVA: 0x0028C568 File Offset: 0x0028A768
			// (set) Token: 0x06009EAD RID: 40621 RVA: 0x0028C59C File Offset: 0x0028A79C
			public unsafe ColorGradingCurve satVSsat
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(ColorGradingModel.CurvesSettings.NativeFieldInfoPtr_satVSsat);
					IntPtr intPtr2 = *intPtr;
					return (intPtr2 != 0) ? new ColorGradingCurve(intPtr2) : null;
				}
				set
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
					IL2CPP.il2cpp_gc_wbarrier_set_field(intPtr, intPtr + (IntPtr)IL2CPP.il2cpp_field_get_offset(ColorGradingModel.CurvesSettings.NativeFieldInfoPtr_satVSsat), IL2CPP.Il2CppObjectBaseToPtr(value));
				}
			}

			// Token: 0x17003582 RID: 13698
			// (get) Token: 0x06009EAE RID: 40622 RVA: 0x0028C5C4 File Offset: 0x0028A7C4
			// (set) Token: 0x06009EAF RID: 40623 RVA: 0x0028C5F8 File Offset: 0x0028A7F8
			public unsafe ColorGradingCurve lumVSsat
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(ColorGradingModel.CurvesSettings.NativeFieldInfoPtr_lumVSsat);
					IntPtr intPtr2 = *intPtr;
					return (intPtr2 != 0) ? new ColorGradingCurve(intPtr2) : null;
				}
				set
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
					IL2CPP.il2cpp_gc_wbarrier_set_field(intPtr, intPtr + (IntPtr)IL2CPP.il2cpp_field_get_offset(ColorGradingModel.CurvesSettings.NativeFieldInfoPtr_lumVSsat), IL2CPP.Il2CppObjectBaseToPtr(value));
				}
			}

			// Token: 0x17003583 RID: 13699
			// (get) Token: 0x06009EB0 RID: 40624 RVA: 0x0028C620 File Offset: 0x0028A820
			// (set) Token: 0x06009EB1 RID: 40625 RVA: 0x0028C648 File Offset: 0x0028A848
			public unsafe int e_CurrentEditingCurve
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(ColorGradingModel.CurvesSettings.NativeFieldInfoPtr_e_CurrentEditingCurve);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(ColorGradingModel.CurvesSettings.NativeFieldInfoPtr_e_CurrentEditingCurve)) = value;
				}
			}

			// Token: 0x17003584 RID: 13700
			// (get) Token: 0x06009EB2 RID: 40626 RVA: 0x0028C66C File Offset: 0x0028A86C
			// (set) Token: 0x06009EB3 RID: 40627 RVA: 0x0028C694 File Offset: 0x0028A894
			public unsafe bool e_CurveY
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(ColorGradingModel.CurvesSettings.NativeFieldInfoPtr_e_CurveY);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(ColorGradingModel.CurvesSettings.NativeFieldInfoPtr_e_CurveY)) = value;
				}
			}

			// Token: 0x17003585 RID: 13701
			// (get) Token: 0x06009EB4 RID: 40628 RVA: 0x0028C6B8 File Offset: 0x0028A8B8
			// (set) Token: 0x06009EB5 RID: 40629 RVA: 0x0028C6E0 File Offset: 0x0028A8E0
			public unsafe bool e_CurveR
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(ColorGradingModel.CurvesSettings.NativeFieldInfoPtr_e_CurveR);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(ColorGradingModel.CurvesSettings.NativeFieldInfoPtr_e_CurveR)) = value;
				}
			}

			// Token: 0x17003586 RID: 13702
			// (get) Token: 0x06009EB6 RID: 40630 RVA: 0x0028C704 File Offset: 0x0028A904
			// (set) Token: 0x06009EB7 RID: 40631 RVA: 0x0028C72C File Offset: 0x0028A92C
			public unsafe bool e_CurveG
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(ColorGradingModel.CurvesSettings.NativeFieldInfoPtr_e_CurveG);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(ColorGradingModel.CurvesSettings.NativeFieldInfoPtr_e_CurveG)) = value;
				}
			}

			// Token: 0x17003587 RID: 13703
			// (get) Token: 0x06009EB8 RID: 40632 RVA: 0x0028C750 File Offset: 0x0028A950
			// (set) Token: 0x06009EB9 RID: 40633 RVA: 0x0028C778 File Offset: 0x0028A978
			public unsafe bool e_CurveB
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(ColorGradingModel.CurvesSettings.NativeFieldInfoPtr_e_CurveB);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(ColorGradingModel.CurvesSettings.NativeFieldInfoPtr_e_CurveB)) = value;
				}
			}

			// Token: 0x04006A4C RID: 27212
			private static readonly IntPtr NativeFieldInfoPtr_master;

			// Token: 0x04006A4D RID: 27213
			private static readonly IntPtr NativeFieldInfoPtr_red;

			// Token: 0x04006A4E RID: 27214
			private static readonly IntPtr NativeFieldInfoPtr_green;

			// Token: 0x04006A4F RID: 27215
			private static readonly IntPtr NativeFieldInfoPtr_blue;

			// Token: 0x04006A50 RID: 27216
			private static readonly IntPtr NativeFieldInfoPtr_hueVShue;

			// Token: 0x04006A51 RID: 27217
			private static readonly IntPtr NativeFieldInfoPtr_hueVSsat;

			// Token: 0x04006A52 RID: 27218
			private static readonly IntPtr NativeFieldInfoPtr_satVSsat;

			// Token: 0x04006A53 RID: 27219
			private static readonly IntPtr NativeFieldInfoPtr_lumVSsat;

			// Token: 0x04006A54 RID: 27220
			private static readonly IntPtr NativeFieldInfoPtr_e_CurrentEditingCurve;

			// Token: 0x04006A55 RID: 27221
			private static readonly IntPtr NativeFieldInfoPtr_e_CurveY;

			// Token: 0x04006A56 RID: 27222
			private static readonly IntPtr NativeFieldInfoPtr_e_CurveR;

			// Token: 0x04006A57 RID: 27223
			private static readonly IntPtr NativeFieldInfoPtr_e_CurveG;

			// Token: 0x04006A58 RID: 27224
			private static readonly IntPtr NativeFieldInfoPtr_e_CurveB;

			// Token: 0x04006A59 RID: 27225
			private static readonly IntPtr NativeMethodInfoPtr_get_defaultSettings_Public_Static_get_CurvesSettings_0;
		}

		// Token: 0x020005BD RID: 1469
		[Serializable]
		public sealed class Settings : ValueType
		{
			// Token: 0x1700358E RID: 13710
			// (get) Token: 0x06009EBA RID: 40634 RVA: 0x0028C79C File Offset: 0x0028A99C
			public unsafe static ColorGradingModel.Settings defaultSettings
			{
				[CallerCount(2)]
				[CachedScanResults(RefRangeStart = 648832, RefRangeEnd = 648834, XrefRangeStart = 648823, XrefRangeEnd = 648832, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
				get
				{
					IntPtr* ptr = null;
					IntPtr intPtr2;
					IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(ColorGradingModel.Settings.NativeMethodInfoPtr_get_defaultSettings_Public_Static_get_Settings_0, 0, (void**)ptr, ref intPtr2);
					Il2CppException.RaiseExceptionIfNecessary(intPtr2);
					return new ColorGradingModel.Settings(intPtr);
				}
			}

			// Token: 0x06009EBB RID: 40635 RVA: 0x0028C7D8 File Offset: 0x0028A9D8
			// Note: this type is marked as 'beforefieldinit'.
			static Settings()
			{
				Il2CppClassPointerStore<ColorGradingModel.Settings>.NativeClassPtr = IL2CPP.GetIl2CppNestedType(Il2CppClassPointerStore<ColorGradingModel>.NativeClassPtr, "Settings");
				IL2CPP.il2cpp_runtime_class_init(Il2CppClassPointerStore<ColorGradingModel.Settings>.NativeClassPtr);
				ColorGradingModel.Settings.NativeFieldInfoPtr_tonemapping = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<ColorGradingModel.Settings>.NativeClassPtr, "tonemapping");
				ColorGradingModel.Settings.NativeFieldInfoPtr_basic = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<ColorGradingModel.Settings>.NativeClassPtr, "basic");
				ColorGradingModel.Settings.NativeFieldInfoPtr_channelMixer = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<ColorGradingModel.Settings>.NativeClassPtr, "channelMixer");
				ColorGradingModel.Settings.NativeFieldInfoPtr_colorWheels = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<ColorGradingModel.Settings>.NativeClassPtr, "colorWheels");
				ColorGradingModel.Settings.NativeFieldInfoPtr_curves = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<ColorGradingModel.Settings>.NativeClassPtr, "curves");
				ColorGradingModel.Settings.NativeMethodInfoPtr_get_defaultSettings_Public_Static_get_Settings_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<ColorGradingModel.Settings>.NativeClassPtr, 100675709);
			}

			// Token: 0x06009EBC RID: 40636 RVA: 0x001295E7 File Offset: 0x001277E7
			public Settings(IntPtr pointer)
				: base(pointer)
			{
			}

			// Token: 0x06009EBD RID: 40637 RVA: 0x0028C87C File Offset: 0x0028AA7C
			public unsafe Settings()
			{
				IntPtr intPtr = stackalloc byte[(UIntPtr)IL2CPP.il2cpp_class_value_size(Il2CppClassPointerStore<ColorGradingModel.Settings>.NativeClassPtr, (UIntPtr)0)];
				base..ctor(IL2CPP.il2cpp_value_box(Il2CppClassPointerStore<ColorGradingModel.Settings>.NativeClassPtr, intPtr));
			}

			// Token: 0x17003589 RID: 13705
			// (get) Token: 0x06009EBE RID: 40638 RVA: 0x0028C8AC File Offset: 0x0028AAAC
			// (set) Token: 0x06009EBF RID: 40639 RVA: 0x0028C8D4 File Offset: 0x0028AAD4
			public unsafe ColorGradingModel.TonemappingSettings tonemapping
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(ColorGradingModel.Settings.NativeFieldInfoPtr_tonemapping);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(ColorGradingModel.Settings.NativeFieldInfoPtr_tonemapping)) = value;
				}
			}

			// Token: 0x1700358A RID: 13706
			// (get) Token: 0x06009EC0 RID: 40640 RVA: 0x0028C8F8 File Offset: 0x0028AAF8
			// (set) Token: 0x06009EC1 RID: 40641 RVA: 0x0028C920 File Offset: 0x0028AB20
			public unsafe ColorGradingModel.BasicSettings basic
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(ColorGradingModel.Settings.NativeFieldInfoPtr_basic);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(ColorGradingModel.Settings.NativeFieldInfoPtr_basic)) = value;
				}
			}

			// Token: 0x1700358B RID: 13707
			// (get) Token: 0x06009EC2 RID: 40642 RVA: 0x0028C944 File Offset: 0x0028AB44
			// (set) Token: 0x06009EC3 RID: 40643 RVA: 0x0028C96C File Offset: 0x0028AB6C
			public unsafe ColorGradingModel.ChannelMixerSettings channelMixer
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(ColorGradingModel.Settings.NativeFieldInfoPtr_channelMixer);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(ColorGradingModel.Settings.NativeFieldInfoPtr_channelMixer)) = value;
				}
			}

			// Token: 0x1700358C RID: 13708
			// (get) Token: 0x06009EC4 RID: 40644 RVA: 0x0028C990 File Offset: 0x0028AB90
			// (set) Token: 0x06009EC5 RID: 40645 RVA: 0x0028C9B8 File Offset: 0x0028ABB8
			public unsafe ColorGradingModel.ColorWheelsSettings colorWheels
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(ColorGradingModel.Settings.NativeFieldInfoPtr_colorWheels);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(ColorGradingModel.Settings.NativeFieldInfoPtr_colorWheels)) = value;
				}
			}

			// Token: 0x1700358D RID: 13709
			// (get) Token: 0x06009EC6 RID: 40646 RVA: 0x0028C9DC File Offset: 0x0028ABDC
			// (set) Token: 0x06009EC7 RID: 40647 RVA: 0x0028CA0E File Offset: 0x0028AC0E
			public ColorGradingModel.CurvesSettings curves
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(ColorGradingModel.Settings.NativeFieldInfoPtr_curves);
					return new ColorGradingModel.CurvesSettings(IL2CPP.il2cpp_value_box(Il2CppClassPointerStore<ColorGradingModel.CurvesSettings>.NativeClassPtr, intPtr));
				}
				set
				{
					cpblk(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(ColorGradingModel.Settings.NativeFieldInfoPtr_curves), IL2CPP.il2cpp_object_unbox(IL2CPP.Il2CppObjectBaseToPtr(value)), IL2CPP.il2cpp_class_value_size(Il2CppClassPointerStore<ColorGradingModel.CurvesSettings>.NativeClassPtr, (UIntPtr)0));
				}
			}

			// Token: 0x04006A5A RID: 27226
			private static readonly IntPtr NativeFieldInfoPtr_tonemapping;

			// Token: 0x04006A5B RID: 27227
			private static readonly IntPtr NativeFieldInfoPtr_basic;

			// Token: 0x04006A5C RID: 27228
			private static readonly IntPtr NativeFieldInfoPtr_channelMixer;

			// Token: 0x04006A5D RID: 27229
			private static readonly IntPtr NativeFieldInfoPtr_colorWheels;

			// Token: 0x04006A5E RID: 27230
			private static readonly IntPtr NativeFieldInfoPtr_curves;

			// Token: 0x04006A5F RID: 27231
			private static readonly IntPtr NativeMethodInfoPtr_get_defaultSettings_Public_Static_get_Settings_0;
		}
	}
}
