Tween算法及缓动效果（JS，C++）

最新推荐文章于 2019-07-02 09:33:43 发布
最新推荐文章于 2019-07-02 09:33:43 发布
阅读量2.1k 收藏 1
点赞数 1
分类专栏： C++

原帖地址：http://www.cnblogs.com/cloudgamer/archive/2009/01/06/Tween.html


C++代码：


Tween.h

#pragma once

#include <math.h>

// Algorithm Reference:
//http://www.robertpenner.com/easing/
//http://www.cnblogs.com/cloudgamer/archive/2009/01/06/Tween.html

#ifndef PI
#define PI	3.1415926f
#endif

const float EPSINON = 0.000001f;
#define EQUAL_ZERO(x) ((x >= - EPSINON) && (x <= EPSINON)) ? TRUE : FALSE

class CTween
{
public:
	CTween(void);
	~CTween(void);

	// Linear
	float Linear_easeIn(float t, float b, float c, float d);
	float Linear_easeOut(float t, float b, float c, float d);
	float Linear_easeInOut(float t, float b, float c, float d);

	// Quadratic
	float Quad_easeIn(float t, float b, float c, float d);
	float Quad_easeOut(float t, float b, float c, float d);
	float Quad_easeInOut(float t, float b, float c, float d);

	// Cubic
	float Cubic_easeIn(float t, float b, float c, float d);
	float Cubic_easeOut(float t, float b, float c, float d);
	float Cubic_easeInOut(float t, float b, float c, float d);

	// Quartic
	float Quart_easeIn(float t, float b, float c, float d);
	float Quart_easeOut(float t, float b, float c, float d);
	float Quart_easeInOut(float t, float b, float c, float d);

	// Quintic
	float Quint_easeIn(float t, float b, float c, float d);
	float Quint_easeOut(float t, float b, float c, float d);
	float Quint_easeInOut(float t, float b, float c, float d);

	// Sinusoidal
	float Sine_easeIn(float t, float b, float c, float d);
	float Sine_easeOut(float t, float b, float c, float d);
	float Sine_easeInOut(float t, float b, float c, float d);

	// Exponential
	float Expo_easeIn(float t, float b, float c, float d);
	float Expo_easeOut(float t, float b, float c, float d);
	float Expo_easeInOut(float t, float b, float c, float d);

	// Circular
	float Circ_easeIn(float t, float b, float c, float d);
	float Circ_easeOut(float t, float b, float c, float d);
	float Circ_easeInOut(float t, float b, float c, float d);

	// Elastic
	float Elastic_easeIn(float t, float b, float c, float d, float a = 0.0f, float p = 0.0f);
	float Elastic_easeOut(float t, float b, float c, float d, float a = 0.0f, float p = 0.0f);
	float Elastic_easeInOut(float t, float b, float c, float d, float a = 0.0f, float p = 0.0f);

	// Back
	float Back_easeIn(float t, float b, float c, float d, float s = 0.0f);
	float Back_easeOut(float t, float b, float c, float d, float s = 0.0f);
	float Back_easeInOut(float t, float b, float c, float d, float s = 0.0f);

	// Bounce
	float Bounce_easeOut(float t, float b, float c, float d);
	float Bounce_easeIn(float t, float b, float c, float d);
	float Bounce_easeInOut(float t, float b, float c, float d);

public:
	float t, b, c, d, a, p;
};


Tween.cpp

#include "StdAfx.h"
#include "Tween.h"

CTween::CTween(void)
{
}

CTween::~CTween(void)
{
}

// Linear
float CTween::Linear_easeIn(float t, float b, float c, float d)
{
	return c * t / d + b;
}

float CTween::Linear_easeOut(float t, float b, float c, float d)
{
	return c * t / d + b;
}

float CTween::Linear_easeInOut(float t, float b, float c, float d)
{
	return c * t / d + b;
}

// Quadratic
float CTween::Quad_easeIn(float t, float b, float c, float d)
{
	return c * (t /= d) * t + b;
}

