using System;
using System.Collections.Generic;
using System.Runtime.CompilerServices;
using UnityEngine.Internal;
using UnityEngine.Scripting;

namespace UnityEngine.Rendering
{
	// Token: 0x020000AC RID: 172
	[UsedByNativeCode]
	public sealed class CommandBuffer : IDisposable
	{
		// Token: 0x06000C6B RID: 3179 RVA: 0x00011620 File Offset: 0x0000F820
		public CommandBuffer()
		{
			this.m_Ptr = IntPtr.Zero;
			CommandBuffer.InitBuffer(this);
		}

		// Token: 0x06000C6C RID: 3180 RVA: 0x0001163C File Offset: 0x0000F83C
		~CommandBuffer()
		{
			this.Dispose(false);
		}

		// Token: 0x06000C6D RID: 3181 RVA: 0x00011670 File Offset: 0x0000F870
		public void Dispose()
		{
			this.Dispose(true);
			GC.SuppressFinalize(this);
		}

		// Token: 0x06000C6E RID: 3182 RVA: 0x00011680 File Offset: 0x0000F880
		private void Dispose(bool disposing)
		{
			this.ReleaseBuffer();
			this.m_Ptr = IntPtr.Zero;
		}

		// Token: 0x06000C6F RID: 3183
		[GeneratedByOldBindingsGenerator]
		[MethodImpl(MethodImplOptions.InternalCall)]
		private static extern void InitBuffer(CommandBuffer buf);

		// Token: 0x06000C70 RID: 3184
		[ThreadAndSerializationSafe]
		[GeneratedByOldBindingsGenerator]
		[MethodImpl(MethodImplOptions.InternalCall)]
		private extern void ReleaseBuffer();

		// Token: 0x06000C71 RID: 3185 RVA: 0x00011694 File Offset: 0x0000F894
		public void Release()
		{
			this.Dispose();
		}

		// Token: 0x06000C72 RID: 3186
		[GeneratedByOldBindingsGenerator]
		[MethodImpl(MethodImplOptions.InternalCall)]
		public extern void SetComputeFloatParam(ComputeShader computeShader, string name, float val);

		// Token: 0x06000C73 RID: 3187
		[GeneratedByOldBindingsGenerator]
		[MethodImpl(MethodImplOptions.InternalCall)]
		public extern void SetComputeIntParam(ComputeShader computeShader, string name, int val);

		// Token: 0x06000C74 RID: 3188 RVA: 0x000116A0 File Offset: 0x0000F8A0
		public void SetComputeVectorParam(ComputeShader computeShader, string name, Vector4 val)
		{
			CommandBuffer.INTERNAL_CALL_SetComputeVectorParam(this, computeShader, name, ref val);
		}

		// Token: 0x06000C75 RID: 3189
		[GeneratedByOldBindingsGenerator]
		[MethodImpl(MethodImplOptions.InternalCall)]
		private static extern void INTERNAL_CALL_SetComputeVectorParam(CommandBuffer self, ComputeShader computeShader, string name, ref Vector4 val);

		// Token: 0x06000C76 RID: 3190 RVA: 0x000116B0 File Offset: 0x0000F8B0
		public void SetComputeFloatParams(ComputeShader computeShader, string name, params float[] values)
		{
			this.Internal_SetComputeFloats(computeShader, name, values);
		}

		// Token: 0x06000C77 RID: 3191
		[GeneratedByOldBindingsGenerator]
		[MethodImpl(MethodImplOptions.InternalCall)]
		private extern void Internal_SetComputeFloats(ComputeShader computeShader, string name, float[] values);

		// Token: 0x06000C78 RID: 3192 RVA: 0x000116BC File Offset: 0x0000F8BC
		public void SetComputeIntParams(ComputeShader computeShader, string name, params int[] values)
		{
			this.Internal_SetComputeInts(computeShader, name, values);
		}

		// Token: 0x06000C79 RID: 3193
		[GeneratedByOldBindingsGenerator]
		[MethodImpl(MethodImplOptions.InternalCall)]
		private extern void Internal_SetComputeInts(ComputeShader computeShader, string name, int[] values);

		// Token: 0x06000C7A RID: 3194 RVA: 0x000116C8 File Offset: 0x0000F8C8
		public void SetComputeTextureParam(ComputeShader computeShader, int kernelIndex, string name, RenderTargetIdentifier rt)
		{
			this.Internal_SetComputeTextureParam(computeShader, kernelIndex, name, ref rt);
		}

		// Token: 0x06000C7B RID: 3195
		[GeneratedByOldBindingsGenerator]
		[MethodImpl(MethodImplOptions.InternalCall)]
		private extern void Internal_SetComputeTextureParam(ComputeShader computeShader, int kernelIndex, string name, ref RenderTargetIdentifier rt);

		// Token: 0x06000C7C RID: 3196
		[GeneratedByOldBindingsGenerator]
		[MethodImpl(MethodImplOptions.InternalCall)]
		public extern void SetComputeBufferParam(ComputeShader computeShader, int kernelIndex, string name, ComputeBuffer buffer);

		// Token: 0x06000C7D RID: 3197 RVA: 0x000116D8 File Offset: 0x0000F8D8
		public void DispatchCompute(ComputeShader computeShader, int kernelIndex, int threadGroupsX, int threadGroupsY, int threadGroupsZ)
		{
			this.Internal_DispatchCompute(computeShader, kernelIndex, threadGroupsX, threadGroupsY, threadGroupsZ);
		}

		// Token: 0x06000C7E RID: 3198
		[GeneratedByOldBindingsGenerator]
		[MethodImpl(MethodImplOptions.InternalCall)]
		private extern void Internal_DispatchCompute(ComputeShader computeShader, int kernelIndex, int threadGroupsX, int threadGroupsY, int threadGroupsZ);

		// Token: 0x06000C7F RID: 3199 RVA: 0x000116E8 File Offset: 0x0000F8E8
		public void DispatchCompute(ComputeShader computeShader, int kernelIndex, ComputeBuffer indirectBuffer, uint argsOffset)
		{
			this.Internal_DispatchComputeIndirect(computeShader, kernelIndex, indirectBuffer, argsOffset);
		}

		// Token: 0x06000C80 RID: 3200
		[GeneratedByOldBindingsGenerator]
		[MethodImpl(MethodImplOptions.InternalCall)]
		private extern void Internal_DispatchComputeIndirect(ComputeShader computeShader, int kernelIndex, ComputeBuffer indirectBuffer, uint argsOffset);

		// Token: 0x06000C81 RID: 3201
		[GeneratedByOldBindingsGenerator]
		[MethodImpl(MethodImplOptions.InternalCall)]
		public extern void CopyCounterValue(ComputeBuffer src, ComputeBuffer dst, uint dstOffsetBytes);

		// Token: 0x170002D3 RID: 723
		// (get) Token: 0x06000C82 RID: 3202
		// (set) Token: 0x06000C83 RID: 3203
		public extern string name
		{
			[GeneratedByOldBindingsGenerator]
			[MethodImpl(MethodImplOptions.InternalCall)]
			get;
			[GeneratedByOldBindingsGenerator]
			[MethodImpl(MethodImplOptions.InternalCall)]
			set;
		}

		// Token: 0x170002D4 RID: 724
		// (get) Token: 0x06000C84 RID: 3204
		public extern int sizeInBytes
		{
			[GeneratedByOldBindingsGenerator]
			[MethodImpl(MethodImplOptions.InternalCall)]
			get;
		}

		// Token: 0x06000C85 RID: 3205
		[GeneratedByOldBindingsGenerator]
		[MethodImpl(MethodImplOptions.InternalCall)]
		public extern void Clear();

