unity毛玻璃效果(高斯模糊)

已于 2022-11-04 16:36:06 修改
阅读量4.2k 收藏 5
点赞数 1
分类专栏： unity Shader 文章标签： unity c#
于 2021-04-05 20:57:05 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45023328/article/details/115448067
版权
unity 同时被 2 个专栏收录
132 篇文章 20 订阅
订阅专栏
Shader
10 篇文章 0 订阅
订阅专栏

高斯模糊（英语：Gaussian Blur），也叫高斯平滑，通常用它来减少图像噪声以及降低细节层次。这种模糊技术生成的图像，其视觉效果就像是经过一个半透明屏幕在观察图像，这与镜头焦外成像效果散景以及普通照明阴影中的效果都明显不同。高斯平滑也用于计算机视觉算法中的预先处理阶段，以增强图像在不同比例大小下的图像效果（参见尺度空间表示以及尺度空间实现）。 从数学的角度来看，图像的高斯模糊过程就是图像与正态分布做卷积。由于正态分布又叫作高斯分布，所以这项技术就叫作高斯模糊。图像与圆形方框模糊做卷积将会生成更加精确的焦外成像效果。由于高斯函数的傅立叶变换是另外一个高斯函数，所以高斯模糊对于图像来说就是一个低通滤波器。

// Upgrade NOTE: replaced 'mul(UNITY_MATRIX_MVP,*)' with 'UnityObjectToClipPos(*)'

Shader "my/FrostedGlass"
{
    Properties
    {
        _blurSizeXY("BlurSizeXY", Range(0,10)) = 2
    }
        SubShader
    {
        // 透明队列，在所有不透明的几何图形后绘制
        Tags { "Queue" = "Transparent" }

        // 采样后面的图像
        GrabPass { }

        Pass
        {
            CGPROGRAM
            #pragma target 3.0
            #pragma debug
            #pragma vertex vert
            #pragma fragment frag

            sampler2D _GrabTexture : register(s0);
            float _blurSizeXY;

            struct data
            {
                float4 vertex : POSITION;
                float3 normal : NORMAL;
            };
            struct v2f
            {
                float4 position : POSITION;
                float4 screenPos : TEXCOORD0;
            };

            v2f vert(data i)
            {
                v2f o;
                o.position = UnityObjectToClipPos(i.vertex);
                o.screenPos = float4(o.position.x, o.position.y, o.position.z, o.position.w);
                return o;
            }

            half4 frag(v2f i) : COLOR
            {
                float2 screenPos = i.screenPos.xy / i.screenPos.w;
                float depth = _blurSizeXY * 0.0005;

                screenPos.x = (screenPos.x + 1) * 0.5;
                screenPos.y = 1 - (screenPos.y + 1) * 0.5;

                half4 sum = half4(0,0,0,0);

                sum += tex2D(_GrabTexture, float2(screenPos.x - 5.0 * depth, screenPos.y + 5.0 * depth)) * 0.025;
                sum += tex2D(_GrabTexture, float2(screenPos.x + 5.0 * depth, screenPos.y - 5.0 * depth)) * 0.025;

                sum += tex2D(_GrabTexture, float2(screenPos.x - 4.0 * depth, screenPos.y + 4.0 * depth)) * 0.05;
                sum += tex2D(_GrabTexture, float2(screenPos.x + 4.0 * depth, screenPos.y - 4.0 * depth)) * 0.05;

                sum += tex2D(_GrabTexture, float2(screenPos.x - 3.0 * depth, screenPos.y + 3.0 * depth)) * 0.09;
                sum += tex2D(_GrabTexture, float2(screenPos.x + 3.0 * depth, screenPos.y - 3.0 * depth)) * 0.09;

                sum += tex2D(_GrabTexture, float2(screenPos.x - 2.0 * depth, screenPos.y + 2.0 * depth)) * 0.12;
                sum += tex2D(_GrabTexture, float2(screenPos.x + 2.0 * depth, screenPos.y - 2.0 * depth)) * 0.12;

                sum += tex2D(_GrabTexture, float2(screenPos.x - 1.0 * depth, screenPos.y + 1.0 * depth)) * 0.15;
                sum += tex2D(_GrabTexture, float2(screenPos.x + 1.0 * depth, screenPos.y - 1.0 * depth)) * 0.15;

                sum += tex2D(_GrabTexture, screenPos - 5.0 * depth) * 0.025;
                sum += tex2D(_GrabTexture, screenPos - 4.0 * depth) * 0.05;
                sum += tex2D(_GrabTexture, screenPos - 3.0 * depth) * 0.09;
                sum += tex2D(_GrabTexture, screenPos - 2.0 * depth) * 0.12;
                sum += tex2D(_GrabTexture, screenPos - 1.0 * depth) * 0.15;
                sum += tex2D(_GrabTexture, screenPos) * 0.16;
                sum += tex2D(_GrabTexture, screenPos + 5.0 * depth) * 0.15;
                sum += tex2D(_GrabTexture, screenPos + 4.0 * depth) * 0.12;
                sum += tex2D(_GrabTexture, screenPos + 3.0 * depth) * 0.09;
                sum += tex2D(_GrabTexture, screenPos + 2.0 * depth) * 0.05;
                sum += tex2D(_GrabTexture, screenPos + 1.0 * depth) * 0.025;

                return sum / 2;
            }
            ENDCG
        }
    }
        Fallback Off
}

