UnityShader 屏幕后处理

已于 2023-06-02 01:18:00 修改
阅读量515 收藏 2
点赞数
文章标签： unity 游戏引擎
于 2022-02-24 18:11:42 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/awsl_tsl/article/details/123117442
版权

亮度，饱和度，对比度调整

需要对屏幕进行后处理，实现需要获取屏幕的画面，在Unity中，使用Graphics.Blit(source, destination, material)来处理屏幕画面，source为原纹理，destination是目标纹理，material为材质，该函数会使用material.shader来处理原纹理，然后返回目标纹理。对原纹理的处理与对贴图纹理的处理相同。

        挂载在Camera上的脚本：

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

public class BrightnessSaturationAndContrast : PostEffectsBase
{
    public Shader mshader;
    private Material mat;
    public Material material{
        get{
            mat = CheckShaderAndCreateMaterial(mshader, mat);
            return mat;
        }
    }

    [Range(0.0f, 3.0f)]
    public float brightness = 1.0f;

    [Range(0.0f, 3.0f)]
    public float saturation = 1.0f;

    [Range(0.0f, 3.0f)]
    public float contrast = 1.0f;

    private void OnRenderImage(RenderTexture source, RenderTexture destination)
    {
        if(material == null){
            Graphics.Blit(source, destination);
        }
        else{
            material.SetFloat("_Brightness", brightness);
            material.SetFloat("_Saturation", saturation);
            material.SetFloat("_Contrast", contrast);

            Graphics.Blit(source, destination, material);
        }
    }
}

        脚本使用的Shader： 

Shader "Unlit/BSCPostEffectMat"
{
    Properties
    {
        _MainTex ("Texture", 2D) = "white" {}
        _Brightness("Brightness", float) = 1
        _Saturation("Saturation", float) = 1
        _Contrast("Contrast", float) = 1
    }
    SubShader
    {
        Tags { "RenderType"="Opaque" }

        Pass
        {
            ZWrite Off
            ZTest Always
            Cull Off

            CGPROGRAM
            #pragma vertex vert
            #pragma fragment frag

            #include "UnityCG.cginc"

            float _Brightness;
            float _Saturation;
            float _Contrast;

            struct appdata
            {
                float4 vertex : POSITION;
                float2 uv : TEXCOORD0;
            };

            struct v2f
            {
                float2 uv : TEXCOORD0;
                float4 vertex : SV_POSITION;
            };

            sampler2D _MainTex;
            float4 _MainTex_ST;

            v2f vert (appdata v)
            {
                v2f o;
                o.vertex = UnityObjectToClipPos(v.vertex);
                o.uv = TRANSFORM_TEX(v.uv, _MainTex);
                return o;
            }

            fixed4 frag (v2f i) : SV_Target
            {
                fixed4 col = tex2D(_MainTex, i.uv);

                fixed3 finalColor = col.rgb * _Brightness;
                fixed luminance = 0.2125 * col.r + 0.7154 * col.g + 0.0721 * col.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, 1);
            }
            ENDCG
        }
    }
}

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

        以上为去色公式，用于将颜色饱和度变为0，即黑白图像。以下为调整过的屏幕图像与屏幕原图像。

边缘检测 

在屏幕后处理过程中，很多时候我们需要获得描边效果。显然可知，需要描边的像素点都是位于色彩分界线处的像素。所以只需要使用边缘检测算子卷积计算各像素点是否在色彩分界线上即可。

 一般是将垂直方向检测的算子和水平方向检测的算子的绝对值相加作为描边程度的判断依据。

        挂载在Camera上的脚本： 

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

public class EdgeDetection : PostEffectsBase
{
    public Shader mshader;
    private Material mat;
    public Material material
    {
        get
        {
            mat = CheckShaderAndCreateMaterial(mshader, mat);
            return mat;
        }
    }

    public Color EdgeColor;

    [Range(0.0f, 1.0f)]
    public float EdgeOnly = 1.0f;

