Unity HilightingSystem屏幕后实现物体外发光描边效果

企业开发 2023-04-08 01:35:06 阅读次数: 0

Unity实现物体外发光描边效果方式有好几种，如重叠放大模型描边Pass、卷积核描边、屏幕后处理等。

HIightingSytem使用了屏幕后期效果实现，效果如下：

在这里插入图片描述

整理出核心代码如下，主要分为4个步骤。

1 ，根据场景上所有需要描边的物体轮廓，将它们画到一张RenderTexture上，其中黑色部分A通道值为0。实现着色器为HighlightingOpaque.Shader。

在这里插入图片描述

2，将RenderTexture模糊化，通过偏移uv混合周围像素的值，包括混合A通道的值。实现着色器为HighlightingBlur.Shader。

混合后的RGB通道的值

在这里插入图片描述

混合后A通道的值：

在这里插入图片描述

3，通过模板测试，裁剪和场景中描边模型重叠的像素，即在着色器中通过设置重叠部分A通道的值为0。实现着色器为HighlightingCut.Shader。

在这里插入图片描述

4，根据RenderTexture的A通道的值，和屏幕后的Source纹理进行和RenderTexture的RGB值进行差值混合，得出描边效果。

实现着色器为HighlightingComposit.Shader。

在这里插入图片描述

整理出核心代码如下：

OutlineObject.cs

OutlineObjectRender.cs

HighlightingOpaque.shader

HighlightingBlur.shader

HighlightingCut.shader

HighlightingComposite.shader

OutlineObject.cs

一个场景可能挂多个，必须挂在场景物体的有MeshRender/SkinMeshRender的节点上！

OutlineObjectRender.cs

必须挂在有MainCamera的节点上！

OutlineObject.cs

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

public class OutlineObject : MonoBehaviour
{
    
    
    public Color color = Color.red;
    [HideInInspector]
    public Renderer render;
    [HideInInspector]
    public Material objMat;
    private void Start()
    {
    
    
        render = GetComponent<MeshRenderer>();
        if (render == null)
            render = GetComponent<SkinnedMeshRenderer>();
        objMat = new Material(Shader.Find("Hidden/Highlighted/Opaque"));
        OutlineObjectRender.Instance.AddOutlineObject(this);
    }
}

OutlineObjectRender.cs

using UnityEngine;
using UnityEngine.Rendering;
using System.Collections.Generic;
public class OutlineObjectRender : MonoBehaviour
{
    
    
    public static OutlineObjectRender Instance;

    private List<OutlineObject> outlineObjs = new List<OutlineObject>();
    private CommandBuffer buf;

                             //1，渲染OutlineObject对象成平面纹理；
    private Material blurMat;//2，将步骤1纹理模糊化，模糊边缘向平面周边扩散；
    private Material maskMat;//3，通过模板测试，不渲染步骤2纹理中和模型重叠的片元部分，只渲染模糊边框；
    private Material combineMat;//4，将当前相机渲染的屏幕结果，与步骤3得出的轮廓纹理结合得出描边效果。

    private RenderTextureDescriptor rtft;
    private RenderTexture rt;
    private RenderTargetIdentifier rtID;

    private int blur0;
    private int blur1;