float CTween::Quad_easeOut(float t, float b, float c, float d)
{
	return -c * (t /= d) * (t - 2) + b;
}

float CTween::Quad_easeInOut(float t, float b, float c, float d)
{
	if ((t /= d / 2) < 1)
		return c / 2 * t * t + b;
	return -c / 2 * ((--t) * (t - 2) - 1) + b;
}

// Cubic
float CTween::Cubic_easeIn(float t, float b, float c, float d)
{
	return c * (t /= d) * t * t + b;
}

float CTween::Cubic_easeOut(float t, float b, float c, float d)
{
	return c * ((t = t / d - 1) * t * t + 1) + b;
}

float CTween::Cubic_easeInOut(float t, float b, float c, float d)
{
	if ((t /= d / 2) < 1)
		return c / 2 * t * t * t + b;
	return c / 2 * ((t -= 2) * t * t + 2) + b;
}

// Quartic
float CTween::Quart_easeIn(float t, float b, float c, float d)
{
	return c * (t /= d) * t * t * t + b;
}

float CTween::Quart_easeOut(float t, float b, float c, float d)
{
	return -c * ((t = t / d - 1) * t * t * t - 1) + b;
}

float CTween::Quart_easeInOut(float t, float b, float c, float d)
{
	if ((t /= d / 2) < 1)
		return c / 2 * t * t * t * t + b;
	return -c / 2 * ((t -= 2) * t * t * t - 2) + b;
}

// Quintic
float CTween::Quint_easeIn(float t, float b, float c, float d)
{
	return c * (t /= d) * t * t * t * t + b;
}

float CTween::Quint_easeOut(float t, float b, float c, float d)
{
	return c * ((t = t / d - 1)* t * t * t * t + 1) + b;
}

float CTween::Quint_easeInOut(float t, float b, float c, float d)
{
	if ((t /= d / 2) < 1)
		return c / 2 * t * t * t * t * t + b;
	return c / 2 * ((t -= 2) * t * t * t * t + 2) + b;
}

// Sinusoidal
float CTween::Sine_easeIn(float t, float b, float c, float d)
{
	return -c * cos(t / d * (PI / 2)) + c + b;
}

float CTween::Sine_easeOut(float t, float b, float c, float d)
{
	return c * sin(t / d * (PI / 2)) + b;
}

float CTween::Sine_easeInOut(float t, float b, float c, float d)
{
	return -c / 2 * (cos(PI * t/ d) - 1) + b;
}

// Exponential
float CTween::Expo_easeIn(float t, float b, float c, float d)
{
	return (t == 0) ? b : c * pow(2, 10 * (t / d - 1)) + b;
}

float CTween::Expo_easeOut(float t, float b, float c, float d)
{
	return (t == d) ? b + c : c * (-pow(2, -10 * t / d) + 1) + b;
}

float CTween::Expo_easeInOut(float t, float b, float c, float d)
{
	if (t == 0)
		return b;
	if (t == d)
		return b+c;
	if ((t /= d / 2) < 1)
		return c / 2 * pow(2, 10 * (t - 1)) + b;
	return c / 2 * (-pow(2, -10 * --t) + 2) + b;
}

// Circular
float CTween::Circ_easeIn(float t, float b, float c, float d)
{
	return -c * (sqrt(1 - (t /= d) * t) - 1) + b;
}

float CTween::Circ_easeOut(float t, float b, float c, float d)
{
	return c * sqrt(1 - (t = t / d - 1) * t) + b;
}

float CTween::Circ_easeInOut(float t, float b, float c, float d)
{
	if ((t /= d / 2) < 1)
		return -c / 2 * (sqrt(1 - t * t) - 1) + b;
	return c / 2 * (sqrt(1 - (t -= 2) * t) + 1) + b;
}

