UnityExtensions拓展方法

最新推荐文章于 2024-08-23 07:45:00 发布
最新推荐文章于 2024-08-23 07:45:00 发布
阅读量2k 收藏 1
点赞数
分类专栏： Unity
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_32225289/article/details/88057434
版权

可以写一些自己需要经常调用的方法在UnityExtensions脚本中，方便自己的开发：

比如给物体添加脚本，顺带检测该物体是否已经挂载挂该脚本，避免重复挂载。

	static public T AddMissingComponent<T> (this GameObject go) where T : Component
	{
#if UNITY_FLASH
		object comp = go.GetComponent<T>();
#else
		T comp = go.GetComponent<T>();
#endif
		if (comp == null)
		{
#if UNITY_EDITOR
			if (!Application.isPlaying)
				RegisterUndo(go, "Add " + typeof(T));
#endif
			comp = go.AddComponent<T>();
		}
#if UNITY_FLASH
		return (T)comp;
#else
		return comp;
#endif
	}

下面附上参考脚本：可以自己增加方法

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

public static class UnityExtension
{
    static Ray ray;

    static RaycastHit hit;
    /// <summary>
    /// distanceXZ用
    /// </summary>
    static Vector2 p1, p2;

    /// <summary>
    /// 设置X，只改变X c
    /// </summary>
    /// <param name="trans"></param>
    /// <param name="x"></param>
    static public void SetX(this Transform trans ,float x)
    {
        trans.position = new Vector3(x, trans.position.y, trans.position.z);
    }

