← Back to branch summary

~holger-seelig/cobweb.js/trunk

« back to all changes in this revision

Viewing changes to src/cobweb/Browser/Interpolation/CatmullRomSplineInterpolator.js

  • Committer: Holger Seelig
  • Date: 2017-08-22 04:53:24 UTC
  • Revision ID: holger.seelig@yahoo.de-20170822045324-4of4xxgt79669gbt
Switched to npm.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/cobweb/Browser/Interpolation/CatmullRomSplineInterpolator.js
 
1
/* -*- Mode: JavaScript; coding: utf-8; tab-width: 3; indent-tabs-mode: tab; c-basic-offset: 3 -*-
 
2
 *******************************************************************************
 
3
 *
 
4
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 
5
 *
 
6
 * Copyright create3000, Scheffelstraße 31a, Leipzig, Germany 2011.
 
7
 *
 
8
 * All rights reserved. Holger Seelig <holger.seelig@yahoo.de>.
 
9
 *
 
10
 * The copyright notice above does not evidence any actual of intended
 
11
 * publication of such source code, and is an unpublished work by create3000.
 
12
 * This material contains CONFIDENTIAL INFORMATION that is the property of
 
13
 * create3000.
 
14
 *
 
15
 * No permission is granted to copy, distribute, or create derivative works from
 
16
 * the contents of this software, in whole or in part, without the prior written
 
17
 * permission of create3000.
 
18
 *
 
19
 * NON-MILITARY USE ONLY
 
20
 *
 
21
 * All create3000 software are effectively free software with a non-military use
 
22
 * restriction. It is free. Well commented source is provided. You may reuse the
 
23
 * source in any way you please with the exception anything that uses it must be
 
24
 * marked to indicate is contains 'non-military use only' components.
 
25
 *
 
26
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 
27
 *
 
28
 * Copyright 2015, 2016 Holger Seelig <holger.seelig@yahoo.de>.
 
29
 *
 
30
 * This file is part of the Cobweb Project.
 
31
 *
 
32
 * Cobweb is free software: you can redistribute it and/or modify it under the
 
33
 * terms of the GNU General Public License version 3 only, as published by the
 
34
 * Free Software Foundation.
 
35
 *
 
36
 * Cobweb is distributed in the hope that it will be useful, but WITHOUT ANY
 
37
 * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
 
38
 * A PARTICULAR PURPOSE. See the GNU General Public License version 3 for more
 
39
 * details (a copy is included in the LICENSE file that accompanied this code).
 
40
 *
 
41
 * You should have received a copy of the GNU General Public License version 3
 
42
 * along with Cobweb.  If not, see <http://www.gnu.org/licenses/gpl.html> for a
 
43
 * copy of the GPLv3 License.
 
44
 *
 
45
 * For Silvio, Joy and Adi.
 
46
 *
 
47
 ******************************************************************************/
 