		// Token: 0x06000C86 RID: 3206 RVA: 0x000116F8 File Offset: 0x0000F8F8
		[ExcludeFromDocs]
		public void DrawMesh(Mesh mesh, Matrix4x4 matrix, Material material, int submeshIndex, int shaderPass)
		{
			MaterialPropertyBlock materialPropertyBlock = null;
			this.DrawMesh(mesh, matrix, material, submeshIndex, shaderPass, materialPropertyBlock);
		}

		// Token: 0x06000C87 RID: 3207 RVA: 0x00011718 File Offset: 0x0000F918
		[ExcludeFromDocs]
		public void DrawMesh(Mesh mesh, Matrix4x4 matrix, Material material, int submeshIndex)
		{
			MaterialPropertyBlock materialPropertyBlock = null;
			int num = -1;
			this.DrawMesh(mesh, matrix, material, submeshIndex, num, materialPropertyBlock);
		}

		// Token: 0x06000C88 RID: 3208 RVA: 0x00011738 File Offset: 0x0000F938
		[ExcludeFromDocs]
		public void DrawMesh(Mesh mesh, Matrix4x4 matrix, Material material)
		{
			MaterialPropertyBlock materialPropertyBlock = null;
			int num = -1;
			int num2 = 0;
			this.DrawMesh(mesh, matrix, material, num2, num, materialPropertyBlock);
		}

		// Token: 0x06000C89 RID: 3209 RVA: 0x00011758 File Offset: 0x0000F958
		public void DrawMesh(Mesh mesh, Matrix4x4 matrix, Material material, [DefaultValue("0")] int submeshIndex, [DefaultValue("-1")] int shaderPass, [DefaultValue("null")] MaterialPropertyBlock properties)
		{
			if (mesh == null)
			{
				throw new ArgumentNullException("mesh");
			}
			if (submeshIndex < 0 || submeshIndex >= mesh.subMeshCount)
			{
				submeshIndex = Mathf.Clamp(submeshIndex, 0, mesh.subMeshCount - 1);
				Debug.LogWarning(string.Format("submeshIndex out of range. Clampped to {0}.", submeshIndex));
			}
			if (material == null)
			{
				throw new ArgumentNullException("material");
			}
			this.Internal_DrawMesh(mesh, matrix, material, submeshIndex, shaderPass, properties);
		}

		// Token: 0x06000C8A RID: 3210 RVA: 0x000117E4 File Offset: 0x0000F9E4
		private void Internal_DrawMesh(Mesh mesh, Matrix4x4 matrix, Material material, int submeshIndex, int shaderPass, MaterialPropertyBlock properties)
		{
			CommandBuffer.INTERNAL_CALL_Internal_DrawMesh(this, mesh, ref matrix, material, submeshIndex, shaderPass, properties);
		}

		// Token: 0x06000C8B RID: 3211
		[GeneratedByOldBindingsGenerator]
		[MethodImpl(MethodImplOptions.InternalCall)]
		private static extern void INTERNAL_CALL_Internal_DrawMesh(CommandBuffer self, Mesh mesh, ref Matrix4x4 matrix, Material material, int submeshIndex, int shaderPass, MaterialPropertyBlock properties);

		// Token: 0x06000C8C RID: 3212 RVA: 0x000117F8 File Offset: 0x0000F9F8
		[ExcludeFromDocs]
		public void DrawRenderer(Renderer renderer, Material material, int submeshIndex)
		{
			int num = -1;
			this.DrawRenderer(renderer, material, submeshIndex, num);
		}

		// Token: 0x06000C8D RID: 3213 RVA: 0x00011814 File Offset: 0x0000FA14
		[ExcludeFromDocs]
		public void DrawRenderer(Renderer renderer, Material material)
		{
			int num = -1;
			int num2 = 0;
			this.DrawRenderer(renderer, material, num2, num);
		}

		// Token: 0x06000C8E RID: 3214 RVA: 0x00011830 File Offset: 0x0000FA30
		public void DrawRenderer(Renderer renderer, Material material, [DefaultValue("0")] int submeshIndex, [DefaultValue("-1")] int shaderPass)
		{
			if (renderer == null)
			{
				throw new ArgumentNullException("renderer");
			}
			if (submeshIndex < 0)
			{
				submeshIndex = Mathf.Max(submeshIndex, 0);
				Debug.LogWarning(string.Format("submeshIndex out of range. Clampped to {0}.", submeshIndex));
			}
			if (material == null)
			{
				throw new ArgumentNullException("material");
			}
			this.Internal_DrawRenderer(renderer, material, submeshIndex, shaderPass);
		}

		// Token: 0x06000C8F RID: 3215
		[GeneratedByOldBindingsGenerator]
		[MethodImpl(MethodImplOptions.InternalCall)]
		private extern void Internal_DrawRenderer(Renderer renderer, Material material, [DefaultValue("0")] int submeshIndex, [DefaultValue("-1")] int shaderPass);

		// Token: 0x06000C90 RID: 3216 RVA: 0x000118A0 File Offset: 0x0000FAA0
		[ExcludeFromDocs]
		private void Internal_DrawRenderer(Renderer renderer, Material material, int submeshIndex)
		{
			int num = -1;
			this.Internal_DrawRenderer(renderer, material, submeshIndex, num);
		}

		// Token: 0x06000C91 RID: 3217 RVA: 0x000118BC File Offset: 0x0000FABC
		[ExcludeFromDocs]
		private void Internal_DrawRenderer(Renderer renderer, Material material)
		{
			int num = -1;
			int num2 = 0;
			this.Internal_DrawRenderer(renderer, material, num2, num);
		}

		// Token: 0x06000C92 RID: 3218 RVA: 0x000118D8 File Offset: 0x0000FAD8
		[ExcludeFromDocs]
		public void DrawProcedural(Matrix4x4 matrix, Material material, int shaderPass, MeshTopology topology, int vertexCount, int instanceCount)
		{
			MaterialPropertyBlock materialPropertyBlock = null;
			this.DrawProcedural(matrix, material, shaderPass, topology, vertexCount, instanceCount, materialPropertyBlock);
		}

		// Token: 0x06000C93 RID: 3219 RVA: 0x000118F8 File Offset: 0x0000FAF8
		[ExcludeFromDocs]
		public void DrawProcedural(Matrix4x4 matrix, Material material, int shaderPass, MeshTopology topology, int vertexCount)
		{
			MaterialPropertyBlock materialPropertyBlock = null;
			int num = 1;
			this.DrawProcedural(matrix, material, shaderPass, topology, vertexCount, num, materialPropertyBlock);
		}

		// Token: 0x06000C94 RID: 3220 RVA: 0x0001191C File Offset: 0x0000FB1C
		public void DrawProcedural(Matrix4x4 matrix, Material material, int shaderPass, MeshTopology topology, int vertexCount, [DefaultValue("1")] int instanceCount, [DefaultValue("null")] MaterialPropertyBlock properties)
		{
			if (material == null)
			{
				throw new ArgumentNullException("material");
			}
			this.Internal_DrawProcedural(matrix, material, shaderPass, topology, vertexCount, instanceCount, properties);
		}

		// Token: 0x06000C95 RID: 3221 RVA: 0x00011948 File Offset: 0x0000FB48
		private void Internal_DrawProcedural(Matrix4x4 matrix, Material material, int shaderPass, MeshTopology topology, int vertexCount, int instanceCount, MaterialPropertyBlock properties)
		{
			CommandBuffer.INTERNAL_CALL_Internal_DrawProcedural(this, ref matrix, material, shaderPass, topology, vertexCount, instanceCount, properties);
		}

		// Token: 0x06000C96 RID: 3222
		[GeneratedByOldBindingsGenerator]
		[MethodImpl(MethodImplOptions.InternalCall)]
		private static extern void INTERNAL_CALL_Internal_DrawProcedural(CommandBuffer self, ref Matrix4x4 matrix, Material material, int shaderPass, MeshTopology topology, int vertexCount, int instanceCount, MaterialPropertyBlock properties);