    static public void SwitchAt(this IList list,int i1,int i2)
    {
        var tmp = list[i1];
        list[i1] = list[i2];
        list[i2] = tmp;
    }
    /// <summary>
    /// 设置Y，只改变Y c
    /// </summary>
    /// <param name="trans"></param>
    /// <param name="x"></param>
    static public void SetY(this Transform trans, float y)
    {
        trans.position = new Vector3(trans.position.x, y, trans.position.z);
    }
    /// <summary>
    /// 设置Z，只改变Z c
    /// </summary>
    /// <param name="trans"></param>
    /// <param name="x"></param>
    static public void SetZ(this Transform trans, float z)
    {
        trans.position = new Vector3(trans.position.x, trans.position.y, z);
    }
    /// <summary>
    /// 设置LocalX，只改变LocalX c
    /// </summary>
    /// <param name="trans"></param>
    /// <param name="x"></param>
    static public void SetLocalX(this Transform trans, float x)
    {
        trans.localPosition = new Vector3(x, trans.localPosition.y, trans.localPosition.z);
    }
    /// <summary>
    /// 设置LocalY，只改变LocalY c
    /// </summary>
    /// <param name="trans"></param>
    /// <param name="x"></param>
    static public void SetLocalY(this Transform trans, float y)
    {
        trans.localPosition = new Vector3(trans.localPosition.x, y, trans.localPosition.z);
    }
    /// <summary>
    /// 设置LocalZ，只改变LocalZ c
    /// </summary>
    /// <param name="trans"></param>
    /// <param name="x"></param>
    static public void SetLocalZ(this Transform trans, float z)
    {
        trans.localPosition = new Vector3(trans.localPosition.x, trans.localPosition.y, z);
    }
    /// <summary>
    /// 在游戏中，朝向的时候只朝向某个坐标，不低头 c
    /// </summary>
    /// <param name="trans"></param>
    /// <param name="target"></param>
    static public void LookAtXZ(this Transform trans, Vector3 target)
    {
        trans.LookAt(new Vector3(target.x,trans.position.y,target.z));
    }
    /// <summary>
    /// 遍历go c
    /// </summary>
    /// <param name="go"></param>
    /// <param name="handle"></param>
    static public void IterateGameObject(this GameObject go, Action<GameObject> handle)
    {
        Queue q = new Queue();
        q.Enqueue(go);
        while (q.Count != 0)
        {
            GameObject tmpGo = (GameObject)q.Dequeue();
            foreach (Transform t in tmpGo.transform)
            {
                q.Enqueue(t.gameObject);
            }
            if (handle != null)
            {
                handle(tmpGo);
            }
        }
    }
    /// <summary>
    /// 得到100米范围内脚下地面位置
    /// </summary>
    /// <param name="p"></param>
    /// <returns></returns>
    static public Vector3 GetGroundPos(this Vector3 p)
    {
        if (Physics.Linecast(p + new Vector3(0, 10000f, 0), p + new Vector3(0, -10000f, 0), out hit, LayerMask.GetMask(new string[] { eLayer.Ground.ToString() })))
        {
            return new Vector3(p.x, hit.point.y + 0.03f, p.z);
        }
        return p;
    }
    /// <summary>
    /// 设置go层级关系 c
    /// </summary>
    /// <param name="go"></param>
    /// <param name="layer"></param>
    static public void SetAllLayer(this GameObject go,int layer)
    {
        IterateGameObject(go, (g) =>
        {
            g.layer = layer;
        });
    }
    /// <summary>
    /// 只返回平面距离 c
    /// </summary>
    /// <param name="pos"></param>
    /// <param name="target"></param>
    /// <returns></returns>
    static public float DistanceXZ(this Vector3 pos, Vector3 target)
    {
        p1.x = pos.x;
        p1.y = pos.z;
        p2.x = target.x;
        p2.y = target.z;
        return Vector2.Distance(p1,p2);
    }
    /// <summary>
    /// 只返回平面距离 c
    /// </summary>
    /// <param name="pos"></param>
    /// <param name="target"></param>
    /// <returns></returns>
    static public float DistanceXY(this Vector3 pos, Vector3 target)
    {
        p1.x = pos.x;
        p1.y = pos.y;
        p2.x = target.x;
        p2.y = target.y;
        return Vector2.Distance(p1, p2);
    }
    /// <summary>
    /// 重置某个物体的三围等 c
    /// </summary>
    /// <param name="go"></param>
    static public void Reset(this GameObject go)
    {
        go.transform.localPosition = Vector3.zero;
        go.transform.localScale = Vector3.one;
        go.transform.localRotation = Quaternion.Euler(0, 0, 0);
    }
    /// <summary>
    /// 给某个物体创建子物体 c
    /// </summary>
    /// <param name="go"></param>
    /// <param name="name"></param>
    /// <returns></returns>
    static public GameObject CreateGameObject(this GameObject go,string name)
    {
        GameObject obj = new GameObject(name);
        obj.transform.parent = go.transform;
        obj.Reset();
        return obj;
    }
    /// <summary>
    /// 每一帧的移动
    /// </summary>
    /// <param name="t"></param>
    /// <param name="p"></param>
    /// <param name="speed"></param>
    static public void MoveToPerFrame(this Transform t, Vector3 p,float speed)
    {
        t.position += (p - t.position).normalized * speed * Time.deltaTime;
    }
    /// <summary>
    /// 删除某个节点下所有子物体
    /// </summary>
    /// <param name="t"></param>
    static public void DeleteAllChildren(this Transform t)
    {
        for (int i = t.childCount; i > -1; i--)
        {
            GameObject.Destroy(t.GetChild(i).gameObject);
        }
    }

    /// <summary>
    /// 将z置为负z
    /// </summary>
    /// <param name="v"></param>
    /// <returns></returns>
    static public Vector3  ReverseZ(this Vector3 v)
    {
        return new Vector3(v.x, v.y, -v.z);
    }
    /// <summary>
    /// 遍历往上寻溯Com
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <param name="go"></param>
    /// <returns></returns>
    public static T GetComFromParent<T>(this GameObject go) where T:Component
    {
        Queue<Transform> q = new Queue<Transform>();
        q.Enqueue(go.transform);
        while (q.Count > 0)
        {
            Transform t = q.Dequeue();
            if (t.GetComponent<T>() != null)
            {
                return t.GetComponent<T>();
            }
            else
            {
                if (t.parent != null)
                {
                    q.Enqueue(t.parent);
                }
                else
                {
                    return null;
                }
            }
        }
        return null;
    }

    public static T GetParentComponent<T>(this Transform t) where T : Component
    {
        if (t.parent == null)
        {
            return null;
        }
        if (t.parent.GetComponent<T>() != null)
        {
            return t.parent.GetComponent<T>();
        }
        return GetParentComponent<T>(t.parent);
    }

