拓展的常用功能 方法

最新推荐文章于 2024-06-27 13:50:44 发布
最新推荐文章于 2024-06-27 13:50:44 发布
阅读量122 收藏
点赞数
分类专栏： 常用功能
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wxxqhf/article/details/86535773
版权 
    public enum RenderingMode
    {
        Opaque,
        Cutout,
        Fade,
        Transparent,
    }
    public static class MyUtilities
    {
        #region Animation
        private static Dictionary<Animation, bool> bool_Animation = new Dictionary<Animation, bool>();
        public static void DetectionAnimation(this Animation ani, string animationName, UnityAction OnStart, UnityAction OnUpdate, UnityAction OnEnd)
        {
            if (!bool_Animation.ContainsKey(ani))
            {
                bool_Animation.Add(ani, false);
            }
            if (!bool_Animation[ani])
            {
                if (ani.IsPlaying(animationName))
                {
                    bool_Animation[ani] = true;
                    OnStart();
                }
            }
            else
            {
                if (ani.IsPlaying(animationName))
                {
                    OnUpdate();
                }
                else
                {
                    OnEnd();
                    bool_Animation.Remove(ani);
                }
            }
        }
        /// <summary>
        /// 根据进度播放动画
        /// </summary>
        /// <param name="ani"></param>
        /// <param name="aniName">动画名称</param>
        /// <param name="progress">进度</param>
        public static void PlayAnimationFollowProgress(this Animation ani, string aniName, float progress)
        {
            AnimationState state = ani[aniName];
            state.normalizedTime = progress;
            state.normalizedSpeed = 0;

            ani.Play(aniName);
        }

        public static IEnumerator IEDetectionAnimation(this Animation ani, string animationName, UnityAction OnStart, UnityAction OnUpdate, UnityAction OnEnd)
        {
            while (!ani.IsPlaying(animationName))
            {
                yield return null;
            }
            OnStart();
            while (ani.IsPlaying(animationName))
            {
                OnUpdate();
                yield return null;
            }
            OnEnd();
        }
        /// <summary>
        /// 倒播动画
        /// </summary>
        /// <param name="ani"></param>
        /// <param name="aniName"></param>
        /// <param name="OnStart"></param>
        /// <param name="OnUpdate"></param>
        /// <param name="OnEnd"></param>
        /// <returns></returns>
        public static IEnumerator IEBackPlayAnimation(this Animation ani, string aniName, UnityAction OnStart = null, UnityAction OnUpdate = null, UnityAction OnEnd = null)
        {
            if (ani == null) yield break;

            ani[aniName].speed = -1;
            ani[aniName].time = ani[aniName].length;
            ani.Play(aniName);

            if (OnStart != null)
            {
                OnStart();
            }

            while (ani.IsPlaying(aniName))
            {
                if (OnUpdate != null)
                {
                    OnUpdate();
                }
                yield return null;
            }
            ani[aniName].speed = 1;
            if (OnEnd != null)
            {
                OnEnd();
            }
        }
        /// <summary>
        /// 正播动画
        /// </summary>
        /// <param name="ani"></param>
        /// <param name="aniName"></param>
        /// <param name="OnStart"></param>
        /// <param name="OnUpdate"></param>
        /// <param name="OnEnd"></param>
        /// <returns></returns>
        public static IEnumerator IEForwardPlayAnimation(this Animation ani, string aniName, UnityAction OnStart = null, UnityAction OnUpdate = null, UnityAction OnEnd = null)
        {
            if (ani == null) yield break;

            if (ani.IsPlaying(aniName))
                yield break;


            ani[aniName].speed = 1;
            ani.Play(aniName);

            if (OnStart != null)
            {
                OnStart();
            }

            while (ani.IsPlaying(aniName))
            {
                if (OnUpdate != null)
                {
                    OnUpdate();
                }

                yield return null;
            }
            if (OnEnd != null)
            {
                OnEnd();
            }
        }
        #endregion
        #region Animator
        private static Dictionary<Animator, bool> bool_Animator = new Dictionary<Animator, bool>();
        public static void DetectionAnimator(this Animator ani, int layerIndex, string stateName, UnityAction OnStart, UnityAction OnUpdate, UnityAction OnEnd)
        {
            if (!bool_Animator.ContainsKey(ani))
            {
                bool_Animator.Add(ani, false);
            }
            if (!bool_Animator[ani])
            {
                if (ani.GetCurrentAnimatorStateInfo(layerIndex).IsName(stateName))
                {
                    bool_Animator[ani] = true;
                    OnStart();
                }
            }
            else
            {
                if (ani.GetCurrentAnimatorStateInfo(layerIndex).IsName(stateName))
                {
                    OnUpdate();
                }
                else
                {
                    bool_Animator[ani] = false;
                    OnEnd();
                }
            }
        }
        public static void ResetBool_Animator()
        {
            if (bool_Animator != null)
                bool_Animator.Clear();
        }

        public static IEnumerator IEDetectionAnimator(this Animator ani, int layerIndex, string stateName, UnityAction OnStart, UnityAction OnUpdate, UnityAction OnEnd)
        {
            while (!ani.GetCurrentAnimatorStateInfo(layerIndex).IsName(stateName))
            {
                yield return null;
            }
            OnStart();
            while (ani.GetCurrentAnimatorStateInfo(layerIndex).IsName(stateName))
            {
                OnUpdate();
                yield return null;
            }
            OnEnd();
        }
        #endregion

        public static string GetParentPath(this Transform target)
        {
            string path = "";

            while (target.parent != null)
            {
                if (path != "")
                {
                    path = "/" + path;
                }

                path = target.parent.name + path;

                target = target.parent;
            }

            return path;
        }

        #region Graphic
        #region  Text
        //   public static Sequence sequence_text;
        public static Dictionary<Text, Sequence> text_Sequence = new Dictionary<Text, Sequence>();
        public static void FadeShowText(this Text text, float showtime, string text_str, Color text_color)
        {

            Sequence sequence_text = null;

            Debug.Log(text_Sequence.ContainsKey(text) + " " + text_Sequence.Count + " " + text.name);

            if (text_Sequence.ContainsKey(text))
            {
                sequence_text = text_Sequence[text];
                sequence_text.Kill(true);
                sequence_text = DOTween.Sequence();
                text_Sequence.Remove(text);
                text_Sequence.Add(text, sequence_text);
            }
            else
            {
                sequence_text = DOTween.Sequence();
                text_Sequence.Add(text, sequence_text);
            }

            text.text = text_str;

            text.color = new Color(text_color.r, text_color.g, text_color.b, 0);

            Tweener t1 = text.DOFade(1, 1);
            Tweener t2 = text.DOFade(0, 1);
            sequence_text.SetId("FadeShowText");
            sequence_text.Append(t1)
                  .AppendInterval(showtime)
                .Append(t2)
                .OnComplete(() =>
                {
                    text_Sequence.Remove(text);
                    Debug.Log("remove");
                });
        }
        #endregion
        public static Dictionary<Graphic, Sequence> graphic_Sequence = new Dictionary<Graphic, Sequence>();
        public static void FadeInOut(this Graphic graphic, float time_stay, UnityAction OnFadeIn, UnityAction OnEnd)
        {
            Tweener t1 = graphic.DOFade(1, 0.8f).OnComplete(() =>
            {
                OnFadeIn();
            });
            Tweener t2 = graphic.DOFade(0, 0.8f).SetDelay(time_stay).OnComplete(() =>
            {
                graphic_Sequence.Remove(graphic);
                OnEnd();
            });
            Sequence sequence = null;
            if (graphic_Sequence.ContainsKey(graphic))
            {
                sequence = graphic_Sequence[graphic];
                sequence.Kill(true);
            }
            //else
            //{
            sequence = DOTween.Sequence();
            sequence.SetId("FadeInOut");
            graphic_Sequence.Add(graphic, sequence);
            //}
            sequence.Append(t1)
                    .AppendInterval(time_stay)
              .Append(t2)
            .AppendCallback(() =>
            {
                graphic_Sequence.Remove(graphic);
                Debug.Log("remove");
            });
        }
        #endregion

        #region MonoBehaviour
        public static void DelayToDo(this MonoBehaviour m, float time, UnityAction method)
        {

            float a = 0;
            Tweener t = DOTween.To(() => { return a; }, (v) => { a = v; }, 10, time).OnComplete(() =>
              {
                  method();
              });
            t.SetId("DelayToDo");
        }


        #endregion
        #region GameObject

        public static void ChangeChildrenTag(this Transform m, string tagName)
        {
            if (m == null) return;

            m.tag = tagName;

            for (int i = 0; i < m.childCount; i++)
            {
                m.GetChild(i).tag = tagName;

                ChangeChildrenTag(m.GetChild(i), tagName);
            }
        }
        #endregion

        #region Transform
        public enum FrontPostionEnum
        {
            Top,//默认向上转25度
            Center,//默认0度
            Bottom//默认向下转25度
        }
        /// <summary>
        /// 得到物体前方N米的位置   不跟随transform.forward
        /// </summary>
        /// <param name="t"></param>
        /// <param name="frontDis">前方距离</param>
        /// <param name="offset">偏移量，360°，可调节</param>
        /// <returns>返回物体的世界坐标</returns>
        public static Vector3 FrontPosition(this Transform t, float frontDis, float offset = 0)
        {
            Vector3 resultV = Vector3.zero;

            resultV = t.position + t.forward * frontDis;

            resultV = new Vector3(resultV.x, t.position.y, resultV.z);

            //前方向量
            Vector3 v = (resultV - t.position).normalized;

            //v的垂直向量
            Vector3 v2 = Quaternion.AngleAxis(90, Vector3.up) * v;

            //旋转offset后的向量
            Vector3 v3 = Quaternion.AngleAxis(offset, v2) * v;

            //位置+向量*距离
            resultV = t.position + v3 * frontDis;

            return resultV;
        }
        /// <summary>
        /// 得到物体前方N米的位置    跟随transform.forward
        /// </summary>
        /// <param name="t"></param>
        /// <param name="frontDis">前方距离</param>
        /// <param name="frontPositionEnum">位置枚举，上方，中间，下方</param>
        /// <param name="offset">偏移量，360°，可调节</param>
        /// <returns>返回物体的世界坐标</returns>
        public static Vector3 FrontPosition(this Transform t, float frontDis, FrontPostionEnum frontPositionEnum, float offset = 0)
        {
            Vector3 resultV = Vector3.zero;

            switch (frontPositionEnum)
            {
                case FrontPostionEnum.Top:
                    resultV = t.position + Quaternion.AngleAxis(offset - 25.0f, t.right) * t.forward * frontDis;
                    break;
                case FrontPostionEnum.Center:
                    resultV = t.position + Quaternion.AngleAxis(offset, t.right) * t.forward * frontDis;
                    break;
                case FrontPostionEnum.Bottom:
                    resultV = t.position + Quaternion.AngleAxis(offset + 25.0f, t.right) * t.forward * frontDis;
                    break;
            }

            return resultV;
        }
        #endregion

        #region Material

        public static void SetMaterialRenderingMode(Material material, RenderingMode renderingMode)
        {
            switch (renderingMode)
            {
                case RenderingMode.Opaque:
                    material.SetInt("_SrcBlend", (int)UnityEngine.Rendering.BlendMode.One);
                    material.SetInt("_DstBlend", (int)UnityEngine.Rendering.BlendMode.Zero);
                    material.SetInt("_ZWrite", 1);
                    material.DisableKeyword("_ALPHATEST_ON");
                    material.DisableKeyword("_ALPHABLEND_ON");
                    material.DisableKeyword("_ALPHAPREMULTIPLY_ON");
                    material.renderQueue = -1;
                    break;
                case RenderingMode.Cutout:
                    material.SetInt("_SrcBlend", (int)UnityEngine.Rendering.BlendMode.One);
                    material.SetInt("_DstBlend", (int)UnityEngine.Rendering.BlendMode.Zero);
                    material.SetInt("_ZWrite", 1);
                    material.EnableKeyword("_ALPHATEST_ON");
                    material.DisableKeyword("_ALPHABLEND_ON");
                    material.DisableKeyword("_ALPHAPREMULTIPLY_ON");
                    material.renderQueue = 2450;
                    break;
                case RenderingMode.Fade:
                    material.SetInt("_SrcBlend", (int)UnityEngine.Rendering.BlendMode.SrcAlpha);
                    material.SetInt("_DstBlend", (int)UnityEngine.Rendering.BlendMode.OneMinusSrcAlpha);
                    material.SetInt("_ZWrite", 0);
                    material.DisableKeyword("_ALPHATEST_ON");
                    material.EnableKeyword("_ALPHABLEND_ON");
                    material.DisableKeyword("_ALPHAPREMULTIPLY_ON");
                    material.renderQueue = 3000;
                    break;
                case RenderingMode.Transparent:
                    material.SetInt("_SrcBlend", (int)UnityEngine.Rendering.BlendMode.One);
                    material.SetInt("_DstBlend", (int)UnityEngine.Rendering.BlendMode.OneMinusSrcAlpha);
                    material.SetInt("_ZWrite", 0);
                    material.DisableKeyword("_ALPHATEST_ON");
                    material.DisableKeyword("_ALPHABLEND_ON");
                    material.EnableKeyword("_ALPHAPREMULTIPLY_ON");
                    material.renderQueue = 3000;
                    break;
            }
        }


        public static void SetTransplant(this Transform target, RenderingMode renderingMode, float apha, bool changeChild)
        {
            if (target.GetComponent<Renderer>())
            {
                for (int i = 0; i < target.GetComponent<Renderer>().materials.Length; i++)
                {

                    target.GetComponent<Renderer>().materials[i].color = new Color(target.GetComponent<Renderer>().materials[i].color.r, target.GetComponent<Renderer>().materials[i].color.g, target.GetComponent<Renderer>().materials[i].color.b, apha);
                    SetMaterialRenderingMode(target.GetComponent<Renderer>().materials[i], renderingMode);
                }
            }
            if (changeChild)
            {
                for (int i = 0; i < target.childCount; i++)
                {
                    SetTransplant(target.GetChild(i), renderingMode, apha, true);
                }
            }
        }

        public static void SetTransplant(Transform target, RenderingMode renderingMode, float apha, float time, bool changeChild)
        {
            if (target.GetComponent<Renderer>())
            {
                for (int i = 0; i < target.GetComponent<Renderer>().materials.Length; i++)
                {
                    SetMaterialRenderingMode(target.GetComponent<Renderer>().materials[i], renderingMode);
                    target.GetComponent<Renderer>().materials[i].DOColor(new Color(target.GetComponent<Renderer>().materials[i].color.r, target.GetComponent<Renderer>().materials[i].color.g, target.GetComponent<Renderer>().materials[i].color.b, apha), time);
                }
            }
            if (changeChild)
            {
                for (int i = 0; i < target.childCount; i++)
                {
                    SetTransplant(target.GetChild(i), renderingMode, apha, time, true);
                }
            }
        }


        public static void SetTransplant(this Transform target, RenderingMode renderingMode, float apha, float time, bool changeChild, UnityAction method)
        {
            if (target.GetComponent<Renderer>())
            {
                for (int i = 0; i < target.GetComponent<Renderer>().materials.Length; i++)
                {
                    target.GetComponent<Renderer>().materials[i].DOColor(new Color(target.GetComponent<Renderer>().materials[i].color.r, target.GetComponent<Renderer>().materials[i].color.g, target.GetComponent<Renderer>().materials[i].color.b, apha), time);
                    SetMaterialRenderingMode(target.GetComponent<Renderer>().materials[i], renderingMode);
                }
            }
            if (changeChild)
            {
                for (int i = 0; i < target.childCount; i++)
                {
                    SetTransplant(target.GetChild(i), renderingMode, apha, time, true);
                }
            }
            DelayToDo(time, method);
        }


        #endregion


        public static void DelayToDo(float time, UnityAction method)
        {
            //Time.timeScale =
            float a = 0;
            Tweener t = DOTween.To(() => { return a; }, (v) => { a = v; }, 10, time).OnComplete(() =>
            {
                method();
            });
            t.SetId("DelayToDo");
        }
        public static void DelayToDo(float time, string Id, UnityAction method)
        {
            //Time.timeScale =
            float a = 0;
            Tweener t = DOTween.To(() => { return a; }, (v) => { a = v; }, 10, time).OnComplete(() =>
            {
                method();
            });
            t.SetId(Id);
        }



    }

    public static class Mathf_Frame
    {
        /// <summary>
        /// 计算直线和面的交点
        /// </summary>
        /// <param name="planeVector">平面的法向量</param>
        /// <param name="planePoint">平面上一点</param>
        /// <param name="lineVector">直线的方向向量</param>
        /// <param name="linePoint">直线上一点</param>
        /// <returns></returns>
        public static Vector3 CalPlaneLineIntersectPoint(Vector3 planeVector, Vector3 planePoint, Vector3 lineVector, Vector3 linePoint)
        {

            Vector3 returnResult = Vector3.zero;
            float vp1, vp2, vp3, n1, n2, n3, v1, v2, v3, m1, m2, m3, t, vpt;
            vp1 = planeVector.x;
            vp2 = planeVector.y;
            vp3 = planeVector.z;
            n1 = planePoint.x;
            n2 = planePoint.y;
            n3 = planePoint.z;
            v1 = lineVector.x;
            v2 = lineVector.y;
            v3 = lineVector.z;
            m1 = linePoint.x;
            m2 = linePoint.y;
            m3 = linePoint.z;
            vpt = v1 * vp1 + v2 * vp2 + v3 * vp3;
            //首先判断直线是否与平面平行  
            if (vpt == 0)
            {
                //  returnResult = null;       
                Debug.Log("无交点");
            }
            else
            {
                t = ((n1 - m1) * vp1 + (n2 - m2) * vp2 + (n3 - m3) * vp3) / vpt;
                returnResult.x = m1 + v1 * t;
                returnResult.y = m2 + v2 * t;
                returnResult.z = m3 + v3 * t;
            }
            return returnResult;
        }

    }

 

