UnityShader---屏幕后处理（内置渲染管线）---13

最新推荐文章于 2023-04-25 20:37:42 发布
最新推荐文章于 2023-04-25 20:37:42 发布
阅读量293 收藏 1
点赞数
文章标签： unity shader
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_41155760/article/details/122175642
版权

后处理Unity基本上都提供了相应的实现了。

后处理基类：

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

[ExecuteInEditMode]
[RequireComponent(typeof(Camera))]
public class PostEffectBase : MonoBehaviour
{

    public Shader usedShader;
    protected Material usedMaterial;

    public Material material
    {
        get
        {
            usedMaterial = CheckShaderAndCreateMaterial(usedShader,usedMaterial);
            return usedMaterial;
        }
    }



    void Start()
    {
        CheckResources();
    }


    protected void CheckResources()
    {
        bool isSupported = CheckSupport();

        if (isSupported == false)
        {
            NotSupport();
        }
    }

    private void NotSupport()
    {
        enabled = false;
    }

    private bool CheckSupport()
    {
        if (SystemInfo.supportsImageEffects == false || SystemInfo.supportsRenderTextures == false)
        {
            Debug.LogError("不支持后处理！");
            return false;
        }

        return true;
    }


    protected Material CheckShaderAndCreateMaterial(Shader shader, Material material)
    {
        if (shader == null)
        {
            return null;
        }

        if (shader.isSupported && material && material.shader == shader)
            return material;

        if (!shader.isSupported)
        {
            return null;
        }
        else
        {
            material = new Material(shader);
            material.hideFlags = HideFlags.DontSave;
            if (material)
                return material;
            else
                return null;
        }
    }
}

调整屏幕亮度饱和度和对比度：

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

public class BrightnessSaturationAndContrast : PostEffectBase
{ 
    [Range(0, 3f)]
    public float brightness = 1;

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

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


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

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

Shader "Unlit/26"
{
    Properties
    {
        _MainTex ("Texture", 2D) = "white" {}
        _Brightness("Brightness",Float)=1
        _Saturation("Saturation",Float)=1
        _Contrast("Contrast",Float)=1
    }
    SubShader
    {
        Pass
        {
            ZTest Always
            Cull Off
            ZWrite Off

            CGPROGRAM
            #pragma vertex vert
            #pragma fragment frag            

            #include "UnityCG.cginc"

            sampler2D _MainTex;            
            half _Brightness;
            half _Saturation;
            half _Contrast;

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

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

            v2f vert (a2v v)
            {
                v2f o;

                o.pos = UnityObjectToClipPos(v.vertex);
                o.uv = v.texcoord;    

                return o;
            }

            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(luminance, finalColor,_Saturation);

                //应用对比度
                fixed3 avgColor = fixed3(0.5, 0.5, 0.5);

                finalColor = lerp(avgColor,finalColor,_Contrast);
               
                return fixed4(finalColor,renderTex.a); 
            }
            ENDCG
        }
    }
}

边缘检测：

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

public class EdgeDetection : PostEffectBase
{
    [Range(0,1f)]
    public float edgeOnly = 0;

    public Color edgeColor = Color.black;

    public Color backgroundColor = Color.white;

