【unity shader】基于UGUI字体的outline优化

Unity游戏开发客户端性能优化基础 Unity游戏开发客户端面经 之 性能优化 篇 阅读详情

基于Shader实现的UGUI描边解决方案

找了一下outline的一些优化的实现方案,但是那个方案的两层text叠加或者是image叠在上面会出现颜色偏差问题。

目前已找到对应的问题并进行了一些修复。

归咎原因就是:

color = (val * (1.0 - color.a)) + (color * color.a);

这里计算color值时,没有考虑到color.a大于1的情况,加入这个color.a大于1,或者小于0,实际算出的color值,他的alpha就有可能小于0。然后就会出现两层叠加出问题的情况。

所以需要对这个color.a进行一些限制,保证这个color.a的值必须要0-1之间。

解决方案:

color.a = saturate(color.a);

并且,给顶点信息传递outline的width还有outline的color,着实效率不高,实际不如直接在properties里面定义2个变量,这样的效率会更高。

顺带讲解一下shader和脚本里面的一些知识点,帮助一下理解:

C#脚本中:

    void SetShaderChannels()
    {
        if (base.graphic.canvas)
        {
            var v1 = base.graphic.canvas.additionalShaderChannels;
            var v2 = AdditionalCanvasShaderChannels.TexCoord1;
            if ((v1 & v2) != v2)
            {
                base.graphic.canvas.additionalShaderChannels |= v2;
            }
            v2 = AdditionalCanvasShaderChannels.TexCoord2;
            if ((v1 & v2) != v2)
            {
                base.graphic.canvas.additionalShaderChannels |= v2;
            }
        }
    }

SetShaderChannels() 方法的作用是给这个text文本的所渲染的canvas添加对应的通道,因为只有添加了对应的通道,在shader中才能正常取到顶点的一些texcoord1-n ,否则在shader中是没法正常取到正确的值。(如下图所示)

_ProcessVertices:

    private void _ProcessVertices()
    {
        for (int i = 0, count = m_VetexList.Count - 3; i <= count; i += 3)
        {
            var v1 = m_VetexList[i];
            var v2 = m_VetexList[i + 1];
            var v3 = m_VetexList[i + 2];

            //进行顶点计算...

            m_VetexList[i] = v1;
            m_VetexList[i + 1] = v2;
            m_VetexList[i + 2] = v3;

        }
    }

_ProcessVertices 这个方法的作用就是重新计算文本的顶点数据,因为默认文本加了描边之后,有可能你这个描边的宽度会超出原来text所显示的区域(如下图所示),所以必须对顶点的位置进行扩大。也就是vertex的position要变大。然后因为顶点位置变大之后,里面的文字内容也会相应变化,所以想要保持里面文本内容跟原来的渲染一致,就需要改变vertex的UV坐标,来让他的表现跟原来一致。这样就能保证文字的范围变大了,同时里面显示的内容还保持不变。

之后是另一个知识点,为什么要一次性取三个m_VetexList里面的值呢?那是因为,unity里面不管是UI还是3D物体,都是由三角面构成的,可以看到下图右边,每个文本的char(字母),都会对应一个正方形的面,这个正方形的面可以看到就是由2个三角面构成,一个每个三角面就对应会有3个顶点,所以一次性取三个m_VetexList里的值,就是可以保证,每次取的这三个值是同一个三角面里的3个顶点数据。然后就可以对应的对这三个顶点进行position和uv的改变,就能达到我们所需要的效果了。

第三个知识点,代码中会由一个uvmin和uvmax,这两个是什么意思呢?为啥要当成uv1和uv2传进去顶点数据呢?原因就是这两个参数是对应每个顶点原来(未进行顶点扩大前)的范围。有了这个范围就能保证在描边绘制的时候,描边属性不会超出范围。这两个参数会被带进shader来进行范围验证(下面的IsInRect函数),只有在范围内的,对应顶点才会由alpha值,否则alpha只会是0。

