绚丽风车loading动效分析与实现！
前两天咱们这边的头儿给我说，有个 gif 动效很不错，能够考虑用来作项目里的loading，问我能不能实现，看了下效果确实不错，也还比较有新意，复杂度也不是很是高，因此就花时间给作了，咱们先一块儿看下原gif图效果：
javascript
若是你想看 GAStudio Github主页，请戳这里；
若是你想看 GAStudio更多技术文章，请戳这里；
QQ技术交流群：277582728；
github地址: github.com/Ajian-studi…java
从效果上看，咱们须要考虑如下几个问题：git
1.叶子的随机产生；
2.叶子随着一条正余弦曲线移动；
3.叶子在移动的时候旋转，旋转方向随机，正时针或逆时针；
4.叶子遇到进度条，彷佛是融合进入；
5.叶子不能超出最左边的弧角；
7.叶子飘出时的角度不是一致，走的曲线的振幅也有差异，不然太有规律性，缺少美感；github
总的看起来，须要注意和麻烦的地方主要是以上几点，固然还有一些细节问题，好比最左边是圆弧等等；编程
那接下来咱们将效果进行分解，而后逐个击破：
整个效果来讲，咱们须要的图主要是飞动的小叶子和右边旋转的风扇，其余的部分均可以用色值进行绘制，固然咱们为了方便，就连底部框一块儿切了；canvas
先从gif 图里把飞动的小叶子和右边旋转的风扇、底部框抠出来，小叶子图以下：dom
咱们须要处理的主要有两个部分：
1.随着进度往前绘制的进度条；
2.不断飞出来的小叶片；函数
1.随着进度往前绘制的进度条:
进度条的位置根据外层传入的 progress 进行计算，能够分为图中 一、二、3 三个阶段：
post
1.当progress 较小，算出的当前距离还在弧形之内时，须要绘制如图所示 1 区域的弧形，其他部分用白色填充；
2.当 progress 算出的距离到2时，须要绘制棕色半圆弧形，其他部分用白色矩形填充；
3.当 progress 算出的距离到3 时，须要绘制棕色半圆弧形，棕色矩形，白色矩形；
4.当 progress 算出的距离到头时，须要绘制棕色半圆弧形，棕色矩形；（能够合并到3中）ui
首先根据进度条的宽度和当前进度、总进度算出当前的位置：
//mProgressWidth为进度条的宽度，根据当前进度算出进度条的位置
mCurrentProgressPosition = mProgressWidth * mProgress / TOTAL_PROGRESS;复制代码
而后按照上面的逻辑进行绘制，其中须要计算上图中的红色弧角角度，计算方法以下：
// 单边角度
int angle = (int) Math.toDegrees(Math.acos((mArcRadius - mCurrentProgressPosition)/ (float) mArcRadius));复制代码
Math.acos() －反余弦函数；
Math.toDegrees() － 弧度转化为角度，Math.toRadians 角度转化为弧度
因此圆弧的起始点为：
int startAngle = 180 - angle;复制代码
圆弧划过的角度为：
2 * angle复制代码
这一块的代码以下：
// mProgressWidth为进度条的宽度，根据当前进度算出进度条的位置
mCurrentProgressPosition = mProgressWidth * mProgress / TOTAL_PROGRESS;
// 即当前位置在图中所示1范围内
if (mCurrentProgressPosition < mArcRadius) {
Log.i(TAG, "mProgress = " + mProgress + "---mCurrentProgressPosition = "
+ mCurrentProgressPosition
+ "--mArcProgressWidth" + mArcRadius);
// 1.绘制白色ARC，绘制orange ARC
// 2.绘制白色矩形
// 1.绘制白色ARC
canvas.drawArc(mArcRectF, 90, 180, false, mWhitePaint);
// 2.绘制白色矩形
mWhiteRectF.left = mArcRightLocation;
canvas.drawRect(mWhiteRectF, mWhitePaint);
// 3.绘制棕色 ARC
// 单边角度
int angle = (int) Math.toDegrees(Math.acos((mArcRadius - mCurrentProgressPosition)
/ (float) mArcRadius));
// 起始的位置
int startAngle = 180 - angle;
// 扫过的角度
int sweepAngle = 2 * angle;
Log.i(TAG, "startAngle = " + startAngle);
canvas.drawArc(mArcRectF, startAngle, sweepAngle, false, mOrangePaint);
} else {
Log.i(TAG, "mProgress = " + mProgress + "---transfer-----mCurrentProgressPosition = "
+ mCurrentProgressPosition
+ "--mArcProgressWidth" + mArcRadius);
// 1.绘制white RECT
// 2.绘制Orange ARC
// 3.绘制orange RECT
// 1.绘制white RECT
mWhiteRectF.left = mCurrentProgressPosition;
canvas.drawRect(mWhiteRectF, mWhitePaint);
// 2.绘制Orange ARC
canvas.drawArc(mArcRectF, 90, 180, false, mOrangePaint);
// 3.绘制orange RECT
mOrangeRectF.left = mArcRightLocation;
mOrangeRectF.right = mCurrentProgressPosition;
canvas.drawRect(mOrangeRectF, mOrangePaint);
}复制代码
2.不断飞出来的小叶片:
首先根据效果状况基本肯定出 曲线函数，标准函数方程为：y = A(wx+Q)+h，其中w影响周期，A影响振幅 ，周期T＝ 2 Math.PI/w;
根据效果能够看出，周期大体为总进度长度，因此肯定w＝(float) ((float) 2 Math.PI /mProgressWidth)；
仔细观察效果，咱们能够发现，叶子飘动的过程当中振幅不是彻底一致的，产生一种错落的效果，既然如此，咱们给叶子定义一个Type，根据Type 肯定不一样的振幅；
咱们建立一个叶子对象：
private class Leaf {
// 在绘制部分的位置
float x, y;
// 控制叶子飘动的幅度
StartType type;
// 旋转角度
int rotateAngle;
// 旋转方向--0表明顺时针，1表明逆时针
int rotateDirection;
// 起始时间(ms)
long startTime;
}复制代码
类型采用枚举进行定义，其实就是用来区分不一样的振幅：
private enum StartType {
LITTLE, MIDDLE, BIG
}复制代码
建立一个LeafFactory类用于建立一个或多个叶子信息：
private class LeafFactory {
private static final int MAX_LEAFS = 6;
Random random = new Random();
// 生成一个叶子信息
public Leaf generateLeaf() {
Leaf leaf = new Leaf();
int randomType = random.nextInt(3);
// 随时类型－ 随机振幅
StartType type = StartType.MIDDLE;
switch (randomType) {
case 0:
break;
case 1:
type = StartType.LITTLE;
break;
case 2:
type = StartType.BIG;
break;
default:
break;
}
leaf.type = type;
// 随机起始的旋转角度
leaf.rotateAngle = random.nextInt(360);
// 随机旋转方向（顺时针或逆时针）
leaf.rotateDirection = random.nextInt(2);
// 为了产生交错的感受，让开始的时间有必定的随机性
mAddTime += random.nextInt((int) (LEAF_FLOAT_TIME * 1.5));
leaf.startTime = System.currentTimeMillis() + mAddTime;
return leaf;
}
// 根据最大叶子数产生叶子信息
public List<Leaf> generateLeafs() {
return generateLeafs(MAX_LEAFS);
}
// 根据传入的叶子数量产生叶子信息
public List<Leaf> generateLeafs(int leafSize) {
List<Leaf> leafs = new LinkedList<Leaf>();
for (int i = 0; i < leafSize; i++) {
leafs.add(generateLeaf());
}
return leafs;
}
}复制代码
定义两个常量分别记录中等振幅和之间的振幅差：
// 中等振幅大小
private static final int MIDDLE_AMPLITUDE = 13;
// 不一样类型之间的振幅差距
private static final int AMPLITUDE_DISPARITY = 5;
// 中等振幅大小
private int mMiddleAmplitude = MIDDLE_AMPLITUDE;
// 振幅差
private int mAmplitudeDisparity = AMPLITUDE_DISPARITY;复制代码
有了以上信息，咱们则能够获取到叶子的Y值：
// 经过叶子信息获取当前叶子的Y值
private int getLocationY(Leaf leaf) {
// y = A(wx+Q)+h
float w = (float) ((float) 2 * Math.PI / mProgressWidth);
float a = mMiddleAmplitude;
switch (leaf.type) {
case LITTLE:
// 小振幅 ＝ 中等振幅 － 振幅差
a = mMiddleAmplitude - mAmplitudeDisparity;
break;
case MIDDLE:
a = mMiddleAmplitude;
break;
case BIG:
// 小振幅 ＝ 中等振幅 + 振幅差
a = mMiddleAmplitude + mAmplitudeDisparity;
break;
default:
break;
}
Log.i(TAG, "---a = " + a + "---w = " + w + "--leaf.x = " + leaf.x);
return (int) (a * Math.sin(w * leaf.x)) + mArcRadius * 2 / 3;
}复制代码
接下来，咱们开始绘制叶子：
/** * 绘制叶子 * * @param canvas */
private void drawLeafs(Canvas canvas) {
long currentTime = System.currentTimeMillis();
for (int i = 0; i < mLeafInfos.size(); i++) {
Leaf leaf = mLeafInfos.get(i);
if (currentTime > leaf.startTime && leaf.startTime != 0) {
// 绘制叶子－－根据叶子的类型和当前时间得出叶子的（x，y）
getLeafLocation(leaf, currentTime);
// 根据时间计算旋转角度
canvas.save();
// 经过Matrix控制叶子旋转
Matrix matrix = new Matrix();
float transX = mLeftMargin + leaf.x;
float transY = mLeftMargin + leaf.y;
Log.i(TAG, "left.x = " + leaf.x + "--leaf.y=" + leaf.y);
matrix.postTranslate(transX, transY);
// 经过时间关联旋转角度，则能够直接经过修改LEAF_ROTATE_TIME调节叶子旋转快慢
float rotateFraction = ((currentTime - leaf.startTime) % LEAF_ROTATE_TIME)
/ (float) LEAF_ROTATE_TIME;
int angle = (int) (rotateFraction * 360);
// 根据叶子旋转方向肯定叶子旋转角度
int rotate = leaf.rotateDirection == 0 ? angle + leaf.rotateAngle : -angle
+ leaf.rotateAngle;
matrix.postRotate(rotate, transX
+ mLeafWidth / 2, transY + mLeafHeight / 2);
canvas.drawBitmap(mLeafBitmap, matrix, mBitmapPaint);
canvas.restore();
} else {
continue;
}
}
}复制代码
最后，向外层暴露几个接口：
/** * 设置中等振幅 * * @param amplitude */
public void setMiddleAmplitude(int amplitude) {
this.mMiddleAmplitude = amplitude;
}
/** * 设置振幅差 * * @param disparity */
public void setMplitudeDisparity(int disparity) {
this.mAmplitudeDisparity = disparity;
}
/** * 获取中等振幅 * * @param amplitude */
public int getMiddleAmplitude() {
return mMiddleAmplitude;
}
/** * 获取振幅差 * * @param disparity */
public int getMplitudeDisparity() {
return mAmplitudeDisparity;
}
/** * 设置进度 * * @param progress */
public void setProgress(int progress) {
this.mProgress = progress;
postInvalidate();
}
/** * 设置叶子飘完一个周期所花的时间 * * @param time */
public void setLeafFloatTime(long time) {
this.mLeafFloatTime = time;
}
/** * 设置叶子旋转一周所花的时间 * * @param time */
public void setLeafRotateTime(long time) {
this.mLeafRotateTime = time;复制代码
这些接口用来干吗呢？用于把咱们的动效作成彻底可手动调节的，这样作有什么好处呢？
1.更加便于产品、射鸡湿查看效果，避免YY，本身手动调节，不会出现要你一遍遍的改参数安装、查看、再改、再查看... ... N遍以后说 “这好像不是我想要的” -- 瞬间天崩地裂，天昏地暗，感受被全世界抛弃；
2.便于体现你是一个考虑全面，思惟缜密，会编程、会设计的艺术家，固然这纯属YY，主要仍是方便你们；
如此一来，射鸡湿们只须要不断的调节便可实时的看到展示的效果，最后只须要把最终的参数反馈过来便可，万事大吉，一了百了；
固然，若是对方是个漂亮的妹子，而你又苦于没有机会搭讪，以上内容就当我没说，尽情的不按要求写吧，她确定会主动找你的，说不定连饭都反过来请了... ...
最终效果以下，原本录了20+s，可是PS只能转5s，因此有兴趣的你们本身运行的玩吧：
最后，附上GAStudio技术交流群和Github，喜欢的话欢迎follow和star：
若是你想看 GAStudio Github主页，请戳这里；
若是你想看 GAStudio更多技术文章，请戳这里；
QQ技术交流群：277582728；
github地址: github.com/Ajian-studi…
- 1. 一个绚丽的loading动效分析与实现！
- 2. 一个绚丽的downloading动效分析与实现！
- 3. Android 实现绚丽多彩的TextView
- 4. 神奇的canvas——点与线绘制的绚丽动画效果
- 5. canvas--绚丽的时钟效果
- 6. 【转】Android 使用Scroller实现绚丽的ListView左右滑动删除Item效果
- 7. Android 使用Scroller实现绚丽的ListView左右滑动删除Item效果
- 8. 用jquery都弱爆了 纯css 实现焦点图的 动态绚丽效果
- 9. css实现动态风车
- 10. android：一个绚丽的注册动画
- 更多相关文章...
- • 现实生活中的 XML - XML 教程
- • Hibernate实现增删改查 - Hibernate教程
- • Spring Cloud 微服务实战(三) - 服务注册与发现
- • ☆基于Java Instrument的Agent实现
-
每一个你不满意的现在，都有一个你没有努力的曾经。