shader2

Shader "MyShader/BackBlur" {
        Properties
        {
        [PerRendererData] _MainTex ("Sprite Texture", 2D) = "white" {}
               _Color ("Main Color", Color) = (1,1,1,1)
        _Size ("Size", Range(0, 20)) = 1
        }
        Category {  
  
        // We must be transparent, so other objects are drawn before this one.  
        Tags {
                       "Queue"="Transparent"
                       "IgnoreProjector"="True"
                       "RenderType"="Transparent"
                       "PreviewType" = "Plane"
                       "CanUseSpriteAtlas" = "True"
               }  
  
  
        SubShader {  
  
            // Horizontal blur  
            GrabPass {                      
                Tags { "LightMode" = "Always" }  
            }  
            Pass {
                Tags { "LightMode" = "Always" }  
                Name "BackBlurHor"
                CGPROGRAM  
                #pragma vertex vert  
                #pragma fragment frag  
                #pragma fragmentoption ARB_precision_hint_fastest  
                #include "UnityCG.cginc"  
  
                struct appdata_t {  
                    float4 vertex : POSITION;  
                    float2 texcoord : TEXCOORD0;
                                      float4 color    : COLOR;
                };  
  
                struct v2f {  
                    float4 vertex : POSITION;  
                    float4 uvgrab : TEXCOORD0;
                                      float4 color    : COLOR;
                };
  
                v2f vert (appdata_t v) {  
                    v2f o;
                    o.vertex = UnityObjectToClipPos(v.vertex);  
                    #if UNITY_UV_STARTS_AT_TOP  
                    float scale = -1.0;  
                    #else  
                    float scale = 1.0;  
                    #endif  
                    o.uvgrab.xy = (float2(o.vertex.x, o.vertex.y*scale) + o.vertex.w) *  0.5;  
                    o.uvgrab.zw = o.vertex.zw;  
                                      o.color = v.color;
                    return o;  
                }  
  
                sampler2D _GrabTexture;  
                float4 _GrabTexture_TexelSize;
                           float4 _MainTex_TexelSize;
                float _Size;
                uniform float4 _Color;
                // static float GaussianKernel[9] = {
                //     0.05, 0.09, 0.12,
                //     0.15, 0.18, 0.15,
                //     0.12, 0.09, 0.05
                // };
                // static float GaussianKernel[19] = {
                //     0.01, 0.02, 0.03, 0.04, 0.05, 0.06, 0.07, 0.08, 0.09,
                //     0.1,
                //     0.09, 0.08, 0.07, 0.06, 0.05, 0.04, 0.03, 0.02, 0.01,
                // };
                // static float GaussianKernelD[19] = {
                //     -9.0, -8.0, -7.0, -6.0, -5.0, -4.0, -3.0, -2.0, -1.0,
                //     0.0,
                //     +1.0, +2.0, +3.0, +4.0, +5.0, +6.0, +7.0, +8.0, +9.0,
                // };
                half4 GrabPixel(v2f i, float weight, float kernelx){
                    if (i.uvgrab.x == 0 && i.uvgrab.y == 0){
                        kernelx = 0;
                    }
                    return tex2Dproj(_GrabTexture, UNITY_PROJ_COORD(float4(i.uvgrab.x +  _GrabTexture_TexelSize.x*kernelx*_Size, i.uvgrab.y, i.uvgrab.z, i.uvgrab.w))) * weight;
                }
                half4 frag( v2f i ) : COLOR {  
                       half4 sum = half4(0,0,0,0);
                    // #define GRABPIXEL(weight, kernelx) tex2Dproj(_GrabTexture,  UNITY_PROJ_COORD(float4(i.uvgrab.x + _GrabTexture_TexelSize.x * kernelx*_Size, i.uvgrab.y,  i.uvgrab.z, i.uvgrab.w))) * weight
                    
                    sum += GrabPixel(i, 0.05, -4.0);
                    sum += GrabPixel(i, 0.09, -3.0);
                    sum += GrabPixel(i, 0.12, -2.0);
                    sum += GrabPixel(i, 0.15, -1.0);
                    sum += GrabPixel(i, 0.18,  0.0);
                    sum += GrabPixel(i, 0.15, +1.0);
                    sum += GrabPixel(i, 0.12, +2.0);
                    sum += GrabPixel(i, 0.09, +3.0);
                    sum += GrabPixel(i, 0.05, +4.0);
                    // sum += GrabPixel(i, 0.01, -9.0);
                    // sum += GrabPixel(i, 0.02, -8.0);
                    // sum += GrabPixel(i, 0.03, -7.0);
                    // sum += GrabPixel(i, 0.04, -6.0);
                    // sum += GrabPixel(i, 0.05, -5.0);
                    // sum += GrabPixel(i, 0.06, -4.0);
                    // sum += GrabPixel(i, 0.07, -3.0);
                    // sum += GrabPixel(i, 0.08, -2.0);
                    // sum += GrabPixel(i, 0.09, -1.0);
                    // sum += GrabPixel(i, 0.10,  0.0);
                    // sum += GrabPixel(i, 0.09, +1.0);
                    // sum += GrabPixel(i, 0.08, +2.0);
                    // sum += GrabPixel(i, 0.07, +3.0);
                    // sum += GrabPixel(i, 0.06, +4.0);
                    // sum += GrabPixel(i, 0.05, +5.0);
                    // sum += GrabPixel(i, 0.04, +6.0);
                    // sum += GrabPixel(i, 0.03, +7.0);
                    // sum += GrabPixel(i, 0.02, +8.0);
                    // sum += GrabPixel(i, 0.01, +9.0);
                    float4 col5 = tex2Dproj(_GrabTexture, UNITY_PROJ_COORD(i.uvgrab));
                                      float decayFactor = 1.0f;
                                      if (i.uvgrab.x == 0 && i.uvgrab.y == 0){
                                             decayFactor = 0;
                                      }
                                      sum = lerp(col5, sum, decayFactor) * i.color *  _Color;
  
                    return sum;  
                }  
                ENDCG  
            }  
            // Vertical blur  
            GrabPass {                          
                Tags { "LightMode" = "Always" }  
            }  
            Pass {  
                Tags { "LightMode" = "Always" }
                Name "BackBlurVer"
                CGPROGRAM  
                #pragma vertex vert  
                #pragma fragment frag  
                #pragma fragmentoption ARB_precision_hint_fastest  
                #include "UnityCG.cginc"  
  
                struct appdata_t {  
                    float4 vertex : POSITION;  
                    float2 texcoord: TEXCOORD0;  
                                      float4 color    : COLOR;
                };  
  
                struct v2f {  
                    float4 vertex : POSITION;  
                    float4 uvgrab : TEXCOORD0;  
                                      float4 color    : COLOR;
                };  
  
                v2f vert (appdata_t v) {  
                    v2f o;  
                    o.vertex = UnityObjectToClipPos(v.vertex);  
                    #if UNITY_UV_STARTS_AT_TOP  
                    float scale = -1.0;  
                    #else  
                    float scale = 1.0;  
                    #endif  
                    o.uvgrab.xy = (float2(o.vertex.x, o.vertex.y*scale) + o.vertex.w) *  0.5;  
                    o.uvgrab.zw = o.vertex.zw;  
                                      o.color = v.color;
                    return o;  
                }  
  
                sampler2D _GrabTexture;  
                float4 _GrabTexture_TexelSize;  
                float _Size;
                uniform float4 _Color;
                half4 GrabPixel(v2f i, float weight, float kernely){
                    if (i.uvgrab.x == 0 && i.uvgrab.y == 0){
                        kernely = 0;
                    }
                    return tex2Dproj( _GrabTexture, UNITY_PROJ_COORD(float4(i.uvgrab.x,  i.uvgrab.y + _GrabTexture_TexelSize.y*kernely*_Size, i.uvgrab.z, i.uvgrab.w))) * weight;
                }
  
                half4 frag( v2f i ) : COLOR {
                    half4 sum = half4(0,0,0,0);  
                    // #define GRABPIXEL(weight,kernely) tex2Dproj( _GrabTexture,  UNITY_PROJ_COORD(float4(i.uvgrab.x, i.uvgrab.y + _GrabTexture_TexelSize.y * kernely*_Size,  i.uvgrab.z, i.uvgrab.w))) * weight  
  
                    sum += GrabPixel(i, 0.05, -4.0);
                    sum += GrabPixel(i, 0.09, -3.0);
                    sum += GrabPixel(i, 0.12, -2.0);
                    sum += GrabPixel(i, 0.15, -1.0);
                    sum += GrabPixel(i, 0.18,  0.0);
                    sum += GrabPixel(i, 0.15, +1.0);
                    sum += GrabPixel(i, 0.12, +2.0);
                    sum += GrabPixel(i, 0.09, +3.0);
                    sum += GrabPixel(i, 0.05, +4.0);
                    // sum += GrabPixel(i, 0.01, -9.0);
                    // sum += GrabPixel(i, 0.02, -8.0);
                    // sum += GrabPixel(i, 0.03, -7.0);
                    // sum += GrabPixel(i, 0.04, -6.0);
                    // sum += GrabPixel(i, 0.05, -5.0);
                    // sum += GrabPixel(i, 0.06, -4.0);
                    // sum += GrabPixel(i, 0.07, -3.0);
                    // sum += GrabPixel(i, 0.08, -2.0);
                    // sum += GrabPixel(i, 0.09, -1.0);
                    // sum += GrabPixel(i, 0.10,  0.0);
                    // sum += GrabPixel(i, 0.09, +1.0);
                    // sum += GrabPixel(i, 0.08, +2.0);
                    // sum += GrabPixel(i, 0.07, +3.0);
                    // sum += GrabPixel(i, 0.06, +4.0);
                    // sum += GrabPixel(i, 0.05, +5.0);
                    // sum += GrabPixel(i, 0.04, +6.0);
                    // sum += GrabPixel(i, 0.03, +7.0);
                    // sum += GrabPixel(i, 0.02, +8.0);
                    // sum += GrabPixel(i, 0.01, +9.0);
                                      float4 col5 = tex2Dproj(_GrabTexture,  UNITY_PROJ_COORD(i.uvgrab));
                                      float decayFactor = 1.0f;
                                      if (i.uvgrab.x == 0 && i.uvgrab.y == 0){
                                             decayFactor = 0;
                                      }
                                      sum = lerp(col5, sum, decayFactor) * i.color *  _Color;
  
                    return sum;  
                }  
                ENDCG  
            }
        }  
    }
}