var uvMin = _Min(v1.uv0, v2.uv0, v3.uv0);
var uvMax = _Max(v1.uv0, v2.uv0, v3.uv0);        
//这里uvMin=pUVOriginMin  uvMax=pUVOriginMax
pVertex.uv1 = pUVOriginMin;     //uv1 uv2 可用  tangent  normal 在缩放情况 会有问题
pVertex.uv2 = pUVOriginMax;

接下来是shader脚本解释:

            fixed IsInRect(float2 pPos, float2 pClipRectMin, float2 pClipRectMax)
            {
                pPos = step(pClipRectMin, pPos) * step(pPos, pClipRectMax);
                return pPos.x * pPos.y;
            }

IsInRect函数,就是前面介绍的范围验证的函数,返回值只会是0或1。0就表示第一个参数pPos这个点不在对应的范围内,1就表示这个点在范围内。(下图是去掉IsInRect范围判断时的对比图)如果没有了这个IsInRect或者这个IsInRect返回值直接返回1,那么效果就会如下图右边图所示,会有一些脏东西在上面,就是因为我们描边取uv的时候,取到一些不该取的uv范围,才会导致下图的问题。所以IsInRect是非常必要的。

另一个知识点:

            fixed SampleAlpha(int pIndex, v2f IN)
            {
                const fixed sinArray[12] = { 0, 0.5, 0.866, 1, 0.866, 0.5, 0, -0.5, -0.866, -1, -0.866, -0.5 };
                const fixed cosArray[12] = { 1, 0.866, 0.5, 0, -0.5, -0.866, -1, -0.866, -0.5, 0, 0.5, 0.866 };
                float2 pos = IN.texcoord + _MainTex_TexelSize.xy * float2(cosArray[pIndex], sinArray[pIndex]) * _OutlineWidth;	//normal.z 存放 _OutlineWidth
                return IsInRect(pos, IN.uv1, IN.uv2) * (tex2D(_MainTex, pos) + _TextureSampleAdd).a * _OutlineColor.a;		//tangent.w 存放 _OutlineColor.w
            }

SampleAlpha方法,这个方法的含义就是对原来uv的值进行12项偏移取对应颜色的alpha值。对应的sinArray跟cosArray是三角函数,对应12个点的x和y的偏移系数。(如下图所示)是取对应偏移点的alpha值。

取到SampleAlpha的alpha值后,对应的就会将取得的12项偏移的alpha进行一次总和,总和的alpha值就直接当成outline颜色的alpha。(所以这个alpha值的范围是[0,12])

所以这个shader算法就是:

1.取到text的原本颜色和alpha(alpha值取决于IsInRect)

2.取到描边颜色,描边颜色的alpha值是uv的12项偏移的alpha的总和(这个outline的alpha值很有可能大于1)

3.对原本颜色和描边颜色进行alpha混合,混合系数是第一步取到的alpha值。

4.最后做一些裁剪工作。

5.输出第三步混合后的颜色。

 

最后,是对应优化过的脚本代码:

C#脚本:

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


[AddComponentMenu("UI/Effects/Outline")]
public class OutlineScript : BaseMeshEffect
{
    public Color OutlineColor = Color.white;
    [Range(0, 8)]
    public int OutlineWidth = 0;

    private static List<UIVertex> m_VetexList = new List<UIVertex>();


    protected override void Awake()
    {
        base.Awake();

        if (CheckShader())
        {
            this.SetShaderChannels();
            this.SetParams();
            this._Refresh();
        }
    }


    bool CheckShader()
    {
        if (base.graphic == null)
        {
            Debug.LogError("No Graphic Component !");
            return false;
        }
        if (base.graphic.material == null)
        {
            Debug.LogError("No Material !");
            return false;
        }
        if (base.graphic.material.shader.name != "Unlit/OutlineShader")
        {
            Debug.LogError("Shader is Not Unlit/OutlineShader");
            return false;
        }
        return true;
    }

    void SetParams()
    {
        if (base.graphic.material != null)
        {
            base.graphic.material.SetColor("_OutlineColor", OutlineColor);
            base.graphic.material.SetFloat("_OutlineWidth", OutlineWidth);
        }

    }

