【Unity渲染——屏幕后处理】Cg代码实现多种模糊算法（持续更新）

最新推荐文章于 2024-04-17 13:53:55 发布
最新推荐文章于 2024-04-17 13:53:55 发布
阅读量199 收藏 3
点赞数 1
分类专栏： 渲染项目实战 文章标签： unity 游戏引擎
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lordEaster/article/details/134776615
版权

常见模糊算法

        图像模糊算法在后处理中有着重要的地位，许多产品级后处理表现都会直接或间接使用模糊算法。在以下项目中将使用Cg代码实现部分模糊算法（均值模糊、高斯模糊、Kawase模糊、双向均值/高斯模糊）。

        参考网站：        一、高品质后处理：十种图像模糊算法的总结与实现

                                  二、Kawase模糊参考网站

                                  三、AI工具——豆包

均值模糊

        图像模糊原理，是使用低通滤波器，过滤图像的高频信息保留低频信息。对图像进行模糊处理。一种常见的方法就是使用卷积滤波器。

        算法原理

        将数字图像视作一个矩阵，每一个像素都是矩阵上的一点。现在我们使用一个矩阵，获取图像上每一个像素附近的像素，这一个矩阵就称之为卷积核。将卷积核中的像素的颜色值进行加权平均，就能得到一个颜色相对平均的图像，从而达到模糊处理的效果。根据卷积核的不同，可以将均值模糊分为3x3的模糊与2x2的模糊。

         2x2卷积核

       使用当前像素作为中心的九宫格区域，取左上、左下、右上、右下四格像素的数值进行加权平均，就是2x2的均值模糊的原理。