	/// 重置transform
	/// 
	public static void ResetTransformView ( this Transform t ) {
		t.localPosition = Vector3.zero;
		t.localRotation = Quaternion.identity;
		t.localScale = Vector3.one;
	}
	public static Material GetMaterial ( this Renderer render ) {
#if UNITY_EDITOR
		return render.material;
#else
		return render.sharedMaterial;
#endif
	}

    #region 碰撞检测

    static public List<T> CheckInSphere<T>(this Vector3 startPos, float radius)where T:Component
    {
        List<T> list = new List<T>();
        //模拟圆形 c
        /**
        GameObject obj = GameObject.CreatePrimitive(PrimitiveType.Sphere);
        obj.transform.localScale = new Vector3(radius, radius , radius );
        obj.transform.position = startPos;
        obj.GetComponent<Collider>().enabled = false;
        **/
        Collider[] colliders = Physics.OverlapSphere(startPos, radius / 2f);
        for (int i = 0; i < colliders.Length; i++)
        {
            T objCom = colliders[i].gameObject.GetComponent<T>();
            if (objCom != null)
            {
                list.Add(objCom);
            }
        }
        return list;
    }

    static public List<T> CheckInTriangle<T>(this Vector3 startPos, Vector3 endPos, float angle) where T:Component
    {
        float distance = Vector3.Distance(startPos, endPos);
        List<T> list = CheckInSphere<T>(startPos, distance * 2f);
        //
        Quaternion q = new Quaternion();
        q.SetFromToRotation(Vector3.forward, (endPos - startPos).normalized);   //置为朝向
        Quaternion r = q * Quaternion.AngleAxis(angle / 2f, Vector3.up);
        Quaternion l = q * Quaternion.AngleAxis(angle / 2f, Vector3.down);
        Vector3 lP = startPos + (l * Vector3.forward) * distance;
        Vector3 rP = startPos + (r * Vector3.forward) * distance;

        for (int i = list.Count - 1; i > -1; i--)
        {
            if (!IsINTriangle(list[i].transform.position, lP, endPos, startPos) && !IsINTriangle(list[i].transform.position, rP, endPos, startPos))
            {
                //如果在扇形外，则删除 c
                //Debug.DrawLine(startPos, endPos, Color.red);
                list.Remove(list[i]);
            }
        }
        return list;
    }


    static bool IsINTriangle(Vector3 point, Vector3 v0, Vector3 v1, Vector3 v2)
    {
        float x = point.x;
        float y = point.z;

        float v0x = v0.x;
        float v0y = v0.z;

        float v1x = v1.x;
        float v1y = v1.z;

        float v2x = v2.x;
        float v2y = v2.z;

        float t = TriangleArea(v0x, v0y, v1x, v1y, v2x, v2y);
        float a = TriangleArea(v0x, v0y, v1x, v1y, x, y) + TriangleArea(v0x, v0y, x, y, v2x, v2y) + TriangleArea(x, y, v1x, v1y, v2x, v2y);

        if (Mathf.Abs(t - a) <= 0.01f)
        {
            return true;
        }
        else
        {
            return false;
        }
    }

    static float TriangleArea(float v0x, float v0y, float v1x, float v1y, float v2x, float v2y)
    {
        return Mathf.Abs((v0x * v1y + v1x * v2y + v2x * v0y
            - v1x * v0y - v2x * v1y - v0x * v2y) / 2f);
    }

