Unity 屏幕模糊效果

最新推荐文章于 2024-06-18 14:28:44 发布
最新推荐文章于 2024-06-18 14:28:44 发布
阅读量3.5k 收藏 31
点赞数 17
分类专栏： Shader 文章标签： unity
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qiyet/article/details/109444093
版权

Unity 屏幕模糊效果

前几天，美术要我做一个屏幕模糊的效果，百度了半天，最后总算解决了。
趁着有时间，现在来总结一下。

首先我这边是为了出效果，所以原理先放一边，来谈谈如何实现。什么高斯模糊，均值模糊先忽略，看起来太懵，要花大时间去钻。总的来说，实现主要是两种类型，一种是基于摄像机，一种是基于UI遮罩实现。

摄像机实现

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

Shader "CameraFilterPack/Blur_Movie" {
    Properties 
    {
            _MainTex ("Base (RGB)", 2D) = "white" {}
            _TimeX ("Time", Range(0.0, 1.0)) = 1.0
            _Distortion ("_Distortion", Range(0.0, 1.0)) = 0.3
            _ScreenResolution ("_ScreenResolution", Vector) = (0.,0.,0.,0.)
            _Radius ("_Radius", Range(0.0, 1000.0)) = 700.0
            _Factor ("_Factor", Range(0.0, 1000.0)) = 200.0
    }
    SubShader 
    {
            Pass
            {
                    ZTest Always
                    CGPROGRAM
                    #pragma vertex vert
                    #pragma fragment frag
                    #pragma fragmentoption ARB_precision_hint_fastest
                    #pragma target 3.0
                    #pragma glsl
                    #include "UnityCG.cginc"
                     
                     
                    uniform sampler2D _MainTex;
                    uniform float _TimeX;
                    uniform float _Distortion;
                    uniform float4 _ScreenResolution;
                    uniform float _Radius;
                    uniform float _Factor;
                     
                struct appdata_t 
        {
            float4 vertex   : POSITION;
            float4 color    : COLOR;
            float2 texcoord : TEXCOORD0;
        };

        struct v2f
        {
              half2 texcoord  : TEXCOORD0;
              float4 vertex   : SV_POSITION;
              fixed4 color    : COLOR;
       };   
          
                      v2f vert(appdata_t IN)
        {
            v2f OUT;
            OUT.vertex = UnityObjectToClipPos(IN.vertex);
            OUT.texcoord = IN.texcoord;
            OUT.color = IN.color;
             
            return OUT;
        }
                  #define tex2D(sampler,uvs)  tex2Dlod( sampler , float4( ( uvs ) , 0.0f , 0.0f) )
                    float4 frag (v2f i) : COLOR
                    {
                            float factor = _Factor/_ScreenResolution.y * 64.0;
                            float radius = _Radius/_ScreenResolution.x * 2.0;
                            float4 col = 0.0; 
                            float4 accumColx = 0.0;
                            float4 accumW = 0.0;
                            for (float j = -5.0; j < 5.0; j += 1.0)
                            {
                                    for (float u = -5.0; u < 5.0; u += 1.0)
                                    { 
                                            float2 offsetx = (1.0/_ScreenResolution.xy) * float2(u + j, j - u);
                                            col = tex2D(_MainTex, i.texcoord.xy + offsetx * radius);
                                            float4 movie = 1.0 + col * col * col * factor;
                                            accumColx = accumColx + col * movie;
                                            accumW += movie;
                                    }
                            }  
                            accumColx = accumColx/accumW;
                            return accumColx;
                    }
                     
                    ENDCG
            }
             
    }
}

c#部分

using UnityEngine;
 
[ExecuteInEditMode]
[AddComponentMenu ("Camera Filter Pack/Blur/Movie")]
public class CameraFilterPack_Blur_Movie : MonoBehaviour {
        #region Variables
        public Shader SCShader;
        private float TimeX = 1.0f;
        private Vector4 ScreenResolution;
        private Material SCMaterial;
        [Range(0,1000)]
        public float Radius = 150.0f;
        [Range(0,1000)]
        public float Factor = 200.0f;
        [Range(1,8)]
        public int FastFilter = 2;
 
        public static float ChangeRadius;
        public static float ChangeFactor;
        public static int ChangeFastFilter;
 
        #endregion
         
        #region Properties
        Material material
        {
                get
                {
                        if(SCMaterial == null)
                        {
                                SCMaterial = new Material(SCShader);
                                SCMaterial.hideFlags = HideFlags.HideAndDontSave;        
                        }
                        return SCMaterial;
                }
        }
        #endregion
        void Start () 
        {
                ChangeRadius = Radius;
                ChangeFactor = Factor;
                ChangeFastFilter = FastFilter;
                SCShader = Shader.Find("CameraFilterPack/Blur_Movie");
 
                if(!SystemInfo.supportsImageEffects)
                {
                        enabled = false;
                        return;
                }
        }
 
