Unity urp 自定义后处理bloom

已于 2024-04-29 22:11:21 修改
阅读量259 收藏 2
点赞数 1
分类专栏： shader 文章标签： unity 着色器
于 2024-04-29 22:10:22 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/TGB666/article/details/138327298
版权
本文详细描述了如何在Unity中创建一个自定义的Unlit/CustomBloom着色器，包括其属性设置、SubShader部分的结构以及与PostProcessComponent和ScriptableRendererFeature的集成，展示了如何实现模糊效果和后期处理功能。
摘要由CSDN通过智能技术生成

直接上代码

shander

Shader "Unlit/CustomBloom"
{
    Properties
    {
        _MainTex ("MainTex", 2D) = "white" {}
        _Bloom("Bloom", 2D) = "white" {}
        _Size("Size",Range(1,10)) = 1
        _Threshold("Threshold",Range(0,1)) = 0
    }
    SubShader
    {
        HLSLINCLUDE

        #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Core.hlsl"
        struct appdata
        {
            float4 vertex : POSITION;
            float2 uv : TEXCOORD0;
        };

        struct v2f_bloom
        {
            float2 uv : TEXCOORD0;
            float4 vertex : SV_POSITION;
        };
        
        struct v2f
        {
            float2 uv[5] : TEXCOORD0;
            float4 vertex : SV_POSITION;
        };
        TEXTURE2D(_MainTex);
        SAMPLER(sampler_MainTex);
        half4 _MainTex_TexelSize;
        half4 _MainTex_ST;

        TEXTURE2D(_BloomTex);
        SAMPLER(sampler_BloomTex);
        half4 _BloomTex_TexelSize;
        half4 _BloomTex_ST;

        float _Size;
        float _Threshold;

        v2f vertH (appdata v)
        {
            v2f o;
            o.vertex = TransformObjectToHClip(v.vertex);
            float2 uv = v.uv;
            o.uv[0] = uv; 
            o.uv[1] = uv + float2(_MainTex_TexelSize.x,0) * _Size;
            o.uv[2] = uv - float2(_MainTex_TexelSize.x,0) * _Size;
            o.uv[3] = uv + float2(_MainTex_TexelSize.x * 2,0) * _Size; 
            o.uv[4] = uv - float2(_MainTex_TexelSize.x * 2,0) * _Size; 

            return o;
        }

        v2f vertV (appdata v)
        {
            v2f o;
            o.vertex = TransformObjectToHClip(v.vertex);
            float2 uv = v.uv;
            o.uv[0] = uv; 
            o.uv[1] = uv + float2(_MainTex_TexelSize.y,0) * _Size;
            o.uv[2] = uv - float2(_MainTex_TexelSize.y,0) * _Size;
            o.uv[3] = uv + float2(_MainTex_TexelSize.y * 2,0) * _Size; 
            o.uv[4] = uv - float2(_MainTex_TexelSize.y * 2,0) * _Size; 

            return o;
        }

        float4 frag (v2f i) : SV_Target
        {
            float weight[3] = {0.4026,0.2442,0.0545};
            float4 col = SAMPLE_TEXTURE2D(_MainTex,sampler_MainTex,i.uv[0]) * weight[0];
            for (int j = 1;j < 3;j++)
            {
                col += SAMPLE_TEXTURE2D(_MainTex,sampler_MainTex,i.uv[2 * j - 1]) * weight[j];
                col += SAMPLE_TEXTURE2D(_MainTex,sampler_MainTex,i.uv[2 * j]) * weight[j];
            }
            return col;
        }

        v2f_bloom vert_bloom (appdata v)
        {
            v2f_bloom o;
            o.vertex = TransformObjectToHClip(v.vertex);
            o.uv = TRANSFORM_TEX(v.uv,_BloomTex);
            return o;
        }

        float4 fragBloom(v2f_bloom i) : SV_Target
        {
            float4 col = SAMPLE_TEXTURE2D(_MainTex,sampler_MainTex,i.uv);
            float b = 0.2125 * col.r + 0.7154 * col.g + 0.0721 * col.b;
            b = clamp(b - _Threshold,0,1);
            return col * b;
        }

        float4 fragFinal(v2f_bloom i) : SV_Target
        {
            float4 col = SAMPLE_TEXTURE2D(_MainTex,sampler_MainTex,i.uv) + SAMPLE_TEXTURE2D(_BloomTex,sampler_BloomTex,i.uv);
            return col;
        }
        ENDHLSL
        Tags { "RenderType"="Opaque" "RenderPipeline"="UniversalPipeline"}
        Cull Off ZWrite Off ZTest Always
        LOD 100
        
        Pass
        {
            name "passBloom"
            HLSLPROGRAM
            #pragma vertex vert_bloom
            #pragma fragment fragBloom
            ENDHLSL
        }
        
        Pass
        {
            name "passh"
            HLSLPROGRAM
            #pragma vertex vertH
            #pragma fragment frag
            ENDHLSL
        }
        
        Pass
        {
            name "passv"
            HLSLPROGRAM
            #pragma vertex vertV
            #pragma fragment frag
            ENDHLSL
        }
        
        Pass
        {
            name "passFinal"
            HLSLPROGRAM
            #pragma vertex vert_bloom
            #pragma fragment fragFinal
            ENDHLSL
        }
    }
}


