ease function 缓动函数 插值算法

最新推荐文章于 2024-10-04 15:50:38 发布
最新推荐文章于 2024-10-04 15:50:38 发布
阅读量3.3k 收藏 3
点赞数
分类专栏： unity3D
各种类型 图标 http://easings.net/zh-cn

官网 .http://www.robertpenner.com/easing/


unity3D 所用C#代码

easing.cs

using UnityEngine;
using System.Collections;
using System;

public static class Easing
{
    // Adapted from source : http://www.robertpenner.com/easing/

    public static float Ease(double linearStep, float acceleration, EasingType type)
    {
        float easedStep = acceleration > 0 ? EaseIn(linearStep, type) : 
                          acceleration < 0 ? EaseOut(linearStep, type) : 
                          (float) linearStep;

        return MathHelper.Lerp(linearStep, easedStep, Math.Abs(acceleration));
    }

    public static float EaseIn(double linearStep, EasingType type)
    {
        switch (type)
        {
            case EasingType.Step:       return linearStep < 0.5 ? 0 : 1;
            case EasingType.Linear:     return (float)linearStep;
            case EasingType.Sine:       return Sine.EaseIn(linearStep);
            case EasingType.Quadratic:  return Power.EaseIn(linearStep, 2);
            case EasingType.Cubic:      return Power.EaseIn(linearStep, 3);
            case EasingType.Quartic:    return Power.EaseIn(linearStep, 4);
            case EasingType.Quintic:    return Power.EaseIn(linearStep, 5);
        }
        throw new NotImplementedException();
    }

    public static float EaseOut(double linearStep, EasingType type)
    {
        switch (type)
        {
            case EasingType.Step:       return linearStep < 0.5 ? 0 : 1;
            case EasingType.Linear:     return (float)linearStep;
            case EasingType.Sine:       return Sine.EaseOut(linearStep);
            case EasingType.Quadratic:  return Power.EaseOut(linearStep, 2);
            case EasingType.Cubic:      return Power.EaseOut(linearStep, 3);
            case EasingType.Quartic:    return Power.EaseOut(linearStep, 4);
            case EasingType.Quintic:    return Power.EaseOut(linearStep, 5);
        }
        throw new NotImplementedException();
    }

    public static float EaseInOut(double linearStep, EasingType easeInType, EasingType easeOutType)
    {
        return linearStep < 0.5 ? EaseInOut(linearStep, easeInType) : EaseInOut(linearStep, easeOutType);
    }
    public static float EaseInOut(double linearStep, EasingType type)
    {
        switch (type)
        {
            case EasingType.Step:       return linearStep < 0.5 ? 0 : 1;
            case EasingType.Linear:     return (float)linearStep;
            case EasingType.Sine:       return Sine.EaseInOut(linearStep);
            case EasingType.Quadratic:  return Power.EaseInOut(linearStep, 2);
            case EasingType.Cubic:      return Power.EaseInOut(linearStep, 3);
            case EasingType.Quartic:    return Power.EaseInOut(linearStep, 4);
            case EasingType.Quintic:    return Power.EaseInOut(linearStep, 5);
        }
        throw new NotImplementedException();
    }

    static class Sine
    {
        public static float EaseIn(double s)
        {
            return (float)Math.Sin(s * MathHelper.HalfPi - MathHelper.HalfPi) + 1;
        }
        public static float EaseOut(double s)
        {
            return (float)Math.Sin(s * MathHelper.HalfPi);
        }
        public static float EaseInOut(double s)
        {
            return (float)(Math.Sin(s * MathHelper.Pi - MathHelper.HalfPi) + 1) / 2;
        }
    }

    static class Power
    {
        public static float EaseIn(double s, int power)
        {
            return (float)Math.Pow(s, power);
        }
        public static float EaseOut(double s, int power)
        {
            var sign = power % 2 == 0 ? -1 : 1;
            return (float)(sign * (Math.Pow(s - 1, power) + sign));
        }
        public static float EaseInOut(double s, int power)
        {
            s *= 2;
            if (s < 1) return EaseIn(s, power) / 2;
            var sign = power % 2 == 0 ? -1 : 1;
            return (float)(sign / 2.0 * (Math.Pow(s - 2, power) + sign * 2));
        }
    }
}