        void OnRenderImage (RenderTexture sourceTexture, RenderTexture destTexture)
        {
         
                if(SCShader != null)
                {
                        int DownScale=FastFilter;
                        TimeX+=Time.deltaTime;
                        if (TimeX>100)  TimeX=0;
                        material.SetFloat("_TimeX", TimeX);
                        material.SetFloat("_Radius", Radius/DownScale);
                        material.SetFloat("_Factor", Factor);
                        material.SetVector("_ScreenResolution",new Vector2(Screen.width/DownScale,Screen.height/DownScale));
                        int rtW = sourceTexture.width/DownScale;
                        int rtH = sourceTexture.height/DownScale;
 
                        if (FastFilter>1)
                        {
                        RenderTexture buffer = RenderTexture.GetTemporary(rtW, rtH, 0);
                        Graphics.Blit(sourceTexture, buffer, material);
                        Graphics.Blit(buffer, destTexture);
                        RenderTexture.ReleaseTemporary(buffer);
                        }
                        else
                        {
                                Graphics.Blit(sourceTexture, destTexture, material);
                        }
                }
                else
                {
                        Graphics.Blit(sourceTexture, destTexture);        
                }
         
                 
        }
void OnValidate()
{
                ChangeRadius=Radius;
                ChangeFactor=Factor;
                ChangeFastFilter=FastFilter;
}
        // Update is called once per frame
        void Update () 
        {
                if (Application.isPlaying)
                {
                        Radius = ChangeRadius;
                        Factor = ChangeFactor;
                        FastFilter = ChangeFastFilter;
                }
                #if UNITY_EDITOR
                if (Application.isPlaying!=true)
                {
                        SCShader = Shader.Find("CameraFilterPack/Blur_Movie");
 
                }
                #endif
 
        }
         
        void OnDisable ()
        {
                if(SCMaterial)
                {
                        DestroyImmediate(SCMaterial);        
                }
                 
        }
 
}

将CameraFilterPack_Blur_Movie 挂在你想实现模糊得摄像机上，就可以实现屏幕模糊效果了。
在这里插入图片描述
调整Radius,Factor,FastFilter三个值去得到你想要得模糊度。

在这里插入图片描述

但这个效果，并不是我要的效果。我做的是2D休闲小游戏的开发，要求背景模糊，但是UI不能模糊。有人说，你看上面效果，UI不是没有模糊吗？不是完全符合你的开发需求？其实，在上面的场景里，我用了两个摄像机，一个主相机照场景，一个UI相机照UI。我只是让主相机模糊了，但UI相机还是正常的。而我开发的2D游戏，是只有一个摄像机的，所以这个方法不能符合我的开发需求。

基于UGI遮罩实现

Shader部分

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  
            }
        }  
    }
}

C#部分

using System.Collections;
using UnityEngine;

namespace Hyperbyte
{
    public static class UIExtentions
    {
        // Clear all child gameobjects of the given gameobject.
        public static void ClearAllChild(this GameObject obj)
        {
            if (obj.transform.childCount > 0)
            {
                foreach (Transform child in obj.transform)
                {
                    GameObject.Destroy(child.gameObject);
                }
            }
        }

		// Clear all child gameobjects of the given transform.
        public static void ClearAllChild(this Transform obj)
        {
            if (obj.childCount > 0)
            {
                foreach (Transform child in obj)
                {
                    GameObject.Destroy(child.gameObject);
                }
            }
        }

		// Clear all child gameobjects of the given rect transform.
        public static void ClearAllChild(this RectTransform obj)
        {
            if (obj.childCount > 0)
            {
                foreach (Transform child in obj)
                {
                    GameObject.Destroy(child.gameObject);
                }
            }
        }

        // Activates the given gameobject with animation. used for only popups of the game.
        public static void Activate(this GameObject target, bool addToStack = true)
        {
            // target.gameObject.SetActive(true);
            // target.transform.SetAsLastSibling();

            // if(addToStack) {
            //     UIController.Instance.Push(target.name);
            // }
        }

        // Deactivates the game object with animation.
        public static void Deactivate(this GameObject target)
        {
            // Animator animator = target.GetComponent<Animator>();
            // if (animator != null)
            // {
            //     animator.Play("Close");
            //     UIController.Instance.StartCoroutine(DisableWindow(target));
            // }
            // else
            // {
            //     target.SetActive(false);
            //     UIController.Instance.Pop(target.name);
            // }
        }

		/// <summary>
		/// Disable given gameobject and removes it from stack added to any.
		/// </summary>
        static IEnumerator DisableWindow(GameObject target)
        {
            yield return new WaitForSeconds(0.3F);
            // target.SetActive(false);
            // UIController.Instance.Pop(target.name);
        }
    }
}