    [Range(0.0f, 1.0f)]
    public float EdgeWidth = 1.0f;

    private void OnRenderImage(RenderTexture source, RenderTexture destination)
    {
        if (material == null)
        {
            Graphics.Blit(source, destination);
        }
        else
        {
            material.SetFloat("_EdgeOnly", EdgeOnly);
            material.SetFloat("_EdgeWidth", EdgeWidth);
            material.SetColor("_EdgeColor", EdgeColor);

            Graphics.Blit(source, destination, material);
        }
    }
}

        脚本使用的shader：

Shader "Unlit/EdgeDetectionMat"
{
    Properties
    {
		_MainTex ("Base (RGB)", 2D) = "white" {}
		_EdgeOnly ("Edge Only", Float) = 1.0
		_EdgeColor ("Edge Color", Color) = (0, 0, 0, 1)
		_EdgeWidth("EdgeWidth", float) = 1
		_BackgroundColor ("Background Color", Color) = (1, 1, 1, 1)
    }
    SubShader
    {
        Pass
        {
            ZWrite Off
            ZTest Always
            Cull Off

            CGPROGRAM
            #pragma vertex vert
            #pragma fragment fragSobel

            #include "UnityCG.cginc"

            struct v2f
            {
                float2 uv[9] : TEXCOORD0;
                float4 pos : SV_POSITION;
            };

            sampler2D _MainTex;
            float4 _MainTex_TexelSize;
            float _EdgeOnly;
            float4 _EdgeColor;
            float4 _BackgroundColor;
			float _EdgeWidth;

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

            fixed luminance(fixed4 color){
                return 0.2125 * color.r + 0.7145 * 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 = abs(edgeX) + abs(edgeY);
				
				return edge;
			}

            fixed4 fragSobel(v2f i) : SV_Target
            {
				half edge = Sobel(i);
				
				edge = lerp(0, edge, _EdgeWidth);

				fixed4 withEdgeColor = lerp(tex2D(_MainTex, i.uv[4]), _EdgeColor, edge);
				fixed4 onlyEdgeColor = lerp(_BackgroundColor, _EdgeColor, edge);
				return lerp(withEdgeColor, onlyEdgeColor, _EdgeOnly);
            }
            ENDCG
        }
    }
    FallBack Off
}

本次使用Sobel算子作为边缘检测算子。

_MainTex_TexelSize.xy可以返回屏幕分辨率下每个像素的大小，比如分辨率为512*256的屏幕，_MainTex_TexelSize.xy的值为(1/512, 1/256)。通过_MainTex_TexelSize.xy可以求得顶点周围各点在UV上的坐标。

不能使用_MainTex_TS，否则无法得到周围各点的正确坐标。

多个屏幕后处理脚本可以在一个Camera上同时使用。

高斯模糊

        高斯模糊的具体实现，是通过将各片元周围片元的颜色进行卷积作为当前片元的颜色输出，原理与边缘检测相同，高斯模糊一般是用高斯核进行卷积。

         但仅计算一个5×5大小的高斯核，就需要得到25个片元是颜色参数。一般不使用这种方法进行卷积计算，而是用5×1和1×5两个矩阵在水平和竖直方向各进行一次计算来近似高斯核卷积的结果。

        又因为矩阵中有多个参数重复出现，所以我们只需要记录三个参数即可。

        同时可以设置高斯模糊的迭代次数，来得到不同的模糊效果。 

         挂载在Camera上的脚本：

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

public class GaussianBlur : PostEffectsBase
{
	public Shader mshader;
	private Material mat = null;

	public Material material{
		get{
			mat = CheckShaderAndCreateMaterial(mshader, mat);
			return mat;
		}
	}

	[Range(0, 3)]
	public float blurspread = 1;

	[Range(1, 8)]
	public int iterations = 1;

	[Range(1, 8)]
	public int downsample = 1;