    void SetShaderChannels()
    {
        if (base.graphic.canvas)
        {
            var v1 = base.graphic.canvas.additionalShaderChannels;
            var v2 = AdditionalCanvasShaderChannels.TexCoord1;
            if ((v1 & v2) != v2)
            {
                base.graphic.canvas.additionalShaderChannels |= v2;
            }
            v2 = AdditionalCanvasShaderChannels.TexCoord2;
            if ((v1 & v2) != v2)
            {
                base.graphic.canvas.additionalShaderChannels |= v2;
            }
        }
    }

#if UNITY_EDITOR
        protected override void OnValidate()
        {
            base.OnValidate();
            if (CheckShader())
            {
                this.SetParams();
                this._Refresh();
            }
        }
#endif


    private void _Refresh()
    {
        base.graphic.SetVerticesDirty();
    }


    public override void ModifyMesh(VertexHelper vh)
    {
        vh.GetUIVertexStream(m_VetexList);

        this._ProcessVertices();

        vh.Clear();
        vh.AddUIVertexTriangleStream(m_VetexList);
    }


    private void _ProcessVertices()
    {
        for (int i = 0, count = m_VetexList.Count - 3; i <= count; i += 3)
        {
            var v1 = m_VetexList[i];
            var v2 = m_VetexList[i + 1];
            var v3 = m_VetexList[i + 2];
            // 计算原顶点坐标中心点
            //
            var minX = _Min(v1.position.x, v2.position.x, v3.position.x);
            var minY = _Min(v1.position.y, v2.position.y, v3.position.y);
            var maxX = _Max(v1.position.x, v2.position.x, v3.position.x);
            var maxY = _Max(v1.position.y, v2.position.y, v3.position.y);
            var posCenter = new Vector2(minX + maxX, minY + maxY) * 0.5f;
            // 计算原始顶点坐标和UV的方向
            //
            Vector2 triX, triY, uvX, uvY;
            Vector2 pos1 = v1.position;
            Vector2 pos2 = v2.position;
            Vector2 pos3 = v3.position;
            if (Mathf.Abs(Vector2.Dot((pos2 - pos1).normalized, Vector2.right))
                > Mathf.Abs(Vector2.Dot((pos3 - pos2).normalized, Vector2.right)))
            {
                triX = pos2 - pos1;
                triY = pos3 - pos2;
                uvX = v2.uv0 - v1.uv0;
                uvY = v3.uv0 - v2.uv0;
            }
            else
            {
                triX = pos3 - pos2;
                triY = pos2 - pos1;
                uvX = v3.uv0 - v2.uv0;
                uvY = v2.uv0 - v1.uv0;
            }
            // 计算原始UV框
            var uvMin = _Min(v1.uv0, v2.uv0, v3.uv0);
            var uvMax = _Max(v1.uv0, v2.uv0, v3.uv0);
            //OutlineColor 和 OutlineWidth 也传入,避免出现不同的材质球
            //var col_rg = new Vector2(OutlineColor.r, OutlineColor.g);       //描边颜色 用uv3 和 tangent的 zw传递
            //var col_ba = new Vector4(0, 0, OutlineColor.b, OutlineColor.a);
            //var normal = new Vector3(0, 0, OutlineWidth);                   //描边的宽度 用normal的z传递

            // 为每个顶点设置新的Position和UV,并传入原始UV框
            v1 = _SetNewPosAndUV(v1, this.OutlineWidth, posCenter, triX, triY, uvX, uvY, uvMin, uvMax);
            v2 = _SetNewPosAndUV(v2, this.OutlineWidth, posCenter, triX, triY, uvX, uvY, uvMin, uvMax);
            v3 = _SetNewPosAndUV(v3, this.OutlineWidth, posCenter, triX, triY, uvX, uvY, uvMin, uvMax);

            // 应用设置后的UIVertex
            //
            m_VetexList[i] = v1;
            m_VetexList[i + 1] = v2;
            m_VetexList[i + 2] = v3;
        }
    }


