using System;
using Il2CppInterop.Common.Attributes;
using Il2CppInterop.Runtime;
using Il2CppInterop.Runtime.InteropTypes.Arrays;
using Il2CppSystem;

namespace UnityEngine.PostProcessing
{
	// Token: 0x02000580 RID: 1408
	public sealed class ColorGradingComponent : PostProcessingComponentRenderTexture<ColorGradingModel>
	{
		// Token: 0x1700349A RID: 13466
		// (get) Token: 0x06009C17 RID: 39959 RVA: 0x002834D0 File Offset: 0x002816D0
		public unsafe override bool active
		{
			[CallerCount(0)]
			[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 647167, XrefRangeEnd = 647168, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
			get
			{
				IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
				IntPtr* ptr = null;
				IntPtr intPtr2;
				IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(ColorGradingComponent.NativeMethodInfoPtr_get_active_Public_Virtual_get_Boolean_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
				return *IL2CPP.il2cpp_object_unbox(intPtr);
			}
		}

		// Token: 0x06009C18 RID: 39960 RVA: 0x00283520 File Offset: 0x00281720
		[CallerCount(0)]
		public unsafe float StandardIlluminantY(float x)
		{
			IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			checked
			{
				IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
				*ptr = ref x;
				IntPtr intPtr2;
				IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(ColorGradingComponent.NativeMethodInfoPtr_StandardIlluminantY_Private_Single_Single_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
				return *IL2CPP.il2cpp_object_unbox(intPtr);
			}
		}

		// Token: 0x06009C19 RID: 39961 RVA: 0x00283584 File Offset: 0x00281784
		[CallerCount(0)]
		public unsafe Vector3 CIExyToLMS(float x, float y)
		{
			IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			IntPtr* ptr;
			checked
			{
				ptr = stackalloc IntPtr[unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)];
				*ptr = ref x;
			}
			ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref y;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(ColorGradingComponent.NativeMethodInfoPtr_CIExyToLMS_Private_Vector3_Single_Single_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			return *IL2CPP.il2cpp_object_unbox(intPtr);
		}

		// Token: 0x06009C1A RID: 39962 RVA: 0x002835FC File Offset: 0x002817FC
		[CallerCount(0)]
		[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 647168, XrefRangeEnd = 647169, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
		public unsafe Vector3 CalculateColorBalance(float temperature, float tint)
		{
			IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			IntPtr* ptr;
			checked
			{
				ptr = stackalloc IntPtr[unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)];
				*ptr = ref temperature;
			}
			ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref tint;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(ColorGradingComponent.NativeMethodInfoPtr_CalculateColorBalance_Private_Vector3_Single_Single_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			return *IL2CPP.il2cpp_object_unbox(intPtr);
		}

		// Token: 0x06009C1B RID: 39963 RVA: 0x00283674 File Offset: 0x00281874
		[CallerCount(0)]
		[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 647169, XrefRangeEnd = 647172, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
		public unsafe static Color NormalizeColor(Color c)
		{
			checked
			{
				IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
				*ptr = ref c;
				IntPtr intPtr2;
				IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(ColorGradingComponent.NativeMethodInfoPtr_NormalizeColor_Private_Static_Color_Color_0, 0, (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
				return *IL2CPP.il2cpp_object_unbox(intPtr);
			}
		}

		// Token: 0x06009C1C RID: 39964 RVA: 0x002836C8 File Offset: 0x002818C8
		[CallerCount(0)]
		[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 647172, XrefRangeEnd = 647175, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
		public unsafe static Vector3 ClampVector(Vector3 v, float min, float max)
		{
			IntPtr* ptr;
			checked
			{
				ptr = stackalloc IntPtr[unchecked((UIntPtr)3) * (UIntPtr)sizeof(IntPtr)];
				*ptr = ref v;
			}
			ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref min;
			ptr[checked(unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref max;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(ColorGradingComponent.NativeMethodInfoPtr_ClampVector_Private_Static_Vector3_Vector3_Single_Single_0, 0, (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			return *IL2CPP.il2cpp_object_unbox(intPtr);
		}

		// Token: 0x06009C1D RID: 39965 RVA: 0x00283744 File Offset: 0x00281944
		[CallerCount(0)]
		[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 647175, XrefRangeEnd = 647181, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
		public unsafe static Vector3 GetLiftValue(Color lift)
		{
			checked
			{
				IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
				*ptr = ref lift;
				IntPtr intPtr2;
				IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(ColorGradingComponent.NativeMethodInfoPtr_GetLiftValue_Public_Static_Vector3_Color_0, 0, (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
				return *IL2CPP.il2cpp_object_unbox(intPtr);
			}
		}

		// Token: 0x06009C1E RID: 39966 RVA: 0x00283798 File Offset: 0x00281998
		[CallerCount(1)]
		[CachedScanResults(RefRangeStart = 647194, RefRangeEnd = 647195, XrefRangeStart = 647181, XrefRangeEnd = 647194, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
		public unsafe static Vector3 GetGammaValue(Color gamma)
		{
			checked
			{
				IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
				*ptr = ref gamma;
				IntPtr intPtr2;
				IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(ColorGradingComponent.NativeMethodInfoPtr_GetGammaValue_Public_Static_Vector3_Color_0, 0, (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
				return *IL2CPP.il2cpp_object_unbox(intPtr);
			}
		}

		// Token: 0x06009C1F RID: 39967 RVA: 0x002837EC File Offset: 0x002819EC
		[CallerCount(1)]
		[CachedScanResults(RefRangeStart = 647204, RefRangeEnd = 647205, XrefRangeStart = 647195, XrefRangeEnd = 647204, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
		public unsafe static Vector3 GetGainValue(Color gain)
		{
			checked
			{
				IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
				*ptr = ref gain;
				IntPtr intPtr2;
				IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(ColorGradingComponent.NativeMethodInfoPtr_GetGainValue_Public_Static_Vector3_Color_0, 0, (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
				return *IL2CPP.il2cpp_object_unbox(intPtr);
			}
		}

		// Token: 0x06009C20 RID: 39968 RVA: 0x00283840 File Offset: 0x00281A40
		[CallerCount(1)]
		[CachedScanResults(RefRangeStart = 647213, RefRangeEnd = 647214, XrefRangeStart = 647205, XrefRangeEnd = 647213, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
		public unsafe static void CalculateLiftGammaGain(Color lift, Color gamma, Color gain, out Vector3 outLift, out Vector3 outGamma, out Vector3 outGain)
		{
			IntPtr* ptr;
			checked
			{
				ptr = stackalloc IntPtr[unchecked((UIntPtr)6) * (UIntPtr)sizeof(IntPtr)];
				*ptr = ref lift;
			}
			ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref gamma;
			ptr[checked(unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref gain;
			ptr[checked(unchecked((UIntPtr)3) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = &outLift;
			ptr[checked(unchecked((UIntPtr)4) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = &outGamma;
			ptr[checked(unchecked((UIntPtr)5) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = &outGain;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(ColorGradingComponent.NativeMethodInfoPtr_CalculateLiftGammaGain_Public_Static_Void_Color_Color_Color_byref_Vector3_byref_Vector3_byref_Vector3_0, 0, (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		}

		// Token: 0x06009C21 RID: 39969 RVA: 0x002838E8 File Offset: 0x00281AE8
		[CallerCount(1)]
		[CachedScanResults(RefRangeStart = 647220, RefRangeEnd = 647221, XrefRangeStart = 647214, XrefRangeEnd = 647220, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
		public unsafe static Vector3 GetSlopeValue(Color slope)
		{
			checked
			{
				IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
				*ptr = ref slope;
				IntPtr intPtr2;
				IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(ColorGradingComponent.NativeMethodInfoPtr_GetSlopeValue_Public_Static_Vector3_Color_0, 0, (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
				return *IL2CPP.il2cpp_object_unbox(intPtr);
			}
		}

		// Token: 0x06009C22 RID: 39970 RVA: 0x0028393C File Offset: 0x00281B3C
		[CallerCount(1)]
		[CachedScanResults(RefRangeStart = 647230, RefRangeEnd = 647231, XrefRangeStart = 647221, XrefRangeEnd = 647230, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
		public unsafe static Vector3 GetPowerValue(Color power)
		{
			checked
			{
				IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
				*ptr = ref power;
				IntPtr intPtr2;
				IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(ColorGradingComponent.NativeMethodInfoPtr_GetPowerValue_Public_Static_Vector3_Color_0, 0, (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
				return *IL2CPP.il2cpp_object_unbox(intPtr);
			}
		}

		// Token: 0x06009C23 RID: 39971 RVA: 0x00283990 File Offset: 0x00281B90
		[CallerCount(0)]
		[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 647231, XrefRangeEnd = 647237, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
		public unsafe static Vector3 GetOffsetValue(Color offset)
		{
			checked
			{
				IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
				*ptr = ref offset;
				IntPtr intPtr2;
				IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(ColorGradingComponent.NativeMethodInfoPtr_GetOffsetValue_Public_Static_Vector3_Color_0, 0, (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
				return *IL2CPP.il2cpp_object_unbox(intPtr);
			}
		}

		// Token: 0x06009C24 RID: 39972 RVA: 0x002839E4 File Offset: 0x00281BE4
		[CallerCount(1)]
		[CachedScanResults(RefRangeStart = 647245, RefRangeEnd = 647246, XrefRangeStart = 647237, XrefRangeEnd = 647245, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
		public unsafe static void CalculateSlopePowerOffset(Color slope, Color power, Color offset, out Vector3 outSlope, out Vector3 outPower, out Vector3 outOffset)
		{
			IntPtr* ptr;
			checked
			{
				ptr = stackalloc IntPtr[unchecked((UIntPtr)6) * (UIntPtr)sizeof(IntPtr)];
				*ptr = ref slope;
			}
			ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref power;
			ptr[checked(unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref offset;
			ptr[checked(unchecked((UIntPtr)3) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = &outSlope;
			ptr[checked(unchecked((UIntPtr)4) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = &outPower;
			ptr[checked(unchecked((UIntPtr)5) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = &outOffset;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(ColorGradingComponent.NativeMethodInfoPtr_CalculateSlopePowerOffset_Public_Static_Void_Color_Color_Color_byref_Vector3_byref_Vector3_byref_Vector3_0, 0, (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		}

		// Token: 0x06009C25 RID: 39973 RVA: 0x00283A8C File Offset: 0x00281C8C
		[CallerCount(0)]
		[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 647246, XrefRangeEnd = 647247, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
		public unsafe TextureFormat GetCurveFormat()
		{
			IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			IntPtr* ptr = null;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(ColorGradingComponent.NativeMethodInfoPtr_GetCurveFormat_Private_TextureFormat_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			return *IL2CPP.il2cpp_object_unbox(intPtr);
		}

		// Token: 0x06009C26 RID: 39974 RVA: 0x00283ADC File Offset: 0x00281CDC
		[CallerCount(1)]
		[CachedScanResults(RefRangeStart = 647312, RefRangeEnd = 647313, XrefRangeStart = 647247, XrefRangeEnd = 647312, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
		public unsafe Texture2D GetCurveTexture()
		{
			IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			IntPtr* ptr = null;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(ColorGradingComponent.NativeMethodInfoPtr_GetCurveTexture_Private_Texture2D_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			IntPtr intPtr3 = intPtr;
			return (intPtr3 != 0) ? new Texture2D(intPtr3) : null;
		}

		// Token: 0x06009C27 RID: 39975 RVA: 0x00283B34 File Offset: 0x00281D34
		[CallerCount(0)]
		[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 647313, XrefRangeEnd = 647318, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
		public unsafe bool IsLogLutValid(RenderTexture lut)
		{
			IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			checked
			{
				IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
				*ptr = IL2CPP.Il2CppObjectBaseToPtr(lut);
				IntPtr intPtr2;
				IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(ColorGradingComponent.NativeMethodInfoPtr_IsLogLutValid_Private_Boolean_RenderTexture_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
				return *IL2CPP.il2cpp_object_unbox(intPtr);
			}
		}

		// Token: 0x06009C28 RID: 39976 RVA: 0x00283B9C File Offset: 0x00281D9C
		[CallerCount(0)]
		[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 647318, XrefRangeEnd = 647319, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
		public unsafe RenderTextureFormat GetLutFormat()
		{
			IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			IntPtr* ptr = null;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(ColorGradingComponent.NativeMethodInfoPtr_GetLutFormat_Private_RenderTextureFormat_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			return *IL2CPP.il2cpp_object_unbox(intPtr);
		}

		// Token: 0x06009C29 RID: 39977 RVA: 0x00283BEC File Offset: 0x00281DEC
		[CallerCount(1)]
		[CachedScanResults(RefRangeStart = 647417, RefRangeEnd = 647418, XrefRangeStart = 647319, XrefRangeEnd = 647417, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
		public unsafe void GenerateLut()
		{
			IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			IntPtr* ptr = null;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(ColorGradingComponent.NativeMethodInfoPtr_GenerateLut_Private_Void_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		}

		// Token: 0x06009C2A RID: 39978 RVA: 0x00283C30 File Offset: 0x00281E30
		[CallerCount(0)]
		[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 647418, XrefRangeEnd = 647443, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
		public unsafe override void Prepare(Material uberMaterial)
		{
			IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			checked
			{
				IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
				*ptr = IL2CPP.Il2CppObjectBaseToPtr(uberMaterial);
				IntPtr intPtr2;
				IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(ColorGradingComponent.NativeMethodInfoPtr_Prepare_Public_Virtual_Void_Material_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			}
		}

		// Token: 0x06009C2B RID: 39979 RVA: 0x00283C8C File Offset: 0x00281E8C
		[CallerCount(0)]
		[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 647443, XrefRangeEnd = 647452, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
		public unsafe void OnGUI()
		{
			IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			IntPtr* ptr = null;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(ColorGradingComponent.NativeMethodInfoPtr_OnGUI_Public_Void_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		}

		// Token: 0x06009C2C RID: 39980 RVA: 0x00283CD0 File Offset: 0x00281ED0
		[CallerCount(0)]
		[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 647452, XrefRangeEnd = 647458, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
		public unsafe override void OnDisable()
		{
			IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			IntPtr* ptr = null;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(ColorGradingComponent.NativeMethodInfoPtr_OnDisable_Public_Virtual_Void_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		}

		// Token: 0x06009C2D RID: 39981 RVA: 0x00283D14 File Offset: 0x00281F14
		[CallerCount(1)]
		[CachedScanResults(RefRangeStart = 647465, RefRangeEnd = 647466, XrefRangeStart = 647458, XrefRangeEnd = 647465, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
		public unsafe ColorGradingComponent()
			: this(IL2CPP.il2cpp_object_new(Il2CppClassPointerStore<ColorGradingComponent>.NativeClassPtr))
		{
			IntPtr* ptr = null;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(ColorGradingComponent.NativeMethodInfoPtr__ctor_Public_Void_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		}

		// Token: 0x06009C2E RID: 39982 RVA: 0x00283D60 File Offset: 0x00281F60
		// Note: this type is marked as 'beforefieldinit'.
		static ColorGradingComponent()
		{
			Il2CppClassPointerStore<ColorGradingComponent>.NativeClassPtr = IL2CPP.GetIl2CppClass("Assembly-CSharp.dll", "UnityEngine.PostProcessing", "ColorGradingComponent");
			IL2CPP.il2cpp_runtime_class_init(Il2CppClassPointerStore<ColorGradingComponent>.NativeClassPtr);
			ColorGradingComponent.NativeFieldInfoPtr_k_InternalLogLutSize = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<ColorGradingComponent>.NativeClassPtr, "k_InternalLogLutSize");
			ColorGradingComponent.NativeFieldInfoPtr_k_CurvePrecision = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<ColorGradingComponent>.NativeClassPtr, "k_CurvePrecision");
			ColorGradingComponent.NativeFieldInfoPtr_k_CurveStep = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<ColorGradingComponent>.NativeClassPtr, "k_CurveStep");
			ColorGradingComponent.NativeFieldInfoPtr_m_GradingCurves = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<ColorGradingComponent>.NativeClassPtr, "m_GradingCurves");
			ColorGradingComponent.NativeFieldInfoPtr_m_pixels = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<ColorGradingComponent>.NativeClassPtr, "m_pixels");
			ColorGradingComponent.NativeMethodInfoPtr_get_active_Public_Virtual_get_Boolean_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<ColorGradingComponent>.NativeClassPtr, 100675533);
			ColorGradingComponent.NativeMethodInfoPtr_StandardIlluminantY_Private_Single_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<ColorGradingComponent>.NativeClassPtr, 100675534);
			ColorGradingComponent.NativeMethodInfoPtr_CIExyToLMS_Private_Vector3_Single_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<ColorGradingComponent>.NativeClassPtr, 100675535);
			ColorGradingComponent.NativeMethodInfoPtr_CalculateColorBalance_Private_Vector3_Single_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<ColorGradingComponent>.NativeClassPtr, 100675536);
			ColorGradingComponent.NativeMethodInfoPtr_NormalizeColor_Private_Static_Color_Color_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<ColorGradingComponent>.NativeClassPtr, 100675537);
			ColorGradingComponent.NativeMethodInfoPtr_ClampVector_Private_Static_Vector3_Vector3_Single_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<ColorGradingComponent>.NativeClassPtr, 100675538);
			ColorGradingComponent.NativeMethodInfoPtr_GetLiftValue_Public_Static_Vector3_Color_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<ColorGradingComponent>.NativeClassPtr, 100675539);
			ColorGradingComponent.NativeMethodInfoPtr_GetGammaValue_Public_Static_Vector3_Color_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<ColorGradingComponent>.NativeClassPtr, 100675540);
			ColorGradingComponent.NativeMethodInfoPtr_GetGainValue_Public_Static_Vector3_Color_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<ColorGradingComponent>.NativeClassPtr, 100675541);
			ColorGradingComponent.NativeMethodInfoPtr_CalculateLiftGammaGain_Public_Static_Void_Color_Color_Color_byref_Vector3_byref_Vector3_byref_Vector3_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<ColorGradingComponent>.NativeClassPtr, 100675542);
			ColorGradingComponent.NativeMethodInfoPtr_GetSlopeValue_Public_Static_Vector3_Color_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<ColorGradingComponent>.NativeClassPtr, 100675543);
			ColorGradingComponent.NativeMethodInfoPtr_GetPowerValue_Public_Static_Vector3_Color_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<ColorGradingComponent>.NativeClassPtr, 100675544);
			ColorGradingComponent.NativeMethodInfoPtr_GetOffsetValue_Public_Static_Vector3_Color_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<ColorGradingComponent>.NativeClassPtr, 100675545);
			ColorGradingComponent.NativeMethodInfoPtr_CalculateSlopePowerOffset_Public_Static_Void_Color_Color_Color_byref_Vector3_byref_Vector3_byref_Vector3_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<ColorGradingComponent>.NativeClassPtr, 100675546);
			ColorGradingComponent.NativeMethodInfoPtr_GetCurveFormat_Private_TextureFormat_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<ColorGradingComponent>.NativeClassPtr, 100675547);
			ColorGradingComponent.NativeMethodInfoPtr_GetCurveTexture_Private_Texture2D_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<ColorGradingComponent>.NativeClassPtr, 100675548);
			ColorGradingComponent.NativeMethodInfoPtr_IsLogLutValid_Private_Boolean_RenderTexture_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<ColorGradingComponent>.NativeClassPtr, 100675549);
			ColorGradingComponent.NativeMethodInfoPtr_GetLutFormat_Private_RenderTextureFormat_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<ColorGradingComponent>.NativeClassPtr, 100675550);
			ColorGradingComponent.NativeMethodInfoPtr_GenerateLut_Private_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<ColorGradingComponent>.NativeClassPtr, 100675551);
			ColorGradingComponent.NativeMethodInfoPtr_Prepare_Public_Virtual_Void_Material_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<ColorGradingComponent>.NativeClassPtr, 100675552);
			ColorGradingComponent.NativeMethodInfoPtr_OnGUI_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<ColorGradingComponent>.NativeClassPtr, 100675553);
			ColorGradingComponent.NativeMethodInfoPtr_OnDisable_Public_Virtual_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<ColorGradingComponent>.NativeClassPtr, 100675554);
			ColorGradingComponent.NativeMethodInfoPtr__ctor_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<ColorGradingComponent>.NativeClassPtr, 100675555);
		}

		// Token: 0x06009C2F RID: 39983 RVA: 0x00283FC0 File Offset: 0x002821C0
		public ColorGradingComponent(IntPtr pointer)
			: base(pointer)
		{
		}

		// Token: 0x17003495 RID: 13461
		// (get) Token: 0x06009C30 RID: 39984 RVA: 0x00283FCC File Offset: 0x002821CC
		// (set) Token: 0x06009C31 RID: 39985 RVA: 0x00283FEA File Offset: 0x002821EA
		public unsafe static int k_InternalLogLutSize
		{
			get
			{
				int num;
				IL2CPP.il2cpp_field_static_get_value(ColorGradingComponent.NativeFieldInfoPtr_k_InternalLogLutSize, (void*)(&num));
				return num;
			}
			set
			{
				IL2CPP.il2cpp_field_static_set_value(ColorGradingComponent.NativeFieldInfoPtr_k_InternalLogLutSize, (void*)(&value));
			}
		}

		// Token: 0x17003496 RID: 13462
		// (get) Token: 0x06009C32 RID: 39986 RVA: 0x00283FFC File Offset: 0x002821FC
		// (set) Token: 0x06009C33 RID: 39987 RVA: 0x0028401A File Offset: 0x0028221A
		public unsafe static int k_CurvePrecision
		{
			get
			{
				int num;
				IL2CPP.il2cpp_field_static_get_value(ColorGradingComponent.NativeFieldInfoPtr_k_CurvePrecision, (void*)(&num));
				return num;
			}
			set
			{
				IL2CPP.il2cpp_field_static_set_value(ColorGradingComponent.NativeFieldInfoPtr_k_CurvePrecision, (void*)(&value));
			}
		}

		// Token: 0x17003497 RID: 13463
		// (get) Token: 0x06009C34 RID: 39988 RVA: 0x0028402C File Offset: 0x0028222C
		// (set) Token: 0x06009C35 RID: 39989 RVA: 0x0028404A File Offset: 0x0028224A
		public unsafe static float k_CurveStep
		{
			get
			{
				float num;
				IL2CPP.il2cpp_field_static_get_value(ColorGradingComponent.NativeFieldInfoPtr_k_CurveStep, (void*)(&num));
				return num;
			}
			set
			{
				IL2CPP.il2cpp_field_static_set_value(ColorGradingComponent.NativeFieldInfoPtr_k_CurveStep, (void*)(&value));
			}
		}

		// Token: 0x17003498 RID: 13464
		// (get) Token: 0x06009C36 RID: 39990 RVA: 0x0028405C File Offset: 0x0028225C
		// (set) Token: 0x06009C37 RID: 39991 RVA: 0x00284090 File Offset: 0x00282290
		public unsafe Texture2D m_GradingCurves
		{
			get
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(ColorGradingComponent.NativeFieldInfoPtr_m_GradingCurves);
				IntPtr intPtr2 = *intPtr;
				return (intPtr2 != 0) ? new Texture2D(intPtr2) : null;
			}
			set
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
				IL2CPP.il2cpp_gc_wbarrier_set_field(intPtr, intPtr + (IntPtr)IL2CPP.il2cpp_field_get_offset(ColorGradingComponent.NativeFieldInfoPtr_m_GradingCurves), IL2CPP.Il2CppObjectBaseToPtr(value));
			}
		}

		// Token: 0x17003499 RID: 13465
		// (get) Token: 0x06009C38 RID: 39992 RVA: 0x002840B8 File Offset: 0x002822B8
		// (set) Token: 0x06009C39 RID: 39993 RVA: 0x002840EC File Offset: 0x002822EC
		public unsafe Il2CppStructArray<Color> m_pixels
		{
			get
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(ColorGradingComponent.NativeFieldInfoPtr_m_pixels);
				IntPtr intPtr2 = *intPtr;
				return (intPtr2 != 0) ? new Il2CppStructArray<Color>(intPtr2) : null;
			}
			set
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
				IL2CPP.il2cpp_gc_wbarrier_set_field(intPtr, intPtr + (IntPtr)IL2CPP.il2cpp_field_get_offset(ColorGradingComponent.NativeFieldInfoPtr_m_pixels), IL2CPP.Il2CppObjectBaseToPtr(value));
			}
		}

		// Token: 0x0400683D RID: 26685
		private static readonly IntPtr NativeFieldInfoPtr_k_InternalLogLutSize;

		// Token: 0x0400683E RID: 26686
		private static readonly IntPtr NativeFieldInfoPtr_k_CurvePrecision;

		// Token: 0x0400683F RID: 26687
		private static readonly IntPtr NativeFieldInfoPtr_k_CurveStep;

		// Token: 0x04006840 RID: 26688
		private static readonly IntPtr NativeFieldInfoPtr_m_GradingCurves;

		// Token: 0x04006841 RID: 26689
		private static readonly IntPtr NativeFieldInfoPtr_m_pixels;

		// Token: 0x04006842 RID: 26690
		private static readonly IntPtr NativeMethodInfoPtr_get_active_Public_Virtual_get_Boolean_0;

		// Token: 0x04006843 RID: 26691
		private static readonly IntPtr NativeMethodInfoPtr_StandardIlluminantY_Private_Single_Single_0;

		// Token: 0x04006844 RID: 26692
		private static readonly IntPtr NativeMethodInfoPtr_CIExyToLMS_Private_Vector3_Single_Single_0;

		// Token: 0x04006845 RID: 26693
		private static readonly IntPtr NativeMethodInfoPtr_CalculateColorBalance_Private_Vector3_Single_Single_0;

		// Token: 0x04006846 RID: 26694
		private static readonly IntPtr NativeMethodInfoPtr_NormalizeColor_Private_Static_Color_Color_0;

		// Token: 0x04006847 RID: 26695
		private static readonly IntPtr NativeMethodInfoPtr_ClampVector_Private_Static_Vector3_Vector3_Single_Single_0;

		// Token: 0x04006848 RID: 26696
		private static readonly IntPtr NativeMethodInfoPtr_GetLiftValue_Public_Static_Vector3_Color_0;

		// Token: 0x04006849 RID: 26697
		private static readonly IntPtr NativeMethodInfoPtr_GetGammaValue_Public_Static_Vector3_Color_0;

		// Token: 0x0400684A RID: 26698
		private static readonly IntPtr NativeMethodInfoPtr_GetGainValue_Public_Static_Vector3_Color_0;

		// Token: 0x0400684B RID: 26699
		private static readonly IntPtr NativeMethodInfoPtr_CalculateLiftGammaGain_Public_Static_Void_Color_Color_Color_byref_Vector3_byref_Vector3_byref_Vector3_0;

		// Token: 0x0400684C RID: 26700
		private static readonly IntPtr NativeMethodInfoPtr_GetSlopeValue_Public_Static_Vector3_Color_0;

		// Token: 0x0400684D RID: 26701
		private static readonly IntPtr NativeMethodInfoPtr_GetPowerValue_Public_Static_Vector3_Color_0;

		// Token: 0x0400684E RID: 26702
		private static readonly IntPtr NativeMethodInfoPtr_GetOffsetValue_Public_Static_Vector3_Color_0;

		// Token: 0x0400684F RID: 26703
		private static readonly IntPtr NativeMethodInfoPtr_CalculateSlopePowerOffset_Public_Static_Void_Color_Color_Color_byref_Vector3_byref_Vector3_byref_Vector3_0;

		// Token: 0x04006850 RID: 26704
		private static readonly IntPtr NativeMethodInfoPtr_GetCurveFormat_Private_TextureFormat_0;

		// Token: 0x04006851 RID: 26705
		private static readonly IntPtr NativeMethodInfoPtr_GetCurveTexture_Private_Texture2D_0;

		// Token: 0x04006852 RID: 26706
		private static readonly IntPtr NativeMethodInfoPtr_IsLogLutValid_Private_Boolean_RenderTexture_0;

		// Token: 0x04006853 RID: 26707
		private static readonly IntPtr NativeMethodInfoPtr_GetLutFormat_Private_RenderTextureFormat_0;

		// Token: 0x04006854 RID: 26708
		private static readonly IntPtr NativeMethodInfoPtr_GenerateLut_Private_Void_0;

		// Token: 0x04006855 RID: 26709
		private static readonly IntPtr NativeMethodInfoPtr_Prepare_Public_Virtual_Void_Material_0;

		// Token: 0x04006856 RID: 26710
		private static readonly IntPtr NativeMethodInfoPtr_OnGUI_Public_Void_0;

		// Token: 0x04006857 RID: 26711
		private static readonly IntPtr NativeMethodInfoPtr_OnDisable_Public_Virtual_Void_0;

		// Token: 0x04006858 RID: 26712
		private static readonly IntPtr NativeMethodInfoPtr__ctor_Public_Void_0;

		// Token: 0x02000581 RID: 1409
		public static class Uniforms : Object
		{
			// Token: 0x06009C3A RID: 39994 RVA: 0x00284114 File Offset: 0x00282314
			// Note: this type is marked as 'beforefieldinit'.
			static Uniforms()
			{
				Il2CppClassPointerStore<ColorGradingComponent.Uniforms>.NativeClassPtr = IL2CPP.GetIl2CppNestedType(Il2CppClassPointerStore<ColorGradingComponent>.NativeClassPtr, "Uniforms");
				IL2CPP.il2cpp_runtime_class_init(Il2CppClassPointerStore<ColorGradingComponent.Uniforms>.NativeClassPtr);
				ColorGradingComponent.Uniforms.NativeFieldInfoPtr__LutParams = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<ColorGradingComponent.Uniforms>.NativeClassPtr, "_LutParams");
				ColorGradingComponent.Uniforms.NativeFieldInfoPtr__NeutralTonemapperParams1 = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<ColorGradingComponent.Uniforms>.NativeClassPtr, "_NeutralTonemapperParams1");
				ColorGradingComponent.Uniforms.NativeFieldInfoPtr__NeutralTonemapperParams2 = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<ColorGradingComponent.Uniforms>.NativeClassPtr, "_NeutralTonemapperParams2");
				ColorGradingComponent.Uniforms.NativeFieldInfoPtr__HueShift = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<ColorGradingComponent.Uniforms>.NativeClassPtr, "_HueShift");
				ColorGradingComponent.Uniforms.NativeFieldInfoPtr__Saturation = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<ColorGradingComponent.Uniforms>.NativeClassPtr, "_Saturation");
				ColorGradingComponent.Uniforms.NativeFieldInfoPtr__Contrast = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<ColorGradingComponent.Uniforms>.NativeClassPtr, "_Contrast");
				ColorGradingComponent.Uniforms.NativeFieldInfoPtr__Balance = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<ColorGradingComponent.Uniforms>.NativeClassPtr, "_Balance");
				ColorGradingComponent.Uniforms.NativeFieldInfoPtr__Lift = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<ColorGradingComponent.Uniforms>.NativeClassPtr, "_Lift");
				ColorGradingComponent.Uniforms.NativeFieldInfoPtr__InvGamma = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<ColorGradingComponent.Uniforms>.NativeClassPtr, "_InvGamma");
				ColorGradingComponent.Uniforms.NativeFieldInfoPtr__Gain = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<ColorGradingComponent.Uniforms>.NativeClassPtr, "_Gain");
				ColorGradingComponent.Uniforms.NativeFieldInfoPtr__Slope = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<ColorGradingComponent.Uniforms>.NativeClassPtr, "_Slope");
				ColorGradingComponent.Uniforms.NativeFieldInfoPtr__Power = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<ColorGradingComponent.Uniforms>.NativeClassPtr, "_Power");
				ColorGradingComponent.Uniforms.NativeFieldInfoPtr__Offset = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<ColorGradingComponent.Uniforms>.NativeClassPtr, "_Offset");
				ColorGradingComponent.Uniforms.NativeFieldInfoPtr__ChannelMixerRed = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<ColorGradingComponent.Uniforms>.NativeClassPtr, "_ChannelMixerRed");
				ColorGradingComponent.Uniforms.NativeFieldInfoPtr__ChannelMixerGreen = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<ColorGradingComponent.Uniforms>.NativeClassPtr, "_ChannelMixerGreen");
				ColorGradingComponent.Uniforms.NativeFieldInfoPtr__ChannelMixerBlue = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<ColorGradingComponent.Uniforms>.NativeClassPtr, "_ChannelMixerBlue");
				ColorGradingComponent.Uniforms.NativeFieldInfoPtr__Curves = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<ColorGradingComponent.Uniforms>.NativeClassPtr, "_Curves");
				ColorGradingComponent.Uniforms.NativeFieldInfoPtr__LogLut = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<ColorGradingComponent.Uniforms>.NativeClassPtr, "_LogLut");
				ColorGradingComponent.Uniforms.NativeFieldInfoPtr__LogLut_Params = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<ColorGradingComponent.Uniforms>.NativeClassPtr, "_LogLut_Params");
				ColorGradingComponent.Uniforms.NativeFieldInfoPtr__ExposureEV = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<ColorGradingComponent.Uniforms>.NativeClassPtr, "_ExposureEV");
			}

			// Token: 0x06009C3B RID: 39995 RVA: 0x0000A74C File Offset: 0x0000894C
			public Uniforms(IntPtr pointer)
				: base(pointer)
			{
			}

			// Token: 0x1700349B RID: 13467
			// (get) Token: 0x06009C3C RID: 39996 RVA: 0x002842D0 File Offset: 0x002824D0
			// (set) Token: 0x06009C3D RID: 39997 RVA: 0x002842EE File Offset: 0x002824EE
			public unsafe static int _LutParams
			{
				get
				{
					int num;
					IL2CPP.il2cpp_field_static_get_value(ColorGradingComponent.Uniforms.NativeFieldInfoPtr__LutParams, (void*)(&num));
					return num;
				}
				set
				{
					IL2CPP.il2cpp_field_static_set_value(ColorGradingComponent.Uniforms.NativeFieldInfoPtr__LutParams, (void*)(&value));
				}
			}

			// Token: 0x1700349C RID: 13468
			// (get) Token: 0x06009C3E RID: 39998 RVA: 0x00284300 File Offset: 0x00282500
			// (set) Token: 0x06009C3F RID: 39999 RVA: 0x0028431E File Offset: 0x0028251E
			public unsafe static int _NeutralTonemapperParams1
			{
				get
				{
					int num;
					IL2CPP.il2cpp_field_static_get_value(ColorGradingComponent.Uniforms.NativeFieldInfoPtr__NeutralTonemapperParams1, (void*)(&num));
					return num;
				}
				set
				{
					IL2CPP.il2cpp_field_static_set_value(ColorGradingComponent.Uniforms.NativeFieldInfoPtr__NeutralTonemapperParams1, (void*)(&value));
				}
			}

			// Token: 0x1700349D RID: 13469
			// (get) Token: 0x06009C40 RID: 40000 RVA: 0x00284330 File Offset: 0x00282530
			// (set) Token: 0x06009C41 RID: 40001 RVA: 0x0028434E File Offset: 0x0028254E
			public unsafe static int _NeutralTonemapperParams2
			{
				get
				{
					int num;
					IL2CPP.il2cpp_field_static_get_value(ColorGradingComponent.Uniforms.NativeFieldInfoPtr__NeutralTonemapperParams2, (void*)(&num));
					return num;
				}
				set
				{
					IL2CPP.il2cpp_field_static_set_value(ColorGradingComponent.Uniforms.NativeFieldInfoPtr__NeutralTonemapperParams2, (void*)(&value));
				}
			}

			// Token: 0x1700349E RID: 13470
			// (get) Token: 0x06009C42 RID: 40002 RVA: 0x00284360 File Offset: 0x00282560
			// (set) Token: 0x06009C43 RID: 40003 RVA: 0x0028437E File Offset: 0x0028257E
			public unsafe static int _HueShift
			{
				get
				{
					int num;
					IL2CPP.il2cpp_field_static_get_value(ColorGradingComponent.Uniforms.NativeFieldInfoPtr__HueShift, (void*)(&num));
					return num;
				}
				set
				{
					IL2CPP.il2cpp_field_static_set_value(ColorGradingComponent.Uniforms.NativeFieldInfoPtr__HueShift, (void*)(&value));
				}
			}

			// Token: 0x1700349F RID: 13471
			// (get) Token: 0x06009C44 RID: 40004 RVA: 0x00284390 File Offset: 0x00282590
			// (set) Token: 0x06009C45 RID: 40005 RVA: 0x002843AE File Offset: 0x002825AE
			public unsafe static int _Saturation
			{
				get
				{
					int num;
					IL2CPP.il2cpp_field_static_get_value(ColorGradingComponent.Uniforms.NativeFieldInfoPtr__Saturation, (void*)(&num));
					return num;
				}
				set
				{
					IL2CPP.il2cpp_field_static_set_value(ColorGradingComponent.Uniforms.NativeFieldInfoPtr__Saturation, (void*)(&value));
				}
			}

			// Token: 0x170034A0 RID: 13472
			// (get) Token: 0x06009C46 RID: 40006 RVA: 0x002843C0 File Offset: 0x002825C0
			// (set) Token: 0x06009C47 RID: 40007 RVA: 0x002843DE File Offset: 0x002825DE
			public unsafe static int _Contrast
			{
				get
				{
					int num;
					IL2CPP.il2cpp_field_static_get_value(ColorGradingComponent.Uniforms.NativeFieldInfoPtr__Contrast, (void*)(&num));
					return num;
				}
				set
				{
					IL2CPP.il2cpp_field_static_set_value(ColorGradingComponent.Uniforms.NativeFieldInfoPtr__Contrast, (void*)(&value));
				}
			}

			// Token: 0x170034A1 RID: 13473
			// (get) Token: 0x06009C48 RID: 40008 RVA: 0x002843F0 File Offset: 0x002825F0
			// (set) Token: 0x06009C49 RID: 40009 RVA: 0x0028440E File Offset: 0x0028260E
			public unsafe static int _Balance
			{
				get
				{
					int num;
					IL2CPP.il2cpp_field_static_get_value(ColorGradingComponent.Uniforms.NativeFieldInfoPtr__Balance, (void*)(&num));
					return num;
				}
				set
				{
					IL2CPP.il2cpp_field_static_set_value(ColorGradingComponent.Uniforms.NativeFieldInfoPtr__Balance, (void*)(&value));
				}
			}

			// Token: 0x170034A2 RID: 13474
			// (get) Token: 0x06009C4A RID: 40010 RVA: 0x00284420 File Offset: 0x00282620
			// (set) Token: 0x06009C4B RID: 40011 RVA: 0x0028443E File Offset: 0x0028263E
			public unsafe static int _Lift
			{
				get
				{
					int num;
					IL2CPP.il2cpp_field_static_get_value(ColorGradingComponent.Uniforms.NativeFieldInfoPtr__Lift, (void*)(&num));
					return num;
				}
				set
				{
					IL2CPP.il2cpp_field_static_set_value(ColorGradingComponent.Uniforms.NativeFieldInfoPtr__Lift, (void*)(&value));
				}
			}

			// Token: 0x170034A3 RID: 13475
			// (get) Token: 0x06009C4C RID: 40012 RVA: 0x00284450 File Offset: 0x00282650
			// (set) Token: 0x06009C4D RID: 40013 RVA: 0x0028446E File Offset: 0x0028266E
			public unsafe static int _InvGamma
			{
				get
				{
					int num;
					IL2CPP.il2cpp_field_static_get_value(ColorGradingComponent.Uniforms.NativeFieldInfoPtr__InvGamma, (void*)(&num));
					return num;
				}
				set
				{
					IL2CPP.il2cpp_field_static_set_value(ColorGradingComponent.Uniforms.NativeFieldInfoPtr__InvGamma, (void*)(&value));
				}
			}

			// Token: 0x170034A4 RID: 13476
			// (get) Token: 0x06009C4E RID: 40014 RVA: 0x00284480 File Offset: 0x00282680
			// (set) Token: 0x06009C4F RID: 40015 RVA: 0x0028449E File Offset: 0x0028269E
			public unsafe static int _Gain
			{
				get
				{
					int num;
					IL2CPP.il2cpp_field_static_get_value(ColorGradingComponent.Uniforms.NativeFieldInfoPtr__Gain, (void*)(&num));
					return num;
				}
				set
				{
					IL2CPP.il2cpp_field_static_set_value(ColorGradingComponent.Uniforms.NativeFieldInfoPtr__Gain, (void*)(&value));
				}
			}

			// Token: 0x170034A5 RID: 13477
			// (get) Token: 0x06009C50 RID: 40016 RVA: 0x002844B0 File Offset: 0x002826B0
			// (set) Token: 0x06009C51 RID: 40017 RVA: 0x002844CE File Offset: 0x002826CE
			public unsafe static int _Slope
			{
				get
				{
					int num;
					IL2CPP.il2cpp_field_static_get_value(ColorGradingComponent.Uniforms.NativeFieldInfoPtr__Slope, (void*)(&num));
					return num;
				}
				set
				{
					IL2CPP.il2cpp_field_static_set_value(ColorGradingComponent.Uniforms.NativeFieldInfoPtr__Slope, (void*)(&value));
				}
			}

			// Token: 0x170034A6 RID: 13478
			// (get) Token: 0x06009C52 RID: 40018 RVA: 0x002844E0 File Offset: 0x002826E0
			// (set) Token: 0x06009C53 RID: 40019 RVA: 0x002844FE File Offset: 0x002826FE
			public unsafe static int _Power
			{
				get
				{
					int num;
					IL2CPP.il2cpp_field_static_get_value(ColorGradingComponent.Uniforms.NativeFieldInfoPtr__Power, (void*)(&num));
					return num;
				}
				set
				{
					IL2CPP.il2cpp_field_static_set_value(ColorGradingComponent.Uniforms.NativeFieldInfoPtr__Power, (void*)(&value));
				}
			}

			// Token: 0x170034A7 RID: 13479
			// (get) Token: 0x06009C54 RID: 40020 RVA: 0x00284510 File Offset: 0x00282710
			// (set) Token: 0x06009C55 RID: 40021 RVA: 0x0028452E File Offset: 0x0028272E
			public unsafe static int _Offset
			{
				get
				{
					int num;
					IL2CPP.il2cpp_field_static_get_value(ColorGradingComponent.Uniforms.NativeFieldInfoPtr__Offset, (void*)(&num));
					return num;
				}
				set
				{
					IL2CPP.il2cpp_field_static_set_value(ColorGradingComponent.Uniforms.NativeFieldInfoPtr__Offset, (void*)(&value));
				}
			}

			// Token: 0x170034A8 RID: 13480
			// (get) Token: 0x06009C56 RID: 40022 RVA: 0x00284540 File Offset: 0x00282740
			// (set) Token: 0x06009C57 RID: 40023 RVA: 0x0028455E File Offset: 0x0028275E
			public unsafe static int _ChannelMixerRed
			{
				get
				{
					int num;
					IL2CPP.il2cpp_field_static_get_value(ColorGradingComponent.Uniforms.NativeFieldInfoPtr__ChannelMixerRed, (void*)(&num));
					return num;
				}
				set
				{
					IL2CPP.il2cpp_field_static_set_value(ColorGradingComponent.Uniforms.NativeFieldInfoPtr__ChannelMixerRed, (void*)(&value));
				}
			}

			// Token: 0x170034A9 RID: 13481
			// (get) Token: 0x06009C58 RID: 40024 RVA: 0x00284570 File Offset: 0x00282770
			// (set) Token: 0x06009C59 RID: 40025 RVA: 0x0028458E File Offset: 0x0028278E
			public unsafe static int _ChannelMixerGreen
			{
				get
				{
					int num;
					IL2CPP.il2cpp_field_static_get_value(ColorGradingComponent.Uniforms.NativeFieldInfoPtr__ChannelMixerGreen, (void*)(&num));
					return num;
				}
				set
				{
					IL2CPP.il2cpp_field_static_set_value(ColorGradingComponent.Uniforms.NativeFieldInfoPtr__ChannelMixerGreen, (void*)(&value));
				}
			}

			// Token: 0x170034AA RID: 13482
			// (get) Token: 0x06009C5A RID: 40026 RVA: 0x002845A0 File Offset: 0x002827A0
			// (set) Token: 0x06009C5B RID: 40027 RVA: 0x002845BE File Offset: 0x002827BE
			public unsafe static int _ChannelMixerBlue
			{
				get
				{
					int num;
					IL2CPP.il2cpp_field_static_get_value(ColorGradingComponent.Uniforms.NativeFieldInfoPtr__ChannelMixerBlue, (void*)(&num));
					return num;
				}
				set
				{
					IL2CPP.il2cpp_field_static_set_value(ColorGradingComponent.Uniforms.NativeFieldInfoPtr__ChannelMixerBlue, (void*)(&value));
				}
			}

			// Token: 0x170034AB RID: 13483
			// (get) Token: 0x06009C5C RID: 40028 RVA: 0x002845D0 File Offset: 0x002827D0
			// (set) Token: 0x06009C5D RID: 40029 RVA: 0x002845EE File Offset: 0x002827EE
			public unsafe static int _Curves
			{
				get
				{
					int num;
					IL2CPP.il2cpp_field_static_get_value(ColorGradingComponent.Uniforms.NativeFieldInfoPtr__Curves, (void*)(&num));
					return num;
				}
				set
				{
					IL2CPP.il2cpp_field_static_set_value(ColorGradingComponent.Uniforms.NativeFieldInfoPtr__Curves, (void*)(&value));
				}
			}

			// Token: 0x170034AC RID: 13484
			// (get) Token: 0x06009C5E RID: 40030 RVA: 0x00284600 File Offset: 0x00282800
			// (set) Token: 0x06009C5F RID: 40031 RVA: 0x0028461E File Offset: 0x0028281E
			public unsafe static int _LogLut
			{
				get
				{
					int num;
					IL2CPP.il2cpp_field_static_get_value(ColorGradingComponent.Uniforms.NativeFieldInfoPtr__LogLut, (void*)(&num));
					return num;
				}
				set
				{
					IL2CPP.il2cpp_field_static_set_value(ColorGradingComponent.Uniforms.NativeFieldInfoPtr__LogLut, (void*)(&value));
				}
			}

			// Token: 0x170034AD RID: 13485
			// (get) Token: 0x06009C60 RID: 40032 RVA: 0x00284630 File Offset: 0x00282830
			// (set) Token: 0x06009C61 RID: 40033 RVA: 0x0028464E File Offset: 0x0028284E
			public unsafe static int _LogLut_Params
			{
				get
				{
					int num;
					IL2CPP.il2cpp_field_static_get_value(ColorGradingComponent.Uniforms.NativeFieldInfoPtr__LogLut_Params, (void*)(&num));
					return num;
				}
				set
				{
					IL2CPP.il2cpp_field_static_set_value(ColorGradingComponent.Uniforms.NativeFieldInfoPtr__LogLut_Params, (void*)(&value));
				}
			}

			// Token: 0x170034AE RID: 13486
			// (get) Token: 0x06009C62 RID: 40034 RVA: 0x00284660 File Offset: 0x00282860
			// (set) Token: 0x06009C63 RID: 40035 RVA: 0x0028467E File Offset: 0x0028287E
			public unsafe static int _ExposureEV
			{
				get
				{
					int num;
					IL2CPP.il2cpp_field_static_get_value(ColorGradingComponent.Uniforms.NativeFieldInfoPtr__ExposureEV, (void*)(&num));
					return num;
				}
				set
				{
					IL2CPP.il2cpp_field_static_set_value(ColorGradingComponent.Uniforms.NativeFieldInfoPtr__ExposureEV, (void*)(&value));
				}
			}

			// Token: 0x04006859 RID: 26713
			private static readonly IntPtr NativeFieldInfoPtr__LutParams;

			// Token: 0x0400685A RID: 26714
			private static readonly IntPtr NativeFieldInfoPtr__NeutralTonemapperParams1;

			// Token: 0x0400685B RID: 26715
			private static readonly IntPtr NativeFieldInfoPtr__NeutralTonemapperParams2;

			// Token: 0x0400685C RID: 26716
			private static readonly IntPtr NativeFieldInfoPtr__HueShift;

			// Token: 0x0400685D RID: 26717
			private static readonly IntPtr NativeFieldInfoPtr__Saturation;

			// Token: 0x0400685E RID: 26718
			private static readonly IntPtr NativeFieldInfoPtr__Contrast;

			// Token: 0x0400685F RID: 26719
			private static readonly IntPtr NativeFieldInfoPtr__Balance;

			// Token: 0x04006860 RID: 26720
			private static readonly IntPtr NativeFieldInfoPtr__Lift;

			// Token: 0x04006861 RID: 26721
			private static readonly IntPtr NativeFieldInfoPtr__InvGamma;

			// Token: 0x04006862 RID: 26722
			private static readonly IntPtr NativeFieldInfoPtr__Gain;

			// Token: 0x04006863 RID: 26723
			private static readonly IntPtr NativeFieldInfoPtr__Slope;

			// Token: 0x04006864 RID: 26724
			private static readonly IntPtr NativeFieldInfoPtr__Power;

			// Token: 0x04006865 RID: 26725
			private static readonly IntPtr NativeFieldInfoPtr__Offset;

			// Token: 0x04006866 RID: 26726
			private static readonly IntPtr NativeFieldInfoPtr__ChannelMixerRed;

			// Token: 0x04006867 RID: 26727
			private static readonly IntPtr NativeFieldInfoPtr__ChannelMixerGreen;

			// Token: 0x04006868 RID: 26728
			private static readonly IntPtr NativeFieldInfoPtr__ChannelMixerBlue;

			// Token: 0x04006869 RID: 26729
			private static readonly IntPtr NativeFieldInfoPtr__Curves;

			// Token: 0x0400686A RID: 26730
			private static readonly IntPtr NativeFieldInfoPtr__LogLut;

			// Token: 0x0400686B RID: 26731
			private static readonly IntPtr NativeFieldInfoPtr__LogLut_Params;

			// Token: 0x0400686C RID: 26732
			private static readonly IntPtr NativeFieldInfoPtr__ExposureEV;
		}
	}
}
