C# Rendering.CommandBuffer类代码示例

 public override void IssueDrawCall_BackStencil(LightWithStencilShadow light, CommandBuffer commands)
 {
     var renderer = GetComponent<Renderer>();
     int n = m_stencil_materials.Length;
     for (int i = 0; i < n; ++i)
     {
         commands.DrawRenderer(renderer, m_stencil_materials[i], i, 1);
     }
 }

 public override void IssueDrawCall_FrontDepth(AndRenderer br, CommandBuffer cb)
 {
     var renderer = GetComponent<Renderer>();
     int n = m_depth_materials.Length;
     for (int i = 0; i < n; ++i)
     {
         cb.DrawRenderer(renderer, m_depth_materials[i], i, 1);
     }
 }

 public CommandBuffer GetCommandBuffer()
 {
     if (m_cb == null)
     {
         m_cb = new CommandBuffer();
         m_cb.name = "Hair Shadow";
         GetComponent<Light>().AddCommandBuffer(LightEvent.AfterShadowMap, m_cb);
     }
     return m_cb;
 }

 void OnDisable()
 {
     if (m_commands != null)
     {
         var cam = GetComponent<Camera>();
         cam.RemoveCommandBuffer(CameraEvent.AfterLighting, m_commands);
         m_commands.Release();
         m_commands = null;
     }
 }

        /// <summary>
        /// Return a new command buffer.
        /// This will be called the first time
        /// the mesh is rendered for each camera 
        /// that renders the ocean.
        /// </summary>
        public override CommandBuffer Create(Camera cam)
        {
            CommandBuffer cmd = new CommandBuffer();
            cmd.name = "Ceto DepthGrab Cmd: " + cam.name;

            //int width = cam.pixelWidth;
            //int height = cam.pixelHeight;

            //int scale = ResolutionToNumber(Resolution);
            //width /= scale;
            //height /= scale;

            RenderTextureFormat format;

            //screen grab currently disabled.
            /*
            if (cam.hdr)
                format = RenderTextureFormat.ARGBHalf;
            else
                format = RenderTextureFormat.ARGB32;

            //Copy screen into temporary RT.
            int grabID = Shader.PropertyToID("Ceto_GrabCopyTexture");
            cmd.GetTemporaryRT(grabID, width, height, 0, FilterMode.Bilinear, format, RenderTextureReadWrite.Default);
            cmd.Blit(BuiltinRenderTextureType.CurrentActive, grabID);
            cmd.SetGlobalTexture(GrabName, grabID);

            */
            if (SystemInfo.SupportsRenderTextureFormat(RenderTextureFormat.RFloat))
                format = RenderTextureFormat.RFloat;
            else
                format = RenderTextureFormat.RHalf;

            //Copy depths into temporary RT.
            int depthID = Shader.PropertyToID("Ceto_DepthCopyTexture");
            cmd.GetTemporaryRT(depthID, cam.pixelWidth, cam.pixelHeight, 0, FilterMode.Point, format, RenderTextureReadWrite.Linear);
            cmd.Blit(BuiltinRenderTextureType.CurrentActive, depthID, m_copyDepthMat, 0);
            cmd.SetGlobalTexture(DepthName, depthID);

            cam.AddCommandBuffer(Event, cmd);

            CommandData data = new CommandData();

            data.command = cmd;
            data.width = cam.pixelWidth;
            data.height = cam.pixelHeight;

            if (m_data.ContainsKey(cam))
                m_data.Remove(cam);

            m_data.Add(cam, data);

            return cmd;
        }

        void OnPreRender()
        {
            if (!gameObject.activeInHierarchy && !enabled) { return; }

            var cam = GetComponent<Camera>();
            if (m_commands == null)
            {
                m_material = new Material(m_shader);
                m_commands = new CommandBuffer();
                m_commands.name = "Rim Light";

                cam.AddCommandBuffer(CameraEvent.AfterLighting, m_commands);
            }

            m_commands.Clear();
            if (cam.hdr)
            {
                m_material.EnableKeyword("UNITY_HDR_ON");
                m_material.SetInt("_SrcBlend", (int)BlendMode.One);
                m_material.SetInt("_DstBlend", (int)BlendMode.One);
                m_commands.SetRenderTarget(BuiltinRenderTextureType.CameraTarget);
            }
            else
            {
                m_material.DisableKeyword("UNITY_HDR_ON");
                m_material.SetInt("_SrcBlend", (int)BlendMode.DstColor);
                m_material.SetInt("_DstBlend", (int)BlendMode.Zero);
                m_commands.SetRenderTarget(BuiltinRenderTextureType.GBuffer3);
            }
            m_commands.DrawMesh(m_quad, Matrix4x4.identity, m_material, 0, 0);

            if (m_edge_highlighting)
            {
                m_material.EnableKeyword("ENABLE_EDGE_HIGHLIGHTING");
            }
            else
            {
                m_material.DisableKeyword("ENABLE_EDGE_HIGHLIGHTING");
            }

            if (m_mul_smoothness)
            {
                m_material.EnableKeyword("ENABLE_SMOOTHNESS_ATTENUAION");
            }
            else
            {
                m_material.DisableKeyword("ENABLE_SMOOTHNESS_ATTENUAION");
            }

            m_material.SetVector("_Color", GetLinearColor());
            m_material.SetVector("_Params1", new Vector4(m_fresnel_bias, m_fresnel_scale, m_fresnel_pow, m_intensity));
            m_material.SetVector("_Params2", new Vector4(m_edge_intensity, m_edge_threshold, m_edge_radius, 0.0f));
        }

	static public int constructor(IntPtr l) {
		try {
			UnityEngine.Rendering.CommandBuffer o;
			o=new UnityEngine.Rendering.CommandBuffer();
			pushValue(l,true);
			pushValue(l,o);
			return 2;
		}
		catch(Exception e) {
			return error(l,e);
		}
	}

        //
        public bool FillBuffer(CommandBuffer buffer)
        {
            if (r == null) { return false; }

            if (lastCamera == Camera.current)
            {
                for (int i = 0, imax = data.Count; i < imax; i++)
                {
                    Data d = data[i];
                    buffer.DrawRenderer(r, d.material, d.submeshIndex);
                }
            }
            return true;
        }

 public override void IssueDrawCall_DepthMask(SubRenderer br, CommandBuffer cb)
 {
     var renderer = GetComponent<Renderer>();
     int n = m_mask_materials.Length;
     for (int i = 0; i < n; ++i)
     {
         cb.DrawRenderer(renderer, m_mask_materials[i], i, 0);
         cb.DrawRenderer(renderer, m_mask_materials[i], i, 1);
         if (br.m_enable_piercing)
         {
             cb.DrawRenderer(renderer, m_mask_materials[i], i, 2);
         }
         cb.DrawRenderer(renderer, m_mask_materials[i], i, 3);
     }
 }

	internal override void UpdateTransform( CommandBuffer updateCB, bool starting )