    private static UIVertex _SetNewPosAndUV(UIVertex pVertex, int pOutLineWidth,
        Vector2 pPosCenter,
        Vector2 pTriangleX, Vector2 pTriangleY,
        Vector2 pUVX, Vector2 pUVY,
        Vector2 pUVOriginMin, Vector2 pUVOriginMax)
    {
        // Position
        var pos = pVertex.position;
        var posXOffset = pos.x > pPosCenter.x ? pOutLineWidth : -pOutLineWidth;
        var posYOffset = pos.y > pPosCenter.y ? pOutLineWidth : -pOutLineWidth;
        pos.x += posXOffset;
        pos.y += posYOffset;
        pVertex.position = pos;
        // UV
        var uv = pVertex.uv0;
        uv += pUVX / pTriangleX.magnitude * posXOffset * (Vector2.Dot(pTriangleX, Vector2.right) > 0 ? 1 : -1);
        uv += pUVY / pTriangleY.magnitude * posYOffset * (Vector2.Dot(pTriangleY, Vector2.up) > 0 ? 1 : -1);
        pVertex.uv0 = uv;

        pVertex.uv1 = pUVOriginMin;     //uv1 uv2 可用  tangent  normal 在缩放情况 会有问题
        pVertex.uv2 = pUVOriginMax;

        return pVertex;
    }


    private static float _Min(float pA, float pB, float pC)
    {
        return Mathf.Min(Mathf.Min(pA, pB), pC);
    }


    private static float _Max(float pA, float pB, float pC)
    {
        return Mathf.Max(Mathf.Max(pA, pB), pC);
    }


    private static Vector2 _Min(Vector2 pA, Vector2 pB, Vector2 pC)
    {
        return new Vector2(_Min(pA.x, pB.x, pC.x), _Min(pA.y, pB.y, pC.y));
    }


    private static Vector2 _Max(Vector2 pA, Vector2 pB, Vector2 pC)
    {
        return new Vector2(_Max(pA.x, pB.x, pC.x), _Max(pA.y, pB.y, pC.y));
    }
}

shader脚本:

Shader "Unlit/OutlineShader" 
{
    Properties
    {
        [PerRendererData] _MainTex ("Main Texture", 2D) = "white" {}
        _Color ("Tint", Color) = (1, 1, 1, 1)
        _OutlineColor ("Outline Color", Color) = (1, 1, 1, 1)
        _OutlineWidth ("Outline Width", Int) = 1
        
        _StencilComp ("Stencil Comparison", Float) = 8
        _Stencil ("Stencil ID", Float) = 0
        _StencilOp ("Stencil Operation", Float) = 0
        _StencilWriteMask ("Stencil Write Mask", Float) = 255
        _StencilReadMask ("Stencil Read Mask", Float) = 255
        
        _ColorMask ("Color Mask", Float) = 15
        
        [Toggle(UNITY_UI_ALPHACLIP)] _UseUIAlphaClip ("Use Alpha Clip", Float) = 0
    }
    
    SubShader
    {
        Tags
        { 
            "Queue"="Transparent" 
            "IgnoreProjector"="True" 
            "RenderType"="Transparent" 
            "PreviewType"="Plane"
            "CanUseSpriteAtlas"="True"
        }
        
        Stencil
        {
            Ref [_Stencil]
            Comp [_StencilComp]
            Pass [_StencilOp] 
            ReadMask [_StencilReadMask]
            WriteMask [_StencilWriteMask]
        }
        
        Cull Off
        Lighting Off
        ZWrite Off
        ZTest [unity_GUIZTestMode]
        Blend SrcAlpha OneMinusSrcAlpha
        // Blend Off
        ColorMask [_ColorMask]
        
        Pass
        {
            Name "OUTLINE"
            
            CGPROGRAM
            #pragma vertex vert
            #pragma fragment frag
            #pragma target 2.0
            
            //Add for RectMask2D  
            #include "UnityUI.cginc"
            //End for RectMask2D  
            
            sampler2D _MainTex;
            fixed4 _Color;
            fixed4 _TextureSampleAdd;
            float4 _MainTex_TexelSize;
            
            float4 _OutlineColor;
            int _OutlineWidth;
            
            //Add for RectMask2D  
            float4 _ClipRect;
            //End for RectMask2D
            
            struct appdata
            {
                float4 vertex : POSITION;
                float4 tangent : TANGENT;
                float4 normal : NORMAL;
                float2 texcoord : TEXCOORD0;
                float2 uv1 : TEXCOORD1;
                float2 uv2 : TEXCOORD2;
                float2 uv3 : TEXCOORD3;
                fixed4 color : COLOR;
            };
            
            
            struct v2f
            {
                float4 vertex : SV_POSITION;
                float4 tangent : TANGENT;
                float4 normal : NORMAL;
                float2 texcoord : TEXCOORD0;
                float2 uv1 : TEXCOORD1;
                float2 uv2 : TEXCOORD2;
                float2 uv3 : TEXCOORD3;
                //Add for RectMask2D  
                float4 worldPosition : TEXCOORD4;
                //End for RectMask2D
                fixed4 color : COLOR;
            };
            
            v2f vert(appdata IN)
            {
                v2f o;
                
                //Add for RectMask2D  
                o.worldPosition = IN.vertex;
                //End for RectMask2D 
                
                o.vertex = UnityObjectToClipPos(IN.vertex);
                o.tangent = IN.tangent;
                o.texcoord = IN.texcoord;
                o.color = IN.color;
                o.uv1 = IN.uv1;
                o.uv2 = IN.uv2;
                o.uv3 = IN.uv3;
                o.normal = IN.normal;
                
                return o;
            }
            /*
            fixed IsInRect(float2 pPos, float4 pClipRect)
            {
                pPos = step(pClipRect.xy, pPos) * step(pPos, pClipRect.zw);
                return pPos.x * pPos.y;
            }
            */
            fixed IsInRect(float2 pPos, float2 pClipRectMin, float2 pClipRectMax)
            {
                pPos = step(pClipRectMin, pPos) * step(pPos, pClipRectMax);
                return pPos.x * pPos.y;
            }
            
            fixed SampleAlpha(int pIndex, v2f IN)
            {
                const fixed sinArray[12] = { 0, 0.5, 0.866, 1, 0.866, 0.5, 0, -0.5, -0.866, -1, -0.866, -0.5 };
                const fixed cosArray[12] = { 1, 0.866, 0.5, 0, -0.5, -0.866, -1, -0.866, -0.5, 0, 0.5, 0.866 };
                float2 pos = IN.texcoord + _MainTex_TexelSize.xy * float2(cosArray[pIndex], sinArray[pIndex]) * _OutlineWidth;	//normal.z 存放 _OutlineWidth
                return IsInRect(pos, IN.uv1, IN.uv2) * (tex2D(_MainTex, pos) + _TextureSampleAdd).a * _OutlineColor.a;		//tangent.w 存放 _OutlineColor.w
            }

            
            fixed4 frag(v2f IN) : SV_Target
            {
                fixed4 color = (tex2D(_MainTex, IN.texcoord) + _TextureSampleAdd) * IN.color;//默认的文字颜色
                if (_OutlineWidth > 0)	//normal.z 存放 _OutlineWidth
                {
                    color.w *= IsInRect(IN.texcoord, IN.uv1, IN.uv2);	//uv1 uv2 存着原始字的uv长方形区域大小
                    
                    half4 val = half4(_OutlineColor.rgb, 0);		//uv3.xy tangent.z 分别存放着 _OutlineColor的rgb
                    //val 是 _OutlineColor的rgb,a是后面计算的
                    val.w += SampleAlpha(0, IN);
                    val.w += SampleAlpha(1, IN);
                    val.w += SampleAlpha(2, IN);
                    val.w += SampleAlpha(3, IN);
                    val.w += SampleAlpha(4, IN);
                    val.w += SampleAlpha(5, IN);
                    val.w += SampleAlpha(6, IN);
                    val.w += SampleAlpha(7, IN);
                    val.w += SampleAlpha(8, IN);
                    val.w += SampleAlpha(9, IN);
                    val.w += SampleAlpha(10, IN);
                    val.w += SampleAlpha(11, IN);

                    color = (val * (1.0 - color.a)) + (color * color.a);
                    color.a = saturate(color.a);
                    color.a *= IN.color.a;	//字逐渐隐藏时,描边也要隐藏
                    
                }
                
                //Add for RectMask2D 
                color.a *= UnityGet2DClipping(IN.worldPosition.xy, _ClipRect);
                #ifdef UNITY_UI_ALPHACLIP
                    clip(color.a - 0.001);
                #endif
                //End for RectMask2D 
                
                return color;
            }
            
            ENDCG
        }
    }
}