public enum EasingType
{
    Step,
    Linear,
    Sine,
    Quadratic,
    Cubic,
    Quartic,
    Quintic
}

public static class MathHelper
{
    public const float Pi = (float)Math.PI;
    public const float HalfPi = (float)(Math.PI / 2);

    public static float Lerp(double from, double to, double step)
    {
        return (float)((to - from) * step + from);
    }
}

Curves.CS

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


public static class QuadBez {
	
	public static Vector3 Interp(Vector3 st, Vector3 en, Vector3 ctrl, float t) {
		float d = 1f - t;
		return d * d * st + 2f * d * t * ctrl + t * t * en;
	}
	
	
	public static Vector3 Velocity(Vector3 st, Vector3 en, Vector3 ctrl, float t) {
		return (2f * st - 4f * ctrl + 2f * en) * t + 2f * ctrl - 2f * st;
	}
	
	
	public static void GizmoDraw(Vector3 st, Vector3 en, Vector3 ctrl, float t) {
		Gizmos.color = Color.red;
		Gizmos.DrawLine(st, ctrl);
		Gizmos.DrawLine(ctrl, en);
		
		Gizmos.color = Color.white;
		Vector3 prevPt = st;
		
		for (int i = 1; i <= 20; i++) {
			float pm = (float) i / 20f;
			Vector3 currPt = Interp(st,en,ctrl,pm);
			Gizmos.DrawLine(currPt, prevPt);
			prevPt = currPt;
		}
		
		Gizmos.color = Color.blue;
		Vector3 pos = Interp(st,en, ctrl,t);
		Gizmos.DrawLine(pos, pos + Velocity(st,en,ctrl,t));
	}
	

}


public static class CubicBez {
	public static Vector3 Interp(Vector3 st, Vector3 en, Vector3 ctrl1, Vector3 ctrl2, float t) {
		float d = 1f - t;
		return d * d * d * st + 3f * d * d * t * ctrl1 + 3f * d * t * t * ctrl2 + t * t * t * en;
	}
	
	
	public static Vector3 Velocity(Vector3 st, Vector3 en, Vector3 ctrl1, Vector3 ctrl2,float t) {
		return (-3f * st + 9f * ctrl1 - 9f * ctrl2 + 3f * en) * t * t
			+  (6f * st - 12f * ctrl1 + 6f * ctrl2) * t
			-  3f * st + 3f * ctrl1;
	}
	
	
	public static void GizmoDraw(Vector3 st, Vector3 en, Vector3 ctrl1, Vector3 ctrl2,float t) {
		Gizmos.color = Color.red;
		Gizmos.DrawLine(st, ctrl1);
		Gizmos.DrawLine(ctrl2, en);
		
		Gizmos.color = Color.white;
		Vector3 prevPt = st;
		
		for (int i = 1; i <= 20; i++) {
			float pm = (float) i / 20f;
			Vector3 currPt = Interp(st,en,ctrl1, ctrl2, pm);
			Gizmos.DrawLine(currPt, prevPt);
			prevPt = currPt;
		}
		
		Gizmos.color = Color.blue;
		Vector3 pos = Interp(st,en,ctrl1, ctrl2, t);
		Gizmos.DrawLine(pos, pos + Velocity(st,en,ctrl1,ctrl2,t));
	}
}


public static class CRSpline {

	
	public static Vector3 Interp(Vector3[] pts, float t) {
		int numSections = pts.Length - 3;
		int currPt = Mathf.Min(Mathf.FloorToInt(t * (float) numSections), numSections - 1);
		float u = t * (float) numSections - (float) currPt;
				
		Vector3 a = pts[currPt];
		Vector3 b = pts[currPt + 1];
		Vector3 c = pts[currPt + 2];
		Vector3 d = pts[currPt + 3];
		
		return .5f * (
			(-a + 3f * b - 3f * c + d) * (u * u * u)
			+ (2f * a - 5f * b + 4f * c - d) * (u * u)
			+ (-a + c) * u
			+ 2f * b
		);
	}
	
