/
MorphWeightSpline.js
161 lines (146 loc) · 5.19 KB
/
MorphWeightSpline.js
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
import Check from "./Check.js";
import defaultValue from "./defaultValue.js";
import defined from "./defined.js";
import DeveloperError from "./DeveloperError.js";
import Spline from "./Spline.js";
/**
* A spline that linearly interpolates over an array of weight values used by morph targets.
*
* @alias MorphWeightSpline
* @constructor
*
* @param {Object} options Object with the following properties:
* @param {Number[]} options.times An array of strictly increasing, unit-less, floating-point times at each point.
* The values are in no way connected to the clock time. They are the parameterization for the curve.
* @param {Number[]} options.weights The array of floating-point control weights given. The weights are ordered such
* that all weights for the targets are given in chronological order and order in which they appear in
* the glTF from which the morph targets come. This means for 2 targets, weights = [w(0,0), w(0,1), w(1,0), w(1,1) ...]
* where i and j in w(i,j) are the time indices and target indices, respectively.
*
* @exception {DeveloperError} weights.length must be greater than or equal to 2.
* @exception {DeveloperError} times.length must be a factor of weights.length.
*
*
* @example
* const times = [ 0.0, 1.5, 3.0, 4.5, 6.0 ];
* const weights = [0.0, 1.0, 0.25, 0.75, 0.5, 0.5, 0.75, 0.25, 1.0, 0.0]; //Two targets
* const spline = new Cesium.WeightSpline({
* times : times,
* weights : weights
* });
*
* const p0 = spline.evaluate(times[0]);
*
* @see ConstantSpline
* @see SteppedSpline
* @see LinearSpline
* @see HermiteSpline
* @see CatmullRomSpline
* @see QuaternionSpline
*/
function MorphWeightSpline(options) {
options = defaultValue(options, defaultValue.EMPTY_OBJECT);
const weights = options.weights;
const times = options.times;
//>>includeStart('debug', pragmas.debug);
Check.defined("weights", weights);
Check.defined("times", times);
Check.typeOf.number.greaterThanOrEquals("weights.length", weights.length, 3);
if (weights.length % times.length !== 0) {
throw new DeveloperError(
"times.length must be a factor of weights.length."
);
}
//>>includeEnd('debug');
this._times = times;
this._weights = weights;
this._count = weights.length / times.length;
this._lastTimeIndex = 0;
}
Object.defineProperties(MorphWeightSpline.prototype, {
/**
* An array of times for the control weights.
*
* @memberof WeightSpline.prototype
*
* @type {Number[]}
* @readonly
*/
times: {
get: function () {
return this._times;
},
},
/**
* An array of floating-point array control weights.
*
* @memberof WeightSpline.prototype
*
* @type {Number[]}
* @readonly
*/
weights: {
get: function () {
return this._weights;
},
},
});
/**
* Finds an index <code>i</code> in <code>times</code> such that the parameter
* <code>time</code> is in the interval <code>[times[i], times[i + 1]]</code>.
* @function
*
* @param {Number} time The time.
* @returns {Number} The index for the element at the start of the interval.
*
* @exception {DeveloperError} time must be in the range <code>[t<sub>0</sub>, t<sub>n</sub>]</code>, where <code>t<sub>0</sub></code>
* is the first element in the array <code>times</code> and <code>t<sub>n</sub></code> is the last element
* in the array <code>times</code>.
*/
MorphWeightSpline.prototype.findTimeInterval =
Spline.prototype.findTimeInterval;
/**
* Wraps the given time to the period covered by the spline.
* @function
*
* @param {Number} time The time.
* @return {Number} The time, wrapped around to the updated animation.
*/
MorphWeightSpline.prototype.wrapTime = Spline.prototype.wrapTime;
/**
* Clamps the given time to the period covered by the spline.
* @function
*
* @param {Number} time The time.
* @return {Number} The time, clamped to the animation period.
*/
MorphWeightSpline.prototype.clampTime = Spline.prototype.clampTime;
/**
* Evaluates the curve at a given time.
*
* @param {Number} time The time at which to evaluate the curve.
* @param {Number[]} [result] The object onto which to store the result.
* @returns {Number[]} The modified result parameter or a new instance of the point on the curve at the given time.
*
* @exception {DeveloperError} time must be in the range <code>[t<sub>0</sub>, t<sub>n</sub>]</code>, where <code>t<sub>0</sub></code>
* is the first element in the array <code>times</code> and <code>t<sub>n</sub></code> is the last element
* in the array <code>times</code>.
*/
MorphWeightSpline.prototype.evaluate = function (time, result) {
const weights = this.weights;
const times = this.times;
const i = (this._lastTimeIndex = this.findTimeInterval(
time,
this._lastTimeIndex
));
const u = (time - times[i]) / (times[i + 1] - times[i]);
if (!defined(result)) {
result = new Array(this._count);
}
for (let j = 0; j < this._count; j++) {
const index = i * this._count + j;
result[j] = weights[index] * (1.0 - u) + weights[index + this._count] * u;
}
return result;
};
export default MorphWeightSpline;