原文链接：https://blog.csdn.net/qq_35711014/article/details/106799394

unity工具人
关注
  • 1
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
Unity Shader-后处理：高斯模糊
puppet_master的专栏
10-14 2万+
一.简介 上一篇文章学习了模糊的原理以及基本的模糊实现，对于清晰和模糊这个定义感觉还是比较说明问题，这里再贴出一下：“清晰的图片，各个像素之间会有明显的过渡，而如果各个像素之间的差距不是很大，那么图像就会模糊了”。鉴于这个定义，我们就可以通过代码来实现模糊的效果。上一篇Unity Shader-后处理：均值模糊中实现了一个基本的均值模糊，也就是将一个像素和其周围的像素取平均值从而进行
【猫猫的Unity Shader之旅】之高斯模糊
dbtxdxy的专栏
10-02 1105
在初识屏幕特效这篇文章我们已经讲过如果在Unity中通过C#脚本和Shader配合实现最简单的屏幕特效，但是这个特效过于简单了，只是对最后将要渲染到屏幕上的颜色(即图像，或者说一张2D纹理)进行了简单的修正。由于屏幕特效本质上是对将要渲染到屏幕上的图像进行处理，所以屏幕特效用到的很多技术都是从图像处理来的，于是乎也就需要一点点(许多多)数学知识。什么是高斯模糊在谈什么是高斯模糊之前我们先来看看什么是
Unity3d UI高斯模糊效果
土豆游戏开发
05-08 2234
如果你当前工程Canvas使用的是Screen Space - Overlay 模式，那么直接可以使用 但是使用Screen Space - Camera 模式，如果模糊效果没有实现话，你可能得到在Scene窗口下能看到模糊效果，但是在Game窗口并没效果，此时你要检查Canvas Plane Distance是不是离的太远造成的！ // Upgrade NOTE: re...
Unity中的模糊效果（基于URP）
最新发布
m0_58594062的博客
06-18 1621
六、移轴模糊 （Tilt Shift Blur）十、方向模糊（Directional Blur）三，Kawase模糊（Kawase Blur）一，高斯模糊（Gaussian Blur）八、粒状模糊（Grainy Blur）九、径向模糊（Radial Blur）五、散景模糊（Bokeh Blur）四、双重模糊（Dual Blur）七、光圈模糊（Iris Blur）二，方框模糊（Box Blur）十种模糊效果，以后处理方式实现。
Unity 高斯模糊
Zyt
02-28 1834
因为Unity提供了GrabPass，可以在Shader中很方便的拿到Panel下面的图像，即_GrabTexture。 注：添加优化。原本的搞死模糊效果达不到苹果的那种细腻效果，修改参数即可。 修改两个#define，kernelx*_Size ->kernelx*_Size * 1.61 // Upgrade NOTE: replaced 'mul(UNITY_MATRIX_MVP,*)' with 'UnityObjectToClipPos(*)' Shader "Custo...
Unity毛玻璃模糊效果Shader
08-03
Unity毛玻璃模糊效果Shader，直接赋值到材质球上进行使用即可。
Unity 高斯模糊Shader
02-27
高斯模糊GaussianBlur，里面提供了实例，该模糊应用的范围包括3D模型、UI（UGUI等）。不同于Unity自带的相机全屏模糊（后处理屏幕特效），是一个材质球的方式，直接模糊当前物体层级的背景图像。可以添加到任何能设置材质球的地方，比如UGUI的一个Panel组件，在Image里的Material中设置此高斯模糊的材质球，则在此Panel后面的所有UI以及3D物体都将模糊，并可以调节强度。里面有两种模糊shader，一种是针对移动端性能优化的，使用了两次高斯模糊；一种是高质量的，三次高斯模糊。
Unity3D UGUI特效之Image高斯模糊效果
12-31
针对移动平台，使用高斯模糊，其实效率不是很高，如果要很好的效果，那么速度卡；如果要速度快，那么效果达不到要求。但是还是在这里记录下，兴许以后能用上。 先说第一个，挂在Image下的模糊特效。 Shader Custom/...
unity CommandBuffer 实现毛玻璃效果
10-16
unity command buffer 实现毛玻璃特效，可用于3D物体或UI。
Unity动态高斯模糊效果Shader
12-21
Unity动态高斯模糊效果Shader
Unity 毛玻璃模糊效果Shader
03-22
总的来说，"Unity毛玻璃模糊效果Shader"是利用Unity的Shader系统创建的一种视觉效果，它通过改变像素颜色和应用模糊算法来模拟毛玻璃的质感。开发者可以通过Shader Graph或其他方式自定义Shader，以达到理想中的模糊...
Unity 高斯模糊(Gaussian Blur) 在UGUI中[高效][易用][效果棒]的实用方案
04-19
2019-04-19 新鲜出炉的原创作品 超实用的 Unity 高斯模糊(Gaussian Blur) 在UGUI中[高效][易用][效果棒]的实用方案 原文地址：https://blog.csdn.net/weixin_43452343/article/details/89407650 应该就是你想要
Unity shader实现高斯模糊效果
08-26
主要为大家详细介绍了Unity shader实现高斯模糊效果，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
Unity Shader - 后处理：高斯模糊
05-25
高斯模糊（Gaussian Blur），又叫做高斯平滑。高斯模糊主要的功能是对图片进行加权平均的过程，与均值模糊中周围像素取平均值不同，高斯模糊进行的是一个加权平均操作，每个像素的颜色值都是由其本身和相邻像素的颜色值进行加权平均得到的，越靠近像素本身，权值越高，越偏离像素的，权值越低。
unity高斯模糊Shader
12-13
基于Unity引擎编写的高斯模糊效果的Shader，真实可用，仅供学习参考
《Unity Shader 入门精要》笔记之高斯模糊
qq_59871555的博客
06-13 1019
在单个Pass中实现高斯模糊可能需要较大的计算量，特别是当高斯核（kernel）较大时。这可能导致性能下降，尤其是在移动设备或性能受限的平台上。
【Unity3d Shader】高斯模糊效果
PangNanGua的专栏
12-26 2941
高斯模糊可以实现模糊效果，可用于眩晕，场景动画等效果 高斯模糊利用了卷积计算，把每个像素和周围的像素混合 见代码实现 c#代码ImageEffectBase using UnityEngine; namespace GameBase.Effect { [RequireComponent(typeof (Camera))] [AddComponentMenu(...
unity 毛玻璃效果
03-30
Unity中的毛玻璃效果通常是通过模糊处理来实现的。下面是一些实现毛玻璃效果的方法： 1. 在Shader中使用模糊算法，例如高斯模糊算法。可以使用Unity自带的Blur Effect Shader或自己编写Shader来实现。 2. 在相机上添加后处理效果，例如使用Unity自带的Bloom或Depth of Field效果来实现毛玻璃效果。 3. 使用RenderTexture实现。首先将场景渲染到一个RenderTexture中，然后对RenderTexture进行模糊处理，最后将模糊后的RenderTexture渲染到屏幕上。 无论选择哪种方法，都需要考虑性能和效果平衡。毛玻璃效果通常需要大量的计算，因此需要在保证效果的同时尽可能减少性能开销。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值