同步最新svn内容

leonard Wu

2018-08-09 a10eea6e4ce647061813519d5b0ea496f29495b9

 Assets/Plugins/PostProcessing/Runtime/Components/BuiltinDebugViewsComponent.cs

@@ -1,258 +1,258 @@
using System.Collections.Generic;
using UnityEngine.Rendering;

namespace UnityEngine.PostProcessing
{
    using Mode = BuiltinDebugViewsModel.Mode;

    public sealed class BuiltinDebugViewsComponent : PostProcessingComponentCommandBuffer<BuiltinDebugViewsModel>
    {
        static class Uniforms
        {
            internal static readonly int _DepthScale = Shader.PropertyToID("_DepthScale");
            internal static readonly int _TempRT     = Shader.PropertyToID("_TempRT");
            internal static readonly int _Opacity    = Shader.PropertyToID("_Opacity");
            internal static readonly int _MainTex    = Shader.PropertyToID("_MainTex");
            internal static readonly int _TempRT2    = Shader.PropertyToID("_TempRT2");
            internal static readonly int _Amplitude  = Shader.PropertyToID("_Amplitude");
            internal static readonly int _Scale      = Shader.PropertyToID("_Scale");
        }

        const string k_ShaderString = "Hidden/Post FX/Builtin Debug Views";

        enum Pass
        {
            Depth,
            Normals,
            MovecOpacity,
            MovecImaging,
            MovecArrows
        }

        ArrowArray m_Arrows;

        class ArrowArray
        {
            public Mesh mesh { get; private set; }

            public int columnCount { get; private set; }
            public int rowCount { get; private set; }

            public void BuildMesh(int columns, int rows)
            {
                // Base shape
                var arrow = new Vector3[6]
                {
                    new Vector3(0f, 0f, 0f),
                    new Vector3(0f, 1f, 0f),
                    new Vector3(0f, 1f, 0f),
                    new Vector3(-1f, 1f, 0f),
                    new Vector3(0f, 1f, 0f),
                    new Vector3(1f, 1f, 0f)
                };

                // make the vertex array
                int vcount = 6 * columns * rows;
                var vertices = new List<Vector3>(vcount);
                var uvs = new List<Vector2>(vcount);

                for (int iy = 0; iy < rows; iy++)
                {
                    for (int ix = 0; ix < columns; ix++)
                    {
                        var uv = new Vector2(
                                (0.5f + ix) / columns,
                                (0.5f + iy) / rows
                                );

                        for (int i = 0; i < 6; i++)
                        {
                            vertices.Add(arrow[i]);
                            uvs.Add(uv);
                        }
                    }
                }

                // make the index array
                var indices = new int[vcount];

                for (int i = 0; i < vcount; i++)
                    indices[i] = i;

                // initialize the mesh object
                mesh = new Mesh { hideFlags = HideFlags.DontSave };
                mesh.SetVertices(vertices);
                mesh.SetUVs(0, uvs);
                mesh.SetIndices(indices, MeshTopology.Lines, 0);
                mesh.UploadMeshData(true);

                // update the properties
                columnCount = columns;
                rowCount = rows;
            }

            public void Release()
            {
                GraphicsUtils.Destroy(mesh);
                mesh = null;
            }
        }

        public override bool active
        {
            get
            {
                return model.IsModeActive(Mode.Depth)
                       || model.IsModeActive(Mode.Normals)
                       || model.IsModeActive(Mode.MotionVectors);
            }
        }

        public override DepthTextureMode GetCameraFlags()
        {
            var mode = model.settings.mode;
            var flags = DepthTextureMode.None;

            switch (mode)
            {
                case Mode.Normals:
                    flags |= DepthTextureMode.DepthNormals;
                    break;
                case Mode.MotionVectors:
                    flags |= DepthTextureMode.MotionVectors | DepthTextureMode.Depth;
                    break;
                case Mode.Depth:
                    flags |= DepthTextureMode.Depth;
                    break;
            }

            return flags;
        }

        public override CameraEvent GetCameraEvent()
        {
            return model.settings.mode == Mode.MotionVectors
                   ? CameraEvent.BeforeImageEffects
                   : CameraEvent.BeforeImageEffectsOpaque;
        }

        public override string GetName()
        {
            return "Builtin Debug Views";
        }