用MyShader/BackBlur新建一个材质，再新建一个Image。把这个Image的材质设置为它。它挡住的地方（层级比他低的）都会变得模糊。在这里插入图片描述
这就完美符合我的需求了。只要把IMAGE遮住底部，就可以完美实现背景模糊的效果。调整它的层级就能决定谁模糊，谁不模糊。

qiyet
关注
  • 17
    点赞
  • 踩
  • 31
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
专栏目录
unity 屏幕模糊
05-25
当这些UI元素出现时，可以利用UI事件触发屏幕模糊效果。通过在Canvas上设置Panel，并应用模糊特效，可以实现背景模糊，使焦点集中在UI元素上。 6. **脚本控制**：在Unity中，我们可以编写C#脚本来控制模糊效果的...
Unity3D UGUI特效之Image高斯模糊效果
12-31
这几天研究了下模糊特效，看了很多文章，其原理就是拿取图片或屏幕数据，然后将周围的元素和目标位置的颜色值进行一个融合计算，然后自己写了一个小小的测试程序。 这个模糊也可以分成两种，一个是自身模糊，一个是...
【Unity】URP屏幕后处理UI模糊效果实现
两水先木示的博客
09-01 3572
主要以上内容，实际上就是因为Render Pass Event是只能After Rendering Transpanrets在透明物体渲染完成后进行屏幕后处理模糊，导致无法实现置顶UI高清，底下UI模糊的需求，如果可以控制这个后处理时机是在置顶UI渲染之前进行后处理，等后处理完成后再渲染指定UI 那就可以，然而...1个Canvas和2个摄像机。Shader代码实现模糊。
【游戏开发小技】Unity通过UI全屏图来模糊场景画面（Shader | 模糊 | 滤镜 | Blur）
热门推荐
linxinfa的专栏
02-14 1万+
【游戏开发小技】Unity通过UI全屏图来模糊场景画面（Shader | 模糊 | 滤镜 | Blur）
Unity中的模糊效果（基于URP）
最新发布
m0_58594062的博客
06-18 1390
六、移轴模糊 （Tilt Shift Blur）十、方向模糊（Directional Blur）三，Kawase模糊（Kawase Blur）一，高斯模糊（Gaussian Blur）八、粒状模糊（Grainy Blur）九、径向模糊（Radial Blur）五、散景模糊（Bokeh Blur）四、双重模糊（Dual Blur）七、光圈模糊（Iris Blur）二，方框模糊（Box Blur）十种模糊效果，以后处理方式实现。
Unity UI界面局部模糊
sinat_34014668的博客
08-31 3164
UI界面局部模糊
【Unity3d】窗体透明
dark00800的专栏
04-21 1万+
偶然在国外网站上看到的一个脚本，通过纯色背景抠像的方法，把windows的窗体透明化，可以用来做无背景的小头像、桌面精灵等。首先新建一个叫TransparentWindow的CS脚本，输入如下代码：using System; using System.Runtime.InteropServices; using UnityEngine;public class TransparentWindow :
Unity UGUI高斯模糊背景效果 简易解决方案
SaberZG的博客
11-18 1万+
UnityUI背景模糊效果简易解决方案1.功能描述简易界面框架搭建合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 1.功能描述 在我们玩游戏的时候，经常会看到一些游戏会对UI做这样的处理： 可以看到，新开的上层UI界面会以下层UI界面的模糊
[转]unity之模糊背景（带你欣赏女人的朦胧美）
小小姑娘
12-08 719
最近项目用到了模糊背景效果。实现方法为：shader。代码来自百度。接下来给大家介绍一下模糊背景的实现过程。首先你需要一个先人已经写好的shader（当然，如果你有能力，也可以自己实现！） 没有的可以通过以下链接下载材质球和对应的shader。 模糊背景shader 模糊背景材质球 shader如下： unity中使用方法： 为工程导入下载的材质球和shader 通常我们新建Material文件夹存放材质球 创建Shader文件夹存放shader代码 新建背景Image，命名为bg，并为其赋上指定的
Unity Build-in管线shader移植到URP管线下
zakerhero的博客
07-20 4942
概述 目前Build-in管线的shader都是代码形式的，不是shader graph。 所以如果想移植到URP管线下，或者HDRP管线下使用，必须修改代码。 具体步骤 在URP管线下，CGIncludes里的某些接口是失效的。 一、灯光模式 灯光模式是forward的接口，在URP下不是这么写的。 修改步骤如下； LightMode里的值改成UniversalForward。如下： "LightMode"="UniversalForward" 删掉以下内容： #define
Unity shader实现高斯模糊效果
08-26
Unity Shader 实现高斯模糊效果 高斯模糊是一种常用的图像处理技术，能够模糊图像的边缘，增加图像的艺术效果。在 Unity 中，使用 Shader 可以实现高斯模糊效果。本文将详细介绍如何使用 Unity Shader 实现高斯模糊...
Unity3D运动模糊特效
06-04
开启混合（Blend）后，通过 Alpha 通道控制当前屏幕纹理与历史屏幕纹理进行混合，当有物体运动时，就会将当前位置的物体影像与历史位置的物体影像进行混合，从而实现运动模糊效果，即模糊拖尾效果。 本资源基于 ...
Unity 毛玻璃模糊效果Shader
03-22
总的来说，"Unity毛玻璃模糊效果Shader"是利用Unity的Shader系统创建的一种视觉效果，它通过改变像素颜色和应用模糊算法来模拟毛玻璃的质感。开发者可以通过Shader Graph或其他方式自定义Shader，以达到理想中的模糊...
11.在Unity URP中使用UI相机
知识无止境
07-15 5373
摘自：《游戏瞎折腾手记》https://zhuanlan.zhihu.com/p/157310749 在Unity中制作UI时，我们通常习惯于单独使用一个Camera来拍摄UI内容。 场景相机 UI相机 最终画面 这种制作方式有不少优点，比如避免了主场景相机的后处理效果可能会干涉UI内容等问题。 然而在Unity新出的URP（通用渲染管线）中，这一制作方法却有点问题。在相当长的一段时间内，LWRP/URP是无法像以前的内置渲染管线一样叠加Camera的。而后来，总算是可以了，但.
Unity关于UGUI的特效包UIEffect
天富儿的博客
06-15 9906
UGUI的特效插件UIEffect资源介绍有关功能UI效果UI流光UI溶解UI 饱和度修改UI 过场动画效果UI 渐变色UI 翻转使用资源链接参考 资源介绍 UIEffect如其名，t为Unity UI提供了视觉效果组件。Demo 完善所见即所得，大家应该用得上。 让我们用效果装饰UI！您可以从脚本以及检查器中随意控制参数。当然支持AnimationClip！ Unity 2017.1或更高版本 有关功能 可以实现超多效果，包括但不限： UI效果 图片处理：灰度图，做旧图，负片效果，图片像素化 颜色处
URP——后期处理特效——环境遮挡Ambient Occlusion
liquanyi007的博客
11-30 5696
Ambient Occlusion 环境遮挡效果使折痕、洞、交叉点和彼此靠近的表面变暗。在现实世界中，这些区域往往会遮挡或遮挡环境光，所以它们看起来更暗。 URP实现了实时屏幕空间环境遮挡(SSAO)效果作为渲染器特性。 注意:SSAO效果是一个渲染器特性，它独立于URP中的后期处理效果。这种效果不依赖于体积，也不与体积相互作用。 下面的图片显示了一个场景，环境遮挡效果的关闭，打开和只有环境遮挡纹理。 环境光遮蔽效果关闭的场景。 打开环境光遮蔽效果的场景。 只有环境光遮
unity 手机 模糊效果_GUI背景模糊效果优化
weixin_39616880的博客
11-25 518
欢迎关注“数天技术”！“ 作者介绍：数字天空项目组客户端工程师 – 文立”导语在游戏界面显示时，通常会对背景进行模糊，使显示界面更加清楚。此外，在处理景深(Depth of Field)和泛光(Bloom)等后处理特效时，模糊效果也是必不可少的。本文针对移动平台，结合实际项目中遇到的UI背景模糊显示效果，讨论了模糊效果的优化解决方案。为了测试不同方案的实际模糊性能，新建了一个较为简单的测...
UGUI 背景虚化Shader
04-27 523
Shader "Custom/Blur" { Properties { _Blur("Blur", float) = 10 } SubShader { Tags{ "Queue" = "Transparent" } GrabPass {} Pass { CGPROGRAM #pragma vertex vert #pragma fragment frag #include "UnityCG.cginc" .
Unity-URP
qq_50682713的博客
09-27 8472
SRP：可编程渲染管线剔除 culling渲染 rendering后处理 postprocessingURP 通用可编程渲染管线使用SRP之后，由RenderPipelineAsset创建RenderPipeline，每帧走RenderPipeline.Render()URP内部RenderData创建Renderer，Camera可以指定使用的Renderer。
unity屏幕高斯模糊
09-19
Unity屏幕高斯模糊是一种后处理屏幕特效，它通过在材质球中设置高斯模糊效果来模糊当前物体层级的背景图像。在Unity中，你可以将高斯模糊效果添加到任何能设置材质球的地方，比如UGUI的Panel组件，在Image组件的Material中设置此高斯模糊效果。高斯模糊的程度取决于高斯核的维数，维数越大模糊程度越大。为了节省性能，可以将二维高斯核拆分为两个一维高斯核，从而减少纹理采样的次数。对于一个大小为5的一维高斯核，实际上只需要记录3个权值即可。
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值