UGUI上显示特效插件ParticleEffectForUGUI

最新推荐文章于 2024-09-13 21:58:13 发布
最新推荐文章于 2024-09-13 21:58:13 发布
阅读量698 收藏 10
点赞数 5
分类专栏： 游戏开发 文章标签： unity ui 游戏引擎 c#
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qilin598866753/article/details/140710905
版权

1. 前言

ui上显示特效常常涉及到层级的问题，常见处理办法是通过控制Canvas和特效Renderer的Sorting Layer以及Order in Layer来控制渲染顺序，这种实现的弊端是不好实现遮罩功能，需要手动把裁剪区域传递给自定义的Shader来实现裁剪，对于使用模板测试的Mask，由于Mask在子节点的UI元素渲染完后，会自动清除模板值，导致渲染特效时无法做模板测试；

鉴于此，有大佬实现了一种用CanvasRenderer来渲染特效的方案，github传送门；

由于使用CanvasRenderer来渲染特效，ParticleEffectForUGUI插件具有如下特点：

        1. 和其他ui元素一样按gameObject位置排序；

        2. 支持Mask和RectMask2D；

        3. 显示相同的特效时，可共享mesh；

2. 安装ParticleEffectForUGUI插件：

3. 使用UIParticle组件来渲染特效：

将要显示的特效拖进UIParticle下：

UIParticle组件识别不到拖进了特效，手动刷新一下：

调整Scale控制特效显示，注意若要支持Mask和RectMask2D，渲染特效的Shader得支持模板测试和矩形裁剪，可参阅插件UIAdditive shader或者unity的UI/Default shader；

可看到特效显示在ui中间：

4. 实现原理：

UIParticleUpdater类，驱动渲染刷新：

#if UNITY_EDITOR
        [InitializeOnLoadMethod]
#else
        [RuntimeInitializeOnLoadMethod(RuntimeInitializeLoadType.BeforeSceneLoad)]
#endif
        private static void InitializeOnLoad()
        {
            //先于ugui中CanvasUpdateRegistry注册，回调应该先执行
            Canvas.willRenderCanvases -= Refresh;
            Canvas.willRenderCanvases += Refresh;
        }

        private static void Refresh()
        {
            // Do not allow it to be called in the same frame.
            if (s_FrameCount == Time.frameCount) return;
            s_FrameCount = Time.frameCount;

            // Simulate -> Primary
            for (var i = 0; i < s_ActiveParticles.Count; i++)
            {
                var uip = s_ActiveParticles[i];
                if (!uip || !uip.canvas || !uip.isPrimary || !s_UpdatedGroupIds.Add(uip.groupId)) continue;

                uip.UpdateTransformScale();
                uip.UpdateRenderers();
            }

            // Simulate -> Others
            for (var i = 0; i < s_ActiveParticles.Count; i++)
            {
                var uip = s_ActiveParticles[i];
                if (!uip || !uip.canvas) continue;

                uip.UpdateTransformScale();     //Primary也会再次执行，感觉不严谨

                if (!uip.useMeshSharing)
                {
                    uip.UpdateRenderers();
                }
                else if (s_UpdatedGroupIds.Add(uip.groupId))
                {
                    uip.UpdateRenderers();
                }
            }

            s_UpdatedGroupIds.Clear();

            // Attract
            for (var i = 0; i < s_ActiveAttractors.Count; i++)
            {
                s_ActiveAttractors[i].Attract();
            }
        }

核心组件UIParticle：

//父节点global Scale
public Vector3 parentScale { get; private set; }

//实际为 1 / Canvas local Scale
public Vector3 canvasScale { get; private set; }

protected override void OnEnable()
{
    _isScaleStored = false;
    ResetGroupId();

    //组件注册
    UIParticleUpdater.Register(this);

    //maskable变化时，触发材质球刷新
    RegisterDirtyMaterialCallback(UpdateRendererMaterial);

    if (0 < particles.Count)
    {
        RefreshParticles(particles);
    }
    else
    {
        RefreshParticles();
    }

    base.OnEnable();
}

/// <summary>
/// This function is called when the behaviour becomes disabled.
/// </summary>
protected override void OnDisable()
{
    _tracker.Clear();
    if (autoScalingMode == AutoScalingMode.Transform && _isScaleStored)
    {
        transform.localScale = _storedScale;
    }

    _isScaleStored = false;
    UIParticleUpdater.Unregister(this);
    _renderers.ForEach(r => r.Reset());
    UnregisterDirtyMaterialCallback(UpdateRendererMaterial);

    base.OnDisable();
}