#endif
	{
		if ( !m_initialized )
		{
			Initialize();
			return;
		}

		Profiler.BeginSample( "Solid.Update" );

		if ( !starting && m_wasVisible )
			m_prevLocalToWorld = m_currLocalToWorld;

		m_moved = true;
		if ( !m_owner.Overlay )
		{
			Vector3 position = m_transform.position;
			Quaternion rotation = m_transform.rotation;
			Vector3 scale = m_transform.lossyScale;

			m_moved = starting ||
				VectorChanged( position, m_lastPosition ) ||
				RotationChanged( rotation, m_lastRotation ) ||
				VectorChanged( scale, m_lastScale );

			if ( m_moved )
			{
				m_lastPosition = position;
				m_lastRotation = rotation;
				m_lastScale = scale;
			}
		}

		m_currLocalToWorld = m_transform.localToWorldMatrix;

		if ( starting || !m_wasVisible )
			m_prevLocalToWorld = m_currLocalToWorld;

		m_wasVisible = m_meshRenderer.isVisible;

		Profiler.EndSample();
	}

 internal override void RenderVectors(Camera camera, CommandBuffer renderCB, float scale, Quality quality)
 {
     if (this.m_initialized && !this.m_error && this.m_meshRenderer.isVisible)
     {
         bool flag = (this.m_owner.Instance.CullingMask & 1 << this.m_obj.gameObject.layer) != 0;
         if (!flag || (flag && this.m_moved))
         {
             int num = (!flag) ? 255 : this.m_owner.Instance.GenerateObjectId(this.m_obj.gameObject);
             Matrix4x4 value;
             if (this.m_obj.FixedStep)
             {
                 value = this.m_owner.PrevViewProjMatrixRT * this.m_currLocalToWorld;
             }
             else
             {
                 value = this.m_owner.PrevViewProjMatrixRT * this.m_prevLocalToWorld;
             }
             renderCB.SetGlobalMatrix("_AM_MATRIX_PREV_MVP", value);
             renderCB.SetGlobalFloat("_AM_OBJECT_ID", (float)num * 0.003921569f);
             renderCB.SetGlobalFloat("_AM_MOTION_SCALE", (!flag) ? 0f : scale);
             int num2 = (quality != Quality.Mobile) ? 2 : 0;
             for (int i = 0; i < this.m_sharedMaterials.Length; i++)
             {
                 MotionState.MaterialDesc materialDesc = this.m_sharedMaterials[i];
                 int shaderPass = num2 + ((!materialDesc.coverage) ? 0 : 1);
                 if (materialDesc.coverage)
                 {
                     Texture mainTexture = materialDesc.material.mainTexture;
                     if (mainTexture != null)
                     {
                         materialDesc.propertyBlock.SetTexture("_MainTex", mainTexture);
                     }
                     if (materialDesc.cutoff)
                     {
                         materialDesc.propertyBlock.SetFloat("_Cutoff", materialDesc.material.GetFloat("_Cutoff"));
                     }
                 }
                 renderCB.DrawMesh(this.m_mesh, this.m_transform.localToWorldMatrix, this.m_owner.Instance.SolidVectorsMaterial, i, shaderPass, materialDesc.propertyBlock);
             }
         }
     }
 }

	internal virtual void RenderVectors( Camera camera, CommandBuffer renderCB, float scale, AmplifyMotion.Quality quality ) {}

	internal abstract void UpdateTransform( CommandBuffer updateCB, bool starting );

        void OnDisable()
        {
            RemoveCommandBuffers();

            if (m_cb_copy != null)
            {
                m_cb_copy.Release();
                m_cb_copy = null;
            }

            for (int i = 0; i < m_scratch_buffers.Length; ++i)
            {
                m_scratch_buffers[i].Release();
            }
            m_scratch_buffers = null;

            fcAPI.fcGuard(() =>
            {
                EraseCallbacks();
                fcAPI.fcExrDestroyContext(m_ctx);
                m_ctx.ptr = System.IntPtr.Zero;
            });
        }

        void OnEnable()
        {
            m_outputDir.CreateDirectory();
            m_quad = FrameCapturerUtils.CreateFullscreenQuad();
            m_mat_copy = new Material(m_shCopy);

            // initialize exr context
            fcAPI.fcExrConfig conf = fcAPI.fcExrConfig.default_value;
            m_ctx = fcAPI.fcExrCreateContext(ref conf);

            // initialize render targets
            m_scratch_buffers = new RenderTexture[m_targets.Length];
            for (int i = 0; i < m_scratch_buffers.Length; ++i)
            {
                var rt = m_targets[i];
                m_scratch_buffers[i] = new RenderTexture(rt.width, rt.height, 0, rt.format);
                m_scratch_buffers[i].Create();
            }

            // initialize command buffers
            {
                m_cb_copy = new CommandBuffer();
                m_cb_copy.name = "PngOffscreenRecorder: Copy";
                for (int i = 0; i < m_targets.Length; ++i)
                {
                    m_cb_copy.SetRenderTarget(m_scratch_buffers[i]);
                    m_cb_copy.SetGlobalTexture("_TmpRenderTarget", m_targets[i]);
                    m_cb_copy.DrawMesh(m_quad, Matrix4x4.identity, m_mat_copy, 0, 3);
                }
            }
        }