		// Token: 0x06000C97 RID: 3223 RVA: 0x00011960 File Offset: 0x0000FB60
		[ExcludeFromDocs]
		public void DrawProceduralIndirect(Matrix4x4 matrix, Material material, int shaderPass, MeshTopology topology, ComputeBuffer bufferWithArgs, int argsOffset)
		{
			MaterialPropertyBlock materialPropertyBlock = null;
			this.DrawProceduralIndirect(matrix, material, shaderPass, topology, bufferWithArgs, argsOffset, materialPropertyBlock);
		}

		// Token: 0x06000C98 RID: 3224 RVA: 0x00011980 File Offset: 0x0000FB80
		[ExcludeFromDocs]
		public void DrawProceduralIndirect(Matrix4x4 matrix, Material material, int shaderPass, MeshTopology topology, ComputeBuffer bufferWithArgs)
		{
			MaterialPropertyBlock materialPropertyBlock = null;
			int num = 0;
			this.DrawProceduralIndirect(matrix, material, shaderPass, topology, bufferWithArgs, num, materialPropertyBlock);
		}

		// Token: 0x06000C99 RID: 3225 RVA: 0x000119A4 File Offset: 0x0000FBA4
		public void DrawProceduralIndirect(Matrix4x4 matrix, Material material, int shaderPass, MeshTopology topology, ComputeBuffer bufferWithArgs, [DefaultValue("0")] int argsOffset, [DefaultValue("null")] MaterialPropertyBlock properties)
		{
			if (material == null)
			{
				throw new ArgumentNullException("material");
			}
			if (bufferWithArgs == null)
			{
				throw new ArgumentNullException("bufferWithArgs");
			}
			this.Internal_DrawProceduralIndirect(matrix, material, shaderPass, topology, bufferWithArgs, argsOffset, properties);
		}

		// Token: 0x06000C9A RID: 3226 RVA: 0x000119E4 File Offset: 0x0000FBE4
		private void Internal_DrawProceduralIndirect(Matrix4x4 matrix, Material material, int shaderPass, MeshTopology topology, ComputeBuffer bufferWithArgs, int argsOffset, MaterialPropertyBlock properties)
		{
			CommandBuffer.INTERNAL_CALL_Internal_DrawProceduralIndirect(this, ref matrix, material, shaderPass, topology, bufferWithArgs, argsOffset, properties);
		}

		// Token: 0x06000C9B RID: 3227
		[GeneratedByOldBindingsGenerator]
		[MethodImpl(MethodImplOptions.InternalCall)]
		private static extern void INTERNAL_CALL_Internal_DrawProceduralIndirect(CommandBuffer self, ref Matrix4x4 matrix, Material material, int shaderPass, MeshTopology topology, ComputeBuffer bufferWithArgs, int argsOffset, MaterialPropertyBlock properties);

		// Token: 0x06000C9C RID: 3228 RVA: 0x000119FC File Offset: 0x0000FBFC
		[ExcludeFromDocs]
		public void DrawMeshInstanced(Mesh mesh, int submeshIndex, Material material, int shaderPass, Matrix4x4[] matrices, int count)
		{
			MaterialPropertyBlock materialPropertyBlock = null;
			this.DrawMeshInstanced(mesh, submeshIndex, material, shaderPass, matrices, count, materialPropertyBlock);
		}

		// Token: 0x06000C9D RID: 3229 RVA: 0x00011A1C File Offset: 0x0000FC1C
		[ExcludeFromDocs]
		public void DrawMeshInstanced(Mesh mesh, int submeshIndex, Material material, int shaderPass, Matrix4x4[] matrices)
		{
			MaterialPropertyBlock materialPropertyBlock = null;
			int num = matrices.Length;
			this.DrawMeshInstanced(mesh, submeshIndex, material, shaderPass, matrices, num, materialPropertyBlock);
		}

		// Token: 0x06000C9E RID: 3230 RVA: 0x00011A40 File Offset: 0x0000FC40
		public void DrawMeshInstanced(Mesh mesh, int submeshIndex, Material material, int shaderPass, Matrix4x4[] matrices, [DefaultValue("matrices.Length")] int count, [DefaultValue("null")] MaterialPropertyBlock properties)
		{
			if (!SystemInfo.supportsInstancing)
			{
				throw new InvalidOperationException("DrawMeshInstanced is not supported.");
			}
			if (mesh == null)
			{
				throw new ArgumentNullException("mesh");
			}
			if (submeshIndex < 0 || submeshIndex >= mesh.subMeshCount)
			{
				throw new ArgumentOutOfRangeException("submeshIndex", "submeshIndex out of range.");
			}
			if (material == null)
			{
				throw new ArgumentNullException("material");
			}
			if (matrices == null)
			{
				throw new ArgumentNullException("matrices");
			}
			if (count < 0 || count > Mathf.Min(Graphics.kMaxDrawMeshInstanceCount, matrices.Length))
			{
				throw new ArgumentOutOfRangeException("count", string.Format("Count must be in the range of 0 to {0}.", Mathf.Min(Graphics.kMaxDrawMeshInstanceCount, matrices.Length)));
			}
			if (count > 0)
			{
				this.Internal_DrawMeshInstanced(mesh, submeshIndex, material, shaderPass, matrices, count, properties);
			}
		}

		// Token: 0x06000C9F RID: 3231
		[GeneratedByOldBindingsGenerator]
		[MethodImpl(MethodImplOptions.InternalCall)]
		private extern void Internal_DrawMeshInstanced(Mesh mesh, int submeshIndex, Material material, int shaderPass, Matrix4x4[] matrices, int count, MaterialPropertyBlock properties);

		// Token: 0x06000CA0 RID: 3232 RVA: 0x00011B24 File Offset: 0x0000FD24
		[ExcludeFromDocs]
		public void DrawMeshInstancedIndirect(Mesh mesh, int submeshIndex, Material material, int shaderPass, ComputeBuffer bufferWithArgs, int argsOffset)
		{
			MaterialPropertyBlock materialPropertyBlock = null;
			this.DrawMeshInstancedIndirect(mesh, submeshIndex, material, shaderPass, bufferWithArgs, argsOffset, materialPropertyBlock);
		}

		// Token: 0x06000CA1 RID: 3233 RVA: 0x00011B44 File Offset: 0x0000FD44
		[ExcludeFromDocs]
		public void DrawMeshInstancedIndirect(Mesh mesh, int submeshIndex, Material material, int shaderPass, ComputeBuffer bufferWithArgs)
		{
			MaterialPropertyBlock materialPropertyBlock = null;
			int num = 0;
			this.DrawMeshInstancedIndirect(mesh, submeshIndex, material, shaderPass, bufferWithArgs, num, materialPropertyBlock);
		}

		// Token: 0x06000CA2 RID: 3234 RVA: 0x00011B68 File Offset: 0x0000FD68
		public void DrawMeshInstancedIndirect(Mesh mesh, int submeshIndex, Material material, int shaderPass, ComputeBuffer bufferWithArgs, [DefaultValue("0")] int argsOffset, [DefaultValue("null")] MaterialPropertyBlock properties)
		{
			if (!SystemInfo.supportsInstancing)
			{
				throw new InvalidOperationException("Instancing is not supported.");
			}
			if (mesh == null)
			{
				throw new ArgumentNullException("mesh");
			}
			if (submeshIndex < 0 || submeshIndex >= mesh.subMeshCount)
			{
				throw new ArgumentOutOfRangeException("submeshIndex", "submeshIndex out of range.");
			}
			if (material == null)
			{
				throw new ArgumentNullException("material");
			}
			if (bufferWithArgs == null)
			{
				throw new ArgumentNullException("bufferWithArgs");
			}
			this.Internal_DrawMeshInstancedIndirect(mesh, submeshIndex, material, shaderPass, bufferWithArgs, argsOffset, properties);
		}

