devbox
IT小白
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

unity ugui特效实现方式_ugui 图片高亮材质

作者：IT小白 | 2024-06-02 01:45:48

赞

踩

ugui 图片高亮材质

原理：

        将unity 粒子系统的每个粒子计算颜色，位置，以及uv计算，映射一个长方形内，继承MaskableGraphic类，并重写protected override void OnPopulateMesh(VertexHelper vh)方法，将生成的rect 通过vh.AddUIVertexQuad(_quad);画出。

代码：

  1. using UnityEngine;
  2. using UnityEngine.UI;
  3.  
  4. /// <summary>
  5. /// add by ggr at 2018/07/30
  6. /// UI层的粒子特效，能解决的问题：
  7. /// 1、粒子特效在滚动列表区外裁剪
  8. /// 2、粒子特效层级调整，即可以在夹在任意两个UI元素之间
  9. /// 3、不同分辨率的适配
  10. /// 使用：
  11. /// 主要是特效的美术人员使用。
  12. /// 1、在粒子系统的物体上挂上这个脚本
  13. /// 2、此时会禁用和清空粒子系统的 renderer 模块
  14. /// 3、把材质球拖到脚本上的material字段上
  15. /// </summary>
  16. [ExecuteInEditMode]
  17. [RequireComponent(typeof(CanvasRenderer), typeof(ParticleSystem))]
  18. public class UIParticleSystem : MaskableGraphic
  19. {
  20.     [Tooltip("勾上这个，会把粒子系统放在LateUpdate里运行")]
  21.     public bool fixedTime = true;
  22.     [Range(1, 60)]
  23.     public int maxParticleCount = 15;
  24.  
  25.     private Transform _transform;
  26.     private ParticleSystem pSystem;
  27.     private ParticleSystem.Particle[] particles;
  28.     private UIVertex[] _quad = new UIVertex[4];
  29.     private Vector4 imageUV = Vector4.zero;
  30.     private ParticleSystem.TextureSheetAnimationModule textureSheetAnimation;
  31.     private int textureSheetAnimationFrames;
  32.     private Vector2 textureSheetAnimationFrameSize;
  33.     private ParticleSystemRenderer pRenderer;
  34.  
  35.     private Material currentMaterial;
  36.  
  37.     private Texture currentTexture;
  38.  
  39.     private ParticleSystem.MainModule mainModule;
  40.  
  41.     public override Texture mainTexture
  42.     {
  43.         get
  44.         {
  45.             return currentTexture;
  46.         }
  47.     }
  48.  
  49.     protected bool Initialize()
  50.     {
  51.         // initialize members
  52.         if (_transform == null)
  53.         {
  54.             _transform = transform;
  55.         }
  56.         if (pSystem == null)
  57.         {
  58.             pSystem = GetComponent<ParticleSystem>();
  59.  
  60.             if (pSystem == null)
  61.             {
  62.                 return false;
  63.             }
  64.  
  65.             mainModule = pSystem.main;
  66.             //最大存活粒子数限制为15，不要太大，影响效率
  67.             if (pSystem.main.maxParticles > maxParticleCount)
  68.             {
  69.                 mainModule.maxParticles = maxParticleCount;
  70.             }
  71.  
  72.             pRenderer = pSystem.GetComponent<ParticleSystemRenderer>();
  73.             if (pRenderer != null)
  74.             {
  75.                 pRenderer.material = null;
  76.                 pRenderer.enabled = false;
  77.             }
  78.  
  79.             currentMaterial = material;
  80.             if (currentMaterial && currentMaterial.HasProperty("_MainTex"))
  81.             {
  82.                 currentTexture = currentMaterial.mainTexture;
  83.                 if (currentTexture == null)
  84.                     currentTexture = Texture2D.whiteTexture;
  85.             }
  86.             material = currentMaterial;
  87.             // automatically set scaling
  88.             mainModule.scalingMode = ParticleSystemScalingMode.Hierarchy;
  89.  
  90.             particles = null;
  91.         }
  92.         if (particles == null)
  93.             particles = new ParticleSystem.Particle[pSystem.main.maxParticles];
  94.  
  95.         imageUV = new Vector4(0, 0, 1, 1);
  96.  
  97.         // prepare texture sheet animation
  98.         textureSheetAnimation = pSystem.textureSheetAnimation;
  99.         textureSheetAnimationFrames = 0;
  100.         textureSheetAnimationFrameSize = Vector2.zero;
  101.         if (textureSheetAnimation.enabled)
  102.         {
  103.             textureSheetAnimationFrames = textureSheetAnimation.numTilesX * textureSheetAnimation.numTilesY;
  104.             textureSheetAnimationFrameSize = new Vector2(1f / textureSheetAnimation.numTilesX, 1f / textureSheetAnimation.numTilesY);
  105.         }
  106.  
  107.         return true;
  108.     }
  109.  
  110.     protected override void Awake()
  111.     {
  112.         base.Awake();
  113.         if (!Initialize())
  114.             enabled = false;
  115.         //不需要响应事件
  116.         raycastTarget = false;
  117.     }
  118.  
  119.     protected override void OnPopulateMesh(VertexHelper vh)
  120.     {
  121. #if UNITY_EDITOR
  122.         if (!Application.isPlaying)
  123.         {
  124.             if (!Initialize())
  125.             {
  126.                 return;
  127.             }
  128.         }
  129. #endif
  130.         // prepare vertices
  131.         vh.Clear();
  132.  
  133.         if (!gameObject.activeInHierarchy)
  134.         {
  135.             return;
  136.         }
  137.  
  138.         Vector2 temp = Vector2.zero;
  139.         Vector2 corner1 = Vector2.zero;
  140.         Vector2 corner2 = Vector2.zero;
  141.         // iterate through current particles
  142.         int count = pSystem.GetParticles(particles);
  143.  
  144.         for (int i = 0; i < count; ++i)
  145.         {
  146.             ParticleSystem.Particle particle = particles[i];
  147.  
  148.             // get particle properties
  149.             Vector2 position = (mainModule.simulationSpace == ParticleSystemSimulationSpace.Local ? particle.position : _transform.InverseTransformPoint(particle.position));
  150.             float rotation = -particle.rotation * Mathf.Deg2Rad;
  151.             float rotation90 = rotation + Mathf.PI / 2;
  152.             Color32 color = particle.GetCurrentColor(pSystem);
  153.             float size = particle.GetCurrentSize(pSystem) * 0.5f;
  154.  
  155.             // apply scale
  156.             if (mainModule.scalingMode == ParticleSystemScalingMode.Shape)
  157.                 position /= canvas.scaleFactor;
  158.  
  159.             // apply texture sheet animation
  160.             Vector4 particleUV = imageUV;
  161.             if (textureSheetAnimation.enabled)
  162.             {
  163.                 float frameProgress = 1 - (particle.remainingLifetime / particle.startLifetime);
  164.  
  165.                 if (textureSheetAnimation.frameOverTime.curveMin != null)
  166.                 {
  167.                     frameProgress = textureSheetAnimation.frameOverTime.curveMin.Evaluate(1 - (particle.remainingLifetime / particle.startLifetime));
  168.                 }
  169.                 else if (textureSheetAnimation.frameOverTime.curve != null)
  170.                 {
  171.                     frameProgress = textureSheetAnimation.frameOverTime.curve.Evaluate(1 - (particle.remainingLifetime / particle.startLifetime));
  172.                 }
  173.                 else if (textureSheetAnimation.frameOverTime.constant > 0)
  174.                 {
  175.                     frameProgress = textureSheetAnimation.frameOverTime.constant - (particle.remainingLifetime / particle.startLifetime);
  176.                 }
  177.  
  178.                 frameProgress = Mathf.Repeat(frameProgress * textureSheetAnimation.cycleCount, 1);
  179.                 int frame = 0;
  180.  
  181.                 switch (textureSheetAnimation.animation)
  182.                 {
  183.  
  184.                     case ParticleSystemAnimationType.WholeSheet:
  185.                         frame = Mathf.FloorToInt(frameProgress * textureSheetAnimationFrames);
  186.                         break;
  187.  
  188.                     case ParticleSystemAnimationType.SingleRow:
  189.                         frame = Mathf.FloorToInt(frameProgress * textureSheetAnimation.numTilesX);
  190.  
  191.                         int row = textureSheetAnimation.rowIndex;
  192.                         frame += row * textureSheetAnimation.numTilesX;
  193.                         break;
  194.                 }
  195.  
  196.                 frame %= textureSheetAnimationFrames;
  197.  
  198.                 particleUV.x = (frame % textureSheetAnimation.numTilesX) * textureSheetAnimationFrameSize.x;
  199.                 particleUV.y = Mathf.FloorToInt(frame / textureSheetAnimation.numTilesX) * textureSheetAnimationFrameSize.y;
  200.                 particleUV.z = particleUV.x + textureSheetAnimationFrameSize.x;
  201.                 particleUV.w = particleUV.y + textureSheetAnimationFrameSize.y;
  202.             }
  203.  
  204.             temp.x = particleUV.x;
  205.             temp.y = particleUV.y;
  206.  
  207.             _quad[0] = UIVertex.simpleVert;
  208.             _quad[0].color = color;
  209.             _quad[0].uv0 = temp;
  210.  
  211.             temp.x = particleUV.x;
  212.             temp.y = particleUV.w;
  213.             _quad[1] = UIVertex.simpleVert;
  214.             _quad[1].color = color;
  215.             _quad[1].uv0 = temp;
  216.  
  217.             temp.x = particleUV.z;
  218.             temp.y = particleUV.w;
  219.             _quad[2] = UIVertex.simpleVert;
  220.             _quad[2].color = color;
  221.             _quad[2].uv0 = temp;
  222.  
  223.             temp.x = particleUV.z;
  224.             temp.y = particleUV.y;
  225.             _quad[3] = UIVertex.simpleVert;
  226.             _quad[3].color = color;
  227.             _quad[3].uv0 = temp;
  228.  
  229.             if (rotation == 0)
  230.             {
  231.                 // no rotation
  232.                 corner1.x = position.x - size;
  233.                 corner1.y = position.y - size;
  234.                 corner2.x = position.x + size;
  235.                 corner2.y = position.y + size;
  236.  
  237.                 temp.x = corner1.x;
  238.                 temp.y = corner1.y;
  239.                 _quad[0].position = temp;
  240.                 temp.x = corner1.x;
  241.                 temp.y = corner2.y;
  242.                 _quad[1].position = temp;
  243.                 temp.x = corner2.x;
  244.                 temp.y = corner2.y;
  245.                 _quad[2].position = temp;
  246.                 temp.x = corner2.x;
  247.                 temp.y = corner1.y;
  248.                 _quad[3].position = temp;
  249.             }
  250.             else
  251.             {
  252.                 // apply rotation
  253.                 Vector2 right = new Vector2(Mathf.Cos(rotation), Mathf.Sin(rotation)) * size;
  254.                 Vector2 up = new Vector2(Mathf.Cos(rotation90), Mathf.Sin(rotation90)) * size;
  255.  
  256.                 _quad[0].position = position - right - up;
  257.                 _quad[1].position = position - right + up;
  258.                 _quad[2].position = position + right + up;
  259.                 _quad[3].position = position + right - up;
  260.             }
  261.  
  262.             vh.AddUIVertexQuad(_quad);
  263.         }
  264.     }
  265.  
  266.     void Update()
  267.     {
  268.         if (!fixedTime && Application.isPlaying)
  269.         {
  270.             pSystem.Simulate(Time.unscaledDeltaTime, false, false, true);
  271.             SetAllDirty();
  272.  
  273.             if ((currentMaterial != null && currentTexture != currentMaterial.mainTexture) ||
  274.                 (material != null && currentMaterial != null && material.shader != currentMaterial.shader))
  275.             {
  276.                 pSystem = null;
  277.                 Initialize();
  278.             }
  279.         }
  280.     }
  281.  
  282.     void LateUpdate()
  283.     {
  284.         if (!Application.isPlaying)
  285.         {
  286.             SetAllDirty();
  287.         }
  288.         else
  289.         {
  290.             if (fixedTime)
  291.             {
  292.                 pSystem.Simulate(Time.unscaledDeltaTime, false, false, true);
  293.                 SetAllDirty();
  294.                 if ((currentMaterial != null && currentTexture != currentMaterial.mainTexture) ||
  295.                     (material != null && currentMaterial != null && material.shader != currentMaterial.shader))
  296.                 {
  297.                     pSystem = null;
  298.                     Initialize();
  299.                 }
  300.             }
  301.         }
  302.         if (material == currentMaterial)
  303.             return;
  304.         pSystem = null;
  305.         Initialize();
  306.     }
  307. }

 

