We started this series by learning how to animate HTML elements using mojs. In the second tutorial, we moved on to animation of built-in SVG shapes using the Shape module. The third tutorial covered more ways of animating SVG shapes using the ShapeSwirl and stagger modules.
Now, we will learn how to animate different SVG shapes in a burst formation using the Burst module. This tutorial will depend on concepts we covered in the previous three tutorials. If you have not already read them, I would suggest that you go through them first.
Creating Basic Burst Animations
The first thing that we need to do before we can create any burst animations is instantiate a Burst object. After that, we can just specify the values of different properties to control how the animation plays out. The names of a lot of properties in the Burst module are the same as the properties in the Shape module. However, these properties perform very different tasks in this case.
The left and right properties determine the initial position of the burst instead of particles inside it. Similarly, the x and y properties determine the shift of the whole burst instead of individual particles.
The radius of the circle formed by all the burst particles is controlled by the radius property. This is very different from the radius property of individual shapes, which determines the size of those shapes. In the case of a burst, the radius determines how much further apart the individual shapes in it are going to be.
The number of shapes or particles in a single burst can be specified using the count property. By default, there will be five particles in each burst that you create. All these particles are evenly spaced over the circumference of the burst. For example, if there are four particles, they will be placed at 90 degrees to each other. If there are three particles, they will be placed at 120 degrees.
If you don’t want the burst particles to cover the whole 360 degrees, you can specify the portion that should be covered using the degree property. Any value above 0 is valid for this property. The specified number of degrees will be evenly distributed between all the particles. If the degree value is over 360, the shapes might overlap.
The angle specified using the angle property determines the angle of the whole burst. In this case, individual particles are not rotated around their own center but around the center of the burst. This is similar to how the earth revolves around the sun, which is different from the rotation of the earth on its own axis.
The scale property scales the value of all physical properties of the burst and in turn individual shapes. Just like other burst properties, all shapes in it would be scaled at once. Setting the burst scale to 3 will increase the radius of the whole burst as well as the size of individual shapes by 3.
In the following code snippet, we are creating five different bursts using the properties we just discussed.
var burstA = new mojs.Burst({
count: 20
});
var burstB = new mojs.Burst({
angle: {
0: 360
},
scale: {
1: 2
},
radius: 10
});
var burstC = new mojs.Burst({
angle: {
0: 360
},
scale: {
1: 2
},
radius: {
10: 100
}
});
var burstD = new mojs.Burst({
degree: 180,
radiusX: 10,
angle: -90,
scale: {
1: 2
},
radius: {
10: 100
}
});
var burstE = new mojs.Burst({
count: 20,
degree: 3600
});
You can see that burstA and burstE only differ in the number of degrees that they have to cover. Since the particles in burstA have to cover 360 degrees (the default value), they are placed 360/20 = 18 degrees apart. On the other hand, the particles in burstE are placed 3600/20 = 180 degrees apart. Starting from zero, the first particle is placed at 0 degrees, and the next is placed at 180 degrees.
The third particle is then placed at 360 degrees, which is basically equal to 0 degrees. The fourth particle is then placed at 540 degrees, but that is basically equal to 180 degrees. In other words, all the odd numbered particles are placed at 0 degrees, and all the even number particles are placed at 180 degrees. In the end, you only see two particles because all others overlap with the first two.
It is important to remember that you cannot directly control the duration, delay or easing function of the burst animations. The module determines all these values automatically based on the values of different children being animated.
Manipulating Individual Burst Particles
So far in this tutorial, all the particles in a burst had the same animation applied to them. Their angle, scale, radius, and position all changed by the same value. Moreover, we were not able to control the duration and delay of either the individual particles or the burst as a whole. The mojs Burst module does not have a set of properties which can directly change all these values. However, we can specify the animation value for individual particles, which in turn affects the burst animation.
All the particles in a burst animation are considered to be children of the original Burst object. Therefore, mojs allows us to control the animation of individual burst particles using a children property, which accepts an object as its value. You can use all the ShapeSwirl properties except x and y inside the children object. This makes sense because the individual particles in a burst animation have to appear at certain positions, and allowing us to randomly change the position of individual particles will change the configuration.
Any children property values that you don’t specify will be set to the default provided by the ShapeSwirl module. In the following example, we are animating 20 different lines of our burst animation. This time, the angle property has been set on individual particles instead of the Burst object so that only the lines rotate around their center instead of the whole object. As we learned in the previous tutorial, all the ShapeSwirl objects scale down from 1 to 0 by default. That’s why the lengths of the lines change from 40 to 0 in the animation.
var burstA = new mojs.Burst({
count: 20,
children: {
shape: 'line',
stroke: 'black',
radius: 20,
angle: {
0: 180
}
}
});
As I mentioned earlier, we can animate all the ShapeSwirl properties inside the burst animations. Each child in the animation can have its own set of properties. If only one value is provided, it will be applied on all the child particles. If the values are provided as an array, they will be applied sequentially, one particle at a time.
Here is the JavaScript code to create five different burst animations using all the concepts we have learned so far.
var burstA = new mojs.Burst({
count: 20,
angle: {
0: 180
},
radius: {
0: 100
},
children: {
shape: "polygon",
stroke: "black",
radius: 20,
angle: {
0: 360
},
duration: 4000
}
});
var burstB = new mojs.Burst({
count: 20,
angle: {
0: 180
},
radius: {
0: 100
},
children: {
shape: "polygon",
fill: ["yellow", "cyan", "orange"],
stroke: "black",
radius: 20,
scale: {
1: 2
},
duration: 2000
},
isShowEnd: false
});
var burstC = new mojs.Burst({
count: 20,
angle: {
0: -180
},
radius: {
0: 100
},
children: {
shape: "circle",
fill: ["red", "black", "blue"],
radius: {
10: "stagger(5, 1)"
}
}
});
var burstD = new mojs.Burst({
count: 6,
radius: {
0: 100
},
children: {
shape: "circle",
fill: ["red", "yellow", "blue"],
scale: {
1: "rand(1, 10)"
}
},
isShowEnd: false
});
var burstE = new mojs.Burst({
count: 6,
radius: {
0: 100
},
children: {
shape: "circle",
fill: ["red", "yellow", "blue"],
stroke: "black",
scale: {
1: "rand(1, 10)"
}
}
}).then({
angle: {
0: 360
},
radius: {
100: 0
},
scale: {
1: 0
}
});
In the first burst animation, the angle applied directly on the Burst object rotates the whole group around the center of the burst object. However, the angle applied inside the children property rotates all the triangles around their own centers. We also slowed down the burst animation by changing the animation duration for all the children to 4000ms.
In the second burst animation, the color of all the triangles is taken from the array passed to the fill property. We have specified only three fill colors, but the total number of triangles is 20. In such cases, mojs keeps cycling through the array elements and fills the triangles with the same three colors again and again.
In the fourth animation, we use rand strings, which we learned about in the previous tutorial, to randomly choose a scale value for all the child particles. We also set the value of isShowEnd property to false in order to hide the particles at the end of the animation.
In the fifth animation, we use the then() method from the Shape module tutorial to play another animation sequence after the first one finishes.
Final Thoughts
The aim of this series was to get you acquainted with the basics of the mojs animation library. Each tutorial focused on a single module and how you can use the properties in that module to create basic animations.
This last tutorial used the concepts from the previous tutorials to create slightly more complicated animations. Mojs is a very powerful animation library, and the final results you get depend on how creative you can get with all the properties, so keep experimenting.
If there is anything that you would like me to clarify in this tutorial, please let me know in the comments.
Powered by WPeMatico