		// Token: 0x06000CA3 RID: 3235
		[GeneratedByOldBindingsGenerator]
		[MethodImpl(MethodImplOptions.InternalCall)]
		private extern void Internal_DrawMeshInstancedIndirect(Mesh mesh, int submeshIndex, Material material, int shaderPass, ComputeBuffer bufferWithArgs, int argsOffset, MaterialPropertyBlock properties);

		// Token: 0x06000CA4 RID: 3236 RVA: 0x00011C00 File Offset: 0x0000FE00
		public void SetRenderTarget(RenderTargetIdentifier rt)
		{
			this.SetRenderTarget_Single(ref rt, 0, CubemapFace.Unknown, 0);
		}

		// Token: 0x06000CA5 RID: 3237 RVA: 0x00011C10 File Offset: 0x0000FE10
		public void SetRenderTarget(RenderTargetIdentifier rt, int mipLevel)
		{
			this.SetRenderTarget_Single(ref rt, mipLevel, CubemapFace.Unknown, 0);
		}

		// Token: 0x06000CA6 RID: 3238 RVA: 0x00011C20 File Offset: 0x0000FE20
		public void SetRenderTarget(RenderTargetIdentifier rt, int mipLevel, CubemapFace cubemapFace)
		{
			this.SetRenderTarget_Single(ref rt, mipLevel, cubemapFace, 0);
		}

		// Token: 0x06000CA7 RID: 3239 RVA: 0x00011C30 File Offset: 0x0000FE30
		public void SetRenderTarget(RenderTargetIdentifier rt, int mipLevel, CubemapFace cubemapFace, int depthSlice)
		{
			this.SetRenderTarget_Single(ref rt, mipLevel, cubemapFace, depthSlice);
		}

		// Token: 0x06000CA8 RID: 3240 RVA: 0x00011C40 File Offset: 0x0000FE40
		public void SetRenderTarget(RenderTargetIdentifier color, RenderTargetIdentifier depth)
		{
			this.SetRenderTarget_ColDepth(ref color, ref depth, 0, CubemapFace.Unknown, 0);
		}

		// Token: 0x06000CA9 RID: 3241 RVA: 0x00011C50 File Offset: 0x0000FE50
		public void SetRenderTarget(RenderTargetIdentifier color, RenderTargetIdentifier depth, int mipLevel)
		{
			this.SetRenderTarget_ColDepth(ref color, ref depth, mipLevel, CubemapFace.Unknown, 0);
		}

		// Token: 0x06000CAA RID: 3242 RVA: 0x00011C60 File Offset: 0x0000FE60
		public void SetRenderTarget(RenderTargetIdentifier color, RenderTargetIdentifier depth, int mipLevel, CubemapFace cubemapFace)
		{
			this.SetRenderTarget_ColDepth(ref color, ref depth, mipLevel, cubemapFace, 0);
		}

		// Token: 0x06000CAB RID: 3243 RVA: 0x00011C74 File Offset: 0x0000FE74
		public void SetRenderTarget(RenderTargetIdentifier color, RenderTargetIdentifier depth, int mipLevel, CubemapFace cubemapFace, int depthSlice)
		{
			this.SetRenderTarget_ColDepth(ref color, ref depth, mipLevel, cubemapFace, depthSlice);
		}

		// Token: 0x06000CAC RID: 3244 RVA: 0x00011C88 File Offset: 0x0000FE88
		public void SetRenderTarget(RenderTargetIdentifier[] colors, RenderTargetIdentifier depth)
		{
			this.SetRenderTarget_Multiple(colors, ref depth);
		}

		// Token: 0x06000CAD RID: 3245
		[GeneratedByOldBindingsGenerator]
		[MethodImpl(MethodImplOptions.InternalCall)]
		private extern void SetRenderTarget_Single(ref RenderTargetIdentifier rt, int mipLevel, CubemapFace cubemapFace, int depthSlice);

		// Token: 0x06000CAE RID: 3246
		[GeneratedByOldBindingsGenerator]
		[MethodImpl(MethodImplOptions.InternalCall)]
		private extern void SetRenderTarget_ColDepth(ref RenderTargetIdentifier color, ref RenderTargetIdentifier depth, int mipLevel, CubemapFace cubemapFace, int depthSlice);

		// Token: 0x06000CAF RID: 3247
		[GeneratedByOldBindingsGenerator]
		[MethodImpl(MethodImplOptions.InternalCall)]
		private extern void SetRenderTarget_Multiple(RenderTargetIdentifier[] color, ref RenderTargetIdentifier depth);

		// Token: 0x06000CB0 RID: 3248 RVA: 0x00011C94 File Offset: 0x0000FE94
		public void CopyTexture(RenderTargetIdentifier src, RenderTargetIdentifier dst)
		{
			this.CopyTexture_Internal(ref src, -1, -1, -1, -1, -1, -1, ref dst, -1, -1, -1, -1, 1);
		}

		// Token: 0x06000CB1 RID: 3249 RVA: 0x00011CB8 File Offset: 0x0000FEB8
		public void CopyTexture(RenderTargetIdentifier src, int srcElement, RenderTargetIdentifier dst, int dstElement)
		{
			this.CopyTexture_Internal(ref src, srcElement, -1, -1, -1, -1, -1, ref dst, dstElement, -1, -1, -1, 2);
		}

		// Token: 0x06000CB2 RID: 3250 RVA: 0x00011CDC File Offset: 0x0000FEDC
		public void CopyTexture(RenderTargetIdentifier src, int srcElement, int srcMip, RenderTargetIdentifier dst, int dstElement, int dstMip)
		{
			this.CopyTexture_Internal(ref src, srcElement, srcMip, -1, -1, -1, -1, ref dst, dstElement, dstMip, -1, -1, 3);
		}

		// Token: 0x06000CB3 RID: 3251 RVA: 0x00011D04 File Offset: 0x0000FF04
		public void CopyTexture(RenderTargetIdentifier src, int srcElement, int srcMip, int srcX, int srcY, int srcWidth, int srcHeight, RenderTargetIdentifier dst, int dstElement, int dstMip, int dstX, int dstY)
		{
			this.CopyTexture_Internal(ref src, srcElement, srcMip, srcX, srcY, srcWidth, srcHeight, ref dst, dstElement, dstMip, dstX, dstY, 4);
		}

		// Token: 0x06000CB4 RID: 3252 RVA: 0x00011D30 File Offset: 0x0000FF30
		public void SetViewport(Rect pixelRect)
		{
			CommandBuffer.INTERNAL_CALL_SetViewport(this, ref pixelRect);
		}

		// Token: 0x06000CB5 RID: 3253
		[GeneratedByOldBindingsGenerator]
		[MethodImpl(MethodImplOptions.InternalCall)]
		private static extern void INTERNAL_CALL_SetViewport(CommandBuffer self, ref Rect pixelRect);

		// Token: 0x06000CB6 RID: 3254
		[GeneratedByOldBindingsGenerator]
		[MethodImpl(MethodImplOptions.InternalCall)]
		private extern void CopyTexture_Internal(ref RenderTargetIdentifier src, int srcElement, int srcMip, int srcX, int srcY, int srcWidth, int srcHeight, ref RenderTargetIdentifier dst, int dstElement, int dstMip, int dstX, int dstY, int mode);

		// Token: 0x06000CB7 RID: 3255 RVA: 0x00011D3C File Offset: 0x0000FF3C
		public void Blit(Texture source, RenderTargetIdentifier dest)
		{
			this.Blit_Texture(source, ref dest, null, -1, new Vector2(1f, 1f), new Vector2(0f, 0f));
		}