// Elastic
float CTween::Elastic_easeIn(float t, float b, float c, float d, float a/* = 0.0f*/, float p/* = 0.0f*/)
{
	float s = 0;
	if (t == 0)
		return b;
	if ((t /= d) == 1)
		return b + c;
	if (!p)
		p = d * .3f;
	if (!a || a < abs(c))
	{
		a = c;
		s = p/4;
	}
	else
		s = p / (2 * PI) * asin (c / a);
	return -(a * pow(2, 10 * (t -= 1)) * sin((t * d - s) * (2 * PI) / p)) + b;
}

float CTween::Elastic_easeOut(float t, float b, float c, float d, float a/* = 0.0f*/, float p/* = 0.0f*/)
{
	float s = 0;
	if (t == 0)
		return b;
	if ((t /= d) == 1)
		return (b + c);
	if (!p)
		p = d *.3f;
	if (!a || a < abs(c))
	{
		a = c;
		s = p / 4;
	}
	else
		s = p / (2 * PI) * sin((float)c / a);

	return (a * pow(2.0f, (int) - 10 * t) * sin((t * d - s) * (2 * PI) / p) + c + b);
}

float CTween::Elastic_easeInOut(float t, float b, float c, float d, float a/* = 0.0f*/, float p/* = 0.0f*/)
{
	float s = 0;
	if (t == 0)
		return b;
	if ((t /= d / 2) == 2)
		return b + c;
	if (!p)
		p = d * (.3f * 1.5f);
	if (!a || a < abs(c))
	{
		a = c;
		s = p/4;
	}
	else
		s = p / (2 * PI) * asin (c / a);
	if (t < 1)
		return -.5f * (a * pow(2, 10 * (t -= 1)) * sin( (t * d - s) * (2 * PI) / p )) + b;
	return a * pow(2, -10 * (t -= 1)) * sin((t * d - s) * (2 * PI) / p ) * .5f + c + b;
}

// Back
float CTween::Back_easeIn(float t, float b, float c, float d, float s/* = 0.0f*/)
{
	if (EQUAL_ZERO(s))
		s = 1.70158f;
	return c * (t /= d) * t * ((s + 1) * t - s) + b;
}

float CTween::Back_easeOut(float t, float b, float c, float d, float s/* = 0.0f*/)
{
	if (EQUAL_ZERO(s))
		s = 1.70158f;
	return c * ((t = t / d - 1) * t * ((s + 1) * t + s) + 1) + b;
}

float CTween::Back_easeInOut(float t, float b, float c, float d, float s/* = 0.0f*/)
{
	if (EQUAL_ZERO(s))
		s = 1.70158f;
	if ((t /= d / 2) < 1)
		return c / 2 * (t * t * (((s *= (1.525f)) + 1) * t - s)) + b;
	return c / 2 * ((t -= 2) * t * (((s *= (1.525f)) + 1) * t + s) + 2) + b;
}

// Bounce
float CTween::Bounce_easeOut(float t, float b, float c, float d)
{
	if ((t /= d) < (1 / 2.75))
	{
		return c * (7.5625f * t * t) + b;
	}
	else if (t < (2 / 2.75))
	{
		return c * (7.5625f * (t -= (1.5f / 2.75f)) * t + .75f) + b;
	}
	else if (t < (2.5 / 2.75))
	{
		return c * (7.5625f * (t -= (2.25f / 2.75f)) * t + .9375f) + b;
	}
	else
	{
		return c * (7.5625f * (t -= (2.625f / 2.75f)) * t + .984375f) + b;
	}
}

float CTween::Bounce_easeIn(float t, float b, float c, float d)
{
	return c - Bounce_easeOut(d - t, 0, c, d) + b;
}

float CTween::Bounce_easeInOut(float t, float b, float c, float d)
{
	if (t < d / 2)
		return Bounce_easeIn(t * 2, 0, c, d) * .5f + b;
	else return Bounce_easeOut(t * 2 - d, 0, c, d) * .5f + c * .5f + b;
}


