精华内容
下载资源
问答
  • Unity屏幕后处理

    千次阅读 2019-01-08 20:31:55
     过程:摄像中添加屏幕后处理脚本,OnRenderImage(RenderTexture src, RenderTexture dest)会将当前渲染的图像存储在src的纹理中,使用Graphics.Blit(RenderTexture src, RenderTexture dest, Material ...

            后处理:渲染完整个场景得到屏幕图像后,对这个图像进行操作。

            过程:摄像中添加屏幕后处理脚本,OnRenderImage(RenderTexture src, RenderTexture dest)会将当前渲染的图像存储在src的纹理中,使用Graphics.Blit(RenderTexture src,  RenderTexture dest, Material material)和特定的Shader对当前图像进行处理,再把dest显示在屏幕上。注:OnRenderImage是Mono的函数。Graphics.Blit会将第一个参数传给Shader中_MainTex属性。

            渲染状态:关闭深度写入。

            1、简单的调整亮度、饱和度、对比度

            fixed4 frag(v2f i) : SV_Target

             {

                    fixed4 renderTex = tex2D(_MainTex, i.uv);

                     fixed3 finalColor = renderTex.rgb * _Brightness;

                     fixed luminance = 0.2125 * renderTex.r + 0.7154 * renderTex.g + 0.0721 * renderTex.b;

                     fixed3 luminanceColor = fixed3(luminance, luminance, luminance);

                      finalColor = lerp(luminanceColor, finalColor, _Saturation);

                     fixed3 avgColor = fixed3(0.5, 0.5, 0.5);

                      finalColor = lerp(avgColor, finalColor, _Contrast);

                     return fixed4(finalColor, renderTex.a);

             }

             2、边缘检测

             卷积操作:使用卷积核对图像的每个像素进行操作。常见的边缘卷积算子(卷积核)有Sobel,Roberts等。

             由于卷积需要对相邻区域内的纹理进行采样,需要利用_MainTex_TexelSize(可以访问纹理对应的每个纹素的大小)计算相邻区域的纹理坐标。下面是使用Sobel算子实现边缘检测。

    v2f vert(appdata_img v) {
      v2f o;
      o.pos = UnityObjectToClipPos(v.vertex); 
      half2 uv = v.texcoord;   
       o.uv[0] = uv + _MainTex_TexelSize.xy * half2(-1, -1);
       o.uv[1] = uv + _MainTex_TexelSize.xy * half2(0, -1);
       o.uv[2] = uv + _MainTex_TexelSize.xy * half2(1, -1);  
       o.uv[3] = uv + _MainTex_TexelSize.xy * half2(-1, 0);
       o.uv[4] = uv + _MainTex_TexelSize.xy * half2(0, 0);
       o.uv[5] = uv + _MainTex_TexelSize.xy * half2(1, 0);
       o.uv[6] = uv + _MainTex_TexelSize.xy * half2(-1, 1);
       o.uv[7] = uv + _MainTex_TexelSize.xy * half2(0, 1);
       o.uv[8] = uv + _MainTex_TexelSize.xy * half2(1, 1); 
       return o;//存储了邻域的纹理坐标,从片元放在顶点着色器,减少运算,提高性能。
     }

    片元着色器:

    fixed4 fragSobel(v2f i) : SV_Target {
       half edge = Sobel(i);  //计算当前像素的梯度值
       fixed4 withEdgeColor = lerp(_EdgeColor, tex2D(_MainTex, i.uv[4]), edge);
       fixed4 onlyEdgeColor = lerp(_EdgeColor, _BackgroundColor, edge);
       return lerp(withEdgeColor, onlyEdgeColor, _EdgeOnly);
     } 

    简单解释一下lerp:

    float lerp(float a, float b, float w) {
      return a + w*(b-a);
    }

    Sobel函数如下:

    fixed luminance(fixed4 color) {
        return  0.2125 * color.r + 0.7154 * color.g + 0.0721 * color.b;
     }
     

    half Sobel(v2f i) {
       const half Gx[9] = {-1,  0,  1,
                                      -2,  0,  2,
                                     -1,  0,  1};
      const half Gy[9] = {-1, -2, -1,

                                     0,  0,  0,
                                    1,  2,  1};  

        half texColor;
        half edgeX = 0;
        half edgeY = 0;
        for (int it = 0; it < 9; it++) {
             texColor = luminance(tex2D(_MainTex, i.uv[it]));
             edgeX += texColor * Gx[it]; 
             edgeY += texColor * Gy[it]; 
          }
        half edge = 1 - abs(edgeX) - abs(edgeY);
        return edge;
     }

            对9个像素进行采样,计算亮度值,再与水平和竖直方向的卷积核中对应的权重相乘,最后叠加到各自的梯度值上。edge越小越是边缘。

            注:上述我们是对屏幕的颜色信息进行的边缘检测,由于实际中纹理、阴影等很多信息会影响这个结果,因此,会对深度纹理和法线纹理进行边缘检测。

            3、高斯模糊

             均值模糊也是使用了卷积操作,且卷积核中的每个元素值相等,且相加为1,卷积后得到的像素值是其相邻域中各个像素的平均值。中值模糊是邻域中所有像素排序后取中值为像素颜色。

            高斯模糊使用的卷积核叫高斯核。高斯核是正方形的,每个元素按下面这个方程计算,x,y对应当前到中心的距离。

            高斯核的维数越高,模糊程度越大。N*N的高斯核对W*H的图像要采样N*N*W*H次。但是,我们可以将二维的拆成两个一维的,使用两个一维的先后滤波,采样次数2*N*W*H。

             4、bloom效果

             让画面中较亮的部分扩散到周围,朦胧感。实现方法:根据一个阈值将图像中较亮的部分存在一张纹理中,再对这张纹理高斯模糊,最后将它和原图像混合。

            提取较亮的部分:

            fixed4 c = tex2D(_MainTex, i.uv);

            fixed val = clamp(luminance(c) - _Luminance, 0.0, 1.0);

             return c * val;

            5、SSAO(屏幕空间环境光遮蔽)

            用来模拟环境光,被遮蔽的物体环境光要稍微暗一些。

            原理:对铺屏四边形上的每片段,根据周边深度值计算遮蔽因子。这个遮蔽因子用来减少或者抵消片段的环境光照分量。高于片段深度值样本的个数就是遮蔽因子。遮蔽因子是通过采集片段周围球型核心(Kernel)的多个深度样本,并和当前片段深度值对比而得到的。

           实现方式(有很多种):

           基于法线的半球积分:计算P的遮挡值,需要把它周围的像素都当成一个小球,然后计算这个小球对它遮挡值的总和。影响因素有:周围像素点到P的距离,周围像素点到P的向量V和P点的法线的夹角。

           基于视线方向的球积分。

           据不同的需求给SSAO采样点分级,比如要好点的效果可以采样32次以上,要性能高点可以采样8次就够了。有较高要求的SSAO给结果进行模糊处理 降噪 会使明暗程度更加平滑。在较低次数采样下基于View方向的球积分效果表现更好,在较高次数采样下基于normal方向的半球积分表现效果更好。总的来说基于normal方向的计算效果更佳逼真。

            6、DOF(景深)

           现实世界中,相机只能聚焦到一个特定距离的焦平面,焦平面内侧和外侧较远的物体都会被虚化模糊。景深效果可以提高场景深度感,突出重点物体,比如人物摄影的时候虚化背景。焦点上的清晰度是最高的,其余的影像清晰度随着它与焦点的距离成正比例下降。

            原理:通过两张图片,一张清晰的,一张经过高斯模糊的,然后根据图片中每个像素的深度值在两张图片之间差值,就可以达到景深的效果了。模糊的方法可以用前面介绍的高斯模糊。

            Camera Depth Texture记录了屏幕空间所有物体距离相机的距离。

            参考:https://blog.csdn.net/puppet_master/article/details/52819874,写的很不错,实现也有。

           7、SSR

           8、AA

    会增加内存消耗,低内存机型上关掉。

         (持续更新中)

     

     

     

     


     

     

     

     

     

     

     

     

    展开全文
  • 后处理是在渲染完后对图像进行处理,unity使用的是 C# 脚本 就是渲染完后不显示,多走一步,经由脚本处理后再显示到屏幕上,以实现诸如各种模糊效果、Bloom、描边等等 后处理一般过程 获取当前屏幕图像,利用C#脚本...

    后处理原理及过程

    后处理是在渲染完后对图像进行处理,unity使用的是 C# 脚本

    就是渲染完后不显示,多走一步,经由脚本处理后再显示到屏幕上,以实现诸如各种模糊效果、Bloom、描边等等


    后处理一般过程

    获取当前屏幕图像,利用C#脚本调用shader对图像进行处理,在将处理后的图像显示到屏幕上

    原理

    创建了一个同屏幕宽高完全一样的面,将之前的渲染结果作为渲染纹理传入脚本,调用shader对纹理采样渲染回面片

    所以在后处理时需要关闭深度写入等,防止渲染纹理覆盖了特殊情况下最后渲染的半透明物体


    Unity提供了OnRenderImage()函数获取屏幕图像

    MonoBehaviour.OnRenderImage (RenderTexture src, RenderTexture dest)

    /*OnRenderImage中利用Graphics.Blit实现处理*/
    public static void Blit(Texture src, Texture dest);
    
    public static void Blit(Texture src, Texture dest, Material mat, int pass = -1);
    
    public static void Blit(Texture src, Material mat, int pass = -1);
    

    Blit函数获取屏幕图像后调用shader,将源图像src作为一张渲染纹理赋值给shader_MainTex


    边缘检测(描边)

    梯度的本意是一个向量(矢量),表示某一函数在该点处的方向导数沿着该方向取得最大值,即函数在该点处沿着该方向(此梯度的方向)变化最快,变化率最大(为该梯度的模)

    二维空间下的偏微分方程
    ∂ f ( x , y ) ∂ x = lim ⁡ ϵ − > 0 f ( x + ϵ , y ) − f ( x , y ) ϵ \frac{∂f(x,y)}{∂x}=\lim_{\epsilon->0}\frac{f(x+\epsilon,y)-f(x,y)}{\epsilon} xf(x,y)=ϵ>0limϵf(x+ϵ,y)f(x,y)

    ∂ f ( x , y ) ∂ y = lim ⁡ ϵ − > 0 f ( x , y + ϵ ) − f ( x , y ) ϵ \frac{∂f(x,y)}{∂y}=\lim_{\epsilon->0}\frac{f(x,y+\epsilon)-f(x,y)}{\epsilon} yf(x,y)=ϵ>0limϵf(x,y+ϵ)f(x,y)

    由于像素不是连续的,只要计算当前像素沿偏微分方向的差值,ε=1,所以只需进行简单的加减运算

    在xy得到的值经过勾股定理后就得到,二维空间下灰度的变化率

    边缘检测算子

    请添加图片描述

    注意:图中后两个算子是错的,xy方向反了!!!

    一般不采用 Roberts 这样偶数的算子,因为结果对原像素存在偏移


    Prewitt: G x = f ( x + 1 ) + 0 ∗ f ( x ) − f ( x − 1 ) Gx = f(x+1) + 0 * f(x)-f(x-1) Gx=f(x+1)+0f(x)f(x1),提取系数就是[-1, 0, 1]

    所以该算子Gx就是:     同理Gy:
    [-1, 0, 1]				[-1, -1, -1]
    [-1, 0, 1]				[ 0,  0,  0]
    [-1, 0, 1]				[ 1,  1,  1]
    

    Sobel就是prewitt的基础上,加强了对直线上像素的检测


    高斯模糊和 Bloom 效果

    均值模糊

    卷积核的各元素值相同,n*n的核每个的值就是1/n^2

    高斯模糊

    高斯模糊的卷积核又叫高斯核

    高斯模糊的名字来源于高斯分布(正态分布),其概率密度函数所表示的就是均值与样本值之间的关系,所以高斯模糊就是一种权值按距离减少的方法
    G ( x , y ) = 1 2 π σ 2 e − x 2 + y 2 2 σ 2 G(x,y)=\frac{1}{2\pi\sigma^2}e^{-\frac{x^2+y^2}{2\sigma^2}} G(x,y)=2πσ21e2σ2x2+y2
    μ \mu μ就是0,因为当前像素的原点距离为0,方差 σ \sigma σ取标准方差1

    n*n 的高斯核可以使用两个一维的高斯核替换

    而且由于概率密度函数是对称的,所以存储上可以优化


    /*Shader*/
    _MainTex获取屏幕图像
    _MainTex_TexelSize获取纹素尺寸
        
    /*计算纹理坐标*/
    half2 uv[5] : TEXCOORDS0
        //Vertical
        uv[0]=uv;
    	uv[1]=uv + float2(0.0, _MainTex_TexelSize * 1.0);//上方一格的坐标
    	uv[2]=uv - float2(0.0, _MainTex_TexelSize * 1.0);//下方一格的坐标
    	uv[3]=uv + float2(0.0, _MainTex_TexelSize * 2.0);//上方两格的坐标
    	uv[4]=uv - float2(0.0, _MainTex_TexelSize * 2.0);//下方两格的坐标
    	//horizontal同理
    

    Bloom效果

    步骤:提取图像中的亮部(像素的亮度可由rgb通过一定比例的计算获得),对提取的亮部进行高斯模糊,混合原图和Bloom

    luminance = 0.2125 * r + 0.7154 * g + 0.0721 * b,可以看出绿色对亮度的贡献最大,红色次之,蓝色最小


    运动模糊

    方法:累计缓存(混合多张图像),速度缓存(按照像素的运动速度来模糊处理)


    脚本

    /*一般格式*/
    using UnityEngine;
    using System.Collections;
    
    public class MyScript : MonoBehaviour {
        public Shader MyScriptShader;
        private Material MyScriptMaterial = null;
        
        public Material material {
            get {
            	MyScriptMaterial = function(MyScriptShader, MyScriptMaterial);
            	return MyScriptMaterial;
        	}
        }
        
        
        //暴露的属性
        [Range(0, 4)]
        public int temp = 3;
        ...
        
       	//调用shader
        void OnRangeImage(RenderTexture src, RenderTexture dest) {
            if(material != null) {
                material.setFloat("_temp", temp);
                //后处理
                Graphics.Blit(src, dest, material);
            } 
            else {
                //直接返回
                Graphics.Blit(src, dest);
            }
        }
    }
    
    展开全文
  • Unity屏幕后处理参数介绍

    千次阅读 2019-04-08 18:38:50
    导入Unity提供的后处理资源包,PostProcessing 资源包,在相机上添加ProcessingBehaviour脚本。通过编辑对应的ProcessingProfile文件来实现相应的效果。 Fog: 雾特效 Antialiasing:抗锯齿 Ambient Occlusion...

    导入Unity提供的后处理资源包,PostProcessing 资源包,在相机上添加ProcessingBehaviour脚本。通过编辑对应的ProcessingProfile文件来实现相应的效果。

    Fog: 雾特效

    Antialiasing:抗锯齿

    Ambient Occlusion:环境光遮蔽

    ScreenSpace Reflection :屏幕空间反射

    Depth Of Filed:景深

    Motion Blur:运动模糊

    Eye Adaptation: 眼部适应

    Bloom: 增强高光地方,和雾效结合效果更好

    Color Grading :颜色的修正,整体场景色调

    User Lut : 和颜色修正比较相像,把你要修正的颜色做成图片,Unity会自动把场景往这张图上的颜色修正

    Chromatic:色差 一般和Vignette一起用,有镜头光晕的效果

    Grain: 画面颗粒度

    雾效设置,可以在Lighting里面OtherSetting

    雾的颜色和密度以及渲染模式

    具体效果要配合实际场景来进行调整。

     

    展开全文
  • (4)将模糊的图像和原图像混合 经过上面的步骤,能高效的实现bloom效果 常规的bloom是使用: 提取高亮+ 卷积滤波横向和纵向+ 混合高亮模糊图和原图(这种实现方式和原理介绍,网上一大堆,这里就不再细说了) ...

    前言:前几天看米哈游的技术总监说:《崩坏3》的bloom效果的实现是
    (1)高亮像素过滤
    (2)向下采样(降采样)
    (3)向上采样
    (4)将模糊后的图像和原图像混合

    经过上面的步骤,能高效的实现bloom效果


    常规的bloom是使用: 提取高亮+ 卷积滤波横向和纵向+ 混合高亮模糊图和原图(这种实现方式和原理介绍,网上一大堆,这里就不再细说了)



    一.效果图:
    在这里插入图片描述在这里插入图片描述

    话不多说,直接上代码:

    using System.Collections;
    using System.Collections.Generic;
    using UnityEngine;
    
    [ExecuteInEditMode]
    [ImageEffectAllowedInSceneView]
    public class Bloom : MonoBehaviour
    {
        #region constData
        const int firstPass = 0;
        const int downPass = 1;
        const int upPass = 2;
        const int mixPass = 3;
        #endregion
    
    
        public Shader bloom;
        private Material material;
        [Range(0,8)]
        public int Interations;
        [Range(1,10)]// 已经限定从1开始, 只有开启HDR的才会开启bloom
        public float Threshold =1;
        [Range(0,1)]
        public float SoftThreshold = 0.5f;
        [Range(0,10)]
        public float Intensity = 1;
        RenderTexture[] textures = new RenderTexture[8];
        private void OnRenderImage(RenderTexture source, RenderTexture destination)
        {
            if (!material)
            {
                material = new Material(bloom);
                material.hideFlags = HideFlags.HideAndDontSave;
            }
            material.SetFloat("_Threshold", Threshold);
            material.SetFloat("_Intensity", Intensity);
            float knee = Threshold - SoftThreshold;
            Vector4 filter;
            filter.x = Threshold;
            filter.y = Threshold - knee;
            filter.z = 2 * knee;
            filter.w = 4 * knee + 0.00001f;
            // 将参数,以V4的形式传递进shader,将计算量留在CPU,减少GPU的计算
            material.SetVector("_Filter", filter);
    
    
            int width = source.width;
            int height = source.height;
            width /= 2;
            height /= 2;
            RenderTextureFormat format = source.format;
            RenderTexture currentDestination = textures[0] = RenderTexture.GetTemporary(width, height, 0, format);
            Graphics.Blit(source, currentDestination,material,firstPass);
            RenderTexture currentSource = currentDestination;
            int i = 1;
            // 向下采样
            for (; i < Interations; i++)
            {
                width /= 2;
                height /= 2;
                if (height<2)
                {
                    break;
                }
                currentDestination = textures[i] = RenderTexture.GetTemporary(width, height, 0, format);
                Graphics.Blit(currentSource, currentDestination,material,downPass);
                currentSource = currentDestination;
            }
            //向上采样
            for (i-=2; i>=0; i--)
            {
                currentDestination = textures[i];
                textures[i] = null;            
                Graphics.Blit(currentSource, currentDestination,material,upPass);
                RenderTexture.ReleaseTemporary(currentSource);
                currentSource = currentDestination;
            }
            material.SetTexture("_SourceTex", source);
            //混合
            Graphics.Blit(currentDestination, destination,material,mixPass);
            RenderTexture.ReleaseTemporary(currentDestination);
        }
    }
    
    
    Shader "custom/Bloom"
    {
        Properties
        {
            _MainTex ("Texture", 2D) = "white" {}
            //_SourceTex("SourceTex",2D) = "white"{}
            //_Threshold("_Threshold",float) = 1
            //_Filter("_Filter",Vector) = (0,0,0,0)
        }
    
    	CGINCLUDE
                #include "UnityCG.cginc"
                float _Threshold;
                struct appdata
                {
                    float4 vertex : POSITION;
                    float2 uv : TEXCOORD0;
                };
    
                struct v2f
                {
                    float2 uv : TEXCOORD0;
                    float4 vertex : SV_POSITION;
                };
    
                v2f vert (appdata v)
                {
                    v2f o;
                    o.vertex = UnityObjectToClipPos(v.vertex);
                    o.uv = v.uv;
                    return o;
                }
    
                sampler2D _MainTex;
                float4 _MainTex_TexelSize;
                sampler2D _SourceTex;
                float4 _SourceTex_ST; 
                vector _Filter;  
    			float _Intensity;
                half3 Sample(float2 uv)
                {
                    return tex2D(_MainTex,uv).rgb;
                }
                //
                half3 SampleBox(float2 uv,float detail)
                {
                    float4 o = _MainTex_TexelSize.xyxy * float4(-detail,-detail,detail,detail);
                    half3 c = Sample(uv+ o.xy) + Sample(uv + o.xz) + Sample(uv+o.zw) +Sample(uv+o.zx);
                    return c*0.25;
                }
    
                // half3 Prefilter(half3 c)
                // {
                //     half brightness = max(c.r,max(c.g,c.b));
                //     half contribution = max(0,brightness - _Threshold);
                //     contribution /= max(brightness,0.00001);
                //     return contribution;
                // }
                half3 Prefilter(half3 c)
                {
                    half brightness = max(c.r,max(c.g,c.b));
                    half soft = brightness - _Filter.y;
                    soft = clamp(soft,0,_Filter.z);
                    soft = soft * soft/_Filter.w;
                    half contribution = max(soft,brightness- _Filter.x);
                    contribution /= max(brightness,0.00001);
                    return contribution*c;
                }
    
    	ENDCG
        SubShader
        {
            // No culling or depth
            Cull Off ZWrite Off ZTest Always
            Pass
            {        //像素的预筛选
                CGPROGRAM
                #pragma vertex vert
                #pragma fragment frag        
                fixed4 frag (v2f i) : SV_Target
                {
                    half3 col = Prefilter(SampleBox(i.uv,1));
                    return fixed4(col,1);
                }
                ENDCG
            }
    
            Pass
            {
                //下采样
                CGPROGRAM
                #pragma vertex vert
                #pragma fragment frag          
    
                fixed4 frag (v2f i) : SV_Target
                {
                    
                    half3 col = SampleBox(i.uv,1);
                    return fixed4(col,1);
                }
                ENDCG
            }
            Pass
            {
                Blend One One
                // 上采样
                CGPROGRAM
                #pragma vertex vert
                #pragma fragment frag          
    
                fixed4 frag (v2f i) : SV_Target
                {
                    
                    half3 col = SampleBox(i.uv,0.5);
                    return fixed4(col,1);
                }
                ENDCG
            }
            Pass
            {
                //混合
                CGPROGRAM
                #pragma vertex vert
                #pragma fragment frag  
                
                     
    
                fixed4 frag (v2f i) : SV_Target
                {
                    
                    half3 col = SampleBox(i.uv,0.5) + tex2D(_SourceTex,i.uv).rgb * _Intensity;
                    //half3 col = SampleBox(i.uv,1);
                    return fixed4(col,1);
                }
                ENDCG
            }
        }
    }
    
    
    展开全文
  • unity屏幕后处理全家桶v1、v2区别

    千次阅读 2018-01-08 21:22:37
    unity屏幕后处理全家桶v1、v2区别 使用方法区别 参考:https://github.com/Unity-Technologies/PostProcessing/wiki/(v2)-Quickstart 1. v1版本直接将postProcessBehaviour脚本拖到摄像机上,而v2中,将post...
  • 3 Screen Space Reflection 屏幕空间反射该效果基于表面粗糙度计算屏幕空间中的反射; 4 Septh Of Field 景深该效果模拟相机镜头的属性。在现实生活中,相机只能以特定的距离对焦,距离相机更近或更远的物体将会...
  • unity屏幕后处理全家桶之color grading

    千次阅读 2018-01-13 14:00:38
    屏幕后处理全家桶里的color grading是完全实时hdr工具,内部处理是在ACES色彩空间下完成的。 屏幕后处理全家桶里的color grading包含5个部分 1. ToneMapping色彩映射 2. 基础; 3. 通道混合; 4. 轨迹球; 5
  • Unity屏幕后处理四周拉伸效果

    千次阅读 2019-01-26 17:04:19
    最近要搞个效果就是屏幕周围要有种向拉的感觉 其实原理是uv偏移,就是越往里的偏移越少,越往外偏移越大 实现:就是算uv和拉伸中心点距离来计算偏移   其实这个效果是全屏效果,靠近中心点位置也会进行偏移...
  • Unity Shader 屏幕后处理之血屏

    千次阅读 2019-06-25 15:59:41
    看了冯乐乐老师的《Unity Shader入门精要》在感叹Shader牛逼的同时也对图形学产生了莫大的兴趣,推荐各位在学Unity已及对Shader有兴趣的小伙伴一定要看看。因为很基础,所以代码没什么注释。 话不多说,直接上图:...
  • 然后,我们把该射线和线性化的视角空间下的深度值相乘,再加上摄像机的世界位置,就可以得到该像素在世界空间下的位置。 重建世界坐标 只需要知道摄像机在世界下的位置,以及世界空间下该像素相对摄像机的偏移量,...
  • //第一个坐标存储了屏幕颜色图像的采样纹理,剩下4个坐标存储了使用Roberts算子时需要采样的纹理坐标 } ; v2f vert ( appdata_img v ) { v2f o ; o . pos = UnityObjectToClipPos ( v . ...
  • 一种实现方法是利用一块累积缓存来混合多张连续的图像,当物体快速移动产生多张图像,我们取它们之间的平均值作为最后的运动模糊图像。然而这种暴力的方法对性能的消耗很大. 另一种应用广泛的方法是创建和使用速度...
  • 一、建立一个基本的屏幕后处理脚本...因此想要实现屏幕后处理的基础在于得到渲染后的屏幕图像,即抓取屏幕,而unity为我们提供了这样一个方便的接口——OnRenderImage函数。它的函数声明如下: MonoBehaviour.On...
  • unity shader 屏幕后处理

    2016-12-31 07:05:59
    各位老师好,有个关于shader的问题想请教下,我弄了一个屏幕后处理的特效,在onRenderimage里调用graphics.bilt(src,dest,mat)为整个屏幕内物体描边,mat是带上描边shader的材质球 。现在想为另外一个单独物体进行...
  • UnityShader屏幕后处理

    千次阅读 2018-02-26 10:30:00
    屏幕后处理实际为利用shader处理最终呈现在相机中的图片。但是shader不能直接与c#数据传递,所以创建material来沟通。 1 创建shader shader中的_MainTex为默认相机最终图片所以必须。然后就可以调整整张图片的...
  • 屏幕后处理效果(screen post-processing effects)是游戏中实现屏幕特效的常见方法。通常是指在渲染整个场景得到屏幕图像后,再对这个图像进行一系列操作,实现各种屏幕特效。使用这种技术可以为游戏画面添加更多的...
  • edge 0 edge 0.5 edge 1 ... edgeDetectMaterial = CheckShaderAndCreateMaterial(edgeDetectShader, edgeDetectMaterial);... #include "UnityCG.cginc" ...参考 我买的 unity shader 入门精要
  • 模糊的实现方法有很多,例如均值模糊和中值模糊,均值模糊同样使用了卷积操作,它使用的卷积核中的各个元素值都相等,且相加等于1,也就是说,卷积得到的像素值是其领域内各个像素值的平均值。而中值模糊则是选择...
  • Unity PostProcessing 后期处理插件,能让你的游戏画质具有很好的高质量画质。
  • 运动模糊是真实世界中摄像机的一种效果,如果在摄像机曝光时,拍摄场景发生了变化,就会产生运动模糊的画面。...运动模糊的实现有多种方法,一种实现方法是利用多张连续的图像,当物体快速移动产生多张图像,我...
  • 1.创建 2.参数 UNITY中文文档参数介绍 b站视频讲解
  • Unity Shader-后处理屏幕水波效果

    万次阅读 多人点赞 2016-11-03 10:13:10
    一.简介 最近在打黑魂,被虐得死去活来,每次都是想砸电脑的节奏,然而还是忍不住想...下面步入正题,黑魂的传送技能之前会播放一个帅帅的屏幕特效-屏幕水波,从屏幕中间向四周扩散开来,很有赶脚。下面附上一张截图:
  • 实现屏幕后处理,调用OnRenderImage,使用shader public Material material { get { if (curMaterial == null ) { curMaterial = new Material(curShader); curMaterial.hideFlags = HideFlags....
  • 1 片元着色器中计算每个纹素的卷积,设置阀值,判断该点是否为边缘,在边缘颜色与屏幕图片中做插值,如果为边缘则显示边缘颜色。 通常还会设置一个变量,是否改变出边缘外的颜色。 2 在片元着色器中将纹素重新转换...
  • Unity Shader - 后处理屏幕水波纹

    千次阅读 2019-06-30 10:20:39
    转载自:https://blog.csdn.net/puppet_master/article/details/52975666 Shader代码: Shader "Custom/WaterWave" { Properties { _MainTex("Base (RGB)", 2D) = "white" {} ...#include "UnityCG.cgi...
  • 文章目录什么是屏幕后处理Unity实现屏幕后处理的一般流程屏幕后处理基类(检查可用性) 什么是屏幕后处理 屏幕后处理,顾名思义,通常指的是在渲染完整个场景得到屏幕图像后,再对这个图像进行一系列操作,实现各种...
  • 屏幕后处理,指的是在渲染完整个场景得到屏幕图像后, 再对这个图像进行一系列操作,来实现各种屏幕特效。比如说景深效果的实现(离摄像机/焦距越远的部分,图片越模糊),这时候我们需要获取屏幕图像上每个像素点对应...
  • 本文将介绍Unity屏幕后处理的基本方法与游戏角色死亡后的屏幕渐变到黑白效果的实现方法。屏幕后处理是指整个场景每一帧渲染完毕后,再对得到的屏幕图像进行一系列处理并显示到屏幕上的过程。Unity中我们一般使用C#...
  • 后处理脚本 using UnityEngine; using System.Collections; public class Music_Wave: PostEffectsBase { public Shader briSatConShader; private Material briSatConMaterial; public Material material { ...
  • 好久没坚持写blog了,是时候开始撸一波新博文了!学习Unity有一段时间了,关于Shader的书也看了几本《Unity ...貌似一开始关于shader的讲解都是diffuse,不过,我赶脚后处理貌似更简单,所以第一篇来一发简单后处理

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 10,775
精华内容 4,310
关键字:

unity屏幕后处理