		// Token: 0x06000CB8 RID: 3256 RVA: 0x00011D68 File Offset: 0x0000FF68
		public void Blit(Texture source, RenderTargetIdentifier dest, Vector2 scale, Vector2 offset)
		{
			this.Blit_Texture(source, ref dest, null, -1, scale, offset);
		}

		// Token: 0x06000CB9 RID: 3257 RVA: 0x00011D7C File Offset: 0x0000FF7C
		public void Blit(Texture source, RenderTargetIdentifier dest, Material mat)
		{
			this.Blit_Texture(source, ref dest, mat, -1, new Vector2(1f, 1f), new Vector2(0f, 0f));
		}

		// Token: 0x06000CBA RID: 3258 RVA: 0x00011DA8 File Offset: 0x0000FFA8
		public void Blit(Texture source, RenderTargetIdentifier dest, Material mat, int pass)
		{
			this.Blit_Texture(source, ref dest, mat, pass, new Vector2(1f, 1f), new Vector2(0f, 0f));
		}

		// Token: 0x06000CBB RID: 3259 RVA: 0x00011DD8 File Offset: 0x0000FFD8
		private void Blit_Texture(Texture source, ref RenderTargetIdentifier dest, Material mat, int pass, Vector2 scale, Vector2 offset)
		{
			CommandBuffer.INTERNAL_CALL_Blit_Texture(this, source, ref dest, mat, pass, ref scale, ref offset);
		}

		// Token: 0x06000CBC RID: 3260
		[GeneratedByOldBindingsGenerator]
		[MethodImpl(MethodImplOptions.InternalCall)]
		private static extern void INTERNAL_CALL_Blit_Texture(CommandBuffer self, Texture source, ref RenderTargetIdentifier dest, Material mat, int pass, ref Vector2 scale, ref Vector2 offset);

		// Token: 0x06000CBD RID: 3261 RVA: 0x00011DEC File Offset: 0x0000FFEC
		public void Blit(RenderTargetIdentifier source, RenderTargetIdentifier dest)
		{
			this.Blit_Identifier(ref source, ref dest, null, -1, new Vector2(1f, 1f), new Vector2(0f, 0f));
		}

		// Token: 0x06000CBE RID: 3262 RVA: 0x00011E1C File Offset: 0x0001001C
		public void Blit(RenderTargetIdentifier source, RenderTargetIdentifier dest, Vector2 scale, Vector2 offset)
		{
			this.Blit_Identifier(ref source, ref dest, null, -1, scale, offset);
		}

		// Token: 0x06000CBF RID: 3263 RVA: 0x00011E30 File Offset: 0x00010030
		public void Blit(RenderTargetIdentifier source, RenderTargetIdentifier dest, Material mat)
		{
			this.Blit_Identifier(ref source, ref dest, mat, -1, new Vector2(1f, 1f), new Vector2(0f, 0f));
		}

		// Token: 0x06000CC0 RID: 3264 RVA: 0x00011E60 File Offset: 0x00010060
		public void Blit(RenderTargetIdentifier source, RenderTargetIdentifier dest, Material mat, int pass)
		{
			this.Blit_Identifier(ref source, ref dest, mat, pass, new Vector2(1f, 1f), new Vector2(0f, 0f));
		}

		// Token: 0x06000CC1 RID: 3265 RVA: 0x00011E90 File Offset: 0x00010090
		private void Blit_Identifier(ref RenderTargetIdentifier source, ref RenderTargetIdentifier dest, Material mat, int pass, Vector2 scale, Vector2 offset)
		{
			CommandBuffer.INTERNAL_CALL_Blit_Identifier(this, ref source, ref dest, mat, pass, ref scale, ref offset);
		}

		// Token: 0x06000CC2 RID: 3266
		[GeneratedByOldBindingsGenerator]
		[MethodImpl(MethodImplOptions.InternalCall)]
		private static extern void INTERNAL_CALL_Blit_Identifier(CommandBuffer self, ref RenderTargetIdentifier source, ref RenderTargetIdentifier dest, Material mat, int pass, ref Vector2 scale, ref Vector2 offset);

		// Token: 0x06000CC3 RID: 3267
		[GeneratedByOldBindingsGenerator]
		[MethodImpl(MethodImplOptions.InternalCall)]
		public extern void GetTemporaryRT(int nameID, int width, int height, [DefaultValue("0")] int depthBuffer, [DefaultValue("FilterMode.Point")] FilterMode filter, [DefaultValue("RenderTextureFormat.Default")] RenderTextureFormat format, [DefaultValue("RenderTextureReadWrite.Default")] RenderTextureReadWrite readWrite, [DefaultValue("1")] int antiAliasing, [DefaultValue("false")] bool enableRandomWrite, [DefaultValue("RenderTextureMemoryless.None")] RenderTextureMemoryless memorylessMode);

		// Token: 0x06000CC4 RID: 3268 RVA: 0x00011EA4 File Offset: 0x000100A4
		[ExcludeFromDocs]
		public void GetTemporaryRT(int nameID, int width, int height, int depthBuffer, FilterMode filter, RenderTextureFormat format, RenderTextureReadWrite readWrite, int antiAliasing, bool enableRandomWrite)
		{
			RenderTextureMemoryless renderTextureMemoryless = RenderTextureMemoryless.None;
			this.GetTemporaryRT(nameID, width, height, depthBuffer, filter, format, readWrite, antiAliasing, enableRandomWrite, renderTextureMemoryless);
		}

		// Token: 0x06000CC5 RID: 3269 RVA: 0x00011ECC File Offset: 0x000100CC
		[ExcludeFromDocs]
		public void GetTemporaryRT(int nameID, int width, int height, int depthBuffer, FilterMode filter, RenderTextureFormat format, RenderTextureReadWrite readWrite, int antiAliasing)
		{
			RenderTextureMemoryless renderTextureMemoryless = RenderTextureMemoryless.None;
			bool flag = false;
			this.GetTemporaryRT(nameID, width, height, depthBuffer, filter, format, readWrite, antiAliasing, flag, renderTextureMemoryless);
		}

		// Token: 0x06000CC6 RID: 3270 RVA: 0x00011EF4 File Offset: 0x000100F4
		[ExcludeFromDocs]
		public void GetTemporaryRT(int nameID, int width, int height, int depthBuffer, FilterMode filter, RenderTextureFormat format, RenderTextureReadWrite readWrite)
		{
			RenderTextureMemoryless renderTextureMemoryless = RenderTextureMemoryless.None;
			bool flag = false;
			int num = 1;
			this.GetTemporaryRT(nameID, width, height, depthBuffer, filter, format, readWrite, num, flag, renderTextureMemoryless);
		}

		// Token: 0x06000CC7 RID: 3271 RVA: 0x00011F1C File Offset: 0x0001011C
		[ExcludeFromDocs]
		public void GetTemporaryRT(int nameID, int width, int height, int depthBuffer, FilterMode filter, RenderTextureFormat format)
		{
			RenderTextureMemoryless renderTextureMemoryless = RenderTextureMemoryless.None;
			bool flag = false;
			int num = 1;
			RenderTextureReadWrite renderTextureReadWrite = RenderTextureReadWrite.Default;
			this.GetTemporaryRT(nameID, width, height, depthBuffer, filter, format, renderTextureReadWrite, num, flag, renderTextureMemoryless);
		}