参考文献:

https://blog.youkuaiyun.com/zhenmu/article/details/88821562#comments

http://www.cnblogs.com/GuyaWeiren/p/9665106.html

Unity UGUI的Outline(描边)组件的介绍及ABP框架提供的增删改查的基类使用 最大检测距离 阅读详情

相关推荐

Unity UGUI Outline组件深度解析:原理、性能陷阱与优化实战

在UI渲染中,描边(Outline)是一种常见的视觉效果增强技术,用于提升元素的辨识度和视觉层次。其核心原理通常基于多通道渲染(Multi-Pass Rendering)和顶点变换,通过偏移原始网格顶点并多次绘制来实现边缘勾勒。从技术价值看,这种实现方式虽直观,但会显著增加绘制调用(Draw Call),影响渲染性能,尤其在移动端和WebGL平台需格外关注。在应用场景上,描边广泛用于游戏UI、技能图标、文字可读性提升等。本文聚焦Unity UGUI内置Outline组件,深入拆解其实现机制与性能开销,并探讨

weixin_29011395的博客 272

慎用Outline ,UGUI Outline实现原理分析

使用 UGUI 制作背包的时候,同事发现如果背包中添加了大量的物品,比如两百个,Unity就会出错,提示 Canvas element contains more than 65535 vertices. This is not supported 。意思就是 Canvas下面的顶点数过多。

Unity UGUI Text进阶特效:打字机、阴影与渐变实战指南

在Unity UI开发中,文字渲染是信息传达的核心基础。其原理在于通过Canvas渲染管线,将字体纹理与顶点网格结合,最终呈现在屏幕上。掌握文字特效不仅能提升视觉表现力,更是优化用户体验和界面沉浸感的关键技术价值。在游戏对话系统、数据可视化、状态提示和标题设计等应用场景中,动态文字效果至关重要。本文聚焦于UGUI Text组件,深入探讨如何通过协程控制、顶点修改和Shader编程,实现高性能的打字机效果与平滑的颜色渐变,解决实际开发中的渲染效率与表现力平衡问题。

weixin_31130435的博客 296

【Unity】用shader做UGUI字体描边的算法改进

Unity自带的Outline 效率实在太差。 找了基于Shader实现的UGUI描边解决方案http://www.cnblogs.com/GuyaWeiren/p/9665106.html 效果还不错,overdraw和顶点数都不高。 不过方案有2个问题,自己尝试调整了一下, 代码放在这以供参考吧。 (注:把ui存储prefab,运行时动态挂到一个canvas上, 这个canvas 如果...

zhenmu的专栏 1万+

Unity UGUI Outline与Shadow组件性能对比与实战选型指南

在Unity UI开发中,渲染优化是提升应用性能的关键环节。UI特效的实现原理直接影响着Draw Call数量与顶点处理开销,进而决定了应用在移动端等性能敏感平台的流畅度。从技术价值看,深入理解底层渲染机制有助于开发者规避性能陷阱,构建高效的用户界面。在应用场景上,无论是游戏HUD、应用界面还是互动元素,选择合适的描边或阴影效果都至关重要。本文聚焦于Unity UGUI内置的Outline和Shadow这两个核心特效组件,通过剖析其实现原理与性能差异,并结合Draw Call优化等热词,为开发者在不同项目需

weixin_30588675的博客 671

Unity UGUI Outline组件:从原理到实战的描边效果全解析

本文全面解析Unity UGUI Outline组件的原理与实战应用,详细介绍了描边效果的实现方式、参数调校技巧及性能优化方法。通过实际案例展示如何实现按钮特效和文字描边效果,并提供避坑指南,帮助开发者高效使用Outline组件提升UI视觉效果。