	public static Vector3 InterpConstantSpeed(Vector3[] pts, float t) {
		int numSections = pts.Length - 3;
		float mag = 0;
		float [] sizes = new float[pts.Length-1];
		for(var i = 0; i < pts.Length-1; i++) 
		{
			var m = (pts[i+1] - pts[i]).magnitude; 
			sizes[i] = m;
			mag += m;
		}
		
		int currPt=1;
		float s=0;
		double u = 0;
		do
		{
			double tAtBeginning = s/mag;
			double tAtEnd = (s + sizes[currPt+0])/mag;
			u = (t-tAtBeginning) / (tAtEnd - tAtBeginning);
			if(u<0 || u>1)
			{
				s+=sizes[currPt];
				currPt++;
			}
			else
				break;
		} while(currPt < numSections+1);
		u = Mathf.Clamp01((float)u);
		Vector3 a = pts[currPt-1];
		Vector3 b = pts[currPt + 0];
		Vector3 c = pts[currPt + 1];
		Vector3 d = pts[currPt + 2];
		
		return .5f * (
			(-a + 3f * b - 3f * c + d) * (float)(u * u * u)
			+ (2f * a - 5f * b + 4f * c - d) * (float)(u * u)
			+ (-a + c) * (float)u
			+ 2f * b
		);
		
	}
	
	public static Vector3 Velocity(Vector3[] pts, float t) {
		int numSections = pts.Length - 3;
		int currPt = Mathf.Min(Mathf.FloorToInt(t * (float) numSections), numSections - 1);
		float u = t * (float) numSections - (float) currPt;
				
		Vector3 a = pts[currPt];
		Vector3 b = pts[currPt + 1];
		Vector3 c = pts[currPt + 2];
		Vector3 d = pts[currPt + 3];

		return 1.5f * (-a + 3f * b - 3f * c + d) * (u * u)
				+ (2f * a -5f * b + 4f * c - d) * u
				+ .5f * c - .5f * a;
	}
	
	
	public static void GizmoDraw(Vector3[] pts, float t) {
		Gizmos.color = Color.white;
		Vector3 prevPt = Interp(pts, 0);
		
		for (int i = 1; i <= 20; i++) {
			float pm = (float) i / 20f;
			Vector3 currPt = Interp(pts, pm);
			Gizmos.DrawLine(currPt, prevPt);
			prevPt = currPt;
		}
		
		Gizmos.color = Color.blue;
		Vector3 pos = Interp(pts, t);
		Gizmos.DrawLine(pos, pos + Velocity(pts, t));
	}
}

public class Interesting
{
}

public static class Spline
{
	public static Vector3 Interp(Path pts, float t, EasingType ease = EasingType.Linear, bool easeIn = true, bool easeOut = true)
	{
		t = Ease(t, ease, easeIn, easeOut);
		
		if(pts.Length == 0)
		{
			return Vector3.zero;
		}
		else if(pts.Length ==1 )
		{
			return pts[0];
		}
		else if(pts.Length == 2)
		{
			return Vector3.Lerp(pts[0], pts[1], t);
		}
		else if(pts.Length == 3)
		{
			return QuadBez.Interp(pts[0], pts[2], pts[1], t);
		}
		else if(pts.Length == 4)
		{
			return CubicBez.Interp(pts[0], pts[3], pts[1], pts[2], t); 
		}
		else
		{
			return CRSpline.Interp(Wrap(pts), t);
		}
		
		
	}
	
	private static float Ease(float t, EasingType ease = EasingType.Linear, bool easeIn = true, bool easeOut = true)
	{
		t = Mathf.Clamp01(t);
		if(easeIn && easeOut)
		{
			t = Easing.EaseInOut(t, ease);
		} else if(easeIn)
		{
			t = Easing.EaseIn(t, ease);
		} else if(easeOut)
		{
			t = Easing.EaseOut(t, ease);
		}
		return t;
	}
	
	public static Vector3 InterpConstantSpeed(Path pts, float t, EasingType ease = EasingType.Linear, bool easeIn = true, bool easeOut = true)
	{
		t = Ease(t, ease, easeIn, easeOut);
		
		if(pts.Length == 0)
		{
			return Vector3.zero;
		}
		else if(pts.Length ==1 )
		{
			return pts[0];
		}
		else if(pts.Length == 2)
		{
			return Vector3.Lerp(pts[0], pts[1], t);
		}
		else if(pts.Length == 3)
		{
			return QuadBez.Interp(pts[0], pts[2], pts[1], t);
		}
		else if(pts.Length == 4)
		{
			return CubicBez.Interp(pts[0], pts[3], pts[1], pts[2], t); 
		}
		else
		{
			return CRSpline.InterpConstantSpeed(Wrap(pts), t);
		}
		
		
	}
	