		// Token: 0x06000CC8 RID: 3272 RVA: 0x00011F48 File Offset: 0x00010148
		[ExcludeFromDocs]
		public void GetTemporaryRT(int nameID, int width, int height, int depthBuffer, FilterMode filter)
		{
			RenderTextureMemoryless renderTextureMemoryless = RenderTextureMemoryless.None;
			bool flag = false;
			int num = 1;
			RenderTextureReadWrite renderTextureReadWrite = RenderTextureReadWrite.Default;
			RenderTextureFormat renderTextureFormat = RenderTextureFormat.Default;
			this.GetTemporaryRT(nameID, width, height, depthBuffer, filter, renderTextureFormat, renderTextureReadWrite, num, flag, renderTextureMemoryless);
		}

		// Token: 0x06000CC9 RID: 3273 RVA: 0x00011F74 File Offset: 0x00010174
		[ExcludeFromDocs]
		public void GetTemporaryRT(int nameID, int width, int height, int depthBuffer)
		{
			RenderTextureMemoryless renderTextureMemoryless = RenderTextureMemoryless.None;
			bool flag = false;
			int num = 1;
			RenderTextureReadWrite renderTextureReadWrite = RenderTextureReadWrite.Default;
			RenderTextureFormat renderTextureFormat = RenderTextureFormat.Default;
			FilterMode filterMode = FilterMode.Point;
			this.GetTemporaryRT(nameID, width, height, depthBuffer, filterMode, renderTextureFormat, renderTextureReadWrite, num, flag, renderTextureMemoryless);
		}

		// Token: 0x06000CCA RID: 3274 RVA: 0x00011FA4 File Offset: 0x000101A4
		[ExcludeFromDocs]
		public void GetTemporaryRT(int nameID, int width, int height)
		{
			RenderTextureMemoryless renderTextureMemoryless = RenderTextureMemoryless.None;
			bool flag = false;
			int num = 1;
			RenderTextureReadWrite renderTextureReadWrite = RenderTextureReadWrite.Default;
			RenderTextureFormat renderTextureFormat = RenderTextureFormat.Default;
			FilterMode filterMode = FilterMode.Point;
			int num2 = 0;
			this.GetTemporaryRT(nameID, width, height, num2, filterMode, renderTextureFormat, renderTextureReadWrite, num, flag, renderTextureMemoryless);
		}

		// Token: 0x06000CCB RID: 3275 RVA: 0x00011FD8 File Offset: 0x000101D8
		public void GetTemporaryRT(int nameID, RenderTextureDescriptor desc, [DefaultValue("FilterMode.Point")] FilterMode filter)
		{
			CommandBuffer.INTERNAL_CALL_GetTemporaryRT(this, nameID, ref desc, filter);
		}

		// Token: 0x06000CCC RID: 3276 RVA: 0x00011FE8 File Offset: 0x000101E8
		[ExcludeFromDocs]
		public void GetTemporaryRT(int nameID, RenderTextureDescriptor desc)
		{
			FilterMode filterMode = FilterMode.Point;
			CommandBuffer.INTERNAL_CALL_GetTemporaryRT(this, nameID, ref desc, filterMode);
		}

		// Token: 0x06000CCD RID: 3277
		[GeneratedByOldBindingsGenerator]
		[MethodImpl(MethodImplOptions.InternalCall)]
		private static extern void INTERNAL_CALL_GetTemporaryRT(CommandBuffer self, int nameID, ref RenderTextureDescriptor desc, FilterMode filter);

		// Token: 0x06000CCE RID: 3278
		[GeneratedByOldBindingsGenerator]
		[MethodImpl(MethodImplOptions.InternalCall)]
		public extern void GetTemporaryRTArray(int nameID, int width, int height, int slices, [DefaultValue("0")] int depthBuffer, [DefaultValue("FilterMode.Point")] FilterMode filter, [DefaultValue("RenderTextureFormat.Default")] RenderTextureFormat format, [DefaultValue("RenderTextureReadWrite.Default")] RenderTextureReadWrite readWrite, [DefaultValue("1")] int antiAliasing, [DefaultValue("false")] bool enableRandomWrite);

		// Token: 0x06000CCF RID: 3279 RVA: 0x00012004 File Offset: 0x00010204
		[ExcludeFromDocs]
		public void GetTemporaryRTArray(int nameID, int width, int height, int slices, int depthBuffer, FilterMode filter, RenderTextureFormat format, RenderTextureReadWrite readWrite, int antiAliasing)
		{
			bool flag = false;
			this.GetTemporaryRTArray(nameID, width, height, slices, depthBuffer, filter, format, readWrite, antiAliasing, flag);
		}

		// Token: 0x06000CD0 RID: 3280 RVA: 0x0001202C File Offset: 0x0001022C
		[ExcludeFromDocs]
		public void GetTemporaryRTArray(int nameID, int width, int height, int slices, int depthBuffer, FilterMode filter, RenderTextureFormat format, RenderTextureReadWrite readWrite)
		{
			bool flag = false;
			int num = 1;
			this.GetTemporaryRTArray(nameID, width, height, slices, depthBuffer, filter, format, readWrite, num, flag);
		}

		// Token: 0x06000CD1 RID: 3281 RVA: 0x00012054 File Offset: 0x00010254
		[ExcludeFromDocs]
		public void GetTemporaryRTArray(int nameID, int width, int height, int slices, int depthBuffer, FilterMode filter, RenderTextureFormat format)
		{
			bool flag = false;
			int num = 1;
			RenderTextureReadWrite renderTextureReadWrite = RenderTextureReadWrite.Default;
			this.GetTemporaryRTArray(nameID, width, height, slices, depthBuffer, filter, format, renderTextureReadWrite, num, flag);
		}

		// Token: 0x06000CD2 RID: 3282 RVA: 0x0001207C File Offset: 0x0001027C
		[ExcludeFromDocs]
		public void GetTemporaryRTArray(int nameID, int width, int height, int slices, int depthBuffer, FilterMode filter)
		{
			bool flag = false;
			int num = 1;
			RenderTextureReadWrite renderTextureReadWrite = RenderTextureReadWrite.Default;
			RenderTextureFormat renderTextureFormat = RenderTextureFormat.Default;
			this.GetTemporaryRTArray(nameID, width, height, slices, depthBuffer, filter, renderTextureFormat, renderTextureReadWrite, num, flag);
		}

		// Token: 0x06000CD3 RID: 3283 RVA: 0x000120A8 File Offset: 0x000102A8
		[ExcludeFromDocs]
		public void GetTemporaryRTArray(int nameID, int width, int height, int slices, int depthBuffer)
		{
			bool flag = false;
			int num = 1;
			RenderTextureReadWrite renderTextureReadWrite = RenderTextureReadWrite.Default;
			RenderTextureFormat renderTextureFormat = RenderTextureFormat.Default;
			FilterMode filterMode = FilterMode.Point;
			this.GetTemporaryRTArray(nameID, width, height, slices, depthBuffer, filterMode, renderTextureFormat, renderTextureReadWrite, num, flag);
		}

		// Token: 0x06000CD4 RID: 3284 RVA: 0x000120D4 File Offset: 0x000102D4
		[ExcludeFromDocs]
		public void GetTemporaryRTArray(int nameID, int width, int height, int slices)
		{
			bool flag = false;
			int num = 1;
			RenderTextureReadWrite renderTextureReadWrite = RenderTextureReadWrite.Default;
			RenderTextureFormat renderTextureFormat = RenderTextureFormat.Default;
			FilterMode filterMode = FilterMode.Point;
			int num2 = 0;
			this.GetTemporaryRTArray(nameID, width, height, slices, num2, filterMode, renderTextureFormat, renderTextureReadWrite, num, flag);
		}

		// Token: 0x06000CD5 RID: 3285
		[GeneratedByOldBindingsGenerator]
		[MethodImpl(MethodImplOptions.InternalCall)]
		public extern void ReleaseTemporaryRT(int nameID);