/// <summary>
/// Refresh UIParticle.
/// Collect ParticleSystems under the GameObject and refresh the UIParticle.
/// </summary>
public void RefreshParticles()
{
    RefreshParticles(gameObject);
}

/// <summary>
/// Refresh UIParticle.
/// Collect ParticleSystems under the GameObject and refresh the UIParticle.
/// </summary>
private void RefreshParticles(GameObject root)
{
    if (!root) return;

    //获取子节点中属于自己的所有ParticleSystem
    root.GetComponentsInChildren(true, particles);
    for (var i = particles.Count - 1; 0 <= i; i--)
    {
        var ps = particles[i];
        if (!ps || ps.GetComponentInParent<UIParticle>(true) != this)
        {
            particles.RemoveAt(i);
        }
    }

    for (var i = 0; i < particles.Count; i++)
    {
        var ps = particles[i];
        var tsa = ps.textureSheetAnimation;
        if (tsa.mode == ParticleSystemAnimationMode.Sprites && tsa.uvChannelMask == 0)
        {
            tsa.uvChannelMask = UVChannelFlags.UV0;
        }
    }

    RefreshParticles(particles);
}

/// <summary>
/// Refresh UIParticle using a list of ParticleSystems.
/// </summary>
public void RefreshParticles(List<ParticleSystem> particleSystems)
{
    // Collect children UIParticleRenderer components.
    // #246: Nullptr exceptions when using nested UIParticle components in hierarchy
    _renderers.Clear();
    var childCount = transform.childCount;
    for (var i = 0; i < childCount; i++)
    {
        var child = transform.GetChild(i);
        if (child.TryGetComponent(out UIParticleRenderer uiParticleRenderer))
        {
            _renderers.Add(uiParticleRenderer);
        }
    }

    // Reset the UIParticleRenderer components.
    for (var i = 0; i < _renderers.Count; i++)
    {
        _renderers[i].Reset(i);
    }

    //每个ParticleSystem对应一个UIParticleRenderer，trail还需要额外一个UIParticleRenderer
    // Set the ParticleSystem to the UIParticleRenderer. If the trail is enabled, set it additionally.
    var j = 0;
    for (var i = 0; i < particleSystems.Count; i++)
    {
        var ps = particleSystems[i];
        if (!ps) continue;
        GetRenderer(j++).Set(this, ps, false);

        // If the trail is enabled, set it additionally.
        if (ps.trails.enabled)
        {
            GetRenderer(j++).Set(this, ps, true);
        }
    }
}

internal void UpdateTransformScale()
{
    _tracker.Clear();
    //抵消canvas缩放
    canvasScale = canvas.rootCanvas.transform.localScale.Inverse();
    parentScale = transform.parent.lossyScale;
    if (autoScalingMode != AutoScalingMode.Transform)
    {
        if (_isScaleStored)
        {
            transform.localScale = _storedScale;
        }

        _isScaleStored = false;
        return;
    }

    //AutoScalingMode.Transform 的流程
    var currentScale = transform.localScale;
    if (!_isScaleStored)
    {
        _storedScale = currentScale.IsVisible() ? currentScale : Vector3.one;
        _isScaleStored = true;
    }

    _tracker.Add(this, rectTransform, DrivenTransformProperties.Scale);
    var newScale = parentScale.Inverse();
    if (currentScale != newScale)
    {
        //场景中特效Scale为1，放进ui里面得抵消掉ui缩放
        transform.localScale = newScale;
    }
}

internal void UpdateRenderers()
{
    if (!isActiveAndEnabled) return;

    for (var i = 0; i < _renderers.Count; i++)
    {
        var r = _renderers[i];
        if (r) continue;
        //有UIParticleRenderer不存在时，重新刷新下列表
        RefreshParticles(particles);
        break;
    }

    var bakeCamera = GetBakeCamera();
    for (var i = 0; i < _renderers.Count; i++)
    {
        var r = _renderers[i];
        if (!r) continue;

        //获取特效mesh，同步到ui渲染
        r.UpdateMesh(bakeCamera);
    }
}