    static public List<T> CheckInRect<T>(this Vector3 startPos, Vector3 endPos, float width)where T:Component
    {
        //求敌人
        float x = Vector3.Distance(startPos, endPos);
        float radius = Mathf.Sqrt(x * x + width * width * 0.25f);
        Vector3 center = (startPos + endPos) / 2f;
        List<T> enemies = CheckInSphere<T>(center, radius * 2f);
        List<T> resultEnemies = new List<T>();
        //求范围
        Quaternion qr = Quaternion.LookRotation(endPos - startPos);

        Vector3 l = startPos + (qr * Vector3.left) * width / 2f;
        //Debug.DrawLine(startPos, l, Color.red);
        //Vector3 le = l + (qr * Vector3.forward) * x;
        //Debug.DrawLine(l, le, Color.red);
        Vector3 r = startPos + (qr * Vector3.right) * width / 2f;
        //Debug.DrawLine(startPos, r, Color.red);
        //Vector3 re = r + (qr * Vector3.forward) * x;
        //Debug.DrawLine(r, re, Color.red);
        Vector3 f = startPos + (qr * Vector3.forward) * x;
        

        for (int i = enemies.Count - 1; i > -1; i--)
        {
            Vector3 forward = (endPos - startPos).normalized;
            Vector3 toOther = enemies[i].transform.position - startPos;

            if (Vector3.Dot(forward, toOther) >= 0)
            {
                Vector3 e = enemies[i].transform.position;
                Vector3 l0e = e - l; //e到l的向量
                Vector3 r0e = e - r;//e到r的向量
                Vector3 f0e = e - f;//e到f的向量

                Vector3 h0l = startPos - l;//h到l的向量
                Vector3 h0r = startPos - r;//h到r的向量
                Vector3 h0f = startPos - f;//h到f的向量
                if (Vector3.Angle(l0e, h0l) <= 90 && Vector3.Angle(r0e, h0r) <= 90 && Vector3.Angle(f0e, h0f) <= 90)
                {
                    //enemies.RemoveAt(i);
                    resultEnemies.Add(enemies[i]);
                }
            }
        }
        return resultEnemies;
    }

    static public bool IsInArea(this Vector3 p, List<Vector3> pos)
    {
        if (pos.Count > 0)
        {
            int polygonLength = pos.Count, i = 0;
            bool inside = false;
            float pointX = p.x, pointY = p.z;
            float startX, startY, endX, endY;
            Vector3 endPoint = pos[polygonLength - 1];
            endX = endPoint.x;
            endY = endPoint.z;
            while (i < polygonLength)
            {
                startX = endX;
                startY = endY;
                endPoint = pos[i++];
                endX = endPoint.x;
                endY = endPoint.z;
                inside ^= (endY > pointY ^ startY > pointY) && ((pointX - endX) < (pointY - endY) * (startX - endX) / (startY - endY));
            }
            return inside;
        }
        else
        {
            return false;
        }
    }

    static public Vector2 IgnoreY(this Vector3 p)
    {
        return new Vector2(p.x, p.z);
    }
    /// <summary>
    /// 需要自己判断NaN
    /// </summary>
    /// <param name="p"></param>
    /// <param name="p1"></param>
    /// <param name="p2"></param>
    /// <returns></returns>
    static public Vector3 GetVerticalPointOfLine(this Vector3 p,Vector3 p1,Vector3 p2)
    {
        float x = p2.x - p1.x;
        if (x != x || x == 0)
        {
            x = 0.01f;
        }
        float k = (p2.z - p1.z) / x;
        k = Mathf.Clamp(k, float.MinValue, float.MaxValue);
        Vector3 pProject = p;
        if (k == 0) //垂线斜率不存在情况
        {
            pProject.x = p.x;
            pProject.z = p1.z;
        }
        else
        {
            //Debug.Log("k" + k);
            //Debug.Log("(1 / k + k)" + (1 / k + k));
            pProject.x = (float)((k * p1.x + p.x / k + p.z - p1.z) / (1 / k + k));
            pProject.z = (float)(-1 / k * (pProject.x - p.x) + p.z);
        }
        return pProject;
    }

    static public Vector3 GetCenter(this List<Vector3> vets)
    {
        float x = 0, y = 0;
        for (int i = 0; i < vets.Count; i++)
        {
            x += vets[i].x;
            y += vets[i].z;
        }
        return new Vector3(x / ((float)vets.Count), vets[0].y, y / ((float)vets.Count));
    }
    #endregion
}

 