    private void Awake()
    {
    
    
        Instance = this;
        blurMat = new Material(Shader.Find("Hidden/Highlighted/Blur"));
        maskMat = new Material(Shader.Find("Hidden/Highlighted/Cut"));
        combineMat = new Material(Shader.Find("Hidden/Highlighted/Composite"));

        blur0 = Shader.PropertyToID("Blur0");
        blur1 = Shader.PropertyToID("Blur1");

        buf = new CommandBuffer();
        Camera.main.AddCommandBuffer(CameraEvent.BeforeImageEffectsOpaque, buf);
    }
    public void AddOutlineObject(OutlineObject obj) {
    
    
        if (this.outlineObjs.Contains(obj) == false)
        {
    
    
            this.outlineObjs.Add(obj);
        }
    }
    public void RemoveOutlineObject(OutlineObject obj) {
    
    
        if (this.outlineObjs.Contains(obj))
            this.outlineObjs.Remove(obj);
    }
    private void OnPreRender()
    {
    
    
        if (rt == null)
        {
    
    
            Camera cam = GetComponent<Camera>();
            rtft = new RenderTextureDescriptor(cam.pixelWidth, cam.pixelHeight, RenderTextureFormat.ARGB32, 24);
            rtft.colorFormat = RenderTextureFormat.ARGB32;
            rtft.sRGB = QualitySettings.activeColorSpace == ColorSpace.Linear;
            rtft.useMipMap = false;
            rtft.msaaSamples = 8;

            rt = new RenderTexture(rtft);
            rt.filterMode = FilterMode.Point;
            rt.wrapMode = TextureWrapMode.Clamp;

            if (!rt.Create())
            {
    
    
                Debug.LogError("Failed to create RenderTexture!");
            }
            rtID = new RenderTargetIdentifier(rt);
            maskMat.SetFloat("_HighlightingFillAlpha", 0);
        }
        buf.Clear();
        buf.SetRenderTarget(rtID);
        buf.ClearRenderTarget(true, true, new Color(0, 0, 0, 0));

        RenderTextureDescriptor desc = rtft;
        desc.width = rt.width;
        desc.height = rt.height;
        desc.depthBufferBits = 0;

        for (int i = 0; i < this.outlineObjs.Count; i++)
        {
    
    
            //第一步，将所有要描边的render GameObject用Opaque渲染成2D面颜色，Draw到buf里。
            //所有的需要描边的Render对象都要在这里处理一下，用CommandBuff统一画到同一个Texture上，交给下面的步骤处理。
            outlineObjs[i].objMat.SetColor("_HighlightingColor", outlineObjs[i].color);
            buf.DrawRenderer(outlineObjs[i].render, outlineObjs[i].objMat);
        }

        //第二步，对buf的texture进行模糊。
        //获取2张模板用于模糊处理。
        buf.GetTemporaryRT(blur0, desc, FilterMode.Bilinear);
        buf.GetTemporaryRT(blur1, desc, FilterMode.Bilinear);
        RenderTargetIdentifier blurID0 = new RenderTargetIdentifier(blur0);
        RenderTargetIdentifier blurID1 = new RenderTargetIdentifier(blur1);
        //开始模糊循环之前，将rtID传到blurID。
        buf.Blit(rtID, blurID0);
        bool oddEven = true;
        for (int i = 0; i < 4; i++)
        {
    
    
            float off = 1.5f + 0.5f * i;
            buf.SetGlobalFloat(HighlightingSystem.ShaderPropertyID._HighlightingBlurOffset, off);

            if (oddEven)
            {
    
    
                buf.Blit(blurID0, blurID1, blurMat);
            }
            else
            {
    
    
                buf.Blit(blurID1, blurID0, blurMat);
            }
            oddEven = !oddEven;
        }
        //第三步，对得到模糊纹理进行模板测试，去除和模型重叠的片元像素，通过
        buf.Blit(oddEven ? blurID0 : blurID1, rtID, maskMat);

        //
        buf.SetGlobalTexture("_HighlightingBuffer", rtID);

        buf.ReleaseTemporaryRT(blur0);
        buf.ReleaseTemporaryRT(blur1);
    }
    private void OnRenderImage(RenderTexture source, RenderTexture destination)
    {
    
    
        //第四步，与当前屏幕效果混合
        Graphics.Blit(source, destination, combineMat);
    }
}

HighlightingOpaque.shader

用于将场景上需要描边的物体渲染到RenderTexture上。

