diff options
author | Pushkar Joshi | 2012-02-01 14:38:15 -0800 |
---|---|---|
committer | Pushkar Joshi | 2012-02-01 14:38:15 -0800 |
commit | 0e87c02e74e08c7bf156373b0d2459563e17ecd6 (patch) | |
tree | f3d4f1256206c9a13c9f6ef70cdd6f03b5772b5a /js | |
parent | 62d38a080b2918a0284c854e9bf882bfeeea1e0b (diff) | |
download | ninja-0e87c02e74e08c7bf156373b0d2459563e17ecd6.tar.gz |
make GLAnchorPoint functions as part of its prototype
Diffstat (limited to 'js')
-rw-r--r-- | js/helper-classes/RDGE/GLAnchorPoint.js | 230 | ||||
-rw-r--r-- | js/helper-classes/RDGE/GLSubpath.js | 10 |
2 files changed, 124 insertions, 116 deletions
diff --git a/js/helper-classes/RDGE/GLAnchorPoint.js b/js/helper-classes/RDGE/GLAnchorPoint.js index 496b6f60..6b4af072 100644 --- a/js/helper-classes/RDGE/GLAnchorPoint.js +++ b/js/helper-classes/RDGE/GLAnchorPoint.js | |||
@@ -26,125 +26,125 @@ function GLAnchorPoint() { | |||
26 | this._nextX = 0.0; | 26 | this._nextX = 0.0; |
27 | this._nextY = 0.0; | 27 | this._nextY = 0.0; |
28 | this._nextZ = 0.0; | 28 | this._nextZ = 0.0; |
29 | 29 | } | |
30 | // *********** setters ************ | 30 | // *********** setters ************ |
31 | this.setPos = function (x, y, z) { this._x = x; this._y = y; this._z = z; } | 31 | GLAnchorPoint.prototype.setPos = function (x, y, z) { this._x = x; this._y = y; this._z = z; } |
32 | this.setPrevPos = function (x, y, z) { this._prevX = x; this._prevY = y; this._prevZ = z; } | 32 | GLAnchorPoint.prototype.setPrevPos = function (x, y, z) { this._prevX = x; this._prevY = y; this._prevZ = z; } |
33 | this.setNextPos = function (x, y, z) { this._nextX = x; this._nextY = y; this._nextZ = z; } | 33 | GLAnchorPoint.prototype.setNextPos = function (x, y, z) { this._nextX = x; this._nextY = y; this._nextZ = z; } |
34 | |||
35 | this.setPrevFromNext = function () { | ||
36 | //set the previous control point by reflecting the next control point | ||
37 | var dispX = this._nextX - this._x; | ||
38 | var dispY = this._nextY - this._y; | ||
39 | var dispZ = this._nextZ - this._z; | ||
40 | |||
41 | this._prevX = this._x - dispX; | ||
42 | this._prevY = this._y - dispY; | ||
43 | this._prevZ = this._z - dispZ; | ||
44 | } | ||
45 | this.setNextFromPrev = function () { | ||
46 | //set the previous control point by reflecting the next control point | ||
47 | var dispX = this._prevX - this._x; | ||
48 | var dispY = this._prevY - this._y; | ||
49 | var dispZ = this._prevZ - this._z; | ||
50 | |||
51 | this._nextX = this._x - dispX; | ||
52 | this._nextY = this._y - dispY; | ||
53 | this._nextZ = this._z - dispZ; | ||
54 | } | ||
55 | 34 | ||
56 | //translate the next point from the translation that was applied to the prev. point | 35 | GLAnchorPoint.prototype.setPrevFromNext = function () { |
57 | this.translateNextFromPrev = function (tx, ty, tz) { | 36 | //set the previous control point by reflecting the next control point |
58 | // *** compute the rotation of the prev vector *** | 37 | var dispX = this._nextX - this._x; |
59 | var oldP = Vector.create([this._prevX + tx - this._x, this._prevY + ty - this._y, this._prevZ + tz - this._z]); | 38 | var dispY = this._nextY - this._y; |
60 | var newP = Vector.create([this._prevX - this._x, this._prevY - this._y, this._prevZ - this._z]); | 39 | var dispZ = this._nextZ - this._z; |
61 | //compute angle between the two vectors | ||
62 | var axis = Vector.create([0, 0, 0]); | ||
63 | var angle = MathUtils.getAxisAngleBetween3DVectors(oldP, newP, axis); | ||
64 | if (angle === 0) | ||
65 | return; | ||
66 | |||
67 | // *** compute the vector from anchor to next | ||
68 | var oldN = Vector.create([this._nextX - this._x, this._nextY - this._y, this._nextZ - this._z]); | ||
69 | var rotMat = Matrix.Rotation(-angle, axis); | ||
70 | var newN = MathUtils.transformVector(oldN, rotMat); | ||
71 | |||
72 | //TEMP for some situations the axis angle computation returns NaNs | ||
73 | if (isNaN(newN[0]) || isNaN(newN[1]) || isNaN(newN[2])) { | ||
74 | return; | ||
75 | } | ||
76 | //end TEMP | ||
77 | this._nextX = this._x + newN[0]; | ||
78 | this._nextY = this._y + newN[1]; | ||
79 | this._nextZ = this._z + newN[2]; | ||
80 | } | ||
81 | //translate the next point from the translation that was applied to the prev. point | ||
82 | this.translatePrevFromNext = function (tx, ty, tz) { | ||
83 | // *** compute the rotation of the next vector *** | ||
84 | var oldN = Vector.create([this._nextX + tx - this._x, this._nextY + ty - this._y, this._nextZ + tz - this._z]); | ||
85 | var newN = Vector.create([this._nextX - this._x, this._nextY - this._y, this._nextZ - this._z]); | ||
86 | //compute angle between the two vectors | ||
87 | var axis = Vector.create([0, 0, 0]); | ||
88 | var angle = MathUtils.getAxisAngleBetween3DVectors(oldN, newN, axis); | ||
89 | if (angle === 0) | ||
90 | return; | ||
91 | |||
92 | // *** compute the vector from anchor to prev | ||
93 | var oldP = Vector.create([this._prevX - this._x, this._prevY - this._y, this._prevZ - this._z]); | ||
94 | var rotMat = Matrix.Rotation(-angle, axis); | ||
95 | var newP = MathUtils.transformVector(oldP, rotMat); | ||
96 | |||
97 | //TEMP for some situations the axis angle computation returns NaNs | ||
98 | if (isNaN(newP[0]) || isNaN(newP[1]) || isNaN(newP[2])) { | ||
99 | return; | ||
100 | } | ||
101 | //end TEMP | ||
102 | this._prevX = this._x + newP[0]; | ||
103 | this._prevY = this._y + newP[1]; | ||
104 | this._prevZ = this._z + newP[2]; | ||
105 | } | ||
106 | 40 | ||
41 | this._prevX = this._x - dispX; | ||
42 | this._prevY = this._y - dispY; | ||
43 | this._prevZ = this._z - dispZ; | ||
44 | } | ||
45 | GLAnchorPoint.prototype.setNextFromPrev = function () { | ||
46 | //set the previous control point by reflecting the next control point | ||
47 | var dispX = this._prevX - this._x; | ||
48 | var dispY = this._prevY - this._y; | ||
49 | var dispZ = this._prevZ - this._z; | ||
107 | 50 | ||
108 | // ******* modifiers ******* | 51 | this._nextX = this._x - dispX; |
109 | this.translatePrev = function (x, y, z) { | 52 | this._nextY = this._y - dispY; |
110 | this._prevX += x; this._prevY += y; this._prevZ += z; | 53 | this._nextZ = this._z - dispZ; |
111 | } | 54 | } |
112 | this.translateNext = function (x, y, z) { | 55 | |
113 | this._nextX += x; this._nextY += y; this._nextZ += z; | 56 | //translate the next point from the translation that was applied to the prev. point |
114 | } | 57 | GLAnchorPoint.prototype.translateNextFromPrev = function (tx, ty, tz) { |
115 | this.translate = function (x, y, z) { | 58 | // *** compute the rotation of the prev vector *** |
116 | this._x += x; this._y += y; this._z += z; | 59 | var oldP = Vector.create([this._prevX + tx - this._x, this._prevY + ty - this._y, this._prevZ + tz - this._z]); |
117 | } | 60 | var newP = Vector.create([this._prevX - this._x, this._prevY - this._y, this._prevZ - this._z]); |
118 | this.translateAll = function (x, y, z) { | 61 | //compute angle between the two vectors |
119 | this.translate(x, y, z); | 62 | var axis = Vector.create([0, 0, 0]); |
120 | this.translatePrev(x, y, z); | 63 | var angle = MathUtils.getAxisAngleBetween3DVectors(oldP, newP, axis); |
121 | this.translateNext(x, y, z); | 64 | if (angle === 0) |
122 | } | 65 | return; |
123 | 66 | ||
124 | 67 | // *** compute the vector from anchor to next | |
125 | // ********* getters ********** | 68 | var oldN = Vector.create([this._nextX - this._x, this._nextY - this._y, this._nextZ - this._z]); |
126 | this.getPosX = function () { return this._x; } | 69 | var rotMat = Matrix.Rotation(-angle, axis); |
127 | this.getPosY = function () { return this._y; } | 70 | var newN = MathUtils.transformVector(oldN, rotMat); |
128 | this.getPosZ = function () { return this._z; } | 71 | |
129 | this.getPrevX = function () { return this._prevX; } | 72 | //TEMP for some situations the axis angle computation returns NaNs |
130 | this.getPrevY = function () { return this._prevY; } | 73 | if (isNaN(newN[0]) || isNaN(newN[1]) || isNaN(newN[2])) { |
131 | this.getPrevZ = function () { return this._prevZ; } | 74 | return; |
132 | this.getNextX = function () { return this._nextX; } | ||
133 | this.getNextY = function () { return this._nextY; } | ||
134 | this.getNextZ = function () { return this._nextZ; } | ||
135 | this.getPos = function() { return Vector.create([this._x, this._y, this._z]);} | ||
136 | this.getPrev = function() { return Vector.create([this._prevX, this._prevY, this._prevZ]);} | ||
137 | this.getNext = function() { return Vector.create([this._nextX, this._nextY, this._nextZ]);} | ||
138 | //return the square of distance from passed in point to the anchor position | ||
139 | this.getDistanceSq = function (x, y, z) { | ||
140 | return (this._x - x) * (this._x - x) + (this._y - y) * (this._y - y) + (this._z - z) * (this._z - z); | ||
141 | } | ||
142 | //return sq. of distance to prev. | ||
143 | this.getPrevDistanceSq = function (x, y, z) { | ||
144 | return (this._prevX - x) * (this._prevX - x) + (this._prevY - y) * (this._prevY - y) + (this._prevZ - z) * (this._prevZ - z); | ||
145 | } | 75 | } |
146 | //return sq. of distance to next | 76 | //end TEMP |
147 | this.getNextDistanceSq = function (x, y, z) { | 77 | this._nextX = this._x + newN[0]; |
148 | return (this._nextX - x) * (this._nextX - x) + (this._nextY - y) * (this._nextY - y) + (this._nextZ - z) * (this._nextZ - z); | 78 | this._nextY = this._y + newN[1]; |
79 | this._nextZ = this._z + newN[2]; | ||
80 | } | ||
81 | //translate the next point from the translation that was applied to the prev. point | ||
82 | GLAnchorPoint.prototype.translatePrevFromNext = function (tx, ty, tz) { | ||
83 | // *** compute the rotation of the next vector *** | ||
84 | var oldN = Vector.create([this._nextX + tx - this._x, this._nextY + ty - this._y, this._nextZ + tz - this._z]); | ||
85 | var newN = Vector.create([this._nextX - this._x, this._nextY - this._y, this._nextZ - this._z]); | ||
86 | //compute angle between the two vectors | ||
87 | var axis = Vector.create([0, 0, 0]); | ||
88 | var angle = MathUtils.getAxisAngleBetween3DVectors(oldN, newN, axis); | ||
89 | if (angle === 0) | ||
90 | return; | ||
91 | |||
92 | // *** compute the vector from anchor to prev | ||
93 | var oldP = Vector.create([this._prevX - this._x, this._prevY - this._y, this._prevZ - this._z]); | ||
94 | var rotMat = Matrix.Rotation(-angle, axis); | ||
95 | var newP = MathUtils.transformVector(oldP, rotMat); | ||
96 | |||
97 | //TEMP for some situations the axis angle computation returns NaNs | ||
98 | if (isNaN(newP[0]) || isNaN(newP[1]) || isNaN(newP[2])) { | ||
99 | return; | ||
149 | } | 100 | } |
101 | //end TEMP | ||
102 | this._prevX = this._x + newP[0]; | ||
103 | this._prevY = this._y + newP[1]; | ||
104 | this._prevZ = this._z + newP[2]; | ||
105 | } | ||
106 | |||
107 | |||
108 | // ******* modifiers ******* | ||
109 | GLAnchorPoint.prototype.translatePrev = function (x, y, z) { | ||
110 | this._prevX += x; this._prevY += y; this._prevZ += z; | ||
111 | } | ||
112 | GLAnchorPoint.prototype.translateNext = function (x, y, z) { | ||
113 | this._nextX += x; this._nextY += y; this._nextZ += z; | ||
114 | } | ||
115 | GLAnchorPoint.prototype.translate = function (x, y, z) { | ||
116 | this._x += x; this._y += y; this._z += z; | ||
150 | } | 117 | } |
118 | GLAnchorPoint.prototype.translateAll = function (x, y, z) { | ||
119 | this.translate(x, y, z); | ||
120 | this.translatePrev(x, y, z); | ||
121 | this.translateNext(x, y, z); | ||
122 | } | ||
123 | |||
124 | |||
125 | // ********* getters ********** | ||
126 | GLAnchorPoint.prototype.getPosX = function () { return this._x; } | ||
127 | GLAnchorPoint.prototype.getPosY = function () { return this._y; } | ||
128 | GLAnchorPoint.prototype.getPosZ = function () { return this._z; } | ||
129 | GLAnchorPoint.prototype.getPrevX = function () { return this._prevX; } | ||
130 | GLAnchorPoint.prototype.getPrevY = function () { return this._prevY; } | ||
131 | GLAnchorPoint.prototype.getPrevZ = function () { return this._prevZ; } | ||
132 | GLAnchorPoint.prototype.getNextX = function () { return this._nextX; } | ||
133 | GLAnchorPoint.prototype.getNextY = function () { return this._nextY; } | ||