wxxqhf
关注
专栏目录
〖Python零基础入门篇⑱〗- Python字符串常用方法
易编橙 · 终身成长社群，相遇已是上上签！
02-26 4万+
接下来我们会进入 字符串常用方法的应用阶段，重点学习字符串的内置函数。正式学习之前，我们要先了解一个词 `对象` (划重点，不是男女朋友！)，只有知道 `对象是什么？`才能更好的帮助我们接下来的学习。............
〖Python零基础入门篇㉗〗- Python中集合的常用方法
热门推荐
易编橙 · 终身成长社群，相遇已是上上签！
03-03 4万+
什么是集合？集合并不是一种数据处理类型，而是一种中间类型。1.集合(set)是一个无序、不重复的元素序列；2.经常被用来处理两个列表进行交并差的处理性；3.集合与列表一样，支持所有的不可变数据类型
SOTIF预期功能安全分析方法
zqshust的博客
06-20 7634
SOTIF预期功能安全介绍 文章目录SOTIF预期功能安全介绍前言 前言 在汽车四化（电动化、网联化、智能化、共享化）领域，尤其是自动驾驶领域，我们发现不是所有的安全问题都来源于E&E系统故障（ISO26262功能安全定义范畴），还需要考虑外界环境（如超出ODD范围，恶劣天气等的影响），系统性能局限，驾驶员误用等因素的影响，比如以下2016年特斯拉的致死事故。 这类非故障条件下系统功能不及预期而导致的风险就是SOTIF（ISO/PAS 21448 Safety of the intended
Linux文件常用编辑方法
gjzmufeng的博客
04-14 4125
四种常用编辑方法 一 、vi ⅵ就是类似记事本一样的 linux下的常用编辑器了,如果想功能更丰富可以用ⅵm替代ⅵ, vim类似高级的编辑器例如 emeditor,vi/vim的内部有很多的命令技术点要掌握,例如:上文 提到的i就是 insert,进入插入编辑模式的状态的意思,esc键是切换到命令模式,命令模式 下可以敲冒号“:”在后面才可以接命令参数,例如wq,w是write,q为quit,就是...
ListView 用法大全、性能优化以及功能拓展
你若盛开，蜜蜂自来
08-21 1万+
博主声明： 转载请在开头附加本文链接及作者信息，并标记为转载。本文由博主威威喵原创，请多支持与指教。 本文首发于此 博主：威威喵|博客主页：https://blog.csdn.net/smile_running ListView，众所周知，这是一个android中元老级别的控件之一了。虽然，我们现在大多数都用RecyclerView来替代它，但是它还是在我们初学者...
Unity常用的一些简易扩展方法
淡定九号的博客
04-26 4197
Unity常用的一些简易扩展方法 引言 在unity项目的日常开发中，会发现unity现有的一些类的方法不是特别够用，但有些方法使用频率又很高，这时候，我们就可以用到Extension Method 扩展方法，实现自定义的扩展方法。 其次，扩展方法也可以使写法更简便一些。 附：Unity官方教程：教程 实现方法 步骤一 创建一个静态类，没有任何继承。 using UnityEngine; using UnityEngine.UI; /// <summary> /// unity扩展类 ///
Java中String类的常用方法
m0_53067943的博客
11-02 1万+
总结了String类的常用方法
Python列表常用方法
人间凡尘的博客
04-28 2765
文章目录定义特征列表的创建1 方括号 []2 list()3 列表推导式4 根据一个列表生成新的列表增1 append()2 insert(index，object)3 extend(iterable)4 copy()思考删pop(def=index)remove(object)clear()改reverse()sort(reverse=)查count(v)index(v,begin,stop)超级无敌切片大法增删改查列表性质一个关键问题：倒序删除 定义 由一系列变量组成的可变序列容器。 通常只存一类信息.
RouterOS(ROS)+OpenWRT双软路由配置方法及DNS缓存|UPnP等常用功能拓展
Deng's Blog
04-02 3万+
文章主要从零开始，介绍了ROS+OpenWRT双软路由配置方法及常用功能拓展。
功能全，性能强，桌面型拓展坞，奥睿科11合1硬盘拓展坞分享：
最新发布
weixin_45321914的博客
06-27 1061
现在很多人追求轻便办公，MINI PC 和笔记本电脑成为办公首选。虽然PC越做越小巧，确实带来了便利，但随之而来的问题是，许多常用接口都被舍弃了，甚至很多的MINI PC 和笔记本都没有任何的拓展功能。近些年，很多厂商都注意到了这一普遍现象，市场上不少知名的外设品牌也推出了很多实用的拓展坞。价格从几十元到上千元不等。选择拓展坞首先要根据自身的需求入手，但是对于生产力工具来说，还是建议选择功能齐全的拓展坞为首选。最近我入手了奥睿科(ORICO)的一款产品，我觉得它是目前最强大的一款拓展坞。
Javascript拓展String方法小结
10-27
### JavaScript拓展String方法详解 #### 一、引言 在日常的前端开发工作中，字符串处理是必不可少的一部分。JavaScript 的 `String` 类型虽然已经提供了很多内置的方法，但在实际项目中，有时还需要对这些方法进行...
键盘功能全拓展
05-18
《键盘功能全拓展》这节课是小学信息技术课程的一部分，主要针对三年级学生，旨在让他们掌握键盘中的功能键操作，尤其是Shift键和CapsLock键的使用。这两个键在键盘输入中扮演着重要角色，能够实现大小写字母的转换...
系统办公常用拓展名图标
07-24
在"系统办公常用拓展名图标"这个资源中，包含的是12个与办公相关的文件扩展名对应的图标，这些图标有助于用户快速识别不同类型的办公文件。 首先，我们来看一下常见的办公文件扩展名： 1. **.doc(x)**：这是...
Mac微信功能拓展微信插件微信小助手Mac微信插件.zip
06-01
在Mac系统中，微信作为一款常用的即时通讯工具，其本身的功能已经相当全面，但有时候用户可能需要更多定制化的功能来提升工作效率。为了满足这一需求，出现了各种第三方的微信插件，比如“微信小助手”。这款插件是...
C#常用的字符串扩展方法汇总
09-04
这篇文档汇总了C#中常用的字符串扩展方法，特别是针对数据类型的转换。 首先，我们要理解什么是扩展方法。扩展方法是一种特殊的静态方法，可以在非静态上下文中调用，仿佛它是该类的一个实例方法。通过使用`this`...
OnTriggerEnter事件、以及触发碰撞、刚体碰撞研究尝试
wxxqhf的博客
01-14 7109
一、触发碰撞和刚体碰撞 共性：碰撞双方都需要加碰撞器组件，至少有一个添加了刚体组件rigidbody； 异同：触发碰撞需要在 碰撞器勾选is trigger选项，刚体碰撞需要使用物理动力模式（isKinematic 选项不能勾选） 二、OnTriggerEnter事件执行特点； OnTriggerEnter事件不是每帧调用的，它是基于RigidBody物理碰撞后调用的，不管事件所在的脚本是...
计时器_C#
wxxqhf的博客
12-14 924
利用dataTime写计时器功能 public Text text; public float speed = 1; public bool isStart = false; private float beforeTime; private DateTime time; private void Start...
Unity 常用工具方法拓展
wxxqhf的博客
12-17 538
using DG.Tweening; using System.Collections; using System.Collections.Generic; using UnityEngine; using UnityEngine.Events; using UnityEngine.PostProcessing; using UnityEngine.UI; public enum Rende...
unity 通过xml外部加载视频链接，图片
wxxqhf的博客
12-17 531
加载xml的代码   using System.Collections; using System.Collections.Generic; using UnityEngine; using UnityEngine.Events; using System.Xml; using FrameWork; using UnityEngine.UI; public class WebGl_Load...
datagrip有哪一些mysql的拓展功能
07-15
以下是DataGrip中一些MySQL的拓展功能： 1. 智能SQL编辑器：DataGrip提供了强大的SQL编辑器，具有智能代码补全、语法高亮、代码导航等功能，可以提高编写和调试SQL语句的效率。 2. 数据导入和导出：DataGrip支持从...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值