最后看各个特效的ui渲染组件UIParticleRenderer：

        /// <summary>
        /// Perform material modification in this function.
        /// </summary>
        public override Material GetModifiedMaterial(Material baseMaterial)
        {
            _currentMaterialForRendering = null;

            if (!IsActive() || !_parent)
            {
                ModifiedMaterial.Remove(_modifiedMaterial);
                _modifiedMaterial = null;
                return baseMaterial;
            }

            var modifiedMaterial = base.GetModifiedMaterial(baseMaterial);

            var texture = mainTexture;
            if (texture == null && _parent.m_AnimatableProperties.Length == 0)
            {
                ModifiedMaterial.Remove(_modifiedMaterial);
                _modifiedMaterial = null;
                return modifiedMaterial;
            }

            var id = _parent.m_AnimatableProperties.Length == 0 ? 0 : GetInstanceID();
#if UNITY_EDITOR
            var props = EditorJsonUtility.ToJson(modifiedMaterial).GetHashCode();
#else
            var props = 0;
#endif
            //有变化的属性时，需要同步渲染参数到材质球
            modifiedMaterial = ModifiedMaterial.Add(modifiedMaterial, texture, id, props);
            ModifiedMaterial.Remove(_modifiedMaterial);
            _modifiedMaterial = modifiedMaterial;

            return modifiedMaterial;
        }

        public void Set(UIParticle parent, ParticleSystem ps, bool isTrail)
        {
            _parent = parent;
            maskable = parent.maskable;

            gameObject.layer = parent.gameObject.layer;

            _particleSystem = ps;
            _preWarm = _particleSystem.main.prewarm;

#if UNITY_EDITOR
            if (Application.isPlaying)
#endif
            {
                if (_particleSystem.isPlaying || _preWarm)
                {
                    _particleSystem.Clear();
                    _particleSystem.Pause();
                }
            }

            ps.TryGetComponent(out _renderer);
            _renderer.enabled = false;

            //_emitter = emitter;
            _isTrail = isTrail;

            _renderer.GetSharedMaterials(s_Materials);
            material = s_Materials[isTrail ? 1 : 0];
            s_Materials.Clear();

            // Support sprite.
            var tsa = ps.textureSheetAnimation;
            if (tsa.mode == ParticleSystemAnimationMode.Sprites && tsa.uvChannelMask == 0)
            {
                tsa.uvChannelMask = UVChannelFlags.UV0;
            }

            _prevScale = GetWorldScale();
            _prevPsPos = _particleSystem.transform.position;
            _prevScreenSize = new Vector2Int(Screen.width, Screen.height);
            _prevCanvasScale = canvas ? canvas.scaleFactor : 1f;
            _delay = true;

            canvasRenderer.SetTexture(null);

            enabled = true;
        }

        public void UpdateMesh(Camera bakeCamera)
        {
            // No particle to render: Clear mesh.
            if (
                !isActiveAndEnabled || !_particleSystem || !_parent
                || !canvasRenderer || !canvas || !bakeCamera
                || _parent.meshSharing == UIParticle.MeshSharing.Replica
                || !transform.lossyScale.GetScaled(_parent.scale3DForCalc).IsVisible() // Scale is not visible.
                || (!_particleSystem.IsAlive() && !_particleSystem.isPlaying) // No particle.
                || (_isTrail && !_particleSystem.trails.enabled) // Trail, but it is not enabled.
#if UNITY_2018_3_OR_NEWER
                || canvasRenderer.GetInheritedAlpha() <
                0.01f // #102: Do not bake particle system to mesh when the alpha is zero.
#endif
            )
            {
                //不需要渲染特效时，清掉mesh
                Profiler.BeginSample("[UIParticleRenderer] Clear Mesh");
                workerMesh.Clear();
                canvasRenderer.SetMesh(workerMesh);
                _lastBounds = new Bounds();
                Profiler.EndSample();

                return;
            }

            var main = _particleSystem.main;
            var scale = GetWorldScale();
            var psPos = _particleSystem.transform.position;

            // Simulate particles.
            Profiler.BeginSample("[UIParticle] Bake Mesh > Simulate Particles");
            if (!_isTrail && _parent.canSimulate)
            {
#if UNITY_EDITOR
                if (!Application.isPlaying)
                {
                    SimulateForEditor(psPos - _prevPsPos, scale);
                }
                else
#endif
                {
                    ResolveResolutionChange(psPos, scale);
                    Simulate(scale, _parent.isPaused || _delay);

                    if (_delay && !_parent.isPaused)
                    {
                        Simulate(scale, _parent.isPaused);
                    }

                    // When the ParticleSystem simulation is complete, stop it.
                    if (!main.loop
                        && main.duration <= _particleSystem.time
                        && (_particleSystem.IsAlive() || _particleSystem.particleCount == 0)
                       )
                    {
                        _particleSystem.Stop(false);
                    }
                }

                _prevScale = scale;
                _prevPsPos = psPos;
                _delay = false;
            }

            Profiler.EndSample();

            // Bake mesh.
            Profiler.BeginSample("[UIParticleRenderer] Bake Mesh");
            s_CombineInstances[0].mesh.Clear(false);

            // Assertion failed on expression: 'ps->array_size()' #278
            var extends = s_CombineInstances[0].mesh.bounds.extents.x;
            if (!float.IsNaN(extends) && !float.IsInfinity(extends) && 0 < extends)
            {
                //mesh清掉了，但是bounds不会自动清掉
                s_CombineInstances[0].mesh.RecalculateBounds();
            }

            if (_isTrail && _parent.canSimulate && 0 < _particleSystem.particleCount)
            {
#if PS_BAKE_API_V2
                _renderer.BakeTrailsMesh(s_CombineInstances[0].mesh, bakeCamera,
                    ParticleSystemBakeMeshOptions.BakeRotationAndScale);
#else
                _renderer.BakeTrailsMesh(s_CombineInstances[0].mesh, bakeCamera, true);
#endif
            }
            else if (!_isTrail && _renderer.CanBakeMesh())
            {
                _particleSystem.ValidateShape();
#if PS_BAKE_API_V2
                _renderer.BakeMesh(s_CombineInstances[0].mesh, bakeCamera,
                    ParticleSystemBakeMeshOptions.BakeRotationAndScale);    //不包含世界位置，为局部的
#else
                _renderer.BakeMesh(s_CombineInstances[0].mesh, bakeCamera, true);
#endif
            }

            // Too many vertices to render.
            if (65535 <= s_CombineInstances[0].mesh.vertexCount)
            {
                Debug.LogErrorFormat(this,
                    "Too many vertices to render. index={0}, isTrail={1}, vertexCount={2}(>=65535)",
                    _index,
                    _isTrail,
                    s_CombineInstances[0].mesh.vertexCount
                );
                s_CombineInstances[0].mesh.Clear(false);
            }

            Profiler.EndSample();

            // Combine mesh to transform. ([ParticleSystem local ->] world -> renderer local)
            Profiler.BeginSample("[UIParticleRenderer] Combine Mesh");
            if (_parent.canSimulate)
            {
                if (_parent.positionMode == UIParticle.PositionMode.Absolute)
                {
                    s_CombineInstances[0].transform =
                        canvasRenderer.transform.worldToLocalMatrix
                        * GetWorldMatrix(psPos, scale);     // 世界到局部 * 特效局部到世界
                }
                else
                {
                    var diff = _particleSystem.transform.position - _parent.transform.position;
                    s_CombineInstances[0].transform =
                        canvasRenderer.transform.worldToLocalMatrix
                        * Matrix4x4.Translate(diff.GetScaled(scale - Vector3.one))
                        * GetWorldMatrix(psPos, scale);
                }

                workerMesh.CombineMeshes(s_CombineInstances, true, true);

                workerMesh.RecalculateBounds();
                var bounds = workerMesh.bounds;
                //去掉z轴值
                var center = bounds.center;
                center.z = 0;
                bounds.center = center;
                var extents = bounds.extents;
                extents.z = 0;
                bounds.extents = extents;
                workerMesh.bounds = bounds;
                _lastBounds = bounds;

                // Convert linear color to gamma color.
                if (QualitySettings.activeColorSpace == ColorSpace.Linear)
                {
                    //ui渲染默认是Gamma空间?
                    Profiler.BeginSample("[UIParticleRenderer] Convert Linear to Gamma");
                    workerMesh.GetColors(s_Colors);
                    var count_c = s_Colors.Count;
                    for (var i = 0; i < count_c; i++)
                    {
                        var c = s_Colors[i];
                        c.r = c.r.LinearToGamma();
                        c.g = c.g.LinearToGamma();
                        c.b = c.b.LinearToGamma();
                        s_Colors[i] = c;
                    }

                    workerMesh.SetColors(s_Colors);
                    Profiler.EndSample();
                }

                GetComponents(typeof(IMeshModifier), s_Components);
                for (var i = 0; i < s_Components.Count; i++)
                {
#pragma warning disable CS0618 // Type or member is obsolete
                    ((IMeshModifier)s_Components[i]).ModifyMesh(workerMesh);
#pragma warning restore CS0618 // Type or member is obsolete
                }

                s_Components.Clear();
            }

            Profiler.EndSample();


            // Get grouped renderers.
            s_Renderers.Clear();
            if (_parent.useMeshSharing)
            {
                //获取同一组的Renderers，渲染相同特效时，每个特效上都得有个独立的UIParticle, 这样_index才对应
                UIParticleUpdater.GetGroupedRenderers(_parent.groupId, _index, s_Renderers);
            }

            // Set mesh to the CanvasRenderer.
            Profiler.BeginSample("[UIParticleRenderer] Set Mesh");
            for (var i = 0; i < s_Renderers.Count; i++)
            {
                if (s_Renderers[i] == this) continue;
                //共享mesh
                s_Renderers[i].canvasRenderer.SetMesh(workerMesh);
                s_Renderers[i]._lastBounds = _lastBounds;
            }

            if (!_parent.canRender)
            {
                workerMesh.Clear();
            }

            //ui渲染的mesh
            canvasRenderer.SetMesh(workerMesh);
            Profiler.EndSample();

            // Update animatable material properties.
            Profiler.BeginSample("[UIParticleRenderer] Update Animatable Material Properties");

#if UNITY_EDITOR
            if (_modifiedMaterial != material)
            {
                //编辑器显示用了的材质球
                _renderer.GetSharedMaterials(s_Materials);
                material = s_Materials[_isTrail ? 1 : 0];
                s_Materials.Clear();
                SetMaterialDirty();
            }
#endif
            //将粒子渲染器的材质球属性同步到当前使用的材质球
            UpdateMaterialProperties();
            if (_parent.useMeshSharing)
            {
                if (!_currentMaterialForRendering)
                {
                    _currentMaterialForRendering = materialForRendering;
                }

                //将渲染使用的材质球同步到同组的其他特效渲染器
                for (var i = 0; i < s_Renderers.Count; i++)
                {
                    if (s_Renderers[i] == this) continue;

                    s_Renderers[i].canvasRenderer.materialCount = 1;
                    s_Renderers[i].canvasRenderer.SetMaterial(_currentMaterialForRendering, 0);
                }
            }

            Profiler.EndSample();

            s_Renderers.Clear();
        }

        private void Simulate(Vector3 scale, bool paused)
        {
            var main = _particleSystem.main;
            var deltaTime = paused
                ? 0
                : main.useUnscaledTime
                    ? Time.unscaledDeltaTime
                    : Time.deltaTime;

            // Pre-warm:
            if (0 < deltaTime && _preWarm)
            {
                deltaTime += main.duration;
                _preWarm = false;
            }

            // get world position.
            var isLocalSpace = _particleSystem.IsLocalSpace();
            var psTransform = _particleSystem.transform;
            var originLocalPosition = psTransform.localPosition;
            var originLocalRotation = psTransform.localRotation;
            var originWorldPosition = psTransform.position;
            var originWorldRotation = psTransform.rotation;
            var emission = _particleSystem.emission;
            var rateOverDistance = emission.enabled
                                   && 0 < emission.rateOverDistance.constant
                                   && 0 < emission.rateOverDistanceMultiplier;
            if (rateOverDistance && !paused && _isPrevStored)
            {
                // (For rate-over-distance emission,) Move to previous scaled position, simulate (delta = 0).
                var prevScaledPos = isLocalSpace
                    ? _prevPsPos
                    : _prevPsPos.GetScaled(_prevScale.Inverse());
                psTransform.SetPositionAndRotation(prevScaledPos, originWorldRotation);
                _particleSystem.Simulate(0, false, false, false);
            }

            // Move to scaled position, simulate, revert to origin position.
            var scaledPos = isLocalSpace
                ? originWorldPosition
                : originWorldPosition.GetScaled(scale.Inverse());
            psTransform.SetPositionAndRotation(scaledPos, originWorldRotation);
            //驱动特效
            _particleSystem.Simulate(deltaTime, false, false, false);
            psTransform.localPosition = originLocalPosition;
            psTransform.localRotation = originLocalRotation;
        }