        public override void PopulateCommandBuffer(CommandBuffer cb)
        {
            var settings = model.settings;
            var material = context.materialFactory.Get(k_ShaderString);
            material.shaderKeywords = null;

            if (context.isGBufferAvailable)
                material.EnableKeyword("SOURCE_GBUFFER");

            switch (settings.mode)
            {
                case Mode.Depth:
                    DepthPass(cb);
                    break;
                case Mode.Normals:
                    DepthNormalsPass(cb);
                    break;
                case Mode.MotionVectors:
                    MotionVectorsPass(cb);
                    break;
            }

            context.Interrupt();
        }

        void DepthPass(CommandBuffer cb)
        {
            var material = context.materialFactory.Get(k_ShaderString);
            var settings = model.settings.depth;

            cb.SetGlobalFloat(Uniforms._DepthScale, 1f / settings.scale);
            cb.Blit((Texture)null, BuiltinRenderTextureType.CameraTarget, material, (int)Pass.Depth);
        }

        void DepthNormalsPass(CommandBuffer cb)
        {
            var material = context.materialFactory.Get(k_ShaderString);
            cb.Blit((Texture)null, BuiltinRenderTextureType.CameraTarget, material, (int)Pass.Normals);
        }

        void MotionVectorsPass(CommandBuffer cb)
        {
#if UNITY_EDITOR
            // Don't render motion vectors preview when the editor is not playing as it can in some
            // cases results in ugly artifacts (i.e. when resizing the game view).
            if (!Application.isPlaying)
                return;
#endif

            var material = context.materialFactory.Get(k_ShaderString);
            var settings = model.settings.motionVectors;

            // Blit the original source image
            int tempRT = Uniforms._TempRT;
            cb.GetTemporaryRT(tempRT, context.width, context.height, 0, FilterMode.Bilinear);
            cb.SetGlobalFloat(Uniforms._Opacity, settings.sourceOpacity);
            cb.SetGlobalTexture(Uniforms._MainTex, BuiltinRenderTextureType.CameraTarget);
            cb.Blit(BuiltinRenderTextureType.CameraTarget, tempRT, material, (int)Pass.MovecOpacity);

            // Motion vectors (imaging)
            if (settings.motionImageOpacity > 0f && settings.motionImageAmplitude > 0f)
            {
                int tempRT2 = Uniforms._TempRT2;
                cb.GetTemporaryRT(tempRT2, context.width, context.height, 0, FilterMode.Bilinear);
                cb.SetGlobalFloat(Uniforms._Opacity, settings.motionImageOpacity);
                cb.SetGlobalFloat(Uniforms._Amplitude, settings.motionImageAmplitude);
                cb.SetGlobalTexture(Uniforms._MainTex, tempRT);
                cb.Blit(tempRT, tempRT2, material, (int)Pass.MovecImaging);
                cb.ReleaseTemporaryRT(tempRT);
                tempRT = tempRT2;
            }

            // Motion vectors (arrows)
            if (settings.motionVectorsOpacity > 0f && settings.motionVectorsAmplitude > 0f)
            {
                PrepareArrows();

                float sy = 1f / settings.motionVectorsResolution;
                float sx = sy * context.height / context.width;

                cb.SetGlobalVector(Uniforms._Scale, new Vector2(sx, sy));
                cb.SetGlobalFloat(Uniforms._Opacity, settings.motionVectorsOpacity);
                cb.SetGlobalFloat(Uniforms._Amplitude, settings.motionVectorsAmplitude);
                cb.DrawMesh(m_Arrows.mesh, Matrix4x4.identity, material, 0, (int)Pass.MovecArrows);
            }

            cb.SetGlobalTexture(Uniforms._MainTex, tempRT);
            cb.Blit(tempRT, BuiltinRenderTextureType.CameraTarget);
            cb.ReleaseTemporaryRT(tempRT);
        }

        void PrepareArrows()
        {
            int row = model.settings.motionVectors.motionVectorsResolution;
            int col = row * Screen.width / Screen.height;

            if (m_Arrows == null)
                m_Arrows = new ArrowArray();

            if (m_Arrows.columnCount != col || m_Arrows.rowCount != row)
            {
                m_Arrows.Release();
                m_Arrows.BuildMesh(col, row);
            }
        }