		// Token: 0x06000CD6 RID: 3286 RVA: 0x00012104 File Offset: 0x00010304
		public void ClearRenderTarget(bool clearDepth, bool clearColor, Color backgroundColor, [DefaultValue("1.0f")] float depth)
		{
			CommandBuffer.INTERNAL_CALL_ClearRenderTarget(this, clearDepth, clearColor, ref backgroundColor, depth);
		}

		// Token: 0x06000CD7 RID: 3287 RVA: 0x00012114 File Offset: 0x00010314
		[ExcludeFromDocs]
		public void ClearRenderTarget(bool clearDepth, bool clearColor, Color backgroundColor)
		{
			float num = 1f;
			CommandBuffer.INTERNAL_CALL_ClearRenderTarget(this, clearDepth, clearColor, ref backgroundColor, num);
		}

		// Token: 0x06000CD8 RID: 3288
		[GeneratedByOldBindingsGenerator]
		[MethodImpl(MethodImplOptions.InternalCall)]
		private static extern void INTERNAL_CALL_ClearRenderTarget(CommandBuffer self, bool clearDepth, bool clearColor, ref Color backgroundColor, float depth);

		// Token: 0x06000CD9 RID: 3289 RVA: 0x00012134 File Offset: 0x00010334
		public void SetGlobalFloat(string name, float value)
		{
			this.SetGlobalFloat(Shader.PropertyToID(name), value);
		}

		// Token: 0x06000CDA RID: 3290
		[GeneratedByOldBindingsGenerator]
		[MethodImpl(MethodImplOptions.InternalCall)]
		public extern void SetGlobalFloat(int nameID, float value);

		// Token: 0x06000CDB RID: 3291 RVA: 0x00012144 File Offset: 0x00010344
		public void SetGlobalVector(string name, Vector4 value)
		{
			this.SetGlobalVector(Shader.PropertyToID(name), value);
		}

		// Token: 0x06000CDC RID: 3292 RVA: 0x00012154 File Offset: 0x00010354
		public void SetGlobalVector(int nameID, Vector4 value)
		{
			CommandBuffer.INTERNAL_CALL_SetGlobalVector(this, nameID, ref value);
		}

		// Token: 0x06000CDD RID: 3293
		[GeneratedByOldBindingsGenerator]
		[MethodImpl(MethodImplOptions.InternalCall)]
		private static extern void INTERNAL_CALL_SetGlobalVector(CommandBuffer self, int nameID, ref Vector4 value);

		// Token: 0x06000CDE RID: 3294 RVA: 0x00012160 File Offset: 0x00010360
		public void SetGlobalColor(string name, Color value)
		{
			this.SetGlobalColor(Shader.PropertyToID(name), value);
		}

		// Token: 0x06000CDF RID: 3295 RVA: 0x00012170 File Offset: 0x00010370
		public void SetGlobalColor(int nameID, Color value)
		{
			CommandBuffer.INTERNAL_CALL_SetGlobalColor(this, nameID, ref value);
		}

		// Token: 0x06000CE0 RID: 3296
		[GeneratedByOldBindingsGenerator]
		[MethodImpl(MethodImplOptions.InternalCall)]
		private static extern void INTERNAL_CALL_SetGlobalColor(CommandBuffer self, int nameID, ref Color value);

		// Token: 0x06000CE1 RID: 3297 RVA: 0x0001217C File Offset: 0x0001037C
		public void SetGlobalMatrix(string name, Matrix4x4 value)
		{
			this.SetGlobalMatrix(Shader.PropertyToID(name), value);
		}

		// Token: 0x06000CE2 RID: 3298 RVA: 0x0001218C File Offset: 0x0001038C
		public void SetGlobalMatrix(int nameID, Matrix4x4 value)
		{
			CommandBuffer.INTERNAL_CALL_SetGlobalMatrix(this, nameID, ref value);
		}

		// Token: 0x06000CE3 RID: 3299
		[GeneratedByOldBindingsGenerator]
		[MethodImpl(MethodImplOptions.InternalCall)]
		private static extern void INTERNAL_CALL_SetGlobalMatrix(CommandBuffer self, int nameID, ref Matrix4x4 value);

		// Token: 0x06000CE4 RID: 3300
		[GeneratedByOldBindingsGenerator]
		[MethodImpl(MethodImplOptions.InternalCall)]
		public extern void EnableShaderKeyword(string keyword);

		// Token: 0x06000CE5 RID: 3301
		[GeneratedByOldBindingsGenerator]
		[MethodImpl(MethodImplOptions.InternalCall)]
		public extern void DisableShaderKeyword(string keyword);

		// Token: 0x06000CE6 RID: 3302 RVA: 0x00012198 File Offset: 0x00010398
		public void SetViewMatrix(Matrix4x4 view)
		{
			CommandBuffer.INTERNAL_CALL_SetViewMatrix(this, ref view);
		}

		// Token: 0x06000CE7 RID: 3303
		[GeneratedByOldBindingsGenerator]
		[MethodImpl(MethodImplOptions.InternalCall)]
		private static extern void INTERNAL_CALL_SetViewMatrix(CommandBuffer self, ref Matrix4x4 view);

		// Token: 0x06000CE8 RID: 3304 RVA: 0x000121A4 File Offset: 0x000103A4
		public void SetProjectionMatrix(Matrix4x4 proj)
		{
			CommandBuffer.INTERNAL_CALL_SetProjectionMatrix(this, ref proj);
		}

		// Token: 0x06000CE9 RID: 3305
		[GeneratedByOldBindingsGenerator]
		[MethodImpl(MethodImplOptions.InternalCall)]
		private static extern void INTERNAL_CALL_SetProjectionMatrix(CommandBuffer self, ref Matrix4x4 proj);

		// Token: 0x06000CEA RID: 3306 RVA: 0x000121B0 File Offset: 0x000103B0
		public void SetViewProjectionMatrices(Matrix4x4 view, Matrix4x4 proj)
		{
			CommandBuffer.INTERNAL_CALL_SetViewProjectionMatrices(this, ref view, ref proj);
		}

		// Token: 0x06000CEB RID: 3307
		[GeneratedByOldBindingsGenerator]
		[MethodImpl(MethodImplOptions.InternalCall)]
		private static extern void INTERNAL_CALL_SetViewProjectionMatrices(CommandBuffer self, ref Matrix4x4 view, ref Matrix4x4 proj);

		// Token: 0x06000CEC RID: 3308
		[GeneratedByOldBindingsGenerator]
		[MethodImpl(MethodImplOptions.InternalCall)]
		public extern void SetGlobalDepthBias(float bias, float slopeBias);

		// Token: 0x06000CED RID: 3309 RVA: 0x000121C0 File Offset: 0x000103C0
		public void SetGlobalFloatArray(string propertyName, List<float> values)
		{
			this.SetGlobalFloatArray(Shader.PropertyToID(propertyName), values);
		}

		// Token: 0x06000CEE RID: 3310 RVA: 0x000121D0 File Offset: 0x000103D0
		public void SetGlobalFloatArray(int nameID, List<float> values)
		{
			if (values == null)
			{
				throw new ArgumentNullException("values");
			}
			if (values.Count == 0)
			{
				throw new ArgumentException("Zero-sized array is not allowed.");
			}
			this.SetGlobalFloatArrayListImpl(nameID, values);
		}

		// Token: 0x06000CEF RID: 3311
		[GeneratedByOldBindingsGenerator]
		[MethodImpl(MethodImplOptions.InternalCall)]
		private extern void SetGlobalFloatArrayListImpl(int nameID, object values);

		// Token: 0x06000CF0 RID: 3312 RVA: 0x00012204 File Offset: 0x00010404
		public void SetGlobalFloatArray(string propertyName, float[] values)
		{
			this.SetGlobalFloatArray(Shader.PropertyToID(propertyName), values);
		}