	private void OnRenderImage(RenderTexture source, RenderTexture destination)
	{
		if (material != null)
		{
			int scH = source.height / downsample;
			int scW = source.width / downsample;

			material.SetFloat("_BlurSize", blurspread);

			RenderTexture buffer0 = RenderTexture.GetTemporary(scW, scH, 0);
			buffer0.filterMode = FilterMode.Bilinear;

			Graphics.Blit(source, buffer0);

			for (int i = 0; i < iterations; i++)
			{
				RenderTexture buffer1 = RenderTexture.GetTemporary(scW, scH, 0);
				Graphics.Blit(buffer0, buffer1, material, 0);

				RenderTexture.ReleaseTemporary(buffer0);
				buffer0 = buffer1;
				buffer1 = RenderTexture.GetTemporary(scW, scH, 0);
				Graphics.Blit(buffer0, buffer1, material, 1);

				RenderTexture.ReleaseTemporary(buffer0);
				buffer0 = buffer1;
			}

			Graphics.Blit(buffer0, destination);
			RenderTexture.ReleaseTemporary(buffer0);
		}
		else
		{
			Graphics.Blit(source, destination);
		}
	}
}

        挂载在脚本上的Shader： 

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

Shader "Unlit/GaussianBlurMat"
{
    Properties
    {
        _MainTex ("Texture", 2D) = "white" {}
        _BlurSize ("BlurSize", int) = 1
    }
    SubShader
    {
        CGINCLUDE

        sampler2D _MainTex;
        float4 _MainTex_TexelSize;
        int _BlurSize;

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

        struct v2f
        {
            float2 uv[5] : TEXCOORD0;
            float4 vertex : SV_POSITION;
        };

        v2f vertBlurVertial(appdata i){
            v2f o;
            o.vertex = UnityObjectToClipPos(i.vertex);

            half2 midPos = i.texcoord;
            
            o.uv[0] = midPos;
            o.uv[1] = midPos + float2(0.0, _MainTex_TexelSize.y * 1.0) * _BlurSize;
            o.uv[2] = midPos - float2(0.0, _MainTex_TexelSize.y * 1.0) * _BlurSize;
            o.uv[3] = midPos + float2(0.0, _MainTex_TexelSize.y * 2.0) * _BlurSize;
            o.uv[4] = midPos - float2(0.0, _MainTex_TexelSize.y * 2.0) * _BlurSize;

            return o;
        }

        v2f vertBlurHorizontal(appdata i){
            v2f o;
            o.vertex = UnityObjectToClipPos(i.vertex);

            half2 midPos = i.texcoord;
            
            o.uv[0] = midPos;
            o.uv[1] = midPos + float2(_MainTex_TexelSize.x * 1.0, 0.0) * _BlurSize;
            o.uv[2] = midPos - float2(_MainTex_TexelSize.x * 1.0, 0.0) * _BlurSize;
            o.uv[3] = midPos + float2(_MainTex_TexelSize.x * 2.0, 0.0) * _BlurSize;
            o.uv[4] = midPos - float2(_MainTex_TexelSize.x * 2.0, 0.0) * _BlurSize;

            return o;
        }

        fixed4 fragmentBlur(v2f i) : SV_Target{
            float weight[3] = {0.4026, 0.2442, 0.0545};

            fixed3 sum = tex2D(_MainTex, i.uv[0]).rgb * weight[0];

			for (int it = 1; it < 3; it++) {
				sum += tex2D(_MainTex, i.uv[it*2-1]).rgb * weight[it];
				sum += tex2D(_MainTex, i.uv[it*2]).rgb * weight[it];
			}

            return fixed4(sum, 1.0);
        }

        ENDCG

        Tags { "RenderType"="Opaque" }

        Pass
        {
            NAME "BLUR_VERTIAL"

            CGPROGRAM

            #pragma vertex vertBlurVertial
            #pragma fragment fragmentBlur

            ENDCG
        }

        Pass
        {
            NAME "BLUR_HORIZONTAL"

            CGPROGRAM

            #pragma vertex vertBlurHorizontal
            #pragma fragment fragmentBlur

            ENDCG
        }
    }
    FallBack Off
}

