Unity自定义后处理——Bloom效果

已于 2023-07-26 23:55:00 修改
阅读量1k 收藏 1
点赞数 1
分类专栏： Unity屏幕后处理 文章标签： unity 游戏引擎 Bloom 屏幕后处理
于 2023-07-23 18:13:27 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/liweizhao/article/details/131882315
版权

大家好，我是阿赵。
  继续介绍屏幕后处理效果，这一期讲一下Bloom效果。

一、Bloom效果介绍

在这里插入图片描述

还是拿这个模型作为背景。
在这里插入图片描述

Bloom效果，就是一种全屏泛光的效果，让模型和特效有一种真的在发光的感觉。

在这里插入图片描述
在这里插入图片描述

根据参数不一样，可以做出不同的发光效果。

二、原理介绍

  之前在介绍模糊效果的时候说过，Bloom效果也是基于模糊效果制作的。
  Bloom的原理很简单，先用模糊处理，算出一张模糊后的图片，然后把这张图片的RGB和原始屏幕图片的RGB相加就可以了。由于是RGB颜色叠加，所以本身图片颜色越接近白色的地方，越容易爆掉，所以越接近白色的地方发光的感觉就越明显。如果想Bloom的效果更爆一点，就自己对模糊后的图片进一步做处理吧，最常见的手段就是先乘后加，或者Power后再相加也可以
在这里插入图片描述

实现很简单，在原来的模糊效果代码上面，我们应该再加多一个叠加的Shader就可以了。

half4 frag (v2f_img i) : SV_Target
{
    half4 col = tex2D(_MainTex, i.uv);
	half4 brightCol = tex2D(_brightTex, i.uv);
	col.rgb += brightCol.rgb;
    return col;
}

  我这里在处理模糊之前，先加多了一个BrightRange的计算。这是为了控制一下发光的范围。BrightRange的算法很简单，先取原始图片的rgb三个通道颜色值最大的通道的值，然后用这个最大值减去一个我们指定的值。最后把原图的rgb颜色乘以这个值就可以了。

fixed4 frag (v2f_img i) : SV_Target
{
    fixed4 col = tex2D(_MainTex, i.uv);
	float br = max(max(col.r, col.g), col.b);
	br = max(0, (br - _BrightCut)) / max(br, 0.00001);
	col.rgb *= br;
    return col;
}

通过这个值，我们就可以更好的控制发光的范围
三、源码
1、C#部分

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

public class BloomCtrl : MonoBehaviour
{
    private Material blurMat;
    private Material brightMat;
    private Material bloomMat;
    public bool isBlur = false;
    [Range(0, 4)]
    public float blurSize = 0;
    [Range(-3, 3)]
    public float blurOffset = 1;
    [Range(1, 3)]
    public int blurType = 3;
    [Range(0, 1)]
    public float brightCut = 0.5f;
    void Start()
    {

    }


    void Update()
    {

    }

    private Material GetBlurMat(int bType)
    {
        if (bType == 1)
        {
            return new Material(Shader.Find("Hidden/AzhaoBoxBlur"));
        }
        else if (bType == 2)
        {
            return new Material(Shader.Find("Hidden/AzhaoGaussianBlur"));
        }
        else if (bType == 3)
        {
            return new Material(Shader.Find("Hidden/AzhaoKawaseBlur"));
        }
        else
        {
            return null;
        }
    }

    private void ReleaseRT(RenderTexture rt)
    {
        if (rt != null)
        {
            RenderTexture.ReleaseTemporary(rt);
        }
    }