秋城迟暮
关注
专栏目录
Vuforia SDK导入问题Vuforia.UnityExtensions Consider removing one of the references or sign the assembl
41814169的博客
01-03 991
导入Vuforia SDK后就报错，在csdn搜了一下，根本没有这方面的信息，去百度找了一下，有一点收获所以分享出来，但是我在百度找到的解决方案并没有解决我现在的这个问题。 大佬若是有解决方案还请不要栗色，拿出来分享一下。 错误关键词： UnityExtensions.dll Vuforia.UnityExtensions Consider removing one of the r...
Unity与UE4引擎源码内使用到的第三方库的比较
游戏路上的小学生
08-19 9352
首先看UE4中的 Third-Party Libraries UnrealEngine\Engine\Source\ThirdParty 下： 源码路径： exe的安装路径下： ADO 注意：这只是为Windows访问权限设置了Windows包含的一组lib的include路径。 AMD AMD GPU服务（AGS）库使软件开发人员能够查询通常无法通过标准操作系统或图形API获得的AMD GPU软件和硬件状态信息。 解决PC上的AMD驱动程序错误，利用PC...
UnityUIExtensions
04-07
UGUI扩展功能，包含文字效果，按钮扩展等等
Unity UI Extensions
03-14
Unity UI Extensions 原地址在此 方便没有的同学使用 https://bitbucket.org/UnityUIExtensions/unity-ui-extensions/downloads/ Controls Accordion ColorPicker SelectionBox UIFlippable ComboBox AutoCompleteComboBox DropDownList BoundToolTip UIWindowBase UI_Knob TextPic InputFocus Box Slider CooldownButton Segmented Control Stepper Primitives UILineRenderer UILineTextureRenderer UICircle DiamondGraph UICornerCut UIPolygon Layouts Horizontal Scroll Snap Vertical Scroll Snap Flow Layout Group Radial Layout Tile Size Fitter Scroll Snap (alt implementation) Reorderable List UI Vertical Scroller Curved Layout Table Layout FancyScrollView Effects Best Fit Outline Curved Text Gradient Gradient2 Letter Spacing NicerOutline RaycastMask UIFlippable UIImageCrop SoftAlphaMask CylinderText UIParticleSystem CurlyUI
【Unity精品插件】DOTween常用组件 |（13）Extensions组件：扩展你的动画能力
最新发布
Unity打怪升级
08-23 930
Extensions组件是DOTween的一个可选插件，它提供了额外的动画功能和对特定Unity组件的支持。这些扩展包括对粒子系统、音频剪辑、文本Mesh Pro等的动画支持。
UnityUIExtensions-2
03-30
功能特别强大的UI插件，可以实现颜色变换、卡牌拖动等效果
探索Unity UI Extensions：优化你的游戏界面开发
gitblog_00037的博客
04-11 567
探索Unity UI Extensions：优化你的游戏界面开发 去发现同类优质开源项目:https://gitcode.com/ 是一个开源项目，旨在为Unity引擎的用户界面（UI）系统提供额外的功能和组件，使开发者能够更轻松、高效地构建复杂的UI场景。通过这个库，你可以利用一系列预设和脚本，提升你的游戏界面设计能力，让开发工作变得更为流畅。 技术分析 Unity UI Extensions基...
Unity-UI-Extensions.unitypackage
08-25
Unity-UI-Extensions，总有一款效果是你想要的！
vuforia源码(c#)--Vuforia.UnityExtensions.dll能编译调试
10-28
这个资源"vuforia源码(c#)--Vuforia.UnityExtensions.dll能编译调试"显然是与使用C#编程语言进行Vuforia开发相关的。C#是Unity引擎的主要编程语言，而UnityExtensions.dll则是Vuforia为Unity集成提供的扩展库，包含...
Unity3d 周分享（8期 2018.12.16）
游戏路上的小学生
12-16 2012
选自过去1~2周的内容： https://twitter.com/unity3d   和各种其他来源吧   1）、 取消DontDestroyOnLoad效果 DontDestroyOnLoad效果的原理是把物体移动到一个特殊的场景里，这个场景在加载场景时不会被卸载，这个场景里的物体也就不会随着加载场景被销毁。 取消DontDestroyOnLoad效果就是进行一个逆操作，把这个物体移回到...
Unity3d开发（十六） 重写UGUI组件
阿修罗道
09-27 8130
作为Unity3d新版本的UI系统，UGUI以其易用性，逐渐被多数团队所接纳。但随着应用的深入，团队中总有需要自定义一套UI系统的需求。所幸UGUI是一个开源项目，可以在Unity3d的官方的Bitbucket代码库中找到源码。有了源码当然我们可以采用一劳永逸的办法，重编DLL库，并替换掉对应的库实现重写。但我还是不太推荐这样，因为一旦如此做，就无法跟随Unity3d版本升级了。因此本文主要介绍如何通过子类实现重写.
Unity_Extensions:有用的统一扩展的集合
04-02
Unity扩展方法的集合。 已从多个来源收集，将它们全部集中在一个地方 尽管有问题版，也可以自由地请求其他扩展，也可以发布可以添加到集合中的任何有用的扩展。 此处提供更多文档
Unity 插件：Simple UI - Scroll View Extensions v1.0
10-19
The Scroll View Extensions drastically extend the utility of the Unity UI Scroll Rect. Smooth and eased snapping (works great whether dragging using touch, mouse or scroll wheel) and user input dependent animation make it possible to use the Scroll Rect in a wide range of scenarios such as level menus, item menus or interactive maps. Features : • Focus the Scroll Rect on any element within the Scroll Rect • Great control over snapping (animation, inertia etc.) • Extensible system for animating elements that are moving into or out of focus.
UnityUIExtensions-2019-6.unitypackage
08-03
#资源达人分享计划#亲测的UnityUI工具,包含多个场景Demo，使用方便快捷
unity-ui-extensions：每天从bitbucket回购中提取
02-06
自述文件 这是新的Unity UI系统的扩展项目，可以在以下位置找到： 有关更多信息，这是该项目的一些介绍视频： 您可以关注UI扩展团队，以获取有关以下方面的更新和新闻： / / 与Gitter上的Unity UI扩展社区进行： 该存储库中包含扩展脚本/效果和控件的集合，以增强您的Unity UI体验。 这些脚本是从许多来源收集来的，并随着时间的推移进行了组合和改进。 大多数脚本来自上的Scripts线程。 您可以下载/分叉此项目以访问脚本，也可以下载这些预编译的Unity Assets，对于每个发行版而言，它们都具有丰富的优点： -2019.1（aka 2.1） 我们已经扩展
【Unity3D / Extension】 扩展方法01 —— 扩展Transfrom
ls9512
06-16 1549
C#提供了强大而又便利的扩展方法，是我们可以为C#原生、以及各种第三方库中的实例类型增加自定义的方法，这些类的实现，通常是无法看到也无法改变的，但是，通过扩展方法，我们可以为其增加一些极其便利的自定义行为。 MSDN上，对扩展方法的定义如下： “扩展方法使您能够向现有类型“添加”方法，而无需创建新的派生类型、重新编译或以其他方式修改原始类型。” Transform是Unity
Unity SKFramework框架（十四）、Extension 扩展函数
当代野生程序猿
05-31 1045
简介 该部分是框架中使用this关键字给一些类型做的拓展函数，为了支持链式编程或记录、封装一些功能，内容会持续补充，本文给出其中部分示例。 一、DotNet Array /// <summary> /// 遍历 /// </summary> /// <param name="action">遍历事件</param> public static T[] ForEach<T>(this T[] self, Action<int, T
NGUI扩展模块：Unity-NGUIExtension
Unity打怪升级
08-08 1619
在Unity3D开发过程中，NGUI是一个强大的UI框架，它提供了一系列的扩展模块来增强我们的用户体验和开发效率。Unity-NGUIExtension是一系列NGUI的扩展模块，这些模块能够为我们的Unity项目带来额外的功能和优化。
Unity学习笔记--Extension Method 扩展方法
游戏码农一枚，不定时分享技术文章~
07-02 588
引言 最近跟着麦克学习Unity的时候，学习到了类的扩展方法。比如你现在有一个已有的类，你想给它加一个方法，当然如果是你自己写的类可以直接在这个方法里面写，但是如果是Unity自带的类，我们不可能直接去编辑它们，我们只是去利用这个类然后加上一些我们自己的方法。所以我们就可以用到Extension Method 扩展方法。 附：Unity官方教程：教程 注： 下方步骤均为硬性要求，并且以扩展Transform类为例子。 步骤一 首先创建一个类。不继承MonoBehaviour。 将该类设置为Static，也就
[Unity][UGUI]UGUI-Extensions学习--下载安装包
BuladeMian的博客，菜得抠脚，菜得真实
02-10 3438
下载 Unity的包。导入 Unity 的项目工程参考资料：1.UnityUIExtensions Unity-UI-Extensions2.UGUI 扩展集3.（二十五）unity4.6学习Ugui中文文档-------UGUI-Extensions4.5.
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值