	public static Vector3 MoveOnPath(Path pts, Vector3 currentPosition, ref float pathPosition,  float maxSpeed=1f, float smoothnessFactor=100, EasingType ease = EasingType.Linear, bool easeIn = true, bool easeOut = true)
	{
		maxSpeed *= Time.deltaTime;
		pathPosition = Mathf.Clamp01(pathPosition);
		var goal = Interp(pts, pathPosition, ease, easeIn, easeOut);
		float distance;
		while((distance = (goal - currentPosition).magnitude) <= maxSpeed && pathPosition < 1)
		{
			currentPosition = goal;
			maxSpeed -= distance;
			pathPosition = Mathf.Clamp01(pathPosition + 1/smoothnessFactor);
			goal = Interp(pts, pathPosition, ease, easeIn, easeOut);
		}
		if(distance != 0)
		{
			currentPosition = Vector3.MoveTowards(currentPosition, goal, maxSpeed);
		}
		return currentPosition;
	}
	
	public static Vector3 MoveOnPath(Path pts, Vector3 currentPosition, ref float pathPosition, ref Quaternion rotation,  float maxSpeed=1f, float smoothnessFactor=100, EasingType ease = EasingType.Linear, bool easeIn = true, bool easeOut = true)
	{
		var result = MoveOnPath(pts, currentPosition, ref pathPosition, maxSpeed, smoothnessFactor, ease, easeIn, easeOut);
		rotation =  result.Equals(currentPosition) ? Quaternion.identity : Quaternion.LookRotation(result - currentPosition);
		return result;
	}
	
	public static Quaternion RotationBetween(Path pts, float t1, float t2, EasingType ease = EasingType.Linear, bool easeIn = true, bool easeOut = true)
	{
		return Quaternion.LookRotation(Interp(pts, t2, ease, easeIn, easeOut) - Interp(pts, t1, ease, easeIn, easeOut));
	}
	
	
	public static Vector3 Velocity(Path pts, float t, EasingType ease = EasingType.Linear, bool easeIn = true, bool easeOut = true) 
	{
		t = Ease(t);
		if(pts.Length == 0)
		{
			return Vector3.zero;
		}
		else if(pts.Length ==1 )
		{
			return pts[0];
		}
		else if(pts.Length == 2)
		{
			return Vector3.Lerp(pts[0], pts[1], t);
		}
		else if(pts.Length == 3)
		{
			return QuadBez.Velocity(pts[0], pts[2], pts[1], t);
		}
		else if(pts.Length == 4)
		{
			return CubicBez.Velocity(pts[0], pts[3], pts[1], pts[2], t); 
		}
		else
		{
			return CRSpline.Velocity(Wrap(pts), t);
		}
	}
	
	public static Vector3[] Wrap(Vector3[] path)
	{
		return (new Vector3[] { path[0] }).Concat(path).Concat(new Vector3[] { path[path.Length-1]}).ToArray();
	}
		
	public static void GizmoDraw(Vector3[] pts, float t,EasingType ease = EasingType.Linear, bool easeIn = true, bool easeOut = true) {
		Gizmos.color = Color.white;
		Vector3 prevPt = Interp(pts, 0);
		
		for (int i = 1; i <= 20; i++) {
			float pm = (float) i / 20f;
			Vector3 currPt = Interp(pts, pm, ease, easeIn, easeOut);
			Gizmos.DrawLine(currPt, prevPt);
			prevPt = currPt;
		}
		
		Gizmos.color = Color.blue;
		Vector3 pos = Interp(pts, t, ease, easeIn, easeOut);
		Gizmos.DrawLine(pos, pos + Velocity(pts, t, ease, easeIn, easeOut));
	}
	
	public class Path
	{
		private Vector3[] _path;
		
		public Vector3[] path
		{
			get
			{
				return _path;
			}
			set
			{
				_path = value;
			}
		}
		