    private bool CheckNeedCreateBlurMat(Material mat, int bType)
    {
        if (mat == null)
        {
            return true;
        }
        if (mat.shader == null)
        {
            return true;
        }
        if (bType == 1)
        {
            if (mat.shader.name != "Hidden/AzhaoBoxBlur")
            {
                return true;
            }
            else
            {
                return false;
            }
        }
        else if (bType == 2)
        {
            if (mat.shader.name != "Hidden/AzhaoGaussianBlur")
            {
                return true;
            }
            else
            {
                return false;
            }
        }
        else if (bType == 3)
        {
            if (mat.shader.name != "Hidden/AzhaoKawaseBlur")
            {
                return true;
            }
            else
            {
                return false;
            }
        }
        else
        {
            return false;
        }
    }
    private void BlurFun(RenderTexture source, RenderTexture destination, float blurTime, int bType, float offset)
    {
        if (CheckNeedCreateBlurMat(blurMat, bType) == true)
        {
            blurMat = GetBlurMat(bType);
        }
        if (blurMat == null || blurMat.shader == null || blurMat.shader.isSupported == false)
        {
            return;
        }
        blurMat.SetFloat("_BlurOffset", offset);
        float width = source.width;
        float height = source.height;
        int w = Mathf.FloorToInt(width);
        int h = Mathf.FloorToInt(height);
        RenderTexture rt1 = RenderTexture.GetTemporary(w, h);
        RenderTexture rt2 = RenderTexture.GetTemporary(w, h);
        Graphics.Blit(source, rt1);
        for (int i = 0; i < blurTime; i++)
        {
            ReleaseRT(rt2);
            width = width / 2;
            height = height / 2;
            w = Mathf.FloorToInt(width);
            h = Mathf.FloorToInt(height);
            rt2 = RenderTexture.GetTemporary(w, h);
            Graphics.Blit(rt1, rt2, blurMat, 0);
            width = width / 2;
            height = height / 2;
            w = Mathf.FloorToInt(width);
            h = Mathf.FloorToInt(height);
            ReleaseRT(rt1);
            rt1 = RenderTexture.GetTemporary(w, h);
            Graphics.Blit(rt2, rt1, blurMat, 1);
        }
        for (int i = 0; i < blurTime; i++)
        {
            ReleaseRT(rt2);
            width = width * 2;
            height = height * 2;
            w = Mathf.FloorToInt(width);
            h = Mathf.FloorToInt(height);
            rt2 = RenderTexture.GetTemporary(w, h);
            Graphics.Blit(rt1, rt2, blurMat, 0);
            width = width * 2;
            height = height * 2;
            w = Mathf.FloorToInt(width);
            h = Mathf.FloorToInt(height);
            ReleaseRT(rt1);
            rt1 = RenderTexture.GetTemporary(w, h);
            Graphics.Blit(rt2, rt1, blurMat, 1);
        }
        Graphics.Blit(rt1, destination);
        ReleaseRT(rt1);
        rt1 = null;
        ReleaseRT(rt2);
        rt2 = null;
        return;
    }
    private bool BrightRangeFun(RenderTexture source, RenderTexture destination)
    {
        if (brightMat == null)
        {
            brightMat = new Material(Shader.Find("Hidden/BrightRange"));
        }
        if (brightMat == null || brightMat.shader == null || brightMat.shader.isSupported == false)
        {
            return false;
        }
        brightMat.SetFloat("_BrightCut", brightCut);
        Graphics.Blit(source, destination, brightMat);
        return true;

    }