48
 
 
49
 
 
50
define ([
 
51
        "standard/Math/Numbers/Vector4",
 
52
        "standard/Math/Numbers/Matrix4",
 
53
],
 
54
function (Vector4,
 
55
          Matrix4)
 
56
{
 
57
"use strict";
 
58
 
 
59
        var
 
60
                T  = [ ],
 
61
                Fp = [ ],
 
62
                Fm = [ ],
 
63
                S  = new Vector4 (0, 0, 0, 0);
 
64
                
 
65
        var H = new Matrix4 ( 2, -2,  1,  1,
 
66
                                       -3,  3, -2, -1,
 
67
                                        0,  0,  1,  0,
 
68
                                        1,  0,  0,  0);
 
69
 
 
70
        function CatmullRomSplineInterpolator ()
 
71
        {
 
72
                this .T0 = [ ];
 
73
                this .T1 = [ ];
 
74
        }
 
75
 
 
76
        CatmullRomSplineInterpolator .prototype =
 
77
        {
 
78
                constructor: CatmullRomSplineInterpolator,
 
79
                generate: function (closed, key, keyValue, keyVelocity, normalizeVelocity)
 
80
                {
 
81
                        var
 
82
                                T0 = this .T0,
 
83
                                T1 = this .T1;
 
84
 
 
85
                        T0 .length = 0;
 
86
                        T1 .length = 0;
 
87
 
 
88
                        T  .length = 0;
 
89
                        Fp .length = 0;
 
90
                        Fm .length = 0;
 
91
 
 
92
                        if (key .length > 1)
 
93
                        {
 
94
                                // T
 
95
                
 
96
                                if (keyVelocity .length === 0)
 
97
                                {
 
98
                                        if (closed)
 
99
                                                T .push (this .divide (this .subtract (keyValue [1] .getValue (), keyValue [keyValue .size () - 2] .getValue ()), 2));
 
100
                
 
101
                                        else
 
102
                                                T .push (this .create ());
 
103
                
 
104
                                        for (var i = 1, length = keyValue .length - 1; i < length; ++ i)
 
105
                                                T .push (this .divide (this .subtract (keyValue [i + 1] .getValue (), keyValue [i - 1] .getValue ()), 2));
 
106
                
 
107
                                        T .push (this .copy (T [0]));
 
108
                                }
 
109
                                else
 
110
                                {
 
111
                                        for (var i = 0, length = keyVelocity .length; i < length; ++ i)
 
112
                                                T .push (this .copy (keyVelocity [i] .getValue ()));
 
113
                
 
114
                                        if (normalizeVelocity)
 
115
                                        {
 
116
                                                var Dtot = 0;
 
117
                
 
118
                                                for (var i = 0, length = keyValue .length - 1; i < length; ++ i)
 
119
                                                        Dtot += this .abs (this .subtract (keyValue [i] .getValue (), keyValue [i + 1] .getValue ()));
 
120
                
 
121
                                                for (var i = 0, length = T .length - 1; i < length; ++ i)
 
122
                                                        T [i] = this .multiply (T [i], Dtot / this .abs (T [i]));
 
123
                                        }
 
124
                                }
 
125
 
 
126
                                // Fm, Fp
 
127
                
 
128
                                if (closed)
 
129
                                {
 
130
                                        var i_1 = key .length - 1;
 
131
                                        var i_2 = key .length - 2;
 
132
                
 
133
                                        var d = key [1] .getValue () - key [0] .getValue () + key [i_1] .getValue () - key [i_2] .getValue ();
 
134
                
 
135
                                        Fm .push (2 * (key [1]   .getValue () - key [0]   .getValue ()) / d);
 
136
                                        Fp .push (2 * (key [i_1] .getValue () - key [i_2] .getValue ()) / d);
 
137
 
 
138
                                }
 
139
                                else
 
140
                                {
 
141
                                        Fm .push (1);
 
142
                                        Fp .push (1);
 
143
                                }
 
144
 
 
145
                                for (var i = 1, length = key .length - 1; i < length; ++ i)
 
146
                                {
 
147
                                        var d = key [i + 1] .getValue () - key [i - 1] .getValue ();
 
148
                
 
149
                                        Fm .push (2 * (key [i + 1] .getValue () - key [i]     .getValue ()) / d);
 
150
                                        Fp .push (2 * (key [i]     .getValue () - key [i - 1] .getValue ()) / d);
 
151
                                }
 
152
                
 
153
                                Fm .push (Fm [0]);
 
154
                                Fp .push (Fp [0]);
 
155
                
 
156
                                // T0, T1
 
157
                
 
158
                                for (var i = 0, length = T .length; i < length; ++ i)
 
159
                                {
 
160
                                        T0 .push (this .multiply (T [i], Fp [i]));
 
161
                                        T1 .push (this .multiply (T [i], Fm [i]));
 
162
                                }
 
163
                        }
 
164
                        else
 
165
                        {
 
166
                                T0 .push (this .create ());
 
167
                                T1 .push (this .create ());
 
168
                        }
 
169
                },
 
170
                interpolate: function (index0, index1, weight, keyValue)
 
171
                {
 
172
                        S .set (Math .pow (weight, 3), Math .pow (weight, 2), weight, 1);
 
173
                
 
174
                        // Taking dot product from SH and C;
 
175
 
 
176
                        return this .dot (H .multVecMatrix (S),
 
177
                           keyValue [index0] .getValue (),
 
178
                           keyValue [index1] .getValue (),
 
179
                           this .T0 [index0],
 
180
                           this .T1 [index1]);
 
181
                },
 
182
        };
 
183
 
 
184
        return CatmullRomSplineInterpolator;
 
185
});
 
186
 
 
187