    private void OnRenderImage(RenderTexture source, RenderTexture destination)
    {
        if (material != null)
        {
            material.SetFloat("_EdgeOnly", edgeOnly);
            material.SetColor("_EdgeColor", edgeColor);
            material.SetColor("_BackgroundColor", backgroundColor);

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

Shader "Unlit/27"
{
    Properties
    {
        _MainTex ("Texture", 2D) = "white" {}
        _EdgeOnly("EdgeOnly",Float)=1
        _EdgeColor("EdgeColor",Color)=(0,0,0,1)
        _BackgroundColor("BackgroundColor",Color)=(1,1,1,1)
    }
    SubShader
    {
        Tags { "RenderType"="Opaque" }
        LOD 100

        Pass
        {
            CGPROGRAM
            #pragma vertex vert
            #pragma fragment frag          

            #include "UnityCG.cginc"

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

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

            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.7154 * color.g + 0.0721 * color.b;
            }

            //Sobel边缘检测算子
            half Sobel(v2f i)
            {
                const half Gx[9] = { -1,-2,-1,
                                      0, 0, 0,
                                      1, 2, 1 };
                const half Gy[9] = { -1, 0, 1,
                                     -2, 0, 2,
                                     -1, 0, 1 };
                half texColor;
                half edgeX = 0;
                half edgeY = 0;

                //注意参数不要和传进来的参数重名了
                for (int j = 0; j < 9; j++)
                {
                    texColor = luminance(tex2D(_MainTex, i.uv[j]));
                    //texColor = tex2D(_MainTex,i.uv[j]);

                    edgeX += texColor * Gx[j];
                    edgeY += texColor * Gy[j];
                }

                half edge = 1 - abs(edgeX) - abs(edgeY);

                return edge;
            }

            fixed4 frag(v2f i) : SV_Target
            {
                half edge = Sobel(i);

                //edge=0 是边，edge=1 是原图(采样中间值)，0-1之间的进行混合
                
                //edge = edge < 0.1 ? 0 : 1;
                
                fixed4 withEdgeColor = lerp(_EdgeColor,tex2D(_MainTex,i.uv[4]),edge);
                fixed4 onlyEdgeColor = lerp(_EdgeColor,_BackgroundColor,edge);

                return lerp(withEdgeColor, onlyEdgeColor, _EdgeOnly);
            }
            ENDCG
        }
    }
    Fallback Off
}

高斯模糊：

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

public class GaussianBlur : PostEffectBase
{
    [Range(0, 4)]
    public int iterations = 3;

    [Range(0.2f, 3f)]
    public float blurSpread = 0.6f;

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

    private void OnRenderImage(RenderTexture source, RenderTexture destination)
    {
        if (material != null)
        {
            int rtW = source.width / downSample;
            int rtH = source.height / downSample;

            RenderTexture buffer0 = RenderTexture.GetTemporary(rtW, rtH, 0);
            buffer0.filterMode = FilterMode.Bilinear;

            Graphics.Blit(source, buffer0);

            for (int i = 0; i < iterations; i++)
            {
                material.SetFloat("_BlurSize", 1 + i * blurSpread);

                RenderTexture buffer1 = RenderTexture.GetTemporary(rtH, rtW, 0);

                Graphics.Blit(buffer0, buffer1, material, 0);

                RenderTexture.ReleaseTemporary(buffer0);

                buffer0 = buffer1;

                buffer1 = RenderTexture.GetTemporary(rtW, rtH, 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 "Unlit/28"
{
    Properties 
    {
        _MainTex("Base (RGB)", 2D) = "white" {}
        _BlurSize("Blur Size", Float) = 1.0        // 模糊采样距离，过大会产生虚影
    }

    SubShader 
    {
        // 类似C++头文件功能。使用时不用包含在Pass块，Pass中直接指定顶点和片元着色器，可避免编写两个一样的frag函数
        CGINCLUDE

        #include "UnityCG.cginc"

        sampler2D _MainTex;
        float4 _MainTex_TexelSize;
        float _BlurSize;
       
        struct v2f 
        {
            float4 pos : SV_POSITION;
            half2 uv[5]: TEXCOORD0;
        };

        // appdata_img定义在UnityCG.cginc
        v2f vertBlurVertical(appdata_img v) 
        {
            v2f o;
            o.pos = UnityObjectToClipPos(v.vertex);
            half2 uv = v.texcoord;
            o.uv[0] = uv;
            o.uv[1] = uv + float2(0.0, _MainTex_TexelSize.y * 1.0) * _BlurSize;
            o.uv[2] = uv - float2(0.0, _MainTex_TexelSize.y * 1.0) * _BlurSize;
            o.uv[3] = uv + float2(0.0, _MainTex_TexelSize.y * 2.0) * _BlurSize;
            o.uv[4] = uv - float2(0.0, _MainTex_TexelSize.y * 2.0) * _BlurSize;
            return o;
        }
        v2f vertBlurHorizontal(appdata_img v) 
        {
            // 类似处理垂直模糊的顶点着色器
            v2f o;
            o.pos = UnityObjectToClipPos(v.vertex);
            half2 uv = v.texcoord;
            o.uv[0] = uv;
            o.uv[1] = uv + float2(_MainTex_TexelSize.x * 1.0, 0.0) * _BlurSize;
            o.uv[2] = uv - float2(_MainTex_TexelSize.x * 1.0, 0.0) * _BlurSize;
            o.uv[3] = uv + float2(_MainTex_TexelSize.x * 2.0, 0.0) * _BlurSize;
            o.uv[4] = uv - float2(_MainTex_TexelSize.x * 2.0, 0.0) * _BlurSize;
            return o;
        }
        // 两个Pass公用片元着色器
        fixed4 fragBlur(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

        ZTest Always Cull Off ZWrite Off
        Pass 
        {
            NAME "GAUSSIAN_BLUR_VERTICAL"           // 定义名字。可以从其他Shader直接来使用该Pass
            CGPROGRAM
            #pragma vertex vertBlurVertical  
            #pragma fragment fragBlur
            ENDCG
        }
        Pass 
        {
            NAME "GAUSSIAN_BLUR_HORIZONTAL"
            CGPROGRAM
            #pragma vertex vertBlurHorizontal  
            #pragma fragment fragBlur
            ENDCG
        }
    }
}

Bloom：

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

public class Bloom : PostEffectBase
{
    [Range(0, 4)]
    public int iterations = 3;

    [Range(0.2f, 3f)]
    public float blurSpread = 0.6f;

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

    [Range(0, 4f)]
    public float luminanceThreshold = 0.5f;


    private void OnRenderImage(RenderTexture source, RenderTexture destination)
    {
        if (material != null)
        {
            material.SetFloat("_LuminanceThreshold", luminanceThreshold);

            int rtW = source.width / downSample;
            int rtH = source.height / downSample;

            RenderTexture buffer0 = RenderTexture.GetTemporary(rtW, rtH, 0);
            buffer0.filterMode = FilterMode.Bilinear;

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

            for (int i = 0; i < iterations; i++)
            {
                material.SetFloat("_BlurSize", 1 + i * blurSpread);

                RenderTexture buffer1 = RenderTexture.GetTemporary(rtH, rtW, 0);

                Graphics.Blit(buffer0, buffer1, material, 1);

                RenderTexture.ReleaseTemporary(buffer0);
                buffer0 = buffer1;
                buffer1 = RenderTexture.GetTemporary(rtW, rtH, 0);

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

                RenderTexture.ReleaseTemporary(buffer0);

                buffer0 = buffer1;
            }

            material.SetTexture("_Bloom", buffer0);
            Graphics.Blit(source, destination, material, 3);

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

Shader "Unlit/29"
{
	Properties
	{
		_MainTex("Base (RGB)", 2D) = "white" {}
		_Bloom("Bloom",2D) = "black"{}
		_LuminanceThreshold("LuminanceThreshold",Float) = 0.5
		_BlurSize("Blur Size", Float) = 1.0        // 模糊采样距离，过大会产生虚影
	}

		SubShader
		{
			// 类似C++头文件功能。使用时不用包含在Pass块，Pass中直接指定顶点和片元着色器，可避免编写两个一样的frag函数
			CGINCLUDE

			#include "UnityCG.cginc"

			sampler2D _MainTex;
			float4 _MainTex_TexelSize;
			sampler2D _Bloom;
			float _LuminanceThreshold;
			float _BlurSize;

			//先定义提取屏幕较亮区域
			struct v2f
			{
				float4 pos:SV_POSITION;
				half2 uv:TEXCOORD0;
			};

			v2f vertExtractBright(appdata_img v)
			{
				v2f o;

				o.pos = UnityObjectToClipPos(v.vertex);

				o.uv = v.texcoord;

				return o;
			}

			//获取亮度值
			fixed luminance(fixed4 color)
			{
				return 0.2125 * color.r + 0.7154 * color.g + 0.0721 * color.b;
			}

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

				fixed val = clamp(luminance(col) - _LuminanceThreshold, 0.0, 1.0);

				return col * val;
			}
			
			//定义混合Pass 用的

			struct v2fBloom
			{
				float4 pos:SV_POSITION;
				float4 uv:TEXCOORD0;
			};

			v2fBloom vertBloom(appdata_img v)
			{
				v2fBloom o;

				o.pos = UnityObjectToClipPos(v.vertex);

				o.uv.xy = v.texcoord;
				o.uv.zw = v.texcoord;

#if UNITY_UV_STARTS_AT_TOP
				if (_MainTex_TexelSize.y < 0)
					o.uv.w = 1 - o.uv.w;
#endif
				return o; 
			}

			fixed4 fragBloom(v2fBloom i) :SV_Target
			{
				return tex2D(_MainTex,i.uv.xy) + tex2D(_Bloom,i.uv.zw);
			}


			ENDCG

			ZTest Always Cull Off ZWrite Off

			Pass
			{
				CGPROGRAM

				#pragma vertex vertExtractBright
				#pragma fragment fragExtractBright

				ENDCG
			}

			UsePass "Unlit/28/GAUSSIAN_BLUR_VERTICAL"
			UsePass "Unlit/28/GAUSSIAN_BLUR_HORIZONTAL"

			Pass
			{
				CGPROGRAM

				#pragma vertex vertBloom
				#pragma fragment fragBloom

				ENDCG
			}
		}
}

运动模糊：

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

public class MotionBlur : PostEffectBase
{
    [Range(0, 1f)]
    public float blurAmount = 0.5f;

    //累计图像叠加缓存
    private RenderTexture accumulationTexture;

    private void OnDisable()
    {
        DestroyImmediate(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("_BlurAmount", 1 - blurAmount);

            Graphics.Blit(source,accumulationTexture,material);

            Graphics.Blit(accumulationTexture,destination);
        }
        else
        {
            Graphics.Blit(source, destination);
        }
    }
}

Shader "Unlit/30"
{
    Properties
    {
        _MainTex ("Texture", 2D) = "white" {}
        _BlurAmount("BlurAmount",Float)=0.5
    }
    SubShader
    {
        CGINCLUDE

        #include "UnityCG.cginc"

        sampler2D _MainTex;
        fixed _BlurAmount;

        struct v2f
        {
            float4 pos:SV_POSITION;
            half2 uv:TEXCOORD0;
        };

        v2f vert(appdata_img v) 
        {
            v2f o;

            o.pos = UnityObjectToClipPos(v.vertex);

            o.uv = v.texcoord;

            return o;
        }

        fixed4 fragRGB(v2f i) :SV_Target
        {
            return fixed4(tex2D(_MainTex,i.uv).rgb,_BlurAmount);
        }

        half4 fragA(v2f i):SV_Target
        {
            return tex2D(_MainTex,i.uv);
        }


        ENDCG

        ZTest Always Cull Off ZWrite Off

        Pass
        {
            Blend SrcAlpha OneMinusSrcAlpha

            ColorMask RGB

            CGPROGRAM

            #pragma vertex vert
            #pragma fragment fragRGB

            ENDCG
        }

        Pass
        {
            Blend One Zero
            ColorMask A
            CGPROGRAM

            #pragma vertex vert
            #pragma fragment fragA
            ENDCG
        }
    }
}
牛神自
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
UnityShader[3]屏幕后处理学习笔记
Thanatos_Left的博客
07-16 1241
大致学习了画面滤镜、边缘检测、模糊、bloom、深度操作等功能的原理和实现
Unity屏幕后处理
jfy307596479的博客
01-08 4523
        后处理：渲染完整个场景得到屏幕图像后，对这个图像进行操作。         过程：摄像中添加屏幕后处理脚本，OnRenderImage(RenderTexture src, RenderTexture dest)会将当前渲染的图像存储在src的纹理中，使用Graphics.Blit（RenderTexture src,  RenderTexture dest, Material ...
Unity Shader学习记录(19) ——屏幕后处理效果
weixin_45810196的博客
04-25 935
屏幕后处理，顾名思义，通常指的是在渲染完整个场景得到屏幕图像后，再对这个图像进行系列操作，实现各种屏幕特效。使用这种技术，可以为游戏画面添加更多的艺术效果，例如景深(DepthofField)、运动模糊(Motion Blur)等。
Unity 不同渲染管线添加后处理效果方式
SMMMMM_的博客
03-31 1100
在Edit->Project Settings->Graphics->Scriptable Render Pipeline Settings处设置为刚刚新创建的管线资源。项目新建使设为URP工程或者在已有的项目内添加URP插件 在Window->Package Manager->Universal RP导入后。Window->Package Manager->Post Processing->Instsll添加工程内即可。在这个时候项目内材质球可能会显示为洋红色，按照下图步骤点击一键可以恢复大部分材质球。
Games104 Lecture 7 游戏中渲染管线、后处理和其他的一切
Jason__Y的博客
05-01 471
游戏中渲染管线、后处理和其他的一切环境光遮蔽 AOHBAOGTAO雾效深度雾效高度雾效体素雾效抗锯齿 AAFXAA（Fast Approximate Anti-aliasing）TAA后处理BloomTone MappingColor Grading渲染管线Frame GraphV-Sync & G-Sync [写在前面] 由于很多内容在GAMES202中有介绍，所以只记录本人觉得有必要再记录的。 环境光遮蔽 AO HBAO 利用ray-marching思想绕一圈，获取可见边缘线，然后就可以更准确的
【Unity2D好项目分享】用全是好活制作横版卷轴射击游戏②游戏画面后处理以及制作玩家子弹
dangoxiba的博客
05-16 1251
学习目标： 今天学习 学习内容： 提示：这里可以添加要学的内容 例如： 搭建 Java 开发环境 掌握 Java 基本语法 掌握条件语句 掌握循环语句 学习时间： 提示：这里可以添加计划学习的时间 例如： 周一至周五晚上 7 点—晚上9点 周六上午 9 点-上午 11 点 周日下午 3 点-下午 6 点 学习产出： 提示：这里统计学习计划的总量 例如： 技术笔记 2 遍 CSDN 技术博客 3 篇 习的 vlog 视频 1 个 ...
Shader攻占笔记（八）屏幕特效
PopHazel的博客
11-02 2451
屏幕特效前言脚本基类景深效果脚本部分着色器部分碎屏效果动态模糊 前言 【关于作业的狡辩】 本周内容与前几周相比，难度提高了一些，本章的shader需要配合相应的脚本使用。脚本基本上承担两个作用：设置着色器的参数，以及隐式创建承载着色器的材质。因为脚本功能高度相似，可以抽象出一个父类进行统一编写（我的基类脚本为RenderImageBase）。 本周的学习为主，创新之处不多。在阅读案例的过程中，碰到了一些没见过的方法，在这里做简单记录。 【关于debug】 试敲过程中，因为多加了脚本这一层操作，可能不太方便调
Unity 重内置 Built-in 到 可编程 URP 函数对应整理.docx
01-05
Unity 的可编程渲染管线（Scriptable Render Pipeline）代表了 Unity 处理图形方式的一大进步，为用户提供了更多定制管线的能力。然而， Built-in 到 URP 的示例仍然较少，这篇文章提供了 Built-in 到 URP 的示例...
Unity-URP-UI-Blur（2022.2）
最新发布
05-10
与传统的内置渲染管线相比，URP在移动设备和低功耗平台上表现出色，同时在高级特效方面也有所增强。 UI模糊效果，又称为高斯模糊或者景深模糊，常用于模拟真实世界中的焦外效果，使用户界面元素更具层次感。在Unity...
Unity Shader 入门精要-第二章 Unity Shader基础
Wenmeijing的博客
05-25 1323
声明：这里是个人学习《UnityShader入门精要》这本书的学习笔记，图片文字都是书上抄下来的（文字精简了一下，图片都是书上照搬的）。并非个人原创作品，仅供学习交流使用。 3-1 Unity Shader 概述 3-1-1 一对好兄弟：材质和Unity Shader 在unity中我们需要配合使用材质和unity shader 才能达到需要的效果。 3-1-2 Unity中的材质 unity的可视化材质： 3-1-3 unity中的sh..
PostEffectBase.cs
08-20
乐乐姐或某大神代码所用到的PostEffectBase，整个项目太大，不方便传输，这个单独类提供下载，屏幕后置渲染用，unity3d,c#语法，大神毕竟是大神，但是还是那句话，几年前乐乐姐还是大学生，这也是几年前流程的做法，现在有更加新的做法，而且这种渲染处理作用不是太大，而且无法热更新，这个基类也是需要写继承类和加很多配置才能用起来，仅供学习参考，很多效果都能用（需手动把import UnityEditor;引入去掉，避免打包时提示不通过）
Unity-Chan Toon Shader 2 介绍
cangod的博客
05-17 7462
Introduction to Unity-Chan Toon Shader 2 本文档主要是对UTS2官方手册的个人理解与总结（其实以翻译记录为主：>） 仅作为个人学习使用，不得作为商业用途，欢迎转载，并请注明出处。 翻译中有些术语不准确，但不影响理解的，不再一一调整，有些简单的示例可能会被跳过，请谅解。 参考链接：https://github.com/unity3d-jp/UnityCh...
Unity Shader-深度相关知识总结与效果实现（LinearDepth，Reverse Z，世界坐标重建，软粒子，高度雾，运动模糊，扫描线效果）
puppet_master的专栏
06-18 2万+
前言 前言废话依旧比较多，感觉我是个写游戏体验评测的，233。最近想起了《恶灵附身》这款游戏的几个效果： 《恶灵附身》整款游戏都是在一个“疯子”撸总的脑洞世界里面，游戏内容相当恐怖（吓得我当年一边尖叫一边玩，不光把我吓够呛，把我室友也吓坏了），有“贞子”，“保险箱怪”等等至今让我久久不能忘怀的Boss，不过整个游戏既有恐怖的地方，又有刺激的战斗，非常符合三上真司一贯的作风（我是三上...
Unity3D中的Post effects
爱冒险的技术宅
04-24 1万+
提要所谓post effects，就是后处理，在渲染的流水线中属于最后的阶段，处理的对象是由场景生成的一张图片。常见的后处理效果有HDR，Motion Blur等，通过对屏幕空间的后处理，可以很方便的调整游戏整体的风格。基本步骤主要思路就是首先1）将摄像机的RenderTexture传递到Shder里面，Shader在GPU中进行计算，然后2）再将处理后的图片传递回来。第一步需要用C#脚本来处理，
【Unity Shader入门】3、Unity默认的渲染管线
LST329的博客
02-12 2887
Unity的渲染流水线可分为： 应用阶段几何阶段光栅化阶段 一、应用阶段 应用阶段包括 1、顶点数据（Gpu固定实现） 1.1、数据加载到显存中   将渲染所需数据从硬盘加载到内存中，网格纹理等数据又被加载到显存中（一般加载到显存后内存中的数据就会被移除） 1.2、设置渲染状态   这些状态定义了场景中的网格是怎么被渲染的。例如，使用哪个顶点着色器， 片原着色器，光源属性，材质等。 1.3、调...
unity中HideFlags的利用
weixin_30443895的博客
08-19 1456
HideFlags主要用于控制物体在hierarchy，Inspector视图的显示销毁等的bit mask~ None：默认情况，正常可见对象~ API： HideInHierarchy：在Hierarchy视图中隐藏，并且如果它保存在一个资源中，不会显示在Project视图中~ HideInInspector：在Inspector视图中隐藏，无法查看其相关的组件~ Dont...
Unity - 通用渲染管线（URP）1.渲染、后处理
热门推荐
祝你万事顺利的博客
10-28 4万+
简介 The Universal Render Pipeline (URP) is a prebuilt Scriptable Render Pipeline, made by Unity. The technology offers graphics that are scalable to mobile platforms, and you can also use it for higher...
unity渲染管线及升级URP
噗噗噗的博客
05-16 1万+
unity渲染管线及升级URP一，unity渲染管线简介二，通用渲染管线URP三，shader升级URP1，Builtin RP和URP中内置Shader 的对应2，总体结构3，include4，光照模式LightMode5，变体Variants6，预定义宏辅助宏阴影贴图纹理采样器声明光照、雾7，辅助函数变换函数通用辅助函数向前渲染函数屏幕空间顶点光照深度其他7，内置变量8，后处理参考资料 一，unity渲染管线简介 Unity引擎的渲染管线主要分为"渲染核心库"与"渲染策略"两个部分, “渲染核心库”是U
unity中HideFlags~
Never give up~
09-11 3299
None A normal, visible object. This is the default. HideInHierarchy The object will not appear in the hierarchy. HideInInspector It is not possible to view it in the inspector. DontSave The object
Unity3D内置Shader分类与Vertex-Lit详细解析
在Unity3D中，Shader是图形渲染的关键组成部分，它们控制着游戏对象如何在屏幕上显示。ShaderLab是一种特定的脚本语言，用于编写Unity的Shader，它的语法简洁，便于理解，同时能够与Cg/HLSL这样的强大编程语言相结合...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值