        public override void OnDisable()
        {
            if (m_Arrows != null)
                m_Arrows.Release();

            m_Arrows = null;
        }
    }
}
using System.Collections.Generic;

using UnityEngine.Rendering;



namespace UnityEngine.PostProcessing

{

    using Mode = BuiltinDebugViewsModel.Mode;



    public sealed class BuiltinDebugViewsComponent : PostProcessingComponentCommandBuffer<BuiltinDebugViewsModel>

    {

        static class Uniforms

        {

            internal static readonly int _DepthScale = Shader.PropertyToID("_DepthScale");

            internal static readonly int _TempRT     = Shader.PropertyToID("_TempRT");

            internal static readonly int _Opacity    = Shader.PropertyToID("_Opacity");

            internal static readonly int _MainTex    = Shader.PropertyToID("_MainTex");

            internal static readonly int _TempRT2    = Shader.PropertyToID("_TempRT2");

            internal static readonly int _Amplitude  = Shader.PropertyToID("_Amplitude");

            internal static readonly int _Scale      = Shader.PropertyToID("_Scale");

        }



        const string k_ShaderString = "Hidden/Post FX/Builtin Debug Views";



        enum Pass

        {

            Depth,

            Normals,

            MovecOpacity,

            MovecImaging,

            MovecArrows

        }



        ArrowArray m_Arrows;



        class ArrowArray

        {

            public Mesh mesh { get; private set; }



            public int columnCount { get; private set; }

            public int rowCount { get; private set; }



            public void BuildMesh(int columns, int rows)

            {

                // Base shape

                var arrow = new Vector3[6]

                {

                    new Vector3(0f, 0f, 0f),

                    new Vector3(0f, 1f, 0f),

                    new Vector3(0f, 1f, 0f),

                    new Vector3(-1f, 1f, 0f),

                    new Vector3(0f, 1f, 0f),

                    new Vector3(1f, 1f, 0f)

                };



                // make the vertex array

                int vcount = 6 * columns * rows;

                var vertices = new List<Vector3>(vcount);

                var uvs = new List<Vector2>(vcount);



                for (int iy = 0; iy < rows; iy++)

                {

                    for (int ix = 0; ix < columns; ix++)

                    {

                        var uv = new Vector2(

                                (0.5f + ix) / columns,

                                (0.5f + iy) / rows

                                );



                        for (int i = 0; i < 6; i++)

                        {

                            vertices.Add(arrow[i]);

                            uvs.Add(uv);

                        }

                    }

                }



                // make the index array

                var indices = new int[vcount];



                for (int i = 0; i < vcount; i++)

                    indices[i] = i;



                // initialize the mesh object

                mesh = new Mesh { hideFlags = HideFlags.DontSave };

                mesh.SetVertices(vertices);

                mesh.SetUVs(0, uvs);

                mesh.SetIndices(indices, MeshTopology.Lines, 0);

                mesh.UploadMeshData(true);



                // update the properties

                columnCount = columns;

                rowCount = rows;

            }



            public void Release()

            {

                GraphicsUtils.Destroy(mesh);

                mesh = null;

            }

        }



        public override bool active

        {

            get

            {

                return model.IsModeActive(Mode.Depth)

                       || model.IsModeActive(Mode.Normals)

                       || model.IsModeActive(Mode.MotionVectors);

            }

        }



        public override DepthTextureMode GetCameraFlags()

        {

            var mode = model.settings.mode;

            var flags = DepthTextureMode.None;



            switch (mode)

            {

                case Mode.Normals:

                    flags |= DepthTextureMode.DepthNormals;

                    break;

                case Mode.MotionVectors:

                    flags |= DepthTextureMode.MotionVectors | DepthTextureMode.Depth;

                    break;

                case Mode.Depth:

                    flags |= DepthTextureMode.Depth;

                    break;

            }



            return flags;

        }



        public override CameraEvent GetCameraEvent()

        {

            return model.settings.mode == Mode.MotionVectors

                   ? CameraEvent.BeforeImageEffects

                   : CameraEvent.BeforeImageEffectsOpaque;

        }



        public override string GetName()

        {

            return "Builtin Debug Views";

        }



        public override void PopulateCommandBuffer(CommandBuffer cb)

