运动模糊后处理 - Shader

最新推荐文章于 2026-07-28 12:52:34 发布

原创最新推荐文章于 2026-07-28 12:52:34 发布 · 222 阅读

0 ·

本内容遵循CC 4.0 BY-SA版权协议

收录于

Shader 效果

本文介绍了一种在Unity中实现运动模糊效果的方法，通过使用深度纹理和后处理技术，能够根据场景的运动情况生成平滑的模糊效果。该技术特别适用于提高游戏画面的真实感。

脚本

using System;
using UnityEngine;
using UnityEngine.Serialization;

namespace DefaultNamespace
{
    public class MotionBlurWithDepthTexture : PostEffectBase
    {
        [SerializeField] private Shader _motionBlurShader;
        private Material _motionBlurMaterial;
        private Camera _camera;

        [Range(0.0f, 1.0f)] public float blurSize = 0.5f;
        private Matrix4x4 _previousViewProjectionMatrix;

        public Camera MyCamera
        {
            get
            {
                if (_camera == null)
                    _camera = GetComponent<Camera>();
                return _camera;
            }
        }

        public Material MotionBlurMaterial
        {
            get
            {
                _motionBlurMaterial = CheckShaderAndCreateMaterial(_motionBlurShader, _motionBlurMaterial);
                return _motionBlurMaterial;
            }
        }

        private void OnEnable()
        {
            MyCamera.depthTextureMode |= DepthTextureMode.Depth;
            _previousViewProjectionMatrix = MyCamera.projectionMatrix * MyCamera.worldToCameraMatrix;
        }
        

        private void OnRenderImage(RenderTexture src, RenderTexture dest)
        {
            if (MotionBlurMaterial != null)
            {
                MotionBlurMaterial.SetFloat("_BlurSize", blurSize);
                
                MotionBlurMaterial.SetMatrix("_PreviousViewProjectionMatrix", _previousViewProjectionMatrix);
                var currentViewProjectionMatrix = MyCamera.projectionMatrix * MyCamera.worldToCameraMatrix;
                var currentViewProjectionInverseMatrix = currentViewProjectionMatrix.inverse;
                MotionBlurMaterial.SetMatrix("_CurrentViewProjectionInverseMatrix", currentViewProjectionInverseMatrix);
                _previousViewProjectionMatrix = currentViewProjectionMatrix;
                
                Graphics.Blit(src, dest, MotionBlurMaterial);
            }
            else
            {
                Graphics.Blit(src, dest);
            }
        }
    }
}

shader

Shader "Hidden/MotionBlurWithDepthTextrue"
{
    Properties
    {
        _MainTex ("Texture", 2D) = "white" {}
        _BlurSize ("Blur Amount", Float) = 1.0
    }
    SubShader
    {
        CGINCLUDE

        #include <UnityCG.cginc>

        sampler2D _MainTex;
        half4 _MainTex_TexelSize;
        sampler2D _CameraDepthTexture;
        float4x4 _CurrentViewProjectionInverseMatrix;
        float4x4 _PreviousViewProjectionMatrix;
        float _BlurSize;

        struct a2v
        {
            float4 vertex : POSITION;
            float2 texcoord : TEXCOORD0;
        };

        struct v2f
        {
            float4 pos : SV_POSITION;
            float2 uv : TEXCOORD0;
            float2 uv_depth : TEXCOORD1;
        };

        v2f vert(a2v v)
        {
            v2f o;
            o.pos = UnityObjectToClipPos(v.vertex);

            o.uv = v.texcoord.xy;
            o.uv_depth = v.texcoord.xy;

            #if UNITY_UV_STARTS_AT_TOP
            if (_MainTex_TexelSize.y < 0)
                o.uv_depth.y = 1 - o.uv_depth.y;
            #endif

            return o;
        }

        fixed4 frag(v2f i) : SV_Target
        {
            float d = SAMPLE_DEPTH_TEXTURE(_CameraDepthTexture, i.uv_depth);
            float4 H = float4(i.uv.x * 2 - 1, i.uv.y * 2 - 1, d * 2 - 1, 1);
            float4 D = mul(_CurrentViewProjectionInverseMatrix, H);
            float4 worldPos = D / D.w;

            float4 currentPos = H;
            float4 previousPos = mul(_PreviousViewProjectionMatrix, worldPos);
            previousPos /= previousPos.w;

            float2 velocity = (currentPos.xy - previousPos.xy) / 2;

            float2 uv = i.uv;
            float4 color = tex2D(_MainTex, uv);
            uv += velocity * _BlurSize;
            for (int it = 1; it < 3; it++)
            {
                float4 currentColor = tex2D(_MainTex, uv);
                color += currentColor;

                uv += velocity * _BlurSize;
            }

            color /= 3; 

            return fixed4(color.rgb, 1.0);
        }
        
        ENDCG
        
        Pass
        {
            Cull Off ZWrite Off ZTest Always
            
            CGPROGRAM
            
            #pragma vertex vert
            #pragma fragment frag
            
            ENDCG
        }
    }
    
    FallBack off
}