Shader "Hidden/Highlighted/Opaque"
{
    
    
	Properties
	{
    
    
		[HideInInspector] _HighlightingColor ("", Color) = (1, 1, 1, 1)
	}
	
	SubShader
	{
    
    
		Lighting Off
		Fog {
    
     Mode Off }
		ZWrite Off			// Manual depth test
		ZTest Always		// Manual depth test

		Pass
		{
    
    
			Stencil
			{
    
    
				Ref 1
				Comp Always
				Pass Replace
				ZFail Keep
			}

			CGPROGRAM
			#pragma vertex vert
			#pragma fragment frag
			#pragma fragmentoption ARB_precision_hint_fastest
			#pragma target 2.0
			#pragma multi_compile __ HIGHLIGHTING_OVERLAY
			#include "UnityCG.cginc"

			uniform fixed4 _HighlightingColor;

			#ifndef HIGHLIGHTING_OVERLAY
			UNITY_DECLARE_DEPTH_TEXTURE(_CameraDepthTexture);
			#endif
			
			struct vs_input
			{
    
    
				float4 vertex : POSITION;
				UNITY_VERTEX_INPUT_INSTANCE_ID
			};

			struct ps_input
			{
    
    
				float4 pos : SV_POSITION;

				#ifndef HIGHLIGHTING_OVERLAY
				float4 screen : TEXCOORD0;
				#endif
			};
			
			ps_input vert(vs_input v)
			{
    
    
				ps_input o;

				UNITY_SETUP_INSTANCE_ID(v);
				o.pos = UnityObjectToClipPos(v.vertex);

				#ifndef HIGHLIGHTING_OVERLAY
				o.screen = ComputeScreenPos(o.pos);
				COMPUTE_EYEDEPTH(o.screen.z);
				#endif

				return o;
			}

			fixed4 frag(ps_input i) : SV_Target
			{
    
    
				#ifndef HIGHLIGHTING_OVERLAY
				float z = SAMPLE_DEPTH_TEXTURE_PROJ(_CameraDepthTexture, UNITY_PROJ_COORD(i.screen));
				float perspZ = LinearEyeDepth(z);	// LinearEyeDepth automatically handles UNITY_REVERSED_Z case
				#if defined(UNITY_REVERSED_Z)
				z = 1 - z;
				#endif
				float orthoZ = _ProjectionParams.y + z * (_ProjectionParams.z - _ProjectionParams.y);	// near + z * (far - near)
				float sceneZ = lerp(perspZ, orthoZ, unity_OrthoParams.w);
				clip(sceneZ - i.screen.z + 0.01);
				#endif

				return _HighlightingColor;
			}
			ENDCG
		}
	}
	Fallback Off
}

HighlightingBlur.shader

将RenderTexture模糊化，并混合A通道的值。