shader：

  1. Shader "17zuoye/UI Particle Addtive"
  2. {
  3.     Properties
  4.     {
  5.         _MainTex ("Sprite Texture", 2D) = "white" {}
  6.         _Color ("Tint", Color) = (0.5,0.5,0.5,0.5)
  7.  
  8.         _SpeedU("横向速度", float) = 0
  9. 		_SpeedV("纵向速度", float) = 0
  10.  
  11.         _ColorAdd("亮度",float) = 2
  12.  
  13.         _StencilComp ("Stencil Comparison", Float) = 8
  14.         _Stencil ("Stencil ID", Float) = 0
  15.         _StencilOp ("Stencil Operation", Float) = 0
  16.         _StencilWriteMask ("Stencil Write Mask", Float) = 255
  17.         _StencilReadMask ("Stencil Read Mask", Float) = 255
  18.  
  19.         _ColorMask ("Color Mask", Float) = 15
  20.  
  21.         [Toggle(UNITY_UI_ALPHACLIP)] _UseUIAlphaClip ("Use Alpha Clip", Float) = 0
  22.     }
  23.  
  24.     SubShader
  25.     {
  26.         Tags
  27.         {
  28.             "Queue"="Transparent"
  29.             "IgnoreProjector"="True"
  30.             "RenderType"="Transparent"
  31.             "PreviewType"="Plane"
  32.             "CanUseSpriteAtlas"="True"
  33.         }
  34.  
  35.         Stencil
  36.         {
  37.             Ref [_Stencil]
  38.             Comp [_StencilComp]
  39.             Pass [_StencilOp]
  40.             ReadMask [_StencilReadMask]
  41.             WriteMask [_StencilWriteMask]
  42.         }
  43.  
  44.         Cull Off
  45.         Lighting Off
  46.         ZWrite Off
  47.         ZTest [unity_GUIZTestMode]
  48.         Blend SrcAlpha one
  49.         ColorMask [_ColorMask]              
  50.  
  51.         Pass
  52.         {
  53.             Name "Default"
  54.         CGPROGRAM
  55.             #pragma vertex vert
  56.             #pragma fragment frag
  57.             #pragma target 2.0
  58.  
  59.             #include "UnityCG.cginc"
  60.             #include "UnityUI.cginc" // 2D Mask 剪裁。
  61.  
  62.             #pragma multi_compile __ UNITY_UI_CLIP_RECT
  63.             #pragma multi_compile __ UNITY_UI_ALPHACLIP
  64.  
  65.             struct appdata_t
  66.             {
  67.                 float4 vertex   : POSITION;
  68.                 float4 color    : COLOR;
  69.                 float2 texcoord : TEXCOORD0;
  70.                 UNITY_VERTEX_INPUT_INSTANCE_ID
  71.             };
  72.  
  73.             struct v2f
  74.             {
  75.                 float4 vertex   : SV_POSITION;
  76.                 fixed4 color    : COLOR;
  77.                 float2 uv : TEXCOORD0;
  78.                 float4 worldPosition : TEXCOORD1; // 2D Mask 剪裁。
  79.                 UNITY_VERTEX_OUTPUT_STEREO
  80.             };
  81.  
  82.             sampler2D _MainTex;
  83. 			float4 _MainTex_ST;
  84.  
  85.             fixed4 _Color;
  86.             fixed4 _TextureSampleAdd;
  87.             float4 _ClipRect; // 2D Mask 剪裁。
  88.  
  89.             float _SpeedU;
  90. 			float _SpeedV;
  91.             float _ColorAdd;
  92.  
  93.             v2f vert(appdata_t v)
  94.             {
  95.                 v2f OUT;
  96.                 UNITY_SETUP_INSTANCE_ID(v);
  97.                 UNITY_INITIALIZE_VERTEX_OUTPUT_STEREO(OUT);
  98.                 OUT.worldPosition = v.vertex;  // 2D Mask 剪裁。
  99.                 OUT.vertex = UnityObjectToClipPos(OUT.worldPosition);
  100.  
  101.                 OUT.uv = TRANSFORM_TEX(v.texcoord, _MainTex);
  102.  				OUT.uv.xy +=  float2(_SpeedU, _SpeedV ) * _Time.x;
  103.  
  104.                 OUT.color = v.color;
  105.                 return OUT;
  106.             }
  107.  
  108.  
  109.             fixed4 frag(v2f IN) : SV_Target
  110.             {
  111. 				fixed4 albedo = tex2D(_MainTex, IN.uv);
  112. 				
  113. 				fixed4 color = _ColorAdd * IN.color * _Color * albedo;
  114.                 #ifdef UNITY_UI_CLIP_RECT
  115.                 	color.a *= UnityGet2DClipping(IN.worldPosition.xy, _ClipRect); // 2D Mask 剪裁。
  116.                 #endif
  117.  
  118.                 #ifdef UNITY_UI_ALPHACLIP
  119.                 clip (color.a - 0.001);
  120.                 #endif
  121.  
  122.                 return color;
  123.             }
  124.  
  125. 			
  126.         ENDCG
  127.         }
  128.     }
  129. }

原作地址：https://forum.unity.com/threads/free-script-particle-systems-in-ui-screen-space-overlay.406862/

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/IT小白/article/detail/660340
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号