'use strict';
30 |
31 | var Action = require('./Action');
32 |
33 | /**
34 | * @class An ActionLibrary is an object of Actions.
35 | * @param data Data from Blender.
36 | */
37 | function ActionLibrary(data) {
38 | for (var actionName in data) {
39 | this[actionName] = new Action(data[actionName]);
40 | }
41 | }
42 |
43 | module.exports = ActionLibrary;
44 | 'use strict';
30 |
31 | /**
32 | * @class A Marker is a generic information in time.
33 | * @param data Data from Blender
34 | */
35 | function Marker(data) {
36 | /**
37 | * Time.
38 | * @member {number}
39 | */
40 | this.time = data[0];
41 |
42 | /**
43 | * Name.
44 | * @member {string}
45 | */
46 | this.name = data[1];
47 | }
48 |
49 | module.exports = Marker;
50 | 'use strict';
30 |
31 | // GRAPH_OT_easing_type
32 |
33 | /**
34 | * FCurve easing types.
35 | * @enum {number}
36 | * @readonly
37 | */
38 | var Easing = {
39 | /** Automatic easing. */
40 | AUTO: 0,
41 | /** Starts slow. */
42 | IN: 1,
43 | /** Ends slow. */
44 | OUT: 2,
45 | /** Starts and ends slow. */
46 | IN_OUT: 3,
47 | };
48 |
49 | module.exports = Easing;
50 | 'use strict';
30 |
31 | // GRAPH_OT_extrapolation_type
32 |
33 | /**
34 | * FCurve extrapolation types, before its first keyframe and after its last keyframe.
35 | * @enum {number}
36 | * @readonly
37 | */
38 | var Extrapolation = {
39 | /** Keeps a constant value. */
40 | CONSTANT: 0,
41 | /** Continues as straight lines. */
42 | LINEAR: 1,
43 | };
44 |
45 | module.exports = Extrapolation;
46 | 'use strict';
30 |
31 | // POSE_OT_rotation_mode_set
32 |
33 | /**
34 | * Object rotation modes.
35 | * @enum {number}
36 | * @readonly
37 | */
38 | var RotationMode = {
39 | /** Reads from rotation_quaternion and delta_rotation_quaternion paths. */
40 | QUATERNION: 0,
41 | /** Reads from rotation_euler and delta_rotation_euler paths. */
42 | EULER_XYZ: 1,
43 | /** Reads from rotation_euler and delta_rotation_euler paths. */
44 | EULER_YXZ: 3,
45 | /** Reads from rotation_euler and delta_rotation_euler paths. */
46 | EULER_XZY: 2,
47 | /** Reads from rotation_euler and delta_rotation_euler paths. */
48 | EULER_ZXY: 5,
49 | /** Reads from rotation_euler and delta_rotation_euler paths. */
50 | EULER_YZX: 4,
51 | /** Reads from rotation_euler and delta_rotation_euler paths. */
52 | EULER_ZYX: 6,
53 | /** Reads from rotation_axis path. */
54 | AXIS_ANGLE: -1,
55 | };
56 |
57 | module.exports = RotationMode;
58 | 'use strict';
30 |
31 | // GRAPH_OT_interpolation_type
32 |
33 | /**
34 | * FCurve interpolation types, between two keyframes.
35 | * @enum {number}
36 | * @readonly
37 | */
38 | var Interpolation = {
39 | /** No interpolation, value gets held. */
40 | CONSTANT: 0,
41 | /** Straight-line interpolation. */
42 | LINEAR: 1,
43 | /** Smooth interpolation. */
44 | BEZIER: 2,
45 | /** Cubic easing with overshoot and settle. */
46 | BACK: 3,
47 | /** Exponentially decaying parabolic bounce. */
48 | BOUNCE: 4,
49 | /** Circular easing. */
50 | CIRCULAR: 5,
51 | /** Cubic easing. */
52 | CUBIC: 6,
53 | /** Exponentially decaying sine wave. */
54 | ELASTIC: 7,
55 | /** Exponential easing. */
56 | EXPONENTIAL: 8,
57 | /** Quadratic easing. */
58 | QUADRATIC: 9,
59 | /** Quartic easing. */
60 | QUARTIC: 10,
61 | /** Quintic easing. */
62 | QUINTIC: 11,
63 | /** Sinusoidal easing. */
64 | SINUSOIDAL: 12,
65 | };
66 |
67 | module.exports = Interpolation;
68 | 'use strict';
30 |
31 | var FCurve = require('./FCurve');
32 | /**
33 | * Provides a value when a FCurve does not exist.
34 | * @callback FCurveArray~DefaultValues
35 | * @param {number} index Array index
36 | * @param {number} time Evaluation time
37 | * @return {number} Value
38 | */
39 |
40 | /**
41 | * @class A FCurveArray is an array of FCurves.
42 | * @param data Data from Blender.
43 | */
44 | function FCurveArray(data) {
45 | var array = data.map(function(data) {
46 | return data && new FCurve(data);
47 | });
48 |
49 | /**
50 | * Evaluates the array.
51 | * @method FCurveArray~evaluate
52 | * @param {number} time Evaluation time.
53 | * @param {FCurveArray~DefaultValues} defaultValues In case a FCurve does not exist.
54 | * @return {number[]}
55 | */
56 | array.evaluate = function(time, defaultValues) {
57 | return array.map(function(fcurve, index) {
58 | return fcurve ? fcurve.evaluate(time) : defaultValues(index, time);
59 | });
60 | };
61 |
62 | return array;
63 | }
64 |
65 | /**
66 | * Built-in DefaultValues functions.
67 | * @enum {FCurveArray~DefaultValues}
68 | * @readonly
69 | */
70 | FCurveArray.DefaultValues = {
71 | /** Returns 0. */
72 | LOCATION: function() {
73 | return 0;
74 | },
75 | /** Returns 0. */
76 | ROTATION: function() {
77 | return 0;
78 | },
79 | /** Returns 0 for XYZ and 1 for W. */
80 | ROTATION_QUATERNION: function(index) {
81 | return (index === 3 ? 1 : 0);
82 | },
83 | /** Returns 1. */
84 | SCALE: function() {
85 | return 1;
86 | },
87 | };
88 |
89 | module.exports = FCurveArray;
90 | Use animation curves from Blender.
47 |The entry point is the class ActionLibrary. Create an ActionLibrary with the data exported from Blender, and enjoy.
48 |The library relies on glMatrix for math computations.
49 |Copy blender-html5-animations.min.js from the dist folder.
50 |Copy gl-matrix-min.js from glMatrix's dist folder.
51 |<script src="exported-data.js"></script>
52 | <script src="gl-matrix-min.js"></script>
53 | <script src="blender-html5-animations.min.js"></script>
54 | <script>
55 | var myActionLibrary = new blenderHTML5Animations.ActionLibrary(exportedData);
56 |
57 | var value = myActionLibrary['my-action'].paths['location'].evaluate(time, blenderHTML5Animations.FCurveArray.DefaultValues.LOCATION);
58 | </script>npm install --save blender-html5-animationsvar exportedData = require('./exported-data.json');
59 | var blenderHTML5Animations = require('blender-html5-animations');
60 |
61 | var myActionLibrary = new blenderHTML5Animations.ActionLibrary(exportedData);
62 |
63 | var value = myActionLibrary['my-action'].paths['location'].evaluate(time, blenderHTML5Animations.FCurveArray.DefaultValues.LOCATION);Copyright 2016 Jonathan Giroux
64 || Name | 69 | 70 | 71 |Type | 72 | 73 | 74 | 75 | 76 | 77 |Description | 78 |
|---|---|---|
data |
87 |
88 |
89 | 90 | 91 | | 92 | 93 | 94 | 95 | 96 | 97 |Data from Blender. | 98 |
'use strict';
30 |
31 | /**
32 | * @class A Keyframe is a value in time with control handles.
33 | * @param data Data from Blender.
34 | */
35 | function Keyframe(data) {
36 | /**
37 | * Time.
38 | * @member {number}
39 | */
40 | this.time = data[0];
41 |
42 | /**
43 | * Value.
44 | * @member {number}
45 | */
46 | this.value = data[1];
47 |
48 | /**
49 | * Left handle's time.
50 | * @member {number}
51 | */
52 | this.leftTime = data[2];
53 |
54 | /**
55 | * Left handle's value.
56 | * @member {number}
57 | */
58 | this.leftValue = data[3];
59 |
60 | /**
61 | * Right handle's time.
62 | * @member {number}
63 | */
64 | this.rightTime = data[4];
65 |
66 | /**
67 | * Right handle's value.
68 | * @member {number}
69 | */
70 | this.rightValue = data[5];
71 |
72 | /**
73 | * Interpolation type.
74 | * @member {Keyframe.Interpolation}
75 | */
76 | this.interpolation = data[6];
77 |
78 | /**
79 | * Easing type.
80 | * @member {Keyframe.Easing}
81 | */
82 | this.easing = data[7];
83 |
84 | /**
85 | * Overshoot (for back interpolation).
86 | * @member {number}
87 | */
88 | this.overshoot = data[8];
89 |
90 | /**
91 | * Amplitude (for elastic interpolation).
92 | * @member {number}
93 | */
94 | this.amplitude = data[8];
95 |
96 | /**
97 | * Period (for elastic interpolation).
98 | * @member {number}
99 | */
100 | this.period = data[9];
101 | }
102 |
103 | // GRAPH_OT_easing_type
104 |
105 | /**
106 | * FCurve easing types.
107 | * @enum {number}
108 | * @readonly
109 | */
110 | Keyframe.Easing = {
111 | /** Automatic easing. */
112 | AUTO: 0,
113 | /** Starts slow. */
114 | IN: 1,
115 | /** Ends slow. */
116 | OUT: 2,
117 | /** Starts and ends slow. */
118 | IN_OUT: 3,
119 | };
120 |
121 | // GRAPH_OT_interpolation_type
122 |
123 | /**
124 | * FCurve interpolation types, between two keyframes.
125 | * @enum {number}
126 | * @readonly
127 | */
128 | Keyframe.Interpolation = {
129 | /** No interpolation, value gets held. */
130 | CONSTANT: 0,
131 | /** Straight-line interpolation. */
132 | LINEAR: 1,
133 | /** Smooth interpolation. */
134 | BEZIER: 2,
135 | /** Cubic easing with overshoot and settle. */
136 | BACK: 3,
137 | /** Exponentially decaying parabolic bounce. */
138 | BOUNCE: 4,
139 | /** Circular easing. */
140 | CIRCULAR: 5,
141 | /** Cubic easing. */
142 | CUBIC: 6,
143 | /** Exponentially decaying sine wave. */
144 | ELASTIC: 7,
145 | /** Exponential easing. */
146 | EXPONENTIAL: 8,
147 | /** Quadratic easing. */
148 | QUADRATIC: 9,
149 | /** Quartic easing. */
150 | QUARTIC: 10,
151 | /** Quintic easing. */
152 | QUINTIC: 11,
153 | /** Sinusoidal easing. */
154 | SINUSOIDAL: 12,
155 | };
156 |
157 | module.exports = Keyframe;
158 | | Name | 69 | 70 | 71 |Type | 72 | 73 | 74 | 75 | 76 | 77 |Description | 78 |
|---|---|---|
data |
87 |
88 |
89 | 90 | 91 | | 92 | 93 | 94 | 95 | 96 | 97 |Data from Blender | 98 |
'use strict';
30 |
31 | var glMatrixLib = require('gl-matrix');
32 |
33 | var glMatrix = glMatrixLib.glMatrix;
34 | var mat4 = glMatrixLib.mat4;
35 | var vec3 = glMatrixLib.vec3;
36 |
37 | var FCurveArray = require('./FCurveArray');
38 | var Marker = require('./Marker');
39 |
40 | /**
41 | * @class An Action describes a keyframed animation.
42 | * @param data Data from Blender.
43 | */
44 | function Action(data) {
45 | var self = this;
46 |
47 | /**
48 | * Time of the first keyframe.
49 | * @member {number}
50 | */
51 | this.startTime = +Infinity;
52 | /**
53 | * Time of the last keyframe.
54 | * @member {number}
55 | */
56 | this.endTime = -Infinity;
57 |
58 | function timeUpdater(fcurve) {
59 | if (fcurve) {
60 | self.startTime = Math.min(self.startTime, fcurve.keyframes[0].time);
61 | self.endTime = Math.max(self.endTime, fcurve.keyframes[fcurve.keyframes.length - 1].time);
62 | }
63 | }
64 |
65 | /**
66 | * FCurves grouped by data path.
67 | * @member {FCurveArray[]}
68 | */
69 | this.paths = {};
70 | for (var groupName in data[0]) {
71 | var path = new FCurveArray(data[0][groupName]);
72 | this.paths[groupName] = path;
73 |
74 | path.forEach(timeUpdater);
75 | }
76 |
77 | /**
78 | * Pose markers.
79 | * @member {Marker[]}
80 | */
81 | this.markers = data.length > 1 ? data[1].map(function(data) {
82 | return new Marker(data);
83 | }) : [];
84 | }
85 |
86 | // POSE_OT_rotation_mode_set
87 |
88 | /**
89 | * Object rotation modes.
90 | * @enum {number}
91 | * @readonly
92 | */
93 | Action.RotationMode = {
94 | /** Reads from rotation_quaternion and delta_rotation_quaternion paths. */
95 | QUATERNION: 0,
96 | /** Reads from rotation_euler and delta_rotation_euler paths. */
97 | EULER_XYZ: 1,
98 | /** Reads from rotation_euler and delta_rotation_euler paths. */
99 | EULER_YXZ: 3,
100 | /** Reads from rotation_euler and delta_rotation_euler paths. */
101 | EULER_XZY: 2,
102 | /** Reads from rotation_euler and delta_rotation_euler paths. */
103 | EULER_ZXY: 5,
104 | /** Reads from rotation_euler and delta_rotation_euler paths. */
105 | EULER_YZX: 4,
106 | /** Reads from rotation_euler and delta_rotation_euler paths. */
107 | EULER_ZYX: 6,
108 | /** Reads from rotation_axis path. */
109 | AXIS_ANGLE: -1,
110 | };
111 |
112 | /**
113 | * Calls a function for each marker in a time range.
114 | * @param {number} startTime Included start time
115 | * @param {number} endTime Excluded end time
116 | * @param {function} callback Callback
117 | */
118 | Action.prototype.forEachMarker = function(startTime, endTime, callback) {
119 | return this.markers.forEach(function(marker, index) {
120 | if (marker.time >= startTime && marker.time < endTime)
121 | return callback(marker, index);
122 | });
123 | };
124 |
125 | var qmat = new glMatrix.ARRAY_TYPE(16);
126 |
127 | /**
128 | * Computes the local to world matrix.
129 | * @param {mat4} out Receiving matrix
130 | * @param {number} time Evaluation time
131 | * @param {Action.RotationMode} rotationMode Rotation mode
132 | */
133 | Action.prototype.toWorld = function(out, time, rotationMode) {
134 | mat4.identity(out);
135 |
136 | var paths = this.paths;
137 | var angles;
138 |
139 | function computeEulerAngles() {
140 | angles = vec3.fromValues(0, 0, 0);
141 | [paths.rotation_euler, paths.delta_rotation_euler].forEach(function(path) {
142 | if (path)
143 | vec3.add(angles, angles, path.evaluate(time, FCurveArray.DefaultValues.ROTATION));
144 | });
145 | }
146 |
147 | var location = vec3.fromValues(0, 0, 0);
148 | [paths.location, paths.delta_location].forEach(function(path) {
149 | if (path)
150 | vec3.add(location, location, path.evaluate(time, FCurveArray.DefaultValues.LOCATION));
151 | });
152 | mat4.translate(out, out, location);
153 |
154 | switch (rotationMode) {
155 | case Action.RotationMode.QUATERNION:
156 | [paths.rotation_quaternion, paths.delta_rotation_quaternion].forEach(function(path) {
157 | if (path) {
158 | mat4.fromQuat(qmat, path.evaluate(time, FCurveArray.DefaultValues.ROTATION_QUATERNION));
159 | mat4.multiply(out, out, qmat);
160 | }
161 | });
162 | break;
163 |
164 | case Action.RotationMode.EULER_XYZ:
165 | computeEulerAngles();
166 | mat4.rotateZ(out, out, angles[2]);
167 | mat4.rotateY(out, out, angles[1]);
168 | mat4.rotateX(out, out, angles[0]);
169 | break;
170 |
171 | case Action.RotationMode.EULER_XZY:
172 | computeEulerAngles();
173 | mat4.rotateY(out, out, angles[1]);
174 | mat4.rotateZ(out, out, angles[2]);
175 | mat4.rotateX(out, out, angles[0]);
176 | break;
177 |
178 | case Action.RotationMode.EULER_YXZ:
179 | computeEulerAngles();
180 | mat4.rotateZ(out, out, angles[2]);
181 | mat4.rotateX(out, out, angles[0]);
182 | mat4.rotateY(out, out, angles[1]);
183 | break;
184 |
185 | case Action.RotationMode.EULER_YZX:
186 | computeEulerAngles();
187 | mat4.rotateX(out, out, angles[0]);
188 | mat4.rotateZ(out, out, angles[2]);
189 | mat4.rotateY(out, out, angles[1]);
190 | break;
191 |
192 | case Action.RotationMode.EULER_ZXY:
193 | computeEulerAngles();
194 | mat4.rotateY(out, out, angles[1]);
195 | mat4.rotateX(out, out, angles[0]);
196 | mat4.rotateZ(out, out, angles[2]);
197 | break;
198 |
199 | case Action.RotationMode.EULER_ZYX:
200 | computeEulerAngles();
201 | mat4.rotateX(out, out, angles[0]);
202 | mat4.rotateY(out, out, angles[1]);
203 | mat4.rotateZ(out, out, angles[2]);
204 | break;
205 |
206 | case Action.RotationMode.AXIS_ANGLE:
207 | // no delta
208 | if (paths.rotation_axis) {
209 | var vec = paths.rotation_axis.evaluate(time, FCurveArray.DefaultValues.ROTATION);
210 | mat4.rotate(out, out, vec[3], vec);
211 | }
212 | break;
213 | }
214 |
215 | var scale = vec3.fromValues(1, 1, 1);
216 | [paths.scale, paths.delta_scale].forEach(function(path) {
217 | if (path)
218 | vec3.multiply(scale, scale, path.evaluate(time, FCurveArray.DefaultValues.SCALE));
219 | });
220 | mat4.scale(out, out, scale);
221 |
222 | return out;
223 | };
224 |
225 | /**
226 | * Computes the world to local matrix.
227 | * @param {mat4} out Receiving matrix
228 | * @param {number} time Evaluation time
229 | * @param {Action.RotationMode} rotationMode Rotation mode
230 | */
231 | Action.prototype.toLocal = function(out, time, rotationMode) {
232 | this.toWorld(out, time, rotationMode);
233 | mat4.invert(out, out);
234 | return out;
235 | };
236 |
237 | /**
238 | * Applies a CSS3 Transform.
239 | * @param {element} element Receiving element
240 | * @param {number} time Evaluation time
241 | * @param {Action.RotationMode} rotationMode Rotation mode
242 | */
243 | Action.prototype.setElementTransform = function(element, time, rotationMode) {
244 | var mat = new glMatrix.ARRAY_TYPE(16);
245 | this.toWorld(mat, time, rotationMode);
246 |
247 | var transform = 'matrix3d(' + mat.join(',') + ')';
248 |
249 | ['transform', 'mozTransform', 'oTransform', 'webkitTransform'].forEach(function(property) {
250 | element.style[property] = transform;
251 | });
252 | };
253 |
254 | module.exports = Action;
255 | 'use strict';
30 |
31 | var bezier = require('./bezier');
32 | var easing = require('./easing');
33 | var Keyframe = require('./Keyframe');
34 |
35 | /**
36 | * @class A FCurveArray is an array of FCurves.
37 | * @param data Data from Blender.
38 | */
39 | function FCurve(data) {
40 | /**
41 | * Keyframes.
42 | * @member {Keyframe[]}
43 | */
44 | this.keyframes = data[0].map(function(data) {
45 | return new Keyframe(data);
46 | });
47 |
48 | /**
49 | * Extrapolation type.
50 | * @member {FCurve.Extrapolation}
51 | */
52 | this.extrapolation = data[1];
53 | }
54 |
55 | // GRAPH_OT_extrapolation_type
56 |
57 | /**
58 | * FCurve extrapolation types, before its first keyframe and after its last keyframe.
59 | * @enum {number}
60 | * @readonly
61 | */
62 | FCurve.Extrapolation = {
63 | /** Keeps a constant value. */
64 | CONSTANT: 0,
65 | /** Continues as straight lines. */
66 | LINEAR: 1,
67 | };
68 |
69 | /**
70 | * When evaluation time differs less than epsilon from a keyframe, snaps to that keyframe.
71 | * @type {number}
72 | */
73 | FCurve.evaluationTimeEpsilon = 0.0001;
74 |
75 | function areTimesAlmostEqual(t1, t2) {
76 | return Math.abs(t1 - t2) <= FCurve.evaluationTimeEpsilon;
77 | }
78 |
79 | /**
80 | * Evaluates the curve.
81 | * @param {number} time Evaluation time.
82 | * @return {number} Value.
83 | */
84 | FCurve.prototype.evaluate = function(time) {
85 | var leftIndex = 0;
86 | var leftKeyframe = this.keyframes[leftIndex];
87 |
88 | if (areTimesAlmostEqual(time, leftKeyframe.time))
89 | {
90 | return leftKeyframe.value;
91 | }
92 |
93 | if (time <= leftKeyframe.time) {
94 | switch (this.extrapolation) {
95 | case FCurve.Extrapolation.LINEAR:
96 | return leftKeyframe.value + (leftKeyframe.leftValue - leftKeyframe.value) * (time - leftKeyframe.time) / (leftKeyframe.leftTime - leftKeyframe.time);
97 | default:
98 | return leftKeyframe.value;
99 | }
100 | }
101 |
102 | var rightIndex = this.keyframes.length - 1;
103 | var rightKeyframe = this.keyframes[rightIndex];
104 |
105 | if (areTimesAlmostEqual(time, rightKeyframe.time))
106 | {
107 | return rightKeyframe.value;
108 | }
109 |
110 | if (time >= rightKeyframe.time) {
111 | switch (this.extrapolation) {
112 | case FCurve.Extrapolation.LINEAR:
113 | return rightKeyframe.value + (rightKeyframe.rightValue - rightKeyframe.value) * (time - rightKeyframe.time) / (rightKeyframe.rightTime - rightKeyframe.time);
114 | default:
115 | return rightKeyframe.value;
116 | }
117 | }
118 |
119 | while (rightIndex - leftIndex > 1) {
120 | var index = ((leftIndex + rightIndex) / 2) | 0;
121 | if (this.keyframes[index].time >= time)
122 | rightIndex = index;
123 | else
124 | leftIndex = index;
125 | }
126 |
127 | leftKeyframe = this.keyframes[leftIndex];
128 | if (areTimesAlmostEqual(time, leftKeyframe.time))
129 | {
130 | return leftKeyframe.value;
131 | }
132 |
133 | rightKeyframe = this.keyframes[rightIndex];
134 | if (areTimesAlmostEqual(time, rightKeyframe.time))
135 | {
136 | return rightKeyframe.value;
137 | }
138 |
139 | var relTime = time - leftKeyframe.time;
140 | var begin = leftKeyframe.value;
141 | var duration = rightKeyframe.time - leftKeyframe.time;
142 | var change = rightKeyframe.value - leftKeyframe.value;
143 |
144 | switch (leftKeyframe.interpolation) {
145 | case Keyframe.Interpolation.BACK:
146 | switch (leftKeyframe.easing) {
147 | case Keyframe.Easing.IN:
148 | return easing.backEaseIn(relTime, begin, change, duration, leftKeyframe.overshoot);
149 | case Keyframe.Easing.IN_OUT:
150 | return easing.backEaseInOut(relTime, begin, change, duration, leftKeyframe.overshoot);
151 | default:
152 | return easing.backEaseOut(relTime, begin, change, duration, leftKeyframe.overshoot);
153 | }
154 | break;
155 |
156 | case Keyframe.Interpolation.BEZIER:
157 | return bezier(time, leftKeyframe, rightKeyframe);
158 |
159 | case Keyframe.Interpolation.BOUNCE:
160 | switch (leftKeyframe.easing) {
161 | case Keyframe.Easing.IN:
162 | return easing.bounceEaseIn(relTime, begin, change, duration);
163 | case Keyframe.Easing.IN_OUT:
164 | return easing.bounceEaseInOut(relTime, begin, change, duration);
165 | default:
166 | return easing.bounceEaseOut(relTime, begin, change, duration);
167 | }
168 | break;
169 |
170 | case Keyframe.Interpolation.CIRCULAR:
171 | switch (leftKeyframe.easing) {
172 | case Keyframe.Easing.OUT:
173 | return easing.circularEaseOut(relTime, begin, change, duration);
174 | case Keyframe.Easing.IN_OUT:
175 | return easing.circularEaseInOut(relTime, begin, change, duration);
176 | default:
177 | return easing.circularEaseIn(relTime, begin, change, duration);
178 | }
179 | break;
180 |
181 | case Keyframe.Interpolation.CUBIC:
182 | switch (leftKeyframe.easing) {
183 | case Keyframe.Easing.OUT:
184 | return easing.cubicEaseOut(relTime, begin, change, duration);
185 | case Keyframe.Easing.IN_OUT:
186 | return easing.cubicEaseInOut(relTime, begin, change, duration);
187 | default:
188 | return easing.cubicEaseIn(relTime, begin, change, duration);
189 | }
190 | break;
191 |
192 | case Keyframe.Interpolation.ELASTIC:
193 | switch (leftKeyframe.easing) {
194 | case Keyframe.Easing.IN:
195 | return easing.elasticEaseIn(relTime, begin, change, duration);
196 | case Keyframe.Easing.IN_OUT:
197 | return easing.elasticEaseInOut(relTime, begin, change, duration);
198 | default:
199 | return easing.elasticEaseOut(relTime, begin, change, duration, leftKeyframe.amplitude, leftKeyframe.period);
200 | }
201 | break;
202 |
203 | case Keyframe.Interpolation.EXPONENTIAL:
204 | switch (leftKeyframe.easing) {
205 | case Keyframe.Easing.OUT:
206 | return easing.exponentialEaseOut(relTime, begin, change, duration);
207 | case Keyframe.Keyframe.Easing.IN_OUT:
208 | return easing.exponentialEaseInOut(relTime, begin, change, duration);
209 | default:
210 | return easing.exponentialEaseIn(relTime, begin, change, duration);
211 | }
212 | break;
213 |
214 | case Keyframe.Interpolation.LINEAR:
215 | return easing.linear(relTime, begin, change, duration);
216 |
217 | case Keyframe.Interpolation.QUADRATIC:
218 | switch (leftKeyframe.easing) {
219 | case Keyframe.Easing.OUT:
220 | return easing.quadraticEaseOut(relTime, begin, change, duration);
221 | case Keyframe.Easing.IN_OUT:
222 | return easing.quadraticEaseInOut(relTime, begin, change, duration);
223 | default:
224 | return easing.quadraticEaseIn(relTime, begin, change, duration);
225 | }
226 | break;
227 |
228 | case Keyframe.Interpolation.QUARTIC:
229 | switch (leftKeyframe.easing) {
230 | case Keyframe.Easing.OUT:
231 | return easing.quarticEaseOut(relTime, begin, change, duration);
232 | case Keyframe.Easing.IN_OUT:
233 | return easing.quarticEaseInOut(relTime, begin, change, duration);
234 | default:
235 | return easing.quarticEaseIn(relTime, begin, change, duration);
236 | }
237 | break;
238 |
239 | case Keyframe.Interpolation.QUINTIC:
240 | switch (leftKeyframe.easing) {
241 | case Keyframe.Easing.OUT:
242 | return easing.quinticEaseOut(relTime, begin, change, duration);
243 | case Keyframe.Easing.IN_OUT:
244 | return easing.quinticEaseInOut(relTime, begin, change, duration);
245 | default:
246 | return easing.quinticEaseIn(relTime, begin, change, duration);
247 | }
248 | break;
249 |
250 | case Keyframe.Interpolation.SINUSOIDAL:
251 | switch (leftKeyframe.easing) {
252 | case Keyframe.Easing.OUT:
253 | return easing.sinusoidalEaseOut(relTime, begin, change, duration);
254 | case Keyframe.Easing.IN_OUT:
255 | return easing.sinusoidalEaseInOut(relTime, begin, change, duration);
256 | default:
257 | return easing.sinusoidalEaseIn(relTime, begin, change, duration);
258 | }
259 | break;
260 |
261 | default:
262 | return begin;
263 | }
264 | };
265 |
266 | module.exports = FCurve;
267 | | Name | 69 | 70 | 71 |Type | 72 | 73 | 74 | 75 | 76 | 77 |Description | 78 |
|---|---|---|
data |
87 |
88 |
89 | 90 | 91 | | 92 | 93 | 94 | 95 | 96 | 97 |Data from Blender. | 98 |
| Name | 288 | 289 | 290 |Type | 291 | 292 | 293 | 294 | 295 | 296 |Description | 297 |
|---|---|---|
CONSTANT |
306 |
307 |
308 | 309 | 310 | 311 | number 312 | 313 | 314 | 315 | | 316 | 317 | 318 | 319 | 320 | 321 |Keeps a constant value. | 322 |
LINEAR |
329 |
330 |
331 | 332 | 333 | 334 | number 335 | 336 | 337 | 338 | | 339 | 340 | 341 | 342 | 343 | 344 |Continues as straight lines. | 345 |
| Name | 580 | 581 | 582 |Type | 583 | 584 | 585 | 586 | 587 | 588 |Description | 589 |
|---|---|---|
time |
598 |
599 |
600 | 601 | 602 | 603 | number 604 | 605 | 606 | 607 | | 608 | 609 | 610 | 611 | 612 | 613 |Evaluation time. | 614 |
| Name | 69 | 70 | 71 |Type | 72 | 73 | 74 | 75 | 76 | 77 |Description | 78 |
|---|---|---|
data |
87 |
88 |
89 | 90 | 91 | | 92 | 93 | 94 | 95 | 96 | 97 |Data from Blender. | 98 |
| Name | 216 | 217 | 218 |Type | 219 | 220 | 221 | 222 | 223 | 224 |Description | 225 |
|---|---|---|
LOCATION |
234 |
235 |
236 | 237 | 238 | 239 | FCurveArray~DefaultValues 240 | 241 | 242 | 243 | | 244 | 245 | 246 | 247 | 248 | 249 |Returns 0. | 250 |
ROTATION |
257 |
258 |
259 | 260 | 261 | 262 | FCurveArray~DefaultValues 263 | 264 | 265 | 266 | | 267 | 268 | 269 | 270 | 271 | 272 |Returns 0. | 273 |
ROTATION_QUATERNION |
280 |
281 |
282 | 283 | 284 | 285 | FCurveArray~DefaultValues 286 | 287 | 288 | 289 | | 290 | 291 | 292 | 293 | 294 | 295 |Returns 0 for XYZ and 1 for W. | 296 |
SCALE |
303 |
304 |
305 | 306 | 307 | 308 | FCurveArray~DefaultValues 309 | 310 | 311 | 312 | | 313 | 314 | 315 | 316 | 317 | 318 |Returns 1. | 319 |
| Name | 410 | 411 | 412 |Type | 413 | 414 | 415 | 416 | 417 | 418 |Description | 419 |
|---|---|---|
time |
428 |
429 |
430 | 431 | 432 | 433 | number 434 | 435 | 436 | 437 | | 438 | 439 | 440 | 441 | 442 | 443 |Evaluation time. | 444 |
defaultValues |
451 |
452 |
453 | 454 | 455 | 456 | FCurveArray~DefaultValues 457 | 458 | 459 | 460 | | 461 | 462 | 463 | 464 | 465 | 466 |In case a FCurve does not exist. | 467 |
| Name | 588 | 589 | 590 |Type | 591 | 592 | 593 | 594 | 595 | 596 |Description | 597 |
|---|---|---|
index |
606 |
607 |
608 | 609 | 610 | 611 | number 612 | 613 | 614 | 615 | | 616 | 617 | 618 | 619 | 620 | 621 |Array index | 622 |
time |
629 |
630 |
631 | 632 | 633 | 634 | number 635 | 636 | 637 | 638 | | 639 | 640 | 641 | 642 | 643 | 644 |Evaluation time | 645 |
| Name | 133 | 134 | 135 |Type | 136 | 137 | 138 | 139 | 140 | 141 |Description | 142 |
|---|---|---|
AUTO |
151 |
152 |
153 | 154 | 155 | 156 | number 157 | 158 | 159 | 160 | | 161 | 162 | 163 | 164 | 165 | 166 |Automatic easing. | 167 |
IN |
174 |
175 |
176 | 177 | 178 | 179 | number 180 | 181 | 182 | 183 | | 184 | 185 | 186 | 187 | 188 | 189 |Starts slow. | 190 |
OUT |
197 |
198 |
199 | 200 | 201 | 202 | number 203 | 204 | 205 | 206 | | 207 | 208 | 209 | 210 | 211 | 212 |Ends slow. | 213 |
IN_OUT |
220 |
221 |
222 | 223 | 224 | 225 | number 226 | 227 | 228 | 229 | | 230 | 231 | 232 | 233 | 234 | 235 |Starts and ends slow. | 236 |
| Name | 326 | 327 | 328 |Type | 329 | 330 | 331 | 332 | 333 | 334 |Description | 335 |
|---|---|---|
CONSTANT |
344 |
345 |
346 | 347 | 348 | 349 | number 350 | 351 | 352 | 353 | | 354 | 355 | 356 | 357 | 358 | 359 |Keeps a constant value. | 360 |
LINEAR |
367 |
368 |
369 | 370 | 371 | 372 | number 373 | 374 | 375 | 376 | | 377 | 378 | 379 | 380 | 381 | 382 |Continues as straight lines. | 383 |
| Name | 473 | 474 | 475 |Type | 476 | 477 | 478 | 479 | 480 | 481 |Description | 482 |
|---|---|---|
CONSTANT |
491 |
492 |
493 | 494 | 495 | 496 | number 497 | 498 | 499 | 500 | | 501 | 502 | 503 | 504 | 505 | 506 |No interpolation, value gets held. | 507 |
LINEAR |
514 |
515 |
516 | 517 | 518 | 519 | number 520 | 521 | 522 | 523 | | 524 | 525 | 526 | 527 | 528 | 529 |Straight-line interpolation. | 530 |
BEZIER |
537 |
538 |
539 | 540 | 541 | 542 | number 543 | 544 | 545 | 546 | | 547 | 548 | 549 | 550 | 551 | 552 |Smooth interpolation. | 553 |
BACK |
560 |
561 |
562 | 563 | 564 | 565 | number 566 | 567 | 568 | 569 | | 570 | 571 | 572 | 573 | 574 | 575 |Cubic easing with overshoot and settle. | 576 |
BOUNCE |
583 |
584 |
585 | 586 | 587 | 588 | number 589 | 590 | 591 | 592 | | 593 | 594 | 595 | 596 | 597 | 598 |Exponentially decaying parabolic bounce. | 599 |
CIRCULAR |
606 |
607 |
608 | 609 | 610 | 611 | number 612 | 613 | 614 | 615 | | 616 | 617 | 618 | 619 | 620 | 621 |Circular easing. | 622 |
CUBIC |
629 |
630 |
631 | 632 | 633 | 634 | number 635 | 636 | 637 | 638 | | 639 | 640 | 641 | 642 | 643 | 644 |Cubic easing. | 645 |
ELASTIC |
652 |
653 |
654 | 655 | 656 | 657 | number 658 | 659 | 660 | 661 | | 662 | 663 | 664 | 665 | 666 | 667 |Exponentially decaying sine wave. | 668 |
EXPONENTIAL |
675 |
676 |
677 | 678 | 679 | 680 | number 681 | 682 | 683 | 684 | | 685 | 686 | 687 | 688 | 689 | 690 |Exponential easing. | 691 |
QUADRATIC |
698 |
699 |
700 | 701 | 702 | 703 | number 704 | 705 | 706 | 707 | | 708 | 709 | 710 | 711 | 712 | 713 |Quadratic easing. | 714 |
QUARTIC |
721 |
722 |
723 | 724 | 725 | 726 | number 727 | 728 | 729 | 730 | | 731 | 732 | 733 | 734 | 735 | 736 |Quartic easing. | 737 |
QUINTIC |
744 |
745 |
746 | 747 | 748 | 749 | number 750 | 751 | 752 | 753 | | 754 | 755 | 756 | 757 | 758 | 759 |Quintic easing. | 760 |
SINUSOIDAL |
767 |
768 |
769 | 770 | 771 | 772 | number 773 | 774 | 775 | 776 | | 777 | 778 | 779 | 780 | 781 | 782 |Sinusoidal easing. | 783 |
| Name | 873 | 874 | 875 |Type | 876 | 877 | 878 | 879 | 880 | 881 |Description | 882 |
|---|---|---|
QUATERNION |
891 |
892 |
893 | 894 | 895 | 896 | number 897 | 898 | 899 | 900 | | 901 | 902 | 903 | 904 | 905 | 906 |Reads from rotation_quaternion and delta_rotation_quaternion paths. | 907 |
EULER_XYZ |
914 |
915 |
916 | 917 | 918 | 919 | number 920 | 921 | 922 | 923 | | 924 | 925 | 926 | 927 | 928 | 929 |Reads from rotation_euler and delta_rotation_euler paths. | 930 |
EULER_YXZ |
937 |
938 |
939 | 940 | 941 | 942 | number 943 | 944 | 945 | 946 | | 947 | 948 | 949 | 950 | 951 | 952 |Reads from rotation_euler and delta_rotation_euler paths. | 953 |
EULER_XZY |
960 |
961 |
962 | 963 | 964 | 965 | number 966 | 967 | 968 | 969 | | 970 | 971 | 972 | 973 | 974 | 975 |Reads from rotation_euler and delta_rotation_euler paths. | 976 |
EULER_ZXY |
983 |
984 |
985 | 986 | 987 | 988 | number 989 | 990 | 991 | 992 | | 993 | 994 | 995 | 996 | 997 | 998 |Reads from rotation_euler and delta_rotation_euler paths. | 999 |
EULER_YZX |
1006 |
1007 |
1008 | 1009 | 1010 | 1011 | number 1012 | 1013 | 1014 | 1015 | | 1016 | 1017 | 1018 | 1019 | 1020 | 1021 |Reads from rotation_euler and delta_rotation_euler paths. | 1022 |
EULER_ZYX |
1029 |
1030 |
1031 | 1032 | 1033 | 1034 | number 1035 | 1036 | 1037 | 1038 | | 1039 | 1040 | 1041 | 1042 | 1043 | 1044 |Reads from rotation_euler and delta_rotation_euler paths. | 1045 |
AXIS_ANGLE |
1052 |
1053 |
1054 | 1055 | 1056 | 1057 | number 1058 | 1059 | 1060 | 1061 | | 1062 | 1063 | 1064 | 1065 | 1066 | 1067 |Reads from rotation_axis path. | 1068 |