Shader "Hidden/Highlighted/Blur"
{
    
    
	Properties
	{
    
    
		[HideInInspector] _MainTex ("", 2D) = "" {
    
    }
		[HideInInspector] _HighlightingIntensity ("", Range (0.25,0.5)) = 0.3
	}
	
	SubShader
	{
    
    
		Pass
		{
    
    
			ZTest Always
			Cull Off
			ZWrite Off
			Lighting Off
			Fog {
    
     Mode Off }
			
			CGPROGRAM
			#pragma vertex vert
			#pragma fragment frag
			#pragma fragmentoption ARB_precision_hint_fastest
			#pragma target 2.0
			#pragma multi_compile DIAGONAL_DIRECTIONS STRAIGHT_DIRECTIONS ALL_DIRECTIONS
			
			#include "UnityCG.cginc"
			
			uniform sampler2D _MainTex;
			uniform float4 _MainTex_ST;
			uniform float4 _MainTex_TexelSize;
			
			uniform float _HighlightingBlurOffset;
			uniform half _HighlightingIntensity;

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

			struct ps_input
			{
    
    
				float4 pos : SV_POSITION;

				#if defined(ALL_DIRECTIONS)
				float4 uv0 : TEXCOORD0;
				float4 uv1 : TEXCOORD1;
				float4 uv2 : TEXCOORD2;
				float4 uv3 : TEXCOORD3;
				#else
				float4 uv0 : TEXCOORD0;
				float4 uv1 : TEXCOORD1;
				#endif
			};
			
			ps_input vert(vs_input v)
			{
    
    
				ps_input o;
				o.pos = UnityObjectToClipPos(v.vertex);

				float2 uv = UnityStereoScreenSpaceUVAdjust(v.texcoord, _MainTex_ST);
				float2 offs = _HighlightingBlurOffset * _MainTex_TexelSize.xy;

				#if defined(ALL_DIRECTIONS)

				// Diagonal
				o.uv0.x = uv.x - offs.x;
				o.uv0.y = uv.y - offs.y;
				
				o.uv0.z = uv.x + offs.x;
				o.uv0.w = uv.y - offs.y;
				
				o.uv1.x = uv.x + offs.x;
				o.uv1.y = uv.y + offs.y;
				
				o.uv1.z = uv.x - offs.x;
				o.uv1.w = uv.y + offs.y;

				// Straight
				o.uv2.x = uv.x - offs.x;
				o.uv2.y = uv.y;
				
				o.uv2.z = uv.x + offs.x;
				o.uv2.w = uv.y;
				
				o.uv3.x = uv.x;
				o.uv3.y = uv.y - offs.y;
				
				o.uv3.z = uv.x;
				o.uv3.w = uv.y + offs.y;

				#elif defined(STRAIGHT_DIRECTIONS)

				// Straight
				o.uv0.x = uv.x - offs.x;
				o.uv0.y = uv.y;
				
				o.uv0.z = uv.x + offs.x;
				o.uv0.w = uv.y;
				
				o.uv1.x = uv.x;
				o.uv1.y = uv.y - offs.y;
				
				o.uv1.z = uv.x;
				o.uv1.w = uv.y + offs.y;

				#else 

				// Diagonal
				o.uv0.x = uv.x - offs.x;
				o.uv0.y = uv.y - offs.y;
				
				o.uv0.z = uv.x + offs.x;
				o.uv0.w = uv.y - offs.y;
				
				o.uv1.x = uv.x + offs.x;
				o.uv1.y = uv.y + offs.y;
				
				o.uv1.z = uv.x - offs.x;
				o.uv1.w = uv.y + offs.y;

				#endif

				return o;
			}
			
			half4 frag(ps_input i) : SV_Target
			{
    
    
				half4 color1 = tex2D(_MainTex, i.uv0.xy);
				fixed4 color2;

				// For straight or diagonal directions
				color2 = tex2D(_MainTex, i.uv0.zw);
				color1.rgb = max(color1.rgb, color2.rgb);
				color1.a += color2.a;

				color2 = tex2D(_MainTex, i.uv1.xy);
				color1.rgb = max(color1.rgb, color2.rgb);
				color1.a += color2.a;

				color2 = tex2D(_MainTex, i.uv1.zw);
				color1.rgb = max(color1.rgb, color2.rgb);
				color1.a += color2.a;

				// For all directions
				#if defined(ALL_DIRECTIONS)
				color2 = tex2D(_MainTex, i.uv2.xy);
				color1.rgb = max(color1.rgb, color2.rgb);
				color1.a += color2.a;

				color2 = tex2D(_MainTex, i.uv2.zw);
				color1.rgb = max(color1.rgb, color2.rgb);
				color1.a += color2.a;

				color2 = tex2D(_MainTex, i.uv3.xy);
				color1.rgb = max(color1.rgb, color2.rgb);
				color1.a += color2.a;

				color2 = tex2D(_MainTex, i.uv3.zw);
				color1.rgb = max(color1.rgb, color2.rgb);
				color1.a += color2.a;
				#endif
				
				color1.a *= _HighlightingIntensity;
				return color1;
			}
			ENDCG
		}
	}
	
	Fallback off
}

HighlightingCut.shader

通过模板测试，将RenderTexture中和场景中重叠的像素A通道设置为0.

Shader "Hidden/Highlighted/Cut"
{
    
    
	Properties
	{
    
    
		[HideInInspector] _MainTex ("", 2D) = "" {
    
    }
		[HideInInspector] _HighlightingFillAlpha ("", Range(0.0, 1.0)) = 1.0
	}

	SubShader
	{
    
    
		Lighting Off
		Fog {
    
     Mode off }
		ZWrite Off
		ZTest Always
		Cull Back

		Pass
		{
    
    
			Stencil
			{
    
    
				Ref 1
				Comp NotEqual
				Pass Keep
				ZFail Keep
			}

			CGPROGRAM
			#pragma vertex vert
			#pragma fragment frag
			#pragma fragmentoption ARB_precision_hint_fastest
			#pragma target 2.0
			
			#include "UnityCG.cginc"
			
			struct vs_input
			{
    
    
				float4 vertex : POSITION;
				half2 texcoord : TEXCOORD0;
			};
			
			struct ps_input
			{
    
    
				float4 pos : SV_POSITION;
				half2 uv : TEXCOORD0;
			};

			uniform sampler2D _MainTex;
			uniform float4 _MainTex_ST;
			
			ps_input vert(vs_input v)
			{
    
    
				ps_input o;
				o.pos = UnityObjectToClipPos(v.vertex);
				o.uv = UnityStereoScreenSpaceUVAdjust(v.texcoord, _MainTex_ST);
				return o;
			}
			
			fixed4 frag(ps_input i) : SV_Target
			{
    
    
				return tex2D(_MainTex, i.uv);
			}
			ENDCG
		}

		Pass
		{
    
    
			Stencil
			{
    
    
				Ref 1
				Comp Equal
				Pass Keep
				ZFail Keep
			}
			ColorMask A
			
			CGPROGRAM
			#pragma vertex vert
			#pragma fragment frag
			#pragma fragmentoption ARB_precision_hint_fastest
			#pragma target 2.0

			#include "UnityCG.cginc"
			
			struct vs_input
			{
    
    
				float4 vertex : POSITION;
			};
			
			struct ps_input
			{
    
    
				float4 pos : SV_POSITION;
			};

			uniform float _HighlightingFillAlpha;

			ps_input vert(vs_input v)
			{
    
    
				ps_input o;
				o.pos = UnityObjectToClipPos(v.vertex);
				return o;
			}
			
			fixed4 frag() : SV_Target
			{
    
    
				return fixed4(0, 0, 0, _HighlightingFillAlpha);
			}
			ENDCG
		}
	}
	FallBack Off
}