half4 frag (v2f i) : SV_Target
{
    half col = 0;
    //uv坐标采样加上像素偏移值。分别向左上、右上、左下、右下方向进行偏移。
    //定义变量_BlurOffset控制偏移大小
    col += tex2D(_MainTex, i.uv + _MainTex_TexelSize.xy * half2(1,1) * _BlurOffset;
    col += tex2D(_MainTex, i.uv + _MainTex_TexelSize.xy * half2(-1,1) * _BlurOffset;
    col += tex2D(_MainTex, i.uv + _MainTex_TexelSize.xy * half2(1,-1) * _BlurOffset;
    col += tex2D(_MainTex, i.uv + _MainTex_TexelSize.xy * half2(-1,-1) * _BlurOffset;
    //平均
    col *=0.25;
    return col;
}
         3x3卷积核

        原理与2x2卷积核类似，使用3x3大小的卷积核进行卷积操作即可得出。

half4 frag_testTap9 (v2f_img i) : SV_Target 
{
    
    half4 col = 0;
    //uv坐标采样加上像素偏移值。分别向左上、右上、左下、右下方向进行偏移。
    //定义变量_BlurOffset控制偏移大小
    col += tex2D(_MainTex, i.uv);
    col += tex2D(_MainTex, i.uv + _MainTex_TexelSize.xy * half2(1,1) * _BlurOffset);
    col += tex2D(_MainTex, i.uv + _MainTex_TexelSize.xy * half2(-1,1) * _BlurOffset);
    col += tex2D(_MainTex, i.uv + _MainTex_TexelSize.xy * half2(1,-1) * _BlurOffset);
    col += tex2D(_MainTex, i.uv + _MainTex_TexelSize.xy * half2(-1,-1) * _BlurOffset);
 
    //分别向右、左、上、下进行偏移
    col += tex2D(_MainTex, i.uv + _MainTex_TexelSize.xy * half2(1,0) * _BlurOffset);
    col += tex2D(_MainTex, i.uv + _MainTex_TexelSize.xy * half2(-1,0) * _BlurOffset);
    col += tex2D(_MainTex, i.uv + _MainTex_TexelSize.xy * half2(0,-1) * _BlurOffset);
    col += tex2D(_MainTex, i.uv + _MainTex_TexelSize.xy * half2(0,1) * _BlurOffset);
    //平均
    col = col/9.0;
    return col;
}

        代码详解

        将上述2x2、3x3的模糊算法片段着色器分别放在不同的pass中，绑定材质和脚本文件。通过OnRenderImage()函数，使用Graphics.Blit()分别调用以上着色器实现不同的算法。

public enum PassEnum
{
    //定义枚举类用于执行不同的模糊算法
    //实现的滤波器
    Tap4BoxFilter,
    Tap9BoxFilter
}
public Material material;
[Range(1, 10)]    
public int _Iteration = 4;    //定义迭代次数
[Range(0, 7)]
public float blurOffset = 1.0f;    //定义偏移值
public float downSample = 1.0f;    //定义图像降采样值
public PassEnum thePass;    //定义选用的模糊算法

.....


private void OnRenderImage(RenderTexture source, RenderTexture destination)
    {
        int width = (int)(source.width / downSample);
        int height = (int)(source.height / downSample);
        //设置shader的参数
        material.SetFloat("_BlurOffset", blurOffset);

        RenderTexture rt1 = RenderTexture.GetTemporary(width, height);
        RenderTexture rt2 = RenderTexture.GetTemporary(width, height);

        Graphics.Blit(source, rt1);
        
        //定义枚举类PassEnum，判断使用的模糊算法
        if (thePass == PassEnum.Tap4BoxFilter)
        {
            //迭代
            for (int i = 0; i < _Iteration; i++)
            {
                Graphics.Blit(rt1, rt2, material, 0);
                Graphics.Blit(rt2, rt1, material, 0);
            }
        }
        if (thePass == PassEnum.Tap9BoxFilter)
        {
            for (int i = 0; i < _Iteration; i++)
            {
                Graphics.Blit(rt1, rt2, material, 1);
                Graphics.Blit(rt2, rt1, material, 1);
            }
        }
        //将最后结果传递到destination
        Graphics.Blit(rt1, destination);
        //释放资源
        RenderTexture.ReleaseTemporary(rt1);
        RenderTexture.ReleaseTemporary(rt2);
    }

高斯模糊

        高斯模糊是最经典的模糊算法之一。与均值模糊类似，高斯模糊同样使用卷积核对图像进行卷积处理。只是卷积核换成了高斯卷积核。

        算法原理

        高斯模糊实际上是使用了正态分布对图像进行卷积。因为正态分布别称高斯分布，故称高斯模糊。高斯模糊使用5x5的矩阵，模拟正态分布进行加权卷积计算。得出的模糊效果比均值模糊更平滑。有关高斯模糊原理，详细请见高斯模糊原理

\frac{1}{256}\begin{bmatrix} 1 & 4 & 6 & 4 & 1\\ 4 & 16 & 24 & 16 &4 \\ 6 & 24 & 36 & 24 & 6\\ 4 & 16 & 24 & 16 & 4\\ 1 & 4 & 6 & 4 & 1 \end{bmatrix}

一个典型的高斯核↑

        5x5大小的卷积核太大，大量消耗算力，可以将高斯卷积核进行线性分解，拆解成{[1, 4, 6, 4, 1]}^{T} 和  [1, 4, 6, 4, 1]两个条状卷积核，纵向、横向各进行一次卷积处理即可达成高斯卷积核的效果。

        代码详解

half4 frag_HorizontalBlur(v2f i) : SV_Target
{
    half2 uv1 = i.uv + _MainTex_TexelSize.xy * _BlurOffset * half2(1, 0) * -2.0;
    half2 uv2 = i.uv + _MainTex_TexelSize.xy * _BlurOffset * half2(1, 0) * -1.0;
    half2 uv3 = i.uv;
    half2 uv4 = i.uv + _MainTex_TexelSize.xy * _BlurOffset * half2(1, 0) * 1.0;
    half2 uv5 = i.uv + _MainTex_TexelSize.xy * _BlurOffset * half2(1, 0) * 2.0;

  	half4 col = 0;
	col += tex2D(_MainTex, uv1) * 0.05;
    col += tex2D(_MainTex, uv2) * 0.25;
    col += tex2D(_MainTex, uv3) * 0.40;
	col += tex2D(_MainTex, uv4) * 0.25;
	col += tex2D(_MainTex, uv5) * 0.05;
	return col;
}

half4 frag_VerticalBlur(v2f i) : SV_Target
{
	half2 uv1 = i.uv + _MainTex_TexelSize.xy * _BlurOffset * half2(0, 1) * -2.0;
	half2 uv2 = i.uv + _MainTex_TexelSize.xy * _BlurOffset * half2(0, 1) * -1.0;
	half2 uv3 = i.uv;
	half2 uv4 = i.uv + _MainTex_TexelSize.xy * _BlurOffset * half2(0, 1) * 1.0;
	half2 uv5 = i.uv + _MainTex_TexelSize.xy * _BlurOffset * half2(0, 1) * 2.0;

	half4 col = 0;
	col += tex2D(_MainTex, uv1) * 0.05;
	col += tex2D(_MainTex, uv2) * 0.25;
	col += tex2D(_MainTex, uv3) * 0.40;
	col += tex2D(_MainTex, uv4) * 0.25;
	col += tex2D(_MainTex, uv5) * 0.05;
	return col;
}

private void OnRenderImage(RenderTexture source, RenderTexture destination)
{
    ......

    if (thePass == PassEnum.GaussainFilter)
    {
        for (int i = 0; i < _Iteration; i++)
        {
            //分别调用横向、竖向的两个卷积核进行渲染
            Graphics.Blit(rt1, rt2, material, 2);
            Graphics.Blit(rt2, rt1, material, 3);
        }
    }
}

Kawase模糊

        相较于高斯模糊、均值模糊等的“恒定卷积核”，使用“动态卷积核”来提升效率是一种很自然朴素的想法。所以，Kawase模糊被提了出来。

        Kawase Blur的思路是对距离当前像素越来越远的地方对四个角进行采样，且在两个大小相等的纹理之间进行乒乓式的blit。创新点在于，采用了随迭代次数移动的blur kernel，而不是类似高斯模糊，或box blur一样从头到尾固定的blur kernel。

        直接上代码

half4 frag_KawaseBlur(v2f i) : SV_Target
{
    half4 col = 0;

    col += tex2D(_MainTex, i.uv);
    col += tex2D(_MainTex, i.uv + half2(1, 1) * _KawaseRange * _MainTex_TexelSize);
    col += tex2D(_MainTex, i.uv + half2(1, -1) * _KawaseRange * _MainTex_TexelSize);
    col += tex2D(_MainTex, i.uv + half2(-1, 1) * _KawaseRange * _MainTex_TexelSize);
    col += tex2D(_MainTex, i.uv + half2(-1, -1) * _KawaseRange * _MainTex_TexelSize);

    col = col*0.2;
    return col;
}
if (thePass == PassEnum.KawaseFilter)
{
    material.SetFloat("_KawaseRange", 0);
    for(int i = 0; i < _Iteration; i++)
    {
        //设置KawaseRange用于在迭代过程中动态递进采样点
        material.SetFloat("_KawaseRange", (i + 1) * kawaseRange);
        Graphics.Blit(rt1, rt2, material, 3);
        //置换rt1与rt2
        RenderTexture temp = RenderTexture.GetTemporary(width, height);
        temp = rt2;
        rt2 = rt1;
        rt1 = temp;
        RenderTexture.ReleaseTemporary(temp);

    }
    
}

        我们可以看到，相比高斯模糊与均值模糊，Kawase模糊的每一次迭代只需调用一次Blit()函数。通过Unity自带的Frame Debugger进行检查，可以发现Kawase模糊调用Pass的次数更少的情况下，就能达到高斯模糊、均值模糊的模糊效果。也就是说，Kawase模糊计算性能更好。使用Kawase模糊，在一定程度上起到了性能优化的效果。

双重模糊

        算法原理

        Dual Kawase Blur，简称Dual Blur，是SIGGRAPH 2015上ARM团队提出的一种衍生自Kawase Blur的模糊算法。

        相较于Kawase Blur在两个大小相等的纹理之间进行乒乓blit的的思路，Dual Kawase Blur的核心思路在于blit过程中进行降采样和升采样,即对RT进行了降采样以及升采样。

        代码详解

        还是直接上代码。以下是双重高斯模糊

        if (thePass == PassEnum.DoubleGaussain)
        {
            //降采样
            for (int i = 0; i < _Iteration; i++)
            {
                RenderTexture.ReleaseTemporary(rt2);
                width = width / 2;
                height = height / 2;
                rt2 = RenderTexture.GetTemporary(width, height);
                Graphics.Blit(rt1, rt2, material, 2);

                RenderTexture.ReleaseTemporary(rt1);
                width = width / 2;
                height = height / 2;
                rt1 = RenderTexture.GetTemporary(width, height);
                Graphics.Blit(rt2, rt1, material, 3);
            }

            //升采样
            for (int i = 0; i < _Iteration; i++)
            {
                RenderTexture.ReleaseTemporary(rt2);
                width = width * 2;
                height = height * 2;
                rt2 = RenderTexture.GetTemporary(width, height);
                Graphics.Blit(rt1, rt2, material, 2);

                RenderTexture.ReleaseTemporary(rt1);
                width = width * 2;
                height = height * 2;
                rt1 = RenderTexture.GetTemporary(width, height);
                Graphics.Blit(rt2, rt1, material, 3);
            }
        }

        双重模糊只是一个模板，他可以是双重高斯模糊、双重均值模糊、双重Kawase模糊等。只需调整Blit()中调用的片段着色器即可。 

项目源码

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

[ExecuteInEditMode()]
public class BlurEffect : MonoBehaviour
{
    public Material material;
    [Range(1, 10)]
    public int _Iteration = 4;
    [Range(0, 7)]
    public float blurOffset = 1.0f;
    [Range(1, 15)]
    public float downSample = 5.0f;
    public PassEnum thePass;
    [Range(0, 5)]
    public float kawaseRange = 1.0f;
    [Range(0, 7)]
    public float test = 1.5f;
    
    // Start is called before the first frame update
    void Start()
    {
        if(material == null 
           || material.shader == null || material.shader.isSupported == false)
        {
            enabled = false;
            return;
        }

    }

    // Update is called once per frame
    void Update()
    {
        
    }
    private void OnRenderImage(RenderTexture source, RenderTexture destination)
    {
        //use the Screen width + height.
        int width = (int)(source.width / downSample);
        int height = (int)(source.height / downSample);
        //Performance Optimization.set the Vertex Shader caculating(GPU) to C#             caculating(CPU)
        //性能优化：将在GPU（顶点着色器）中计算的内容放在（CPU）C#脚本上进行计算提升性能
        material.SetVector("_BlurOffset", new Vector4(blurOffset / width, blurOffset / height, 0, 0));
        material.SetFloat("_TestOffset", test);

        RenderTexture rt1 = RenderTexture.GetTemporary(width, height);
        RenderTexture rt2 = RenderTexture.GetTemporary(width, height);

        Graphics.Blit(source, rt1);

        if (thePass == PassEnum.Tap4BoxFilter)
        {
            for (int i = 0; i < _Iteration; i++)
            {
                Graphics.Blit(rt1, rt2, material, 0);
                Graphics.Blit(rt2, rt1, material, 0);
            }
        }
        if (thePass == PassEnum.Tap9BoxFilter)
        {
            for (int i = 0; i < _Iteration; i++)
            {
                Graphics.Blit(rt1, rt2, material, 1);
                Graphics.Blit(rt2, rt1, material, 1);
            }
        }
        if (thePass == PassEnum.GaussainFilter)
        {
            for (int i = 0; i < _Iteration; i++)
            {
                Graphics.Blit(rt1, rt2, material, 2);
                Graphics.Blit(rt2, rt1, material, 3);
            }
        }
        if (thePass == PassEnum.KawaseFilter)
        {
            material.SetFloat("_KawaseRange", 0);
            for(int i = 0; i < _Iteration; i++)
            {
                material.SetFloat("_KawaseRange", (i + 1) * kawaseRange);
                Graphics.Blit(rt1, rt2, material, 4);

                RenderTexture temp = RenderTexture.GetTemporary(width, height);

                temp = rt2;
                rt2 = rt1;
                rt1 = temp;
                RenderTexture.ReleaseTemporary(temp);
                //Graphics.Blit(rt2, rt1, material, 4);
            }
            
        }
        if (thePass == PassEnum.DoubleTap4)
        {
            for (int i = 0; i < _Iteration; i++)
            {
                RenderTexture.ReleaseTemporary(rt2);
                width = width / 2;
                height = height / 2;
                rt2 = RenderTexture.GetTemporary(width, height);
                Graphics.Blit(rt1, rt2, material, 0);

                RenderTexture.ReleaseTemporary(rt1);
                width = width / 2;
                height = height / 2;
                rt1 = RenderTexture.GetTemporary(width, height);
                Graphics.Blit(rt2, rt1, material, 0);
            }

            for (int i = 0; i < _Iteration; i++)
            {
                RenderTexture.ReleaseTemporary(rt2);
                width = width * 2;
                height = height * 2;
                rt2 = RenderTexture.GetTemporary(width, height);
                Graphics.Blit(rt1, rt2, material, 0);

                RenderTexture.ReleaseTemporary(rt1);
                width = width * 2;
                height = height * 2;
                rt1 = RenderTexture.GetTemporary(width, height);
                Graphics.Blit(rt2, rt1, material, 0);
            }

        }
        if (thePass == PassEnum.DoubleTap9)
        {
            for (int i = 0; i < _Iteration; i++)
            {
                RenderTexture.ReleaseTemporary(rt2);
                width = width / 2;
                height = height / 2;
                rt2 = RenderTexture.GetTemporary(width, height);
                Graphics.Blit(rt1, rt2, material, 1);

                RenderTexture.ReleaseTemporary(rt1);
                width = width / 2;
                height = height / 2;
                rt1 = RenderTexture.GetTemporary(width, height);
                Graphics.Blit(rt2, rt1, material, 1);
            }

            for (int i = 0; i < _Iteration; i++)
            {
                RenderTexture.ReleaseTemporary(rt2);
                width = width * 2;
                height = height * 2;
                rt2 = RenderTexture.GetTemporary(width, height);
                Graphics.Blit(rt1, rt2, material, 1);

                RenderTexture.ReleaseTemporary(rt1);
                width = width * 2;
                height = height * 2;
                rt1 = RenderTexture.GetTemporary(width, height);
                Graphics.Blit(rt2, rt1, material, 1);
            }

        }
        if (thePass == PassEnum.DoubleGaussain)
        {
            //降采样
            for (int i = 0; i < _Iteration; i++)
            {
                RenderTexture.ReleaseTemporary(rt2);
                width = width / 2;
                height = height / 2;
                rt2 = RenderTexture.GetTemporary(width, height);
                Graphics.Blit(rt1, rt2, material, 2);

                RenderTexture.ReleaseTemporary(rt1);
                width = width / 2;
                height = height / 2;
                rt1 = RenderTexture.GetTemporary(width, height);
                Graphics.Blit(rt2, rt1, material, 3);
            }

            //升采样
            for (int i = 0; i < _Iteration; i++)
            {
                RenderTexture.ReleaseTemporary(rt2);
                width = width * 2;
                height = height * 2;
                rt2 = RenderTexture.GetTemporary(width, height);
                Graphics.Blit(rt1, rt2, material, 2);

                RenderTexture.ReleaseTemporary(rt1);
                width = width * 2;
                height = height * 2;
                rt1 = RenderTexture.GetTemporary(width, height);
                Graphics.Blit(rt2, rt1, material, 3);
            }
        }
        
        Graphics.Blit(rt1, destination);
        RenderTexture.ReleaseTemporary(rt1);
        RenderTexture.ReleaseTemporary(rt2);





    }


}

Shader "Hidden/BlurShader"
{

    Properties
    {
        _MainTex ("Texture", 2D) = "white" {}
        _KawaseRange("KawaseRange", Float) = 1 
        _BlurOffset("BlurOffset", Float) = 1
    }
        //使用CGINCLUDE，将cg语言放在前面，方便管理
        CGINCLUDE
        #include "UnityCG.cginc"

        sampler2D _MainTex;
        float4 _BlurOffset;
        float _KawaseRange;
        float4 _MainTex_TexelSize;


        half4 frag_BoxFilter_4Tap (v2f_img i) : SV_Target
        {
            half4 d = _BlurOffset.xyxy * half4(1,1,-1,-1);
            half4 s = 0;
            //采样进行像素偏移，偏移值与_BlurOffset挂钩
            //计算完毕后做平均
            s += tex2D(_MainTex, i.uv + d.xy);
            s += tex2D(_MainTex, i.uv + d.zy);
            s += tex2D(_MainTex, i.uv + d.xw);
            s += tex2D(_MainTex, i.uv + d.zw);
            s = s*0.25;
            return s;
        }

        half4 frag_testTap9 (v2f_img i) : SV_Target 
        {
            
            half4 col = 0;
            //uv坐标采样加上像素偏移值。分别向左上、右上、左下、右下方向进行偏移。
            //定义变量_BlurOffset控制偏移大小
            col += tex2D(_MainTex, i.uv);
            col += tex2D(_MainTex, i.uv + _MainTex_TexelSize.xy * half2(1,1) * _TestOffset);
            col += tex2D(_MainTex, i.uv + _MainTex_TexelSize.xy * half2(-1,1) * _TestOffset);
            col += tex2D(_MainTex, i.uv + _MainTex_TexelSize.xy * half2(1,-1) * _TestOffset);
            col += tex2D(_MainTex, i.uv + _MainTex_TexelSize.xy * half2(-1,-1) * _TestOffset);
 
            //分别向右、左、上、下进行偏移
            col += tex2D(_MainTex, i.uv + _MainTex_TexelSize.xy * half2(1,0) * _TestOffset);
            col += tex2D(_MainTex, i.uv + _MainTex_TexelSize.xy * half2(-1,0) * _TestOffset);
            col += tex2D(_MainTex, i.uv + _MainTex_TexelSize.xy * half2(0,-1) * _TestOffset);
            col += tex2D(_MainTex, i.uv + _MainTex_TexelSize.xy * half2(0,1) * _TestOffset);
            //平均
            col = col/9.0;
            return col;
        }

        half4 frag_BoxFilter_9Tap (v2f_img i) : SV_Target
        {
            
            //half4 d = _BlurOffset.xyxy * half4(1,-1,0,0);
            half4 d = _BlurOffset.xyxy * half4(-1, -1, 1, 1);
            half4 s = 0;
            s = tex2D(_MainTex, i.uv);
            
            s += tex2D(_MainTex, i.uv + d.xy);
            s += tex2D(_MainTex, i.uv + d.zy);
            s += tex2D(_MainTex, i.uv + d.xw);
            s += tex2D(_MainTex, i.uv + d.zw);

            s += tex2D(_MainTex, i.uv + half2(0.0, d.w));
            s += tex2D(_MainTex, i.uv + half2(0.0, d.y));
            s += tex2D(_MainTex, i.uv + half2(d.z, 0.0));
            s += tex2D(_MainTex, i.uv + half2(d.x, 0.0));
            s = s/9.0;
            return s;
        }

        half4 frag_HorizontalBlur(v2f_img i) : SV_Target
	    {

		    half2 uv1 = i.uv + _BlurOffset.xy * half2(1, 0) * -2.0;
		    half2 uv2 = i.uv + _BlurOffset.xy * half2(1, 0) * -1.0;
		    half2 uv3 = i.uv;
		    half2 uv4 = i.uv + _BlurOffset.xy * half2(1, 0) * 1.0;
		    half2 uv5 = i.uv + _BlurOffset.xy * half2(1, 0) * 2.0;

    		half4 s = 0;
	    	s += tex2D(_MainTex, uv1) * 0.05;
		    s += tex2D(_MainTex, uv2) * 0.25;
		    s += tex2D(_MainTex, uv3) * 0.40;
	    	s += tex2D(_MainTex, uv4) * 0.25;
	    	s += tex2D(_MainTex, uv5) * 0.05;
	    	return s;
	    }

	    half4 frag_VerticalBlur(v2f_img i) : SV_Target
	    {
	    	half2 uv1 = i.uv + _BlurOffset.xy * half2(0, 1) * -2.0;
	    	half2 uv2 = i.uv + _BlurOffset.xy * half2(0, 1) * -1.0;
	    	half2 uv3 = i.uv;
	    	half2 uv4 = i.uv + _BlurOffset.xy * half2(0, 1) * 1.0;
	    	half2 uv5 = i.uv + _BlurOffset.xy * half2(0, 1) * 2.0;

	    	half4 s = 0;
	    	s += tex2D(_MainTex, uv1) * 0.05;
	    	s += tex2D(_MainTex, uv2) * 0.25;
	    	s += tex2D(_MainTex, uv3) * 0.40;
	    	s += tex2D(_MainTex, uv4) * 0.25;
	    	s += tex2D(_MainTex, uv5) * 0.05;
	    	return s;
	    }

        half4 frag_KawaseBlur(v2f_img i) : SV_Target
        {
            half4 d = half4(1,1,-1,-1);
            half4 s = 0;

            s += tex2D(_MainTex, i.uv);

            s += tex2D(_MainTex, i.uv + d.xy * _KawaseRange * _MainTex_TexelSize.xy);
            s += tex2D(_MainTex, i.uv + d.zy * _KawaseRange * _MainTex_TexelSize.xy);
            s += tex2D(_MainTex, i.uv + d.xw * _KawaseRange * _MainTex_TexelSize.xy);
            s += tex2D(_MainTex, i.uv + d.zw * _KawaseRange * _MainTex_TexelSize.xy);

            s = s*0.2;
            return s;
        }

    ENDCG 

    SubShader
    {
        // No culling or depth
        Cull Off ZWrite Off ZTest Always

        Pass    //0号Pass
        {
            CGPROGRAM
            #pragma vertex vert_img
            #pragma fragment frag_BoxFilter_4Tap
            ENDCG
        }

        Pass    //1号Pass
        {
            CGPROGRAM
            #pragma vertex vert_img
            #pragma fragment frag_BoxFilter_9Tap
            ENDCG
        }
        pass    //2号Pass
        {
            CGPROGRAM
            #include "UnityCG.cginc"
            #pragma vertex vert_img
            #pragma fragment frag_HorizontalBlur  
            ENDCG
        }

        pass    //3号Pass
        {
            CGPROGRAM

            #include "UnityCG.cginc"
            #pragma vertex vert_img
            #pragma fragment frag_VerticalBlur
            ENDCG
        }

        pass    //4号Pass
        {
            CGPROGRAM
            #include "UnityCG.cginc"
            #pragma vertex vert_img
            #pragma fragment frag_KawaseBlur
            ENDCG
        }

        

    }
}

Easter菌
关注
  • 1
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
Unity-HDRP-Sense-8
Asincereman的专栏
02-28 1037
如何为一个已经摆放好模型的场景添加环境光设置（Volume的使用）。如何添加后处理效果。如何在相机上添加全屏抗锯齿效果。如何为场景添加光源，光照探针（Light Probe）和反射探针（Reflection Probe）。如何为场景烘培光照贴图。如果只知道这些基本操作，我们充其量只会找猫画虎，知其然但是不知其所以然。下面会详细讲解各个模块的原理，以及通过具体的项目来掩饰它们的用法。
Unity自定义后处理——用偏导数求图片颜色边缘
阿赵的博客
07-27 395
继续介绍屏幕后处理效果的做法。这次介绍一下用偏导数求图形边缘的技术。
Dual-Kawase-Blur：使用OpenGL的Dual Kawase模糊的Qt实现
02-02
Dual-Kawase-Blur：使用OpenGL的Dual Kawase模糊的Qt实现
第十二章 屏幕后处理效果
最新发布
s178435865的专栏
04-17 1050
第十二章 屏幕后处理效果
UnityShader基础（七）——屏幕后处理效果
SliverAsh_的博客
10-09 1452
屏幕后处理是基于渲染纹理实现的，通过更改渲染纹理的颜色等等实现某些某些视觉效果。
Unity Shader学习记录(19) ——屏幕后处理效果
weixin_45810196的博客
04-25 888
屏幕后处理，顾名思义，通常指的是在渲染完整个场景得到屏幕图像后，再对这个图像进行系列操作，实现各种屏幕特效。使用这种技术，可以为游戏画面添加更多的艺术效果，例如景深(DepthofField)、运动模糊(Motion Blur)等。
unity屏幕后处理
weixin_62773441的博客
02-19 341
vert_img unity内置后处理顶点函数；v2f_img unity内置后处理结构体色相调整HSV的r通道，进行一定的偏移再转回rgb饱和度伽马空间点乘的数值： 0.22, 0.707, 0.071pow用来增加对比度，0-1的范围且pow越多会让数值更靠0（更多的是黑色）
Unity Shader入门精要 第十二章——屏幕后处理效果
buzhengli的博客
09-03 405
卷积操作指定是使用一个卷积核（kernel）对一张图像中的每个像素进行一系列的操作。卷积核通常是一个四方形网格结构，该方格每个区域都有一个权重值。对图像中的某个像素进行卷积时，我们会把卷积核的中心位置放置于该像素上(如下图)，翻转核之后依次计算核中每个元素和其覆盖的图像像素值的乘积并求和，得到的就是该位置的新像素值。不同的卷积和就可以得到不同的效果计算核中每个元素和其覆盖的图像像素值的乘积并求和。
Unity3D调整屏幕亮度、饱和度、对比度
05-31
本资源基于Unity实现了调整屏幕亮度、饱和度、对比度。效果见博客→https://zhyan8.blog.csdn.net/article/details/130958521
Unity Shader - 后处理：高斯模糊
05-25
高斯模糊主要的功能是对图片进行加权平均的过程，与均值模糊中周围像素取平均值不同，高斯模糊进行的是一个加权平均操作，每个像素的颜色值都是由其本身和相邻像素的颜色值进行加权平均得到的，越靠近像素本身，权值...
unity 屏幕模糊
05-25
例如你要打开提示面板，对话面板 一系列的提示框 ，你都可以使用这个，他会截取屏幕一张图然后模糊化，非常好用
Unity Shader-后处理：简单均值模糊
05-23
所谓模糊，也就是不清楚，清晰的图片，各个像素之间会有明显的过渡，而如果各个像素之间的差距不是很大，那么图像就会模糊了，极端一点的情况，当一张图片所有的像素之间颜色都差不多时，那么这张图片也就是一个纯色...
unity实现屏幕上写字效果
08-25
主要为大家详细介绍了unity实现屏幕上写字效果，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
共轭梯度（CG）算法
热门推荐
LSEC小陆的博客
11-16 9万+
共轭梯度（CG）方法计算数学与科学工程计算研究所 陆嵩简单介绍共轭梯度方法也是一种迭代方法，不同于Jacobi，Gauss-Seidel和SOR方法，理论上只要n步就能找到真解，实际计算中，考虑到舍入误差，一般迭代3n到5n步，每步的运算量相当与矩阵乘向量的运算量，对稀疏矩阵特别有效。 共轭梯度方法对于求解大型稀疏矩阵是很棒的方法，但是这个方法看起来总不是太靠谱。这个方法也不是越迭代精度越高，有
Shader 高斯模糊和Bloom
sinat_34014668的博客
03-20 831
高斯模糊和Bloom
unity 高斯模糊_十种图像模糊算法的总结与实现
weixin_39755890的博客
12-09 2031
作者：毛星云，腾讯 IEG 游戏开发工程师后处理(Post-Processing)，在图形学和游戏开发等领域是提升最终画面呈现品质的重要渲染技术。后处理渲染技术的好坏，往往决定了游戏画面是否能够达到令人惊艳的级别。图像模糊算法在后处理渲染领域中占据着重要的地位。很多产品级后处理的实现，都会直接或间接依赖于图像模糊算法中的一种或多种。无论是基于高斯模糊(Gaussian Blur)或其改进...
Unity制作二次元卡通渲染角色材质——3、高光反射与ILM贴图
阿赵的博客
06-04 1731
Unity制作二次元卡通渲染角色材质，3、高光反射与ILM贴图
【Unity Shader】屏幕后处理3.0：均值模糊和高斯模糊
qq_41835314的博客
11-01 1916
在Unity中尝试了基于屏幕的均值模糊和高斯模糊效果。
Unity Shader - 均值模糊和高斯模糊
长生但酒狂的博客
01-15 3232
说到模糊处理我们一般就会想到多种模糊处理方法，如均值模糊，高斯模糊等等方式。 通常用它们来减少图像噪声以及降低细节层次。这种模糊技术生成的图像，其视觉效果就像是经过一个半透明屏幕在观察图像，这与镜头焦外成像效果散景以及普通照明阴影中的效果都明显不同。 均值模糊和高斯模糊它们各有各的优势，均值模糊处理速度更快，实现也相对简单一些，高斯模糊处理效果更好，性能差点，实现相对复杂点。 我们先来实现一下相对...
Unity 通过代码实现屏幕分辨率
05-26
在 Unity 中，我们可以通过代码来设置屏幕分辨率。下面是一个简单的示例： ```csharp using UnityEngine; public class ResolutionManager : MonoBehaviour { public int width = 1920; public int height = 1080; public bool fullscreen = true; void Start() { SetResolution(); } void SetResolution() { Screen.SetResolution(width, height, fullscreen); } } ``` 在上面的代码中，我们创建了一个 `ResolutionManager` 类，它包含了屏幕的宽度、高度和是否全屏等属性。在 `Start()` 方法中，我们调用了 `SetResolution()` 方法来设置屏幕分辨率。 在 `SetResolution()` 方法中，我们使用了 `Screen.SetResolution()` 方法来设置屏幕分辨率。该方法需要三个参数：屏幕的宽度、高度和是否全屏。 你可以根据自己的需求修改 `width`、`height` 和 `fullscreen` 属性的值，以达到不同的屏幕分辨率设置。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值