		public int Length
		{
			get
			{
				return path != null ? path.Length : 0;
			}
		}
		
		public Vector3 this[int index]
		{
			get
			{
				return path[index];
			}
		}
		
		public static implicit operator Path(Vector3[] path)
		{
			return new Path() {path = path};
		}
		public static implicit operator Vector3[](Path p)
		{
			return p != null ? p.path : new Vector3[0];
		}
		public static implicit operator Path(Transform[] path)
		{
			return new Path() {path = path.Select(p=>p.position).ToArray()};
		}
		public static implicit operator Path(GameObject[] path)
		{
			return new Path() {path = path.Select(p=>p.transform.position).ToArray()};
		}
		
		
	}

}


chu358177
关注
专栏目录
缓动函数（EaseAction）曲线一览图
09-12
cocos2d 里面的 CCEaseAction：CCEaseSineIn, CCEaseBackIn, CCEaseBounceIn, ....各种缓动样式都在这里面，方便直观查看他们的样式
TextFx——Ease Function(缓动函数)
EasonEasonEasonEason的博客
02-06 1364
TextFx——Ease Function(缓动函数)             By D.S.Qiu 尊重他人的劳动，支持原创，转载请注明出处：http://dsqiu.iteye.com                 之前有介绍过UITweener（点击前往），NGUI用了一个目录“收集”Tween脚本，集成的功能还是很丰富的，只提供了6种缓动函
Unity中40种easing方程的可视化演示与实践
最新发布
weixin_28487725的博客
10-04 1105
本文还有配套的精品资源，点击获取 简介：该可视化前端项目展示了Unity引擎中40种常见缓动方程的应用，帮助开发者直观理解和选择合适的缓动效果。缓动方程在动画中控制物体属性的平滑过渡，如位置、旋转和缩放，是创建自然流畅动画不可或缺的部分。项目包括C#源代码实现、实时预览的Unity场景、关于各缓动方程的文档以及构建可视化界面所需的资源。文档中包含了每个方程的简介和在Unit...
TextFx-Ease Function(缓动函数)
qiudesuo的专栏
01-07 313
        TextFx——Ease Function(缓动函数)             By D.S.Qiu 尊重他人的劳动，支持原创，转载请注明出处：http://dsqiu.iteye.com                 之前有介绍过UITweener（点击前往），NGUI用了一个目录“收集”Tween脚本，集成的功能还是很丰富的，只提供了6种缓动函数（Ease...