泛光效果（Bloom） 

        所谓泛光效果，就是画面的亮部向暗部扩散（？大概表达清楚了吧）的效果 。

        具体实现很简单，实现需要获得屏幕画面的亮部，然后对提取的亮部纹理进行模糊，最后叠加到原纹理上，就实现了Bloom效果。

        获得亮部纹理的方法，在片元着色器中获得该片元的颜色，然后得到对片元去色的结果，减去亮部阈值（超过判断为亮部）并saturate为0到1之间，将最终结果与原片元颜色相乘，就得到了只剩下亮部的纹理。在用高斯模糊的相同方法对亮部纹理模糊迭代，最后与原纹理相加，就得到了Bloom效果。

        挂载在Camera上的脚本： 

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

public class Bloom : PostEffectsBase
{
	public Shader mshader;
	private Material mat = null;

	public Material material
	{
		get
		{
			mat = CheckShaderAndCreateMaterial(mshader, mat);
			return mat;
		}
	}

	[Range(0, 3)]
	public float blurspread = 1;

	[Range(1, 8)]
	public int iterations = 1;

	[Range(1, 8)]
	public int downsample = 1;

	[Range(0, 3)]
	public float Luminance = 0.5f;

	private void OnRenderImage(RenderTexture source, RenderTexture destination)
	{
		if (material != null)
		{
			int scH = source.height / downsample;
			int scW = source.width / downsample;

			material.SetFloat("_BlurSize", blurspread);
			material.SetFloat("_Luminance", Luminance);

			RenderTexture buffer0 = RenderTexture.GetTemporary(scW, scH, 0);
			buffer0.filterMode = FilterMode.Bilinear;

			Graphics.Blit(source, buffer0, material, 2);

			for (int i = 0; i < iterations; i++)
			{
				RenderTexture buffer1 = RenderTexture.GetTemporary(scW, scH, 0);
				Graphics.Blit(buffer0, buffer1, material, 0);

				RenderTexture.ReleaseTemporary(buffer0);
				buffer0 = buffer1;
				buffer1 = RenderTexture.GetTemporary(scW, scH, 0);
				Graphics.Blit(buffer0, buffer1, material, 1);

				RenderTexture.ReleaseTemporary(buffer0);
				buffer0 = buffer1;
			}

			material.SetTexture("_Bloom", buffer0);
			Graphics.Blit(source, destination, material, 3);
			RenderTexture.ReleaseTemporary(buffer0);
		}
		else
		{
			Graphics.Blit(source, destination);
		}
	}
}

         挂载在脚本上的Shader：

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

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