配置参数

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

namespace UnityEngine.Rendering.Universal
{
    public static class CustomBloomShaderName
    {
        public const string _Size = "_Size";
        public const string _Threshold = "_Threshold";
        public const string _MainTex = "_MainTex";
        public const string _BloomTex = "_Bloom";
    }

    public class CustomBloomVolme : VolumeComponent, IPostProcessComponent
    {
        public FloatParameter size = new FloatParameter(0);
        public FloatParameter threshold = new FloatParameter(0.5f);
        public IntParameter sampleCount = new IntParameter(1);
        public IntParameter downSample = new IntParameter(2);

        public bool IsActive()
        {
            return size.value > 0;
        }

        public bool IsTileCompatible()
        {
            return false;
        }
    }
}

实现方法

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.Rendering;
using UnityEngine.Rendering.Universal;
using FogMode = UnityEngine.Rendering.Universal.FogMode;

public class CustomBloomFeature : ScriptableRendererFeature
{
    class CustomBloomPass : ScriptableRenderPass
    {
        private RTHandle source;
        private RTHandle tempTargetHandle;
        private RTHandle tempTargetHandle1;
        public Material bloomMaterial;
        private int sizeId = Shader.PropertyToID(CustomBloomShaderName._Size);
        private int thresholdId = Shader.PropertyToID(CustomBloomShaderName._Threshold);
        private int mainTexId = Shader.PropertyToID(CustomBloomShaderName._MainTex);
        private int bloomTexId = Shader.PropertyToID(CustomBloomShaderName._BloomTex);
        int tempbloom = Shader.PropertyToID("tempbloom");
        int tempbloom1 = Shader.PropertyToID("tempbloom1");
        public CustomBloomPass()
        {
            tempTargetHandle = RTHandles.Alloc(tempbloom, name: "tempbloom");
            tempTargetHandle1 = RTHandles.Alloc(tempbloom1, name: "tempbloom1");
        }

        public void Setup(RTHandle source,Material bloomMaterial)
        {
            this.source = source;
            this.bloomMaterial = bloomMaterial;
            this.renderPassEvent = RenderPassEvent.AfterRenderingTransparents;
        }

        public override void Execute(ScriptableRenderContext context, ref RenderingData renderingData)
        {
            CustomBloomVolme customBloomVolme = VolumeManager.instance.stack.GetComponent<CustomBloomVolme>();
            if (customBloomVolme.IsActive())
            {
                CommandBuffer cmd = CommandBufferPool.Get("CustomBloomPassCmd");
                var desc = renderingData.cameraData.cameraTargetDescriptor;
                desc.msaaSamples = 1;
                desc.depthBufferBits = 0;
                desc.width = desc.width / customBloomVolme.downSample.value;
                desc.height = desc.height / customBloomVolme.downSample.value;

                RenderingUtils.ReAllocateIfNeeded(ref tempTargetHandle, desc, FilterMode.Bilinear, TextureWrapMode.Clamp, name: tempTargetHandle.name);
                RenderingUtils.ReAllocateIfNeeded(ref tempTargetHandle1, desc, FilterMode.Bilinear, TextureWrapMode.Clamp, name: tempTargetHandle1.name);

                bloomMaterial.SetFloat(sizeId,customBloomVolme.size.value);
                bloomMaterial.SetFloat(thresholdId,customBloomVolme.threshold.value);
                
                cmd.Blit(source,tempTargetHandle,bloomMaterial,0);
                
                var lastDown = tempTargetHandle;
                for (int i = 0; i < customBloomVolme.sampleCount.value; i++)
                {
                    cmd.Blit(lastDown,tempTargetHandle1,bloomMaterial,1);
                    lastDown = tempTargetHandle1;
                    cmd.Blit(lastDown,tempTargetHandle,bloomMaterial,2);
                    lastDown = tempTargetHandle;
                }
                
                cmd.SetGlobalTexture(bloomTexId,lastDown);
                cmd.Blit(source,tempTargetHandle1,bloomMaterial,3);
                cmd.Blit(tempTargetHandle1,source);
                //cmd.Blit(tempTargetHandle1,source);
                context.ExecuteCommandBuffer(cmd);
                CommandBufferPool.Release(cmd);
                //RTHandles.Release(tempTargetHandle);
                //RTHandles.Release(tempTargetHandle1);
            }
        }
    }
    