探索 `eases`：一个强大的动画缓动函数库
gitblog_00059的博客
04-27 405
探索 eases：一个强大的动画缓动函数库 easesa grab-bag of modular easing equations项目地址:https://gitcode.com/gh_mirrors/ea/eases 项目简介 在网页和应用开发中，平滑的动画效果是提升用户体验的关键因素之一。 是由 Matt DesLauriers 创建的一个JavaScript库，它提供了一系列丰富的缓动（e...
缓动函数-模拟运动效果-EaseFunction
03-05
基于openFrameworks实现的缓动函数来模拟运动效果。
关于 Ease的几个方法
weixin_30753873的博客
03-06 135
in: 进入的时候慢out：结束的时候慢inout: 进入和结束都慢计算方法：如果 in表达式为 x * x则 out表达式为 1- (1 - x) * (1 - x)inout先把 x*2,再分段套用in , out的表达式 参考我的 Agraphics的 BounceInterpolator 转载于:https://www.cnblogs.com/xzy2046/archive/201...
C 实现通用Tween缓动动画(1)插值公式
scott.cgi
07-05 3465
Tween缓动动画在ui中大量的使用，根据缓动算法可以很快的创造出，预定的缓冲运动效果。其核心的概念就是，给出初始值，目标值，时间。然后差值之间每个时间点上的数值变化，从而得到一组运动轨迹。     我实现的Tween通用结构，主要分为3个部分，每个部分单独一篇文章来解释。 第一， 插值算法公式。根据初始值，目标值，和当前时间，来计算当前属性值。 第二， 定义Tween执行状
JavaScript Tween算法及缓动效果 -源码.zip
12-10
缓动效果可以分为几种类型：线性（Linear）、缓入（Ease In）、缓出（Ease Out）、缓入缓出（Ease In Out）等。每种类型的缓动函数都通过不同的方式改变动画的速度，以提供更自然或特定的视觉体验。 线性缓动是最...
简析缓动曲线
wzf_taker的专栏
09-09 2856
简析缓动曲线 Introduce of the EaseCurve 前言 动效是用户体验失很重要的一部分。随着设备性能的提升和人们对于用户体验越来越高的追求，动效将会越来越重要。动效要遵循客观物理规律以及人的视觉经验，符合用户预期，让用户感觉自然，才能获得用户的喜爱。 本文将从为什么探究缓动曲线、利用物理公式探究缓动曲线、常用缓动曲线、使用曲线拟合尝试剖析苹果ScrollView动效参数、使用线...
android自定义插值器_自定义缓动插值器，可在Android中实现有意义的动作
weixin_26739079的博客
08-24 1306
android自定义插值器Interpolators are very useful to model movement for your UI elements. In this article, we’ll focus on how to create aesthetic motion by using two simple tools: animator and interpolator i...
as3.0缓动程序
04-20
AS3.0缓动程序是ActionScript 3.0中用于实现动态动画效果的一种技术，主要通过缓动函数（Tweening Function）来平滑地改变对象的属性值，如位置、透明度等，使得动画过渡更为自然流畅。在这个场景中提到的" ...
几道Easy算法
qq_41112238的博客
04-30 636
1 两数之和 思路：使用一个HashMap集合存储每一个元素和对应下标。 public int[] twoSum(int[] nums, int target) { HashMap<Integer,Integer> map=new HashMap<>(); for(int i=0;i<nums.length;i++){ ...
游戏中各种EaseFunction的解释
风流海的专栏
05-10 1731
http://hosted.zeh.com.br/tweener/docs/en-us/misc/transitions.html
一个基于C++的缓动库
zhangym365的专栏
09-13 1112
http://libclaw.sourceforge.net/tweeners.html
缓动公式整理（附：C#实现及WPF原版对比）
chinaherolts2008的博客
06-29 418
前言 缓动在动画效果中应用非常广泛，在合适的时候使用一些缓动效果会使得效果更加符合人的直观感受，简单来说，会显得更加自然。 WPF提供了11种缓动效果，涵盖了大部分的使用场景。不过如果需要在非WPF下使用这些缓动效果，就需要知道对应的曲线公式了。因为公式是通用的，所以可以很轻松的使用其他语言实现。 由于本人数学水平有限，所以本文注重的应用而不是原理。在本文中，将会使用C#去实现，并附上与WPF原版的对比效果。 本文参考： 1，https://docs.microsoft.com/zh-cn/dot
ShaderJoy —— 特效常用的 30 种缓动函数 【C/C++】【GLSL】
ShaderJoy 的兴趣技术杂货铺
02-13 2244
效果图： a.Bounce ​​​b.Sine c.Expo d.Circ e.Elastic f.Back 函数代码： #define PI 3.14159f #define c1 1.70158f #define c2 (c1 * 1.525f) // 2.5949095 #define c3 (c1 + 1.f) // 2.70158 #define c4 ...
tweener包 flash缓动
11-17
- Tweener库内部实现了插值算法，根据时间和缓动函数计算出每个帧的对象属性值，确保动画流畅。 5. **事件处理**： - 开发者可以监听`onStart`、`onComplete`、`onUpdate`等事件，以便在动画开始、结束或每一帧时...
ios-数字动画.zip
07-11
- **缓动函数（Ease Function）**：添加缓动效果可以使动画更加自然，常见的有ease-in、ease-out、ease-in-out等。 - **动画持续时间**：设定合适的动画时长，过短可能不易察觉，过长则可能让用户感觉迟钝。 - **...
外部使用QT自带的缓动函数EasingCurve C++动画
茉莉呀的博客
11-23 1572
外部使用QT自带的缓动函数EasingCurve C++动画 QT动画transitions提供了移动动画，可以通过使用transitions调用的函数在自己的c++中实现移动动画逻辑，得到每单位时间移动的位移。 自定义移动动画 可以利用移动的位移，根据测试，手动定义每单位时间移动的位移，通过位移的当前值和目标值比较，手动计算得到一套移动动画。 缓动函数 缓动函数里提供了多种缓动曲线类型，如匀速的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值