        {

            var settings = model.settings;

            var material = context.materialFactory.Get(k_ShaderString);

            material.shaderKeywords = null;



            if (context.isGBufferAvailable)

                material.EnableKeyword("SOURCE_GBUFFER");



            switch (settings.mode)

            {

                case Mode.Depth:

                    DepthPass(cb);

                    break;

                case Mode.Normals:

                    DepthNormalsPass(cb);

                    break;

                case Mode.MotionVectors:

                    MotionVectorsPass(cb);

                    break;

            }



            context.Interrupt();

        }



        void DepthPass(CommandBuffer cb)

        {

            var material = context.materialFactory.Get(k_ShaderString);

            var settings = model.settings.depth;



            cb.SetGlobalFloat(Uniforms._DepthScale, 1f / settings.scale);

            cb.Blit((Texture)null, BuiltinRenderTextureType.CameraTarget, material, (int)Pass.Depth);

        }



        void DepthNormalsPass(CommandBuffer cb)

        {

            var material = context.materialFactory.Get(k_ShaderString);

            cb.Blit((Texture)null, BuiltinRenderTextureType.CameraTarget, material, (int)Pass.Normals);

        }



        void MotionVectorsPass(CommandBuffer cb)

        {

#if UNITY_EDITOR

            // Don't render motion vectors preview when the editor is not playing as it can in some

            // cases results in ugly artifacts (i.e. when resizing the game view).

            if (!Application.isPlaying)

                return;

#endif



            var material = context.materialFactory.Get(k_ShaderString);

            var settings = model.settings.motionVectors;



            // Blit the original source image

            int tempRT = Uniforms._TempRT;

            cb.GetTemporaryRT(tempRT, context.width, context.height, 0, FilterMode.Bilinear);

            cb.SetGlobalFloat(Uniforms._Opacity, settings.sourceOpacity);

            cb.SetGlobalTexture(Uniforms._MainTex, BuiltinRenderTextureType.CameraTarget);

            cb.Blit(BuiltinRenderTextureType.CameraTarget, tempRT, material, (int)Pass.MovecOpacity);



            // Motion vectors (imaging)

            if (settings.motionImageOpacity > 0f && settings.motionImageAmplitude > 0f)

            {

                int tempRT2 = Uniforms._TempRT2;

                cb.GetTemporaryRT(tempRT2, context.width, context.height, 0, FilterMode.Bilinear);

                cb.SetGlobalFloat(Uniforms._Opacity, settings.motionImageOpacity);

                cb.SetGlobalFloat(Uniforms._Amplitude, settings.motionImageAmplitude);

                cb.SetGlobalTexture(Uniforms._MainTex, tempRT);

                cb.Blit(tempRT, tempRT2, material, (int)Pass.MovecImaging);

                cb.ReleaseTemporaryRT(tempRT);

                tempRT = tempRT2;

            }



            // Motion vectors (arrows)

            if (settings.motionVectorsOpacity > 0f && settings.motionVectorsAmplitude > 0f)

            {

                PrepareArrows();



                float sy = 1f / settings.motionVectorsResolution;

                float sx = sy * context.height / context.width;



                cb.SetGlobalVector(Uniforms._Scale, new Vector2(sx, sy));

                cb.SetGlobalFloat(Uniforms._Opacity, settings.motionVectorsOpacity);

                cb.SetGlobalFloat(Uniforms._Amplitude, settings.motionVectorsAmplitude);

                cb.DrawMesh(m_Arrows.mesh, Matrix4x4.identity, material, 0, (int)Pass.MovecArrows);

            }



            cb.SetGlobalTexture(Uniforms._MainTex, tempRT);

            cb.Blit(tempRT, BuiltinRenderTextureType.CameraTarget);

            cb.ReleaseTemporaryRT(tempRT);

        }



        void PrepareArrows()

        {

            int row = model.settings.motionVectors.motionVectorsResolution;

            int col = row * Screen.width / Screen.height;



            if (m_Arrows == null)

                m_Arrows = new ArrowArray();



            if (m_Arrows.columnCount != col || m_Arrows.rowCount != row)

            {

                m_Arrows.Release();

                m_Arrows.BuildMesh(col, row);

            }

        }



        public override void OnDisable()

        {

            if (m_Arrows != null)

                m_Arrows.Release();



            m_Arrows = null;

        }

    }

}