【Unity 实用工具篇】 | UIEffect 实现一系列UGUI特效，灰度、负片、像素化特效
努力前行，总会成为自己心中的那道光
04-16 4万+
在Unity中 UGUI 的使用几乎是必不可少的，虽然也有NGUI、FGUI等可以使用，但使用UGUI的还是占多数。 而在使用UGUI的过程中，除了一些基础的UI交互页面及逻辑，学习一些UGUI特效的使用也是很有必要的。 接下来会分享一些UGUI中比较简单且实用的特效，供有需要的小伙伴学习使用。
ParticleEffectForUGUI：在UnityUI（uGUI）中渲染粒子效果。 可屏蔽，可排序，并且没有多余的CameraRenderTextureCanvas
02-06
UGUI的粒子效果（UI粒子） :warning: 注意：不要使用来引用程序包。 它们将在不久的将来被删除。 :warning: 该插件提供了一个组件，可在Unity 2018.2或更高版本中为uGUI渲染粒子效果。 粒子渲染是可蒙版且可排序的，而没有Camera，RenderTexture或Canvas。 <<| | | >> 描述 该插件使用新的API MeshBake/MashTrailBake （Unity 2018.2添加）来通过CanvasRenderer渲染粒子。 您可以为uGUI遮罩和排序粒子，而无需使用Camera，RenderTexture，Canvas。 将此“烘焙网格”方法与
【Unity UGUI】粒子特效插件：Particle Effect For UGUI
Unity打怪升级
07-30 1474
在Unity游戏开发中，UI（用户界面）是玩家与游戏互动的重要部分。为了让UI更加吸引人，开发者们经常使用粒子效果来增加视觉效果。"Particle Effect For UGUI"是一个在Unity UI（uGUI）中渲染粒子效果的插件，具有可遮罩、可排序的特点，且无需额外的相机、渲染纹理或画布，使得在UI元素上创建动态粒子效果变得简单，创造出绚丽的粒子动画效果。
ParticleEffectForUGUI 项目常见问题解决方案
最新发布
gitblog_09086的博客
09-13 405
ParticleEffectForUGUI 项目常见问题解决方案 ParticleEffectForUGUI Render particle effect in UnityUI(uGUI). Maskable, sortable, and no extra Camera/RenderTexture/Canvas. ...
UGUI中显示粒子特效
weixin_30244681的博客
03-30 343
　　今天在UGUI上显示粒子特效的时候遇到的一些问题，Mark一下。原理：修改特效中每一个ParticleSystem的Layer为UI,并且把ParticleSystemRenderer.sortingOrder值设置为大于Canvas中的sortingOrder值。其实就是控制两个组件 的Render Order。 1. 在UI控件上（eg: Image）显示一个粒子特效 　　...
UGUI 使用 UIParticle 实现 UI 上显示 Particle System 以及 层级遮挡 和 Mask
lq
03-04 6930
UGUI 上使用 Particle System 支持 Sorting Layer 排序渲染
粒子排序插件 - Particle Effect For UGUI
Le_Sam的博客
11-03 1454
转载地址；https://github.com/mob-sakai/ParticleEffectForUGUI
【推荐100个unity插件之12】UGUI的粒子效果（UI粒子）—— Particle Effect For UGUI (UI Particle)
向宇
11-14 5303
该插件使用新的 APIMeshBake/MashTrailBake（随 Unity 2018.2 添加）通过 CanvasRenderer 渲染粒子。您可以在没有 Camera、RenderTexture、Canvas 的情况下为 UGUI 屏蔽和排序粒子。使用自定义顶点流时，可以用“不必要的”数据填充 zw 组件。着色器提示Properties// ...SubShaderTags// ...Stencil// ...Pass// ...// ...struct v2f。
2024年 最新 iPhone手机 历代机型、屏幕尺寸、纵横比、分辨率 整理
热门推荐
努力前行，总会成为自己心中的那道光
01-11 4万+
2024年 最新 iPhone手机 历代机型、屏幕尺寸、纵横比、分辨率 整理 最新iPhone全机型 分辨率 和 尺寸 下面整理了一下目前最新的iPhone受击全机型的分辨率和尺寸等，方便查询和适配。
[Unity] UGUI功能扩展插件包
weixin_33916256的博客
03-22 849
在使用Unity的UGUI时，发现自带的控件很少，而且功能比较简单，比如Button在属性面板中只有一个OnClick事件可以设置。但是我需要有更多功能的Button，比如能在属性面板中设置OnDown, OnUp, OnEnter, OnExit, OnLongClick这些事件等。我在网上看到有高手做了一些东西来增加相关UI组件的易用性，比如雨松Mono大神的EventTriggerListe...
UGUI UI界面显示3D物体以及粒子特效
MySQL与Unity交互
10-26 6394
        年初更新过NGUI相关内容，由于NGUI的版本停留过久，UGUI的开发热度不断上升，最近接触更多的是UGUI。那么在接触UI界面进行3D模型、粒子特效与UI界面相互穿插的时候进行一些相关的方案总结。         对于NGUI拥有UI界面的独立相机以及清晰的层级控制，但是UGUI这方面集成的效果还是不及格的，很多内容需要自己手动设置，对于3D与UI的相互穿插大致上分两个常用的方...