weixin_30924087的博客 340

unity ugui自定义Text字体描边优化性能

**在unity的ugui的用于Text描边的组件outline中,其中的实现是将字体copy出几份往外放置形成背景黑边,随之带来的是性能的高消耗。如果是一两个Text描边还好,如果同屏有大量Text在使用其在描边时,其性能消耗提高十分明显,甚至直接影响到了游戏FPS。 因此,同屏Text描边多时有必要优化一下,因此写一个可以实现Text描边的shader。 一样的道理,shader中有2个Pas...

u012740992的专栏 1万+

Unity UGUI高性能描边Shader方案:原理、实现与优化

在UI/游戏开发中,Shader是实现高级视觉效果的核心技术之一,它通过在GPU上运行的程序,直接控制像素的渲染方式,从而在单次绘制调用内实现复杂效果,显著优化性能。其原理在于对顶点和片段进行数学变换与逻辑判断,这使得开发者能够突破固定渲染管线的限制,实现高度定制化的渲染逻辑。从技术价值看,自定义Shader不仅能提升视觉表现力,如实现渐变、发光等特效,更能从根本上解决性能瓶颈,例如避免多重绘制导致的Draw Call激增。这一特性在移动端和复杂UI场景中尤为重要。应用场景广泛覆盖了游戏UI、应用界面等需要

weixin_30603633的博客 351

用Shader做UGUI字体描边的算法改进

Unity自带的Outline效率实在太差。找了一篇文章《基于Shader实现的UGUI描边解决方案》,效果还不错,Overdraw和顶点数都不高。这篇文章主要介绍了Shader实现Outline的原理和优劣点,感兴趣的读者可以阅读。基于Shader实现的UGUI描边解决方案 - GuyaWeiren - 博客园 不过方案有2个问题,我自己尝试调整了一下,提供代码以供参考。 注:把UI存储Prefab,运行时动态挂到一个Canvas上,如果这个Canvas上的additionalShaderChanne

UWA—简单优化,优化简单! 1072

Unity多语言字体终极方案:告别UGUI Text乱码与性能危机

在游戏开发中,字体渲染是UI系统的核心基础。其原理是通过字形数据生成网格进行文本显示,当字体文件缺失对应字符时,就会出现“口口口”乱码问题。这项技术的价值在于确保多语言环境下文本的正确渲染与性能稳定,直接影响游戏的国际化支持与用户体验。在Unity引擎中,UGUI Text组件常因字体文件臃肿、字符集不全导致内存飙升和显示异常,尤其在处理中文、日文等CJK字符集时问题凸显。通过采用TextMeshPro的字体资产方案,开发者可以按需生成字符图集,精准控制内存占用,彻底解决乱码与性能瓶颈,为全球化项目提供可靠

weixin_33713503的博客 297

Unity UI字体颜色渐变实现:从TextMeshPro顶点操作到Shader方案

在计算机图形学与游戏开发中,顶点颜色操作是控制网格外观的基础技术之一,它允许开发者通过修改网格顶点的颜色属性来实现丰富的视觉效果。其核心原理在于,渲染管线会基于顶点颜色进行插值计算,从而在片元着色阶段生成平滑的颜色过渡。这一技术对于提升用户界面的视觉表现力和动态反馈至关重要,尤其在游戏、数据可视化等需要高视觉冲击力的应用场景中。通过直接操作顶点颜色数组,开发者可以在不依赖复杂Shader的情况下,实现灵活的颜色渐变效果,例如水平、垂直、径向等多种渐变模式。本文聚焦于Unity引擎中的UI系统,深入探讨如何利

weixin_33806300的博客 499

UGUI源码(四)Text

UGUI源码(四)TextText.csShadow 与 OutlineShadow.csOutline.csOutline组件慎用,使用shader实现 Text.cs //部分源码 public class Text : MaskableGraphic, ILayoutElement { //Text 组件在 Inspector 面板上显示的属性 [SerializeField] private FontData m_FontData = FontData.defaultFontData;