    private CustomBloomPass customBloomPass;
    public Material bloomMaterial;
    public override void Create()
    {
        customBloomPass = new CustomBloomPass();
    }

    public override void AddRenderPasses(ScriptableRenderer renderer, ref RenderingData renderingData)
    {
        renderer.EnqueuePass(customBloomPass);
    }

    public override void SetupRenderPasses(ScriptableRenderer renderer, in RenderingData renderingData)
    {
        customBloomPass.Setup(renderer.cameraColorTargetHandle,bloomMaterial);
    }
}
不说废话直接上代码
关注
专栏目录
Unity URP管线设置 后处理的使用
MiYa_ZCW的博客
06-28 4864
Unity 使用URP 的基础配置内容
Unity 升级项目到Urp（通用渲染管线）以及画面后处理
热门推荐
xinzhilinger的博客
03-30 5万+
前言： Urp是一种SRP（可编程渲染管线），相比于默认渲染管线，在提升画面表现的同时，也可以提升游戏的性能表现 开始升级前准备 在开始之前，需要你备份你的项目，确保在升级过程中出现问题还有挽回的空间 关于项目的备份： 可以打包成Package来导出项目 在你做好备份后，就可以正式开始项目的升级工作，我们可以在导航栏中的Window选项中找到Package Manager，点击进去，找到Universal RP，然后点击安装即可完成安装 将默认渲染管线替换为Urp渲染管线 导入Urp插件后，在Pr
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...
Fast Mobile Post Processing Color CorrectionLUT Blur Bloom LWRP URP 1.6.zip
08-04
该软件包包含主要的后处理堆栈功能，这些功能经过了最大程度的优化，即使在低端设备上也可以提高性能，色彩校正、模糊、色差、绽放、图像过滤、插图等等。assets，1.7已经上传：https://download.csdn.net/download/niubitianping/18478392
【推荐100个unity插件之24】Post Processing 后处理插件Post-process Volume 和 Volume最全基础使用说明
最新发布
向宇
08-06 2458
之前我已经实现了不少后处理功能，本文其实就是将他们归类整理，以便更好的查找和理解。在Unity中，后处理（Post-Processing）是在相机所捕捉的图像上应用一些特殊效果的过程，后处理会让图像视觉效果更好（前提是做的好）。这些效果的范围有非常细微的颜色调整，也包括整体的美术风格的大修，可以让场景看起来更加真实或风格化，或者只是变得更好看。就像我们都会用手机拍照，但很多时候我们拍的原始的相片都打不到我们想要的效果。比如照片可能亮度不够，颜色不饱和或者对比度不好等。
Unity自定义后处理——Bloom效果
阿赵的博客
07-23 1261
继续介绍屏幕后处理效果，这一期讲一下Bloom效果。
URP自定义后处理（相机滤镜）
真像大白阿的博客
04-29 1588
前言 之前做游戏一直想弄个可以实时触发相机滤镜的效果，自处找了教程和资料，想要做到自定义效果的话最好办法是在unity 内部实现，这个办法比较硬核，其实不适合我这样的小白，所以我在实现的过程中非常痛苦，我用的unity URP 模式其实自带后处理隐藏菜单的，这功能可以通过添加Volume组件启用，但是要在底层代码中自己写个脚本，类似在底层接一根线出来。 一、自定义render feature 先从底层接线，自定义render feature，怎么定义呢，先找到你的渲染管线，打开菜单栏edit—proj
URP自定义屏幕后处理
阿赵的博客
05-25 2098
URP渲染管线里面怎样使用后处理效果，还有怎样去自定义后处理效果。
URP---自定义后处理流程
m0_56399931的博客
07-22 2004
URP—自定义后处理流程 前记：默认的build-in管线的后处理挺简单，但是换了urp还想上后处理，使用这几天进行了学习---------------------mx 屏幕后处理：通常指在渲染完整个场景得到屏幕图像之后再对这个图像进行一系列操作，实现各种屏幕特效。 在build-in的管线中，后处理的基本流程是： 预处理—用于提前检查各种资源和条件是否满足 在OnRenderImage函数中对shader中的变量进行赋值，并根据shader对源图像进行处理 URP后处理前期准备 在包管理器中导入Uni
unity urp 后处理
08-23
要在Unity URP中实现后处理效果，可以按照以下步骤进行操作： 1. 导入后处理包：打开Unity编辑器，转到Window -> Package Manager。在Package Manager窗口中，搜索并安装 "Universal RP" 包。 2. 创建后处理脚本：...
探索 Unity 中的后处理
分享身边生活经验blog
10-03 4264
后处理描述了我们可以应用于游戏场景的图像效果。场景包含游戏的环境 和菜单。您可以考虑游戏场景设计的一种方法是将每个场景的文件视为一个单独的关卡。您在每个场景中放置环境、障碍物和装饰，本质上是分段设计和构建游戏。您可以应用后期处理效果作为游戏视觉效果的最后润色。有时，您甚至可以使用后期处理为您的游戏创建完全不同的外观。例如，您可以通过使用自动曝光和 Bloom 效果来描绘日光，将黑暗的场景变成明亮的场景。您还可以使用白平衡效果将明亮的一天变成寒冷多云的一天。
KinoBloom：Unity的Bloom效果
02-06
奇诺·布鲁姆 Bloom是Unity的图像效果，可向渲染的帧添加Bloom /遮盖眩光效果。 系统要求 Unity 5.5或更高版本。 安装 从“页面下载unitypackage文件之一，并将其​​导入到项目中。 效果属性 阈值-滤除此亮度级别下的像素。 该值应在伽玛空间（在颜色选择器中使用）中给出。 软膝盖-在阈值下限/上阈值之间进行过渡（0 =硬阈值，1 =软阈值）。 强度-效果的总强度。 半径-控制遮罩效果的程度。 该值与屏幕尺寸无关，可以以与分辨率无关的方式进行控制。 高质量-控制滤镜质量和缓冲液分辨率。 在移动平台上，它可能会强烈影响效果的性能，因此，建议在移动设备上运行时
Fast Bloom Mobile URP VR AR LWRP 1.4.unitypackage
05-14
该程序包包含用于在屏幕上应用光晕的着色器。 该解决方案是目前市场上最快的解决方案。 着色器已在加载场景中的低端移动设备上进行了测试，以优化性能和fps。
unity高斯模糊 & Bloom & 运动模糊
dogman_的博客
04-04 649
由于代码存在大量折叠，推荐复制放入VS CODE观看。
URP管线中自定义Bloom
木马人
11-19 3770
非HDR开启bloom的效果 主要是URP作者的教程 工程源码在我的git中：我的git工程网址 using System.Collections; using System.Collections.Generic; using System.IO; using UnityEditor; using UnityEngine; using UnityEngine.Rendering; partial class PostFXStack { private const string bufferNa
Unity3D URP 仿蜘蛛侠风格化Bloom&AO
weixin_38027841的博客
09-10 1222
通过URP的Custom Renderer Feather 实现风格化后处理效果。并使用shader graph制作Shader
Unity URP下后处理如何实现
qq_15653345的博客
03-22 573
首先，需要一个存储渲染配置信息的类，没什么具体的要求，很多博主喜欢放在RenderFeature类内，最好还是单独建一个文件，这样之后做其他效果也可以通用。重头戏，RenderFeature类，此类作用是实现渲染的逻辑，需要在管线配置文件中点击Add Renderer Feature添加，如图所示。可以使用ShaderGraph写，也可以不用，本文将使用ShaderGraph。渲染的执行，需要在此方法中写具体的渲染逻辑。就是简单的获取深度图进行颜色的混合，效果如下。要实现功能，离不开下图这三个文件。
unity 写一个 bloom shader （built-in 和 urp 实现方式）
lcfengokok的博客
04-09 1108
在Unity中编写一个Bloom（发光）shader是一个相对复杂的任务，因为它涉及到多个渲染步骤和后期处理效果。Bloom效果通常是通过提取场景中的高亮部分，并将它们模糊后叠加回原始图像来实现的。下面是一个简单的Bloom shader示例，它使用了Unity的ShaderLab语言。请注意，这个示例是一个基本的框架，你可能需要根据你的具体需求进行调整和优化。首先，创建一个新的shader文件（例如），并输入以下代码：fragsmoothstep。
URP——后期处理特效——光华Bloom
liquanyi007的博客
11-30 3315
Bloom 在图片中，光华效应产生了从明亮区域边缘延伸出来的光的边缘。这就产生了一种亮光压倒相机的错觉。 光华特效也有镜头污垢的特性，你可以用它来应用一个全屏的污迹或灰尘层来衍射特效。 Using Bloom Bloom使用体积系统，所以要启用和修改Bloom属性，你必须在场景中的体积上添加一个Bloom覆盖。 在体积中添加光华: 在场景或层次视图中，选择一个包含体积组件的游戏对象，在检查器中查看它。 在检查器中，导航到Add Override>Post-processing，然后点..
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值