UI专用的特效插件-Beautiful Transitions v2.3
09-20
UI专用的特效插件-Beautiful Transitions v2.3；UI专用的特效插件-Beautiful Transitions v2.3；UI专用的特效插件-Beautiful Transitions v2.3
Unity3D中使用uGUI实现3D旋转特效（简单，好用）
09-06
Unity3D中使用uGUI实现3D旋转特效（简单，好用），只需要两个脚本文件
Unity - UGUI 动画插件
12-11
Unity UGUI 没有封装动画，该插件为借助 DOTween插件功能，将其封装，可以手动编辑动画，使用方便，避免每次都写代码
Unity UGUI插件，动效UI插件，简约风UI，UI框架，Q弹动画UI，欢迎下载使用。
04-28
Unity UGUI插件，动效UI插件，简约风UI，UI框架，Q弹动画UI，欢迎下载使用。
UGUI流光特效Demo
01-25
游戏开发中，经常会用到在封面对LOGO之类的图片进行流光特效
【Unity 实用工具篇】 | UIEffect 实现一系列UGUI特效，颜色渐变特效
努力前行，总会成为自己心中的那道光
05-08 2万+
在Unity中 UGUI 的使用几乎是必不可少的，虽然也有NGUI、FGUI等可以使用，但使用UGUI的还是占多数。 而在使用UGUI的过程中，除了一些基础的UI交互页面及逻辑，学习一些UGUI特效的使用也是很有必要的。 接下来会分享一些UGUI中比较简单且实用的特效，供有需要的小伙伴学习使用。
Unity3D UGUI显示3D特效
12-02
综上所述，"Unity3D UGUI显示3D特效"涵盖了Unity3D中的粒子系统、UI设计、屏幕适配、性能优化等多个方面。通过熟练掌握这些技术，开发者可以创建出既美观又高效的游戏界面，提升用户体验。在UI3DEffectDemo这个项目...
【Unity 实用工具篇】 | UIEffect 实现一系列UGUI特效，过渡特效
努力前行，总会成为自己心中的那道光
04-23 3万+
在Unity中 UGUI 的使用几乎是必不可少的，虽然也有NGUI、FGUI等可以使用，但使用UGUI的还是占多数。 而在使用UGUI的过程中，除了一些基础的UI交互页面及逻辑，学习一些UGUI特效的使用也是很有必要的。 接下来会分享一些UGUI中比较简单且实用的特效，供有需要的小伙伴学习使用。
ugui minimap插件
05-15
UGUI Minimap插件是一款在Unity引擎中使用的工具，可以为游戏添加一个实时的小地图。插件由Unity技术工程师编写，已在Unity Asset Store上架售卖。 插件的特点是易用性和高度自定义。通过插件中提供的简洁易懂的接口和编辑器工具，用户可以轻松地将小地图集成到他们的游戏中。此外，插件还针对各种不同类型的游戏提供了多种预定义的小地图样式和布局，可以大大减少用户的制作时间。 对于那些需要更高度自定义的用户，UGUI Minimap插件支持使用自定义的图标和背景来覆盖预定义小地图的样式，同时也可以通过编写代码来实现更细节的控制。 此外，UGUI Minimap插件的另一个强大功能是它可以支持多个小地图层，可以用来在不同的游戏场景之间进行切换。同时支持手势缩放和平移操作，游戏玩家可以更加轻松地操作小地图。 总的来说，UGUI Minimap插件是一款非常强大的小地图插件，非常适合那些需要在Unity引擎中开发游戏的开发者和游戏玩家。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值