		// Token: 0x06000CF1 RID: 3313
		[GeneratedByOldBindingsGenerator]
		[MethodImpl(MethodImplOptions.InternalCall)]
		public extern void SetGlobalFloatArray(int nameID, float[] values);

		// Token: 0x06000CF2 RID: 3314 RVA: 0x00012214 File Offset: 0x00010414
		public void SetGlobalVectorArray(string propertyName, List<Vector4> values)
		{
			this.SetGlobalVectorArray(Shader.PropertyToID(propertyName), values);
		}

		// Token: 0x06000CF3 RID: 3315 RVA: 0x00012224 File Offset: 0x00010424
		public void SetGlobalVectorArray(int nameID, List<Vector4> values)
		{
			if (values == null)
			{
				throw new ArgumentNullException("values");
			}
			if (values.Count == 0)
			{
				throw new ArgumentException("Zero-sized array is not allowed.");
			}
			this.SetGlobalVectorArrayListImpl(nameID, values);
		}

		// Token: 0x06000CF4 RID: 3316
		[GeneratedByOldBindingsGenerator]
		[MethodImpl(MethodImplOptions.InternalCall)]
		private extern void SetGlobalVectorArrayListImpl(int nameID, object values);

		// Token: 0x06000CF5 RID: 3317 RVA: 0x00012258 File Offset: 0x00010458
		public void SetGlobalVectorArray(string propertyName, Vector4[] values)
		{
			this.SetGlobalVectorArray(Shader.PropertyToID(propertyName), values);
		}

		// Token: 0x06000CF6 RID: 3318
		[GeneratedByOldBindingsGenerator]
		[MethodImpl(MethodImplOptions.InternalCall)]
		public extern void SetGlobalVectorArray(int nameID, Vector4[] values);

		// Token: 0x06000CF7 RID: 3319 RVA: 0x00012268 File Offset: 0x00010468
		public void SetGlobalMatrixArray(string propertyName, List<Matrix4x4> values)
		{
			this.SetGlobalMatrixArray(Shader.PropertyToID(propertyName), values);
		}

		// Token: 0x06000CF8 RID: 3320 RVA: 0x00012278 File Offset: 0x00010478
		public void SetGlobalMatrixArray(int nameID, List<Matrix4x4> values)
		{
			if (values == null)
			{
				throw new ArgumentNullException("values");
			}
			if (values.Count == 0)
			{
				throw new ArgumentException("Zero-sized array is not allowed.");
			}
			this.SetGlobalMatrixArrayListImpl(nameID, values);
		}

		// Token: 0x06000CF9 RID: 3321
		[GeneratedByOldBindingsGenerator]
		[MethodImpl(MethodImplOptions.InternalCall)]
		private extern void SetGlobalMatrixArrayListImpl(int nameID, object values);

		// Token: 0x06000CFA RID: 3322 RVA: 0x000122AC File Offset: 0x000104AC
		public void SetGlobalMatrixArray(string propertyName, Matrix4x4[] values)
		{
			this.SetGlobalMatrixArray(Shader.PropertyToID(propertyName), values);
		}

		// Token: 0x06000CFB RID: 3323
		[GeneratedByOldBindingsGenerator]
		[MethodImpl(MethodImplOptions.InternalCall)]
		public extern void SetGlobalMatrixArray(int nameID, Matrix4x4[] values);

		// Token: 0x06000CFC RID: 3324 RVA: 0x000122BC File Offset: 0x000104BC
		public void SetGlobalTexture(string name, RenderTargetIdentifier value)
		{
			this.SetGlobalTexture(Shader.PropertyToID(name), value);
		}

		// Token: 0x06000CFD RID: 3325 RVA: 0x000122CC File Offset: 0x000104CC
		public void SetGlobalTexture(int nameID, RenderTargetIdentifier value)
		{
			this.SetGlobalTexture_Impl(nameID, ref value);
		}

		// Token: 0x06000CFE RID: 3326
		[GeneratedByOldBindingsGenerator]
		[MethodImpl(MethodImplOptions.InternalCall)]
		private extern void SetGlobalTexture_Impl(int nameID, ref RenderTargetIdentifier rt);

		// Token: 0x06000CFF RID: 3327 RVA: 0x000122D8 File Offset: 0x000104D8
		public void SetGlobalBuffer(string name, ComputeBuffer value)
		{
			this.SetGlobalBuffer(Shader.PropertyToID(name), value);
		}

		// Token: 0x06000D00 RID: 3328
		[GeneratedByOldBindingsGenerator]
		[MethodImpl(MethodImplOptions.InternalCall)]
		public extern void SetGlobalBuffer(int nameID, ComputeBuffer value);

		// Token: 0x06000D01 RID: 3329 RVA: 0x000122E8 File Offset: 0x000104E8
		public void SetShadowSamplingMode(RenderTargetIdentifier shadowmap, ShadowSamplingMode mode)
		{
			this.SetShadowSamplingMode_Impl(ref shadowmap, mode);
		}

		// Token: 0x06000D02 RID: 3330
		[GeneratedByOldBindingsGenerator]
		[MethodImpl(MethodImplOptions.InternalCall)]
		private extern void SetShadowSamplingMode_Impl(ref RenderTargetIdentifier shadowmap, ShadowSamplingMode mode);

		// Token: 0x06000D03 RID: 3331 RVA: 0x000122F4 File Offset: 0x000104F4
		public void IssuePluginEvent(IntPtr callback, int eventID)
		{
			if (callback == IntPtr.Zero)
			{
				throw new ArgumentException("Null callback specified.");
			}
			this.IssuePluginEventInternal(callback, eventID);
		}

		// Token: 0x06000D04 RID: 3332
		[GeneratedByOldBindingsGenerator]
		[MethodImpl(MethodImplOptions.InternalCall)]
		private extern void IssuePluginEventInternal(IntPtr callback, int eventID);

		// Token: 0x06000D05 RID: 3333
		[GeneratedByOldBindingsGenerator]
		[MethodImpl(MethodImplOptions.InternalCall)]
		public extern void BeginSample(string name);

		// Token: 0x06000D06 RID: 3334
		[GeneratedByOldBindingsGenerator]
		[MethodImpl(MethodImplOptions.InternalCall)]
		public extern void EndSample(string name);

		// Token: 0x06000D07 RID: 3335 RVA: 0x0001231C File Offset: 0x0001051C
		public void IssuePluginEventAndData(IntPtr callback, int eventID, IntPtr data)
		{
			if (callback == IntPtr.Zero)
			{
				throw new ArgumentException("Null callback specified.");
			}
			this.IssuePluginEventAndDataInternal(callback, eventID, data);
		}

		// Token: 0x06000D08 RID: 3336
		[GeneratedByOldBindingsGenerator]
		[MethodImpl(MethodImplOptions.InternalCall)]
		private extern void IssuePluginEventAndDataInternal(IntPtr callback, int eventID, IntPtr data);

		// Token: 0x06000D09 RID: 3337 RVA: 0x00012344 File Offset: 0x00010544
		public void IssuePluginCustomBlit(IntPtr callback, uint command, RenderTargetIdentifier source, RenderTargetIdentifier dest, uint commandParam, uint commandFlags)
		{
			this.IssuePluginCustomBlitInternal(callback, command, ref source, ref dest, commandParam, commandFlags);
		}

		// Token: 0x06000D0A RID: 3338
		[GeneratedByOldBindingsGenerator]
		[MethodImpl(MethodImplOptions.InternalCall)]
		private extern void IssuePluginCustomBlitInternal(IntPtr callback, uint command, ref RenderTargetIdentifier source, ref RenderTargetIdentifier dest, uint commandParam, uint commandFlags);

		// Token: 0x04000166 RID: 358
		internal IntPtr m_Ptr;
	}
}