weixin_42877243的博客 665

Unity UGUI美术字体自动化生成:基于SDF与TextMeshPro的编辑器工具开发

在游戏UI开发中,字体渲染是平衡视觉效果与性能的关键技术。传统位图字体存在缩放模糊、资源臃肿的痛点,而有符号距离场(SDF)技术通过存储像素到轮廓的距离信息,从根本上解决了无限缩放不失真的问题。其技术价值在于,结合Shader能够以极低的运行时开销实现描边、发光等丰富的动态效果,极大地提升了UI的表现力和迭代效率。这一技术已成为Unity中TextMeshPro(TMP)组件的核心,广泛应用于需要高品质、风格化UI的项目,如二次元或国风游戏。本文聚焦于解决美术字体(Art Font)的生产难题,通过开发一个

496

Unity UGUI 文字描边与渐变

Unity UGUI 文字描边与渐变 文字描边 OutLine 默认顶点数为16 将描边距离分别设置x=100,y=50,使用OutLine8 与禁用OutLine8 对比,如下图,顶点数(Verts)相差100 一个字=一张图=2个三角面=6个顶点(vertex)包括2个共用顶点 使用Text,一个文字对应4个顶点,其中2个顶点共用 使用OutLine8,相当于在Text文本后面多绘制了8个文本,此时顶点数=2*6*9=108 Outline8 Code using System.Collections

z2014z的博客 5231

Unity TMP字体材质优化:从原理到实战的性能提升指南

在Unity UI开发中,Draw Call优化与内存管理是提升应用性能的核心课题。其原理在于通过减少渲染批次来降低GPU负载,而材质实例管理是实现高效合批的关键技术。TextMeshPro(TMP)作为现代Unity UI的基石,采用基于纹理图集(Atlas)的SDF(有向距离场)渲染技术,在带来灵活视觉效果的同时,也带来了独特的性能挑战。不当的字体资源管理与材质使用会导致Draw Call飙升与内存占用过高。本文聚焦于TMP字体材质优化,深入解析其纹理图集工作机制,并提供从字体资产创建、材质实例共享到运

weixin_34357436的博客 401

Unity UGUI特效进阶:UIEffect模块化滤镜与性能优化实战

在Unity UI开发中,Shader是实现高级视觉效果的核心技术,它通过编写着色器代码控制像素的渲染方式,从而创造出灰度、模糊、溶解等丰富效果。其原理在于对纹理进行采样和数学运算,改变最终输出的颜色与透明度。掌握Shader技术能极大提升UI的视觉表现力与动态交互体验,广泛应用于游戏技能特效、界面过渡、状态反馈等场景。然而,直接编写与调试Shader门槛较高,且需兼顾性能优化。本文聚焦于开源工具UIEffect,它通过模块化设计将复杂Shader效果封装为直观组件,支持灰度、模糊、RGB分离等热词效果,并

cuiji1279的博客 435

UGUI描边组件深度调优:从参数解析到性能优化的实战指南

在UI开发中,描边是提升视觉层次和可读性的基础技术,其核心原理是通过网格复制与偏移实现轮廓绘制。理解其渲染机制对于平衡效果与性能至关重要,尤其是在移动端高分辨率适配与Draw Call优化场景下。本文聚焦Unity UGUI的Outline组件,深入解构Effect Distance、Effect Color等核心参数,剖析其与Overdraw(过度绘制)和顶点数激增的性能关联。通过实战案例,如移动端高清文字标题与战斗浮动数字,演示如何通过参数标准化、合批管理及替代方案(如纹理烘焙与TextMeshPro)

weixin_30363981的博客 403

Unity 之 UGUI 优化实战经验总结

一篇一看就懂的UGUI实战优化技巧总结,很多实战使用需要注意的小技巧。值君一看,必有收获!

陈言必行 -- Unity游戏开发领域优质博主 1万+
上一篇: 【Unity Shader】非统一缩放概念
下一篇: 【Newtonsoft.Json】踩坑记录
HelloCLanguage
博客等级 码龄10年 10粉丝 11原创
评论 17
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值