    private bool BloomAddFun(RenderTexture source, RenderTexture destination, RenderTexture brightTex)
    {
        if (bloomMat == null)
        {
            bloomMat = new Material(Shader.Find("Hidden/AzhaoBloom"));
        }
        if (bloomMat == null || bloomMat.shader == null || bloomMat.shader.isSupported == false)
        {
            return false;
        }
        bloomMat.SetTexture("_brightTex", brightTex);
        Graphics.Blit(source, destination, bloomMat);
        return true;
    }
    private void OnRenderImage(RenderTexture source, RenderTexture destination)
    {
        if (isBlur == true)
        {
            RenderTexture finalRt = source;
            RenderTexture rt2 = RenderTexture.GetTemporary(source.width, source.height);
            RenderTexture rt3 = RenderTexture.GetTemporary(source.width, source.height);
            BrightRangeFun(source, rt2);
            if (blurSize > 0)
            {
                BlurFun(rt2, rt3, blurSize, blurType, blurOffset);
                BloomAddFun(source, finalRt, rt3);
            }
            Graphics.Blit(finalRt, destination);
            ReleaseRT(finalRt);
            ReleaseRT(rt2);
            ReleaseRT(rt3);

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

2、Shader
  模糊shader就不重复了，参考之前的文章
这里提供一下Bloom和BrightRange的shader
1.Bloom

Shader "Hidden/AzhaoBloom"
{
    Properties
    {
        _MainTex ("Texture", 2D) = "white" {}
		_brightTex("BrightTex",2D) = "black"
    }
    SubShader
    {
        // No culling or depth
        Cull Off ZWrite Off ZTest Always

        Pass
        {
            CGPROGRAM
            #pragma vertex vert_img
            #pragma fragment frag

            #include "UnityCG.cginc"



            sampler2D _MainTex;
		sampler2D _brightTex;

			half4 frag (v2f_img i) : SV_Target
            {
                half4 col = tex2D(_MainTex, i.uv);
				half4 brightCol = tex2D(_brightTex, i.uv);
				col.rgb += brightCol.rgb;
                return col;
            }
            ENDCG
        }
    }
}

2.BrightRange

Shader "Hidden/BrightRange"
{
    Properties
    {
        _MainTex ("Texture", 2D) = "white" {}
		_BrightCut("LightVal",Range(0,1)) = 0.5
    }
    SubShader
    {
        // No culling or depth
        Cull Off ZWrite Off ZTest Always

        Pass
        {
            CGPROGRAM
            #pragma vertex vert_img
            #pragma fragment frag

            #include "UnityCG.cginc"



            sampler2D _MainTex;
			float _BrightCut;

            fixed4 frag (v2f_img i) : SV_Target
            {
                fixed4 col = tex2D(_MainTex, i.uv);
				float br = max(max(col.r, col.g), col.b);
				br = max(0, (br - _BrightCut)) / max(br, 0.00001);
				col.rgb *= br;
                return col;
            }
            ENDCG
        }
    }
}
阿赵3D
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Unity Shader-后处理：Bloom全屏泛光
puppet_master的专栏
10-30 2万+
一.简介 今天来学习一下Bloom效果，中文一般叫做全屏泛光效果，这是一种可以模拟出HDR的全屏后处理效果，但是实现原理与HDR相差很远，效果比HDR差一些，但是比HDR的性能要节省很多。 http://blog.csdn.net/u011047171/article/details/48522073 http://www.tuicool.com/articles/V77N7f h
Unity屏幕特效之Bloom
09-21
UnityShader实例15，配套资源，，适用于移动平台的屏幕bloom特效，效率不错
用Unity实现Bloom
异次元的归来
08-29 1603
Bloom是一种常见的后处理效果，用来给发光的物体增加光晕。接下来让我们看看如何在Unity中实现它。
UnityShader实例15:屏幕特效之Bloom
热门推荐
lupeng的博客
09-21 3万+
Bloom,又称“全屏泛光”，是游戏中常用的一种镜头效果，是一种比较廉价的“伪HDR”效果（如下右图）；使用了Bloom效果后，画面的对比会得到增强，亮的地方曝光也会得到加强，画面也会呈现一种朦胧，梦幻的效果，婚纱摄影中照片处理经常用到这种类似处理效果。Bloom效果一般用来近似模拟HDR效果，效果也比较相向，但实现原理却完全不同。本例将实现一个适合移动平台使用的bloom屏幕特效。
unity3d bloom效果 之渲染效果提升
思玉
05-23 3128
废话不多上代码 C# （肯定是绑定在摄像机上面的，你懂的） public class MobileBloom : MonoBehaviour { //分辨率 public int downSample = 1; //采样率 public int samplerScale = 1; //高亮部分提取阈值 public Color...
【Unity Shader​】 屏幕后处理5.0：讨论双重模糊的Bloom
qq_41835314的博客
11-27 2200
这篇文章就是一个基于双重模糊的讨论
Unity-后期处理效果之Bloom
qq_44512151的博客
06-17 1万+
Unity-后期处理效果之Bloom什么是Bloom 什么是Bloom Bloom是一种游戏常见的一种屏幕效果叫做高光溢出，是一种光学效果，其中来自明亮来源（如闪光）的光表现为泄露到周围对象中。通俗来说就是这种特效可以模拟真实摄像机的一种图像效果，他让画面中较亮的区域"扩散"到周围的区域，造成一种朦胧的效果。 ...
【Unity3D】Bloom特效
little_fat_sheep
06-03 2161
Bloom 特效是指：将画面中较亮的区域向外扩散，造成一种朦脓的效果。实现 Bloom 特效，一般要经过 3 个阶段处理：亮区域检测、高斯模糊、Bloom 合成。根据亮度阈值检测亮区，如下从原图中提取亮区域。将高斯模糊处理后的亮区域图像与原图像叠加。对亮区域进行高斯模糊（原理见→。），使得亮区域往外扩散，并产生朦脓效果。
【TA100】Bloom算法
weixin_45810196的博客
06-26 612
● Bloom，也称辉光，是一种常见的屏幕效果● 模拟摄像机的一种图像效果，让画面中较亮的区域“扩散”到周围的区域中，造成一种朦胧的效果● 可以让物体具有真实的明亮效果● 可以实现光晕效果。
Unity通过Post Processing实现Bloom（Glow)
zouxin_88的专栏
12-13 4931
我这里用的Unity2018.4.14 1.新建工程，【Window】【Pacage Manager】下载Post Processing 2.在MainCamera上添加Post Process Layer，并设置效果作用的Layer，这里为PostProcessing 3.点击Create Empty创建Volume，并添加Post Process Volume，设置图层为PostProcessing. 4.点击Profile的【New】按钮，再点击【Add Effect......
Unity 实现部分物体Bloom效果
SnoopyNa2Co3的博客
12-25 1万+
之前研究了一下怎么让屏幕里部分东西显示bloom效果，例如只是特效显示bloom效果而角色不显示，现在记录一下 我这里加了效果图和工程下载地址，方便大家了解 PS：这个性能有问题，建议看看这边博客，用存储alpha来替换重新渲染一遍带来的性能问题 https://blog.csdn.net/SnoopyNa2Co3/article/details/88075047 扩展：可以修改替换...
bloom效果UNITY资源包
05-11
bloom效果UNITY资源包 实现我们常用的bloom后置处理效果 这个插件是一个性能足够在低端设备上跑的版本，在线上业务上运行无障碍
unity自定义弹出框功能
08-25
unity自定义弹出框功能 Unity 是一个功能强大且广泛应用的游戏引擎，自定义弹出框功能是 Unity 中的一个重要组件，能为用户提供更加友好的交互体验。下面我们将详细介绍 Unity 自定义弹出框功能的实现。 Unity ...
完整的简单后处理Unity urp工程
最新发布
04-09
本项目“完整的简单后处理Unity urp工程”是针对这一技术的一个实践示例，它包含了一系列后处理效果的实现，以帮助开发者更好地理解和应用URP。 URP的核心目标是优化渲染性能，特别是在移动设备和高性能PC上，通过...
unity自定义虚拟键盘UI Keyboard(UnityPackage)
04-19
UI Keyboard - Unity Package 这是一个可下载的 Unity 包，可以轻松地集成到您的项目中。它的想法是可以使用基于UI的键盘让用户输入数据。最初，这是由于WebGL在移动设备上的局限性，它不会在输入字段处于活动状态时...
Kino：Unity的自定义后期处理效果的集合
02-06
奇诺Kino是Unity （HDRP）的自定义后期处理效果的集合。系统要求Unity 2019.3 HDRP 7.1特效条纹 条纹增加了水平拉伸的光晕，大致类似于变形的镜头光晕。 尽管从物理上讲既不正确，也不节约能源，但只需单击几下即可...
Unity Shader - Bloom(光晕、泛光)
长生但酒狂的博客
05-14 5161
前言 Bloom（光晕）是一种计算机图形效果，用于视频游戏，演示和高动态范围渲染（HDRR）中，以再现真实相机的成像伪像。该效果会产生从图像中明亮区域的边界延伸的条纹（或羽毛），从而造成超亮的光使摄像机或眼睛捕捉场景的幻觉。 效果对比如下: 左边是原图, 右边Bloom处理后的 原理: Bloom的实现原理非常简单，大致分为三步: 对需要处理的图像经过亮度提取, 并且通过一个阙值来控制亮度 对经过亮度提取后的图像进行模糊处理(这里是采用高斯模糊) 最后再叠加原图和模糊处理后的图像,输出即可 实现 下面
Unity 之 后处理实现界面灰度效果(PostProcessing实现 | Shader实现)
陈言必行 -- Unity游戏开发领域优质博主
12-02 4230
一般由于政策特殊日期等因素，或者游戏内角色死亡效果要求等等，我们会想看到一个整体灰色的效果。Unity使用两种方式实现。
UnityShader入门精要——Bloom效果
weixin_51327051的博客
02-20 2454
Bloom特效是游戏中常见的一种屏幕效果。这种特效可以模拟真实摄像机的一一种图像效果， 它让画面中较亮的区域“扩散”到周围的区域中，造成-种朦胧的效果。 Bloom的实现原理非常简单:我们首先根据一个阈值提取出图像中的较亮区域，把它们存储在一张渲染纹理中，再利用高斯模糊对这张渲染纹理进行模糊处理，模拟光线扩散的效果，最后再将其和原图像进行混合，得到最终的效果。（基于高斯模糊） 后处理脚本： using UnityEngine; using System.Collections; public ..
unity 实现后处理Bloom
04-20
很高兴回答你的问题。Unity中实现后处理Bloom效果可以使用Unity自带的Post Processing Stack或者其他第三方的插件来实现。其中Post Processing Stack是Unity 2018版本及以后版本才加入的，如果你使用的是早期版本的Unity，需要安装Post Processing Stack插件。实现Bloom效果的过程可以简单分为两步：首先在Camera上加入Post Processing组件，然后在Post Processing Volume中添加Bloom效果，并且根据需求调整Bloom的参数即可。希望这个回答能够帮到你，如果有更多问题可以继续提问。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值