HighlightingComposite.shader

根据RenderTexture中A通道的值，将RenderTexture的RGB值和屏幕纹理插值叠加。得出最后的描边效果。

Shader "Hidden/Highlighted/Composite"
{
    
    
	Properties
	{
    
    
		[HideInInspector] _MainTex ("", 2D) = "" {
    
    }
		[HideInInspector] _HighlightingBuffer ("", 2D) = "" {
    
    }
	}
	
	SubShader
	{
    
    
		Pass
		{
    
    
			Lighting Off
			Fog {
    
     Mode off }
			ZWrite Off
			ZTest Always
			Cull Off
			
			CGPROGRAM
			#pragma vertex vert
			#pragma fragment frag
			#pragma fragmentoption ARB_precision_hint_fastest
			#pragma target 2.0
			#include "UnityCG.cginc"

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

			struct ps_input
			{
    
    
				float4 pos : SV_POSITION;
				half2 uv0 : TEXCOORD0;
				half2 uv1 : TEXCOORD1;
			};

			uniform sampler2D _MainTex;
			uniform float4 _MainTex_ST;
			uniform float4 _MainTex_TexelSize;
			uniform sampler2D _HighlightingBuffer;

			ps_input vert(vs_input v)
			{
    
    
				ps_input o;
				o.pos = UnityObjectToClipPos(v.vertex);
				o.uv0 = UnityStereoScreenSpaceUVAdjust(v.texcoord, _MainTex_ST);
				o.uv1 = o.uv0;

				#if UNITY_UV_STARTS_AT_TOP
				if (_MainTex_TexelSize.y < 0)
				{
    
    
					o.uv1.y = 1-o.uv1.y;
				}
				#endif

				return o;
			}

			fixed4 frag(ps_input i) : SV_Target
			{
    
    
				fixed4 c1 = tex2D(_MainTex, i.uv0);
				fixed4 c2 = tex2D(_HighlightingBuffer, i.uv1);
				c1.rgb = lerp(c1.rgb, c2.rgb, c2.a);
				return c1;
			}
			ENDCG
		}
	}
	FallBack Off
}

猜你喜欢

转载自blog.csdn.net/u012740992/article/details/104110980
今日推荐
《美国对全球网络空间安全与发展的威胁和破坏》报告发布
火速冲上 GitHub 热榜 —— 开源编程语言、框架哪有这么可爱？
北京人形机器人创新中心发布全球首个纯电驱拟人奔跑的全尺寸人形机器人“天工”
LFOSSA 源来如此公开课 | 掌握云原生未来：CNCF 认证全面攻略与备考秘籍
国产云输入法——仅华为无云端数据上传安全问题
周排行
Python环境安装与基础语法（1）——计算机基础知识
IMU预积分
ADAS中的LDW、FCW、BSD、LCA、ACC、AEB、APA、DMS代表的含义
B站笔试两道题
skyeye arm 硬件虚拟机环境的搭建
Web前端静态页面示例
数组-合并排序数组 II-简单
springcloud之版本问题启动报错
面向对象-------------匿名对象(六)
输入URL到页面呈现中间发生了什么？
每日归档
更多
2024-04-30(1)
2024-04-29(40)
2024-04-28(0)
2024-04-27(56)
2024-04-26(39)
2024-04-25(22)
2024-04-24(36)
2024-04-23(26)
2024-04-22(39)
2024-04-21(0)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022