Wyq_nathan
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Tween 模拟缓动效果
05-03
Tween 一个jsC插件，用来模拟缓动效果
C++实现缓动动画效果，使用Tween算法（含详细代码）
Coding14的博客
02-09 1260
C++实现缓动动画效果，使用Tween算法（含详细代码）1、简介2、代码3、重要说明 1、简介 在实际的项目开发中，遇到需要通过算法为程序提供流畅的显示效果的时候，我们通常需要借助计时器和位置计算的算法来实现。这里的Tween就是一个缓动数据计算的类，有了tween算法，我们就可以在此基础上，根据具体的业务调整数据实现流畅的缓动效果了。 2、代码 #pragma once // Algorithm Reference: //http://www.cnblogs.com/cloudgamer/archive/
tweeny:现代C ++补间库
04-12
吐温 Tweeny是一个中间库，旨在为游戏和其他精美的交互式软件创建复杂的动画。 它利用现代C ++的功能为开发人员提供直观的API，以声明任何类型的补间，只要它们支持算术运算即可。 Tweeny的目标是提供一种在设置屏幕对象的位置，比例，旋转，帧或其他值的动画时创建流体插值的方法，方法是将其值设置为补间起始点，然后在每个补间步骤之后重新插入结果。 它具有以下特点： 描述性的（希望如此）直观的API， 30多种缓动功能， 允许自定义缓动功能， 多点补间 异类值集的同时补间， 类似时间轴的用法（允许进行任意搜索）， 仅标头 零外部依赖 前进或后退：) 接受lambda，函子和函数作为步骤并寻求回调 强制性的hello world示例： 从单词hello到世界线性地逐个字符地插入50步骤： auto helloworld = tweeny::from( ' h ' ,
TweenJS
JQG的博客
10-18 671
DOCTYPE html> html> head> meta charset="UTF-8"> title>TweenJStitle> style type="text/css"> * { margin: 0; padding: 0; } #div1 { width: 50px; height: 50px; background: red; positi
JavaScript实现的Tween算法及缓冲特效。
qq_40708273的博客
02-06 446
本文实例讲述了JavaScript实现的Tween算法及缓冲特效。分享给大家供大家参考，具体如下： 这里演示Tween 算法及缓冲特效的JavaScript代码，利用它可以做缓动、弹簧等很多动画效果，怎么利用flash的Tween类的算法，来做js的Tween算法，并利用它做一些简单的缓动效果呢，看懂了本代码你就明白了。 运行效果截图如下： 在线演示地址如下： http://d
cocos2d-x节点（CCActionTween.h)API
runaying的专栏
12-08 2549
本文来自http://blog.csdn.net/runaying ，引用必须注明出处！ cocos2d-x节点（CCActionTween.h)API 温馨提醒：为了大家能更好学习，强烈推荐大家看看本人的这篇博客 Cocos2d-X权威指南笔记 //补间动画 ///cocos2d-x-3.0alpha0/cocos2dx/actions #ifndef __CCACTION
cocos2d-X 节点（CCTween.h）API
runaying的专栏
11-25 2206
本文来自http://blog.csdn.net/runaying ，引用必须注明出处！ cocos2d-X 节点（CCSpriteFrameCache.h）API 温馨提醒：为了大家能更好学习，强烈推荐大家看看本人的这篇博客 Cocos2d-X权威指南笔记
JavaScript Tween算法及缓动效果 -源码.zip
12-10
JavaScript Tween算法是动画效果中常用的一种技术，它用于在一段时间内平滑地改变一个或多个对象的属性。Tween，即“缓动”，在图形和游戏编程中尤其常见，用来实现平滑过渡效果，如物体的移动、旋转或颜色变化等。...
JavaScript Tween算法及缓动效果第1/2页
10-30
JavaScript Tween算法是用于实现平滑动画过渡的技术，它...总之，JavaScript Tween算法是实现平滑过渡动画的关键，通过理解和应用不同类型的缓动函数，我们可以创建出丰富多样的动画效果，提升用户在网页交互中的体验。
tween.js缓动补间动画算法示例
11-27
首先引入一个概念就补间动画 Flash做动画时会用到Tween类，利用它可以做很多动画效果，例如缓动、弹簧等等。 tween.js在Flash中可以解释为补间动画. 那么问题来了,什么是补间动画呢? 相信学过Flash的都知道补间动画...
tween自动动画
08-09
tween自动动画
iTween for UE4.16
06-16
For those who may not know, iTween is a procedural animation package for Unity that allows you to animate objects on the fly during runtime. Move here, rotate this way, change to this colour, scale to this size, etc.
JavaScript实现的Tween算法及缓冲特效实例代码
10-23
JavaScript中的Tween算法可以与各种动画库结合使用，如GSAP（GreenSock Animation Platform）和Tween.js，这些库提供了丰富的缓动函数和更高级的功能，如链式调用、延迟、回调等，让开发者能更轻松地创建复杂的动画...
tween缓动画的基本算法
huhudeni的博客
07-02 912
笔者在做canvas的游戏框架的时候遇到了动画的相关算法问题 下面就是通常使用的一些 动画的算法 可以给大家一些参考 下面是相关的变量 这个是示意图 /* * t: current time（当前时间）； * b: beginning value（初始值）； * c: change in value（变化量）； * d: duration（持续时间）。 */ Linear：线性...
Tween动画及缓动函数
Sclifftop - 保安大队长
04-24 6338
缓动tween结构很简单，它是基于初始值，结束值，作用域公式来实现的。 缓动函数包括quad、cubic、sine、quint、circt、bounce、back、expo、elastic、quart等等 转载自：https://www.jianshu.com/p/c157c5898153 Zszen 图示 下图所示，所有公式的作用域都是从0～1 简介 首先说一下一般引擎下的twe...
JavaScript Tween算法及缓动效果
cloudgamer
01-06 273
Flash做动画时会用到Tween类，利用它可以做很多动画效果，例如缓动、弹簧等等。我这里要教大家的是怎么利用flash的Tween类的算法，来做js的Tween算法，并利用它做一些简单的缓动效果。前台效果预览完整实例下载 效果说明首先大家到这里下载flash的as脚本（建议看看这里的demo），1.0和2.0都可以（里面的算法都一样）。例如打开2.0的可以看到几个as文件，每个文件对应一个Tw...
C 实现通用Tween缓动动画(1)插值公式
scott.cgi
07-05 3409
Tween缓动动画在ui中大量的使用，根据缓动算法可以很快的创造出，预定的缓冲运动效果。其核心的概念就是，给出初始值，目标值，时间。然后差值之间每个时间点上的数值变化，从而得到一组运动轨迹。     我实现的Tween通用结构，主要分为3个部分，每个部分单独一篇文章来解释。 第一， 插值算法公式。根据初始值，目标值，和当前时间，来计算当前属性值。 第二， 定义Tween执行状
DOTween和iTween比较
ai_little_ai的博客
09-13 9309
1、DOTween更加人性化 比如：想以恒定的速度移动到某个地方，并且要指定移动方式、移动完成时要回调函数 iTween调用方式复杂：（需要自己去拼接一个Hashtable，需要记住各种字符串） 而DOTween直接点调用就可以了（）， 可以使用链式编程 2、DOTween执行效率更高，性能好 因为iTween大量使用sendmessage消息传递机制（而sendmsg使用...
K-means聚类.py ACM比赛常用算法k-means算法
最新发布
07-14
K-means聚类.py ACM比赛常用算法k-means算法
cocos tween缓动
09-11
Cocos Tween是Cocos Creator引擎中用于实现缓动效果的工具。它可以让开发者更方便地创建和控制对象的动画效果。Cocos Tween提供了多种方法来实现缓动效果，包括使用to()方法、使用sequence()方法、以及使用...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值