Shader "Unlit/BloomMat"
{
    Properties
    {
        _MainTex ("Texture", 2D) = "white" {}
        _Bloom ("Bloom", 2D) = "white" {}
        _BlurSize ("BlurSize", int) = 1
        _Luminance("Luminance", float) = 0.5
    }
    SubShader
    {
        CGINCLUDE

        sampler2D _MainTex;
        float4 _MainTex_TexelSize; 
        sampler2D _Bloom;
        float4 _Bloom_TexelSize;
        int _BlurSize;
        float _Luminance;

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

        struct v2f
        {
            float2 uv : TEXCOORD0;
            float4 vertex : SV_POSITION;
        };

        v2f vertexBloom(appdata i){
            v2f o;
            o.vertex = UnityObjectToClipPos(i.vertex);

            o.uv = i.texcoord;

            return o;
        }

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

        fixed4 fragmentBloom(v2f i) : SV_Target{
            fixed4 col = tex2D(_MainTex, i.uv);

            fixed val = saturate(Getluminance(col) - _Luminance);

            val = val + _Luminance * val / (1.0 - _Luminance);

            return col * val;
        }

        fixed4 fragmentMixed(v2f i) : SV_Target{
            fixed4 col = tex2D(_MainTex, i.uv);
            fixed4 bloomCol = tex2D(_Bloom, i.uv);

            return col + bloomCol;
        }

        ENDCG

        ZTest Always ZWrite Off Cull Off

        Tags { "RenderType"="Opaque" }

        UsePass "Unlit/GaussianBlurMat/BLUR_VERTIAL"

        UsePass "Unlit/GaussianBlurMat/BLUR_HORIZONTAL"

        Pass
        {
            CGPROGRAM
            #pragma vertex vertexBloom
            #pragma fragment fragmentBloom
            ENDCG
        }

        Pass
        {
            CGPROGRAM
            #pragma vertex vertexBloom
            #pragma fragment fragmentMixed
            ENDCG
        }
    }
    FallBack Off
}

 运动模糊（MotionBlur）

         对于运动模糊的实现有两种方法，一种是累计缓存（Accumulation buffer），一种是速度缓存（velocity buffer），本例中使用累计缓存实现运动模糊。我们需要保存之前的渲染结果，不断的把当前渲染的图像叠加到之前渲染的图像中，从而产生一种运动轨迹的视觉效果。

        具体我们需要使用一个RenderTexture，来存储每次屏幕渲染的结果，然后使用MarkRestoreExpected()方法，恢复该变量之前存储的图像。在直接将当前屏幕图像渲染到该变量中（在Graphics.Blit中使用了非null的输出，会依据material的渲染方式将当前渲染的结果与输出的结果相混合，如果不在material的Pass中设置混合模式，则原纹理的渲染结果会直接覆盖输出纹理的内容）

         挂载在Camera上的脚本：

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

public class MotionBlur : PostEffectsBase
{
	public Shader mshader;
	private Material mat = null;

	public Material material{
		get{
			mat = CheckShaderAndCreateMaterial(mshader, mat);
			return mat;
		}
	}

	[Range(0.0f, 0.9f)]
	public float bluralpha;

	private RenderTexture accumulationTexture;

	private void OnRenderImage(RenderTexture source, RenderTexture destination)
	{
		if(material != null){
			if(accumulationTexture == null || accumulationTexture.width != source.width || accumulationTexture.height != source.height){
				DestroyImmediate(accumulationTexture);
				accumulationTexture = new RenderTexture(source.width, source.height, 0);
				accumulationTexture.hideFlags = HideFlags.HideAndDontSave;
				Graphics.Blit(source, accumulationTexture);
			}

			accumulationTexture.MarkRestoreExpected();
			material.SetFloat("_BlurAlpha", bluralpha);
			Graphics.Blit(source, accumulationTexture, material);
			Graphics.Blit(accumulationTexture, destination);
		}
		else{
			Graphics.Blit(source, destination);
		}
	}
}

        挂载在脚本上的Shader：

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

Shader "Unlit/MotionBlurMat"
{
    Properties
    {
        _MainTex ("Texture", 2D) = "white" {}
        _BlurAlpha("MotionAlpha", float) = 0.9
    }
    SubShader
    {
        CGINCLUDE

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

        struct v2f{
          float4 vertex : SV_POSITION;
          float2 uv : TEXCOORD0;
        };

        sampler2D _MainTex;
        float4 _MainTex_TS;
        float _BlurAlpha;

        v2f vertexMotion(appdata i){
            v2f o;

            o.vertex = UnityObjectToClipPos(i.vertex);

            o.uv = i.texcoord;

            return o;
        }

        fixed4 fragMotion(v2f i) : SV_Target{
            fixed4 col = tex2D(_MainTex, i.uv);

            return fixed4(col.rgb, _BlurAlpha);
        }

        ENDCG

        Pass{
            ZWrite Off ZTest Always Cull Off

            Blend SrcAlpha OneMinusSrcAlpha

            CGPROGRAM

            #pragma vertex vertexMotion
            #pragma fragment fragMotion

            ENDCG
        }
    }
}

         通过设置的Alpha值，确定每一次混合的程度。

Padid
关注
Unity Shader 屏幕后处理反相
qq_44800780的博客
12-10 803
Shader代码如下： Properties { _MainTex ("Base (RGB)", 2D) = "white" {}//渲染纹理 } SubShader { Pass { ZTest Always Cull Off ZWrite Off CGPROGRAM #include "UnityCG.cginc" #prag...
Unity Shader 屏幕后处理灰度
qq_44800780的博客
12-10 520
原理： 移除场景中除了黑白灰以外所有的颜色，让整个图像灰度化(Grayscale)。很简单的实现方式是，取所有的颜色分量，将它们平均化,但是但人眼会对绿色更加敏感一些，而对蓝色不那么敏感，所以为了获取物理上更精确的效果，我们需要使用加权的(Weighted)通道： 脚本如下: public Shader shader;//相应的shader private Material ma...
unity 利用Graphics.Blit来制作图片效果
wnagleiming的博客
01-20 1492
source可以是当前相机的RenderTexture也可以是准备好的一张图，然后利用material提供的效果将效果输出到renderTexture,第三个参数是使用哪个pass 0表示是使用第一个。下面是例子对应的shader，是一个模糊效果。
Unity Shader - 后处理：高斯模糊
05-25
高斯模糊（Gaussian Blur），又叫做高斯平滑。高斯模糊主要的功能是对图片进行加权平均的过程，与均值模糊中周围像素取平均值不同，高斯模糊进行的是一个加权平均操作，每个像素的颜色值都是由其本身和相邻像素的颜色值进行加权平均得到的，越靠近像素本身，权值越高，越偏离像素的，权值越低。
UnityShader——基础篇之UnityShader基础
最新发布
Aubyn11的博客
06-23 2090
Unity Shader 是 Unity 为研发者提供的高层记得渲染抽象层，Unity 希望以这种方式来让开发者更加轻松的控制渲染，见下图：在 Unity 中，所有的 Unity Shader 都是使用 ShaderLab 来编写的ShaderLab 是 Unity 编写 Unity Shader 的一种说明性语言，它使用了一些嵌套在花括号内部的**语义&&（syntax。
unity shader屏幕后处理
weixin_46525412的博客
06-27 401
unity shader屏幕后处理
UnityShader基础（七）——屏幕后处理效果
SliverAsh_的博客
10-09 1607
屏幕后处理是基于渲染纹理实现的，通过更改渲染纹理的颜色等等实现某些某些视觉效果。
Unity Shader入门精要 第十二章——屏幕后处理效果
buzhengli的博客
09-03 566
卷积操作指定是使用一个卷积核（kernel）对一张图像中的每个像素进行一系列的操作。卷积核通常是一个四方形网格结构，该方格每个区域都有一个权重值。对图像中的某个像素进行卷积时，我们会把卷积核的中心位置放置于该像素上(如下图)，翻转核之后依次计算核中每个元素和其覆盖的图像像素值的乘积并求和，得到的就是该位置的新像素值。不同的卷积和就可以得到不同的效果计算核中每个元素和其覆盖的图像像素值的乘积并求和。
Unity中后处理 脚本 和 Shader
楠溪泽岸的博客
12-09 1007
我们在上篇文章中提到，在Unity中实现后处理效果，需要同时结合 脚本 和 Shader，我们在这篇文章中编写所需要使用的C#脚本。
Unity Shader屏幕后处理 全局雾效的实现
qq_44800780的博客
12-11 1342
原理： 根据深度纹理重建每个像素在世界空间下的位置，首先对图像空间下的视锥体射线进行插值，这条射线存储了该像素在世界空间下到摄像机的方向信息.然后，我们把该射线和线性化后的视角空间下的深度值相乘，再加上摄像机的世界位置，就可以得到该像素在世界空间下的位置。 重建世界坐标 只需要知道摄像机在世界下的位置，以及世界空间下该像素相对摄像机的偏移量，把它们相加就可以得到该像素的世界坐标 float3 w...
Unity Shader屏幕后处理 边缘检测
qq_44800780的博客
12-10 349
原理 利用边缘检测算子对图像进行卷积操作 如何知道哪里才算是边缘呢？ 如果相邻像素之间存在差别明显的颜色、亮度、纹理等属性，我们就会认为它们之间应该有一条边界。这种相邻像素之间的插值可以用梯度来表示，边缘处的梯度绝对值会比较大. 三种常见的边缘检测算子 它们都包含了两个方向的卷积核，分别用于检测水平方向和竖直方向上的边缘信息，在进行边缘检测时，我们需要对每个像素分别进行一次卷积计算，得到两个方向...
Unity Shader-后处理：景深
05-26
通过两张图片，一张清晰的，一张经过高斯模糊的，然后根据图片中每个像素的深度值在两张图片之间差值，就可以达到景深的效果了。
Unity_屏幕_Shader水波纹效果,挂在摄像机上就能用
03-29
Unity屏幕Shader水波纹效果,挂在摄像机上就能用,可以连续点击
简易unity屏幕特效代码（shader+C#）
09-13
包内包含文件：场景，相机， 一个名为asd的贴图一张， 一个C#特效脚本， 一个简单的特效shader等。 相关文档：http://blog.csdn.net/leelizc/article/details/77967937
Unity Shader屏幕后处理高斯模糊
qq_44800780的博客
12-10 318
原理 利用卷积计算，使用的卷积核叫高斯核 使用一个N x N的高斯核对图像进行卷积滤波，就需要N x N x W x H次纹理采样，当N的大小不断增加时，采样次数会变得非常巨大，不过我们可以把这个二维高斯函数拆分成两个一维函数. 得到的结果是一样的。 实现 我们会先后调用两个Pass，第一个Pass使用竖直方向的一维高斯核进行滤波，第二个Pass使用水平方向的一维高斯核，得到最终的目标图像. 首先...
UnityShader屏幕后处理
雪球的博客
02-26 1549
屏幕后处理实际为利用shader处理最终呈现在相机中的图片。但是shader不能直接与c#数据传递，所以创建material来沟通。 1 创建shader shader中的_MainTex为默认相机最终图片所以必须。然后就可以调整整张图片的风格渲染。 2 检查这个平台是不是支持图片效果。 protected bool CheckSupport() { if (Sys...
unity屏幕后处理
weixin_62773441的博客
02-19 403
vert_img unity内置后处理顶点函数；v2f_img unity内置后处理结构体色相调整HSV的r通道，进行一定的偏移再转回rgb饱和度伽马空间点乘的数值： 0.22, 0.707, 0.071pow用来增加对比度，0-1的范围且pow越多会让数值更靠0（更多的是黑色）
UnityShader入门精要——屏幕后处理效果（1）
weixin_51327051的博客
02-17 967
基本的屏幕后处理脚本系统 OnRenderImage函数：得到渲染后的屏幕图像，即抓取屏幕，声明如下： MonoBehaviour.OnRenderImage(RenderTexture src,RenderTexture dest) 当我们在脚本中声明此函数后，Unity 会把当前渲染得到的图像存储在第一一个参 数对应的源渲染纹理中，通过函数中的一- 系列操作后，再把目标渲染纹理，即第二个参数对应的渲染纹理显示到屏幕上。在OnRenderImage函数中，我们通常是利用Graphics.Blit
unity shader学习---屏幕后处理
qq_39542170的博客
03-27 4562
边缘检测，高斯模糊，Bloom
Unity Shader教程：深度解析水墨风格实现
- 开发者使用C#编写后处理代码，例如`PostEffectBase`类作为屏幕后处理的基类，该类允许在Unity的Inspector面板上直接拖拽预设的Shader，并生成相应的材质。 - `GenerateMaterial`方法用于根据指定的Shader创建一...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值