diff options
author | hwc487 | 2012-07-03 11:41:06 -0700 |
---|---|---|
committer | hwc487 | 2012-07-03 11:41:06 -0700 |
commit | 92822886cecd76eeac8207742f290e5b87902ddb (patch) | |
tree | 30b6d9e965b7887eb1785e3198732d0f30de4b35 /js/helper-classes/3D | |
parent | ca16a8f1c7b4da2ca7a46467b450e002866ae8ba (diff) | |
download | ninja-92822886cecd76eeac8207742f290e5b87902ddb.tar.gz |
fixes for grid drawing.
Diffstat (limited to 'js/helper-classes/3D')
-rwxr-xr-x | js/helper-classes/3D/StageLine.js | 299 | ||||
-rwxr-xr-x | js/helper-classes/3D/math-utils.js | 9 |
2 files changed, 187 insertions, 121 deletions
diff --git a/js/helper-classes/3D/StageLine.js b/js/helper-classes/3D/StageLine.js index 540109dc..12efb140 100755 --- a/js/helper-classes/3D/StageLine.js +++ b/js/helper-classes/3D/StageLine.js | |||
@@ -52,149 +52,201 @@ var StageLine = exports.StageLine = Object.create(Object.prototype, { | |||
52 | // Methods | 52 | // Methods |
53 | /////////////////////////////////////////////////////////////////////// | 53 | /////////////////////////////////////////////////////////////////////// |
54 | 54 | ||
55 | intersectWithPlane: { | 55 | intersectWithPlane: { |
56 | value: function( plane ) | 56 | value: function( plane ) |
57 | { | 57 | { |
58 | // if the plane is edge-on, ignore it | 58 | // if the plane is edge-on, ignore it |
59 | if ( MathUtils.fpSign( plane.getPlaneEq()[2] ) == 0 ) return; | 59 | if ( MathUtils.fpSign( plane.getPlaneEq()[2] ) == 0 ) return; |
60 | 60 | ||
61 | // do some quick box tests. | 61 | // do some quick box tests. |
62 | var minPt = this.getMinPoint(), | 62 | var minPt = this.getMinPoint(), |
63 | maxPt = this.getMaxPoint(); | 63 | maxPt = this.getMaxPoint(); |
64 | 64 | ||
65 | if (maxPt[0] < plane._rect.getLeft()) return; | 65 | if (maxPt[0] < plane._rect.getLeft()) return; |
66 | if (minPt[0] > plane._rect.getRight()) return; | 66 | if (minPt[0] > plane._rect.getRight()) return; |
67 | 67 | ||
68 | if (maxPt[1] < plane._rect.getTop()) return; | 68 | if (maxPt[1] < plane._rect.getTop()) return; |
69 | if (minPt[1] > plane._rect.getBottom()) return; | 69 | if (minPt[1] > plane._rect.getBottom()) return; |
70 | 70 | ||
71 | if (minPt[2] > plane.getZMax()) return; | 71 | if (minPt[2] > plane.getZMax()) return; |
72 | 72 | ||
73 | // get the boundary points for the plane | 73 | // get the boundary points for the plane |
74 | var boundaryPts = plane.getBoundaryPoints(); | 74 | var boundaryPts = plane.getBoundaryPoints().slice(); |
75 | 75 | ||
76 | // get the points and direction vector for the current line | 76 | // get the points and direction vector for the current line |
77 | var pt0 = this.getPoint0(), pt1 = this.getPoint1(); | 77 | var pt0 = this.getPoint0(), pt1 = this.getPoint1(); |
78 | //var lineDir = pt1.subtract( pt0 ); | 78 | //var lineDir = pt1.subtract( pt0 ); |
79 | var lineDir = vecUtils.vecSubtract(3, pt1, pt0); | 79 | var lineDir = vecUtils.vecSubtract(3, pt1, pt0); |
80 | 80 | ||
81 | // intersect with the front plane | 81 | // intersect with the front plane |
82 | var planeEq = plane.getPlaneEq(); | 82 | var planeEq = plane.getPlaneEq(); |
83 | var t = MathUtils.vecIntersectPlaneForParam( pt0, lineDir, planeEq ); | 83 | var t = MathUtils.vecIntersectPlaneForParam( pt0, lineDir, planeEq ); |
84 | if (t != undefined) | 84 | if (t != undefined) |
85 | { | 85 | { |
86 | if ((MathUtils.fpSign(t) >= 0) && (MathUtils.fpCmp(t,1.0) <= 0)) | 86 | if ((MathUtils.fpSign(t) >= 0) && (MathUtils.fpCmp(t,1.0) <= 0)) |
87 | { | 87 | { |
88 | // get the intersection point | 88 | // get the intersection point |
89 | var pt = MathUtils.interpolateLine3D( pt0, pt1, t ); | 89 | var pt = MathUtils.interpolateLine3D( pt0, pt1, t ); |
90 | 90 | ||
91 | // see if the intersection point is contained in the bounds | 91 | // see if the intersection point is contained in the bounds |
92 | //var contains = this.boundaryContainsPoint( boundaryPts, plane.isBackFacing(), pt ); | 92 | //var contains = this.boundaryContainsPoint( boundaryPts, plane.isBackFacing(), pt ); |
93 | var contains = MathUtils.boundaryContainsPoint( boundaryPts, pt, plane.isBackFacing() ); | 93 | var onEdge = []; |
94 | if (contains == MathUtils.INSIDE) | 94 | var contains = MathUtils.boundaryContainsPoint( boundaryPts, pt, plane.isBackFacing(), onEdge ); |
95 | { | 95 | if (contains == MathUtils.INSIDE) |
96 | // add the intersection | 96 | { |
97 | var dot = MathUtils.dot3( pt0, planeEq ) + planeEq[3]; | 97 | // add the intersection |
98 | var deltaVis = (dot > 0) ? 1 : -1; | 98 | var dot = MathUtils.dot3( pt0, planeEq ) + planeEq[3]; |
99 | var deltaVis = (dot > 0) ? 1 : -1; | ||
99 | // if (plane.isBackFacing()) | 100 | // if (plane.isBackFacing()) |
100 | // deltaVis = (dot < 0) ? 1 : -1; | 101 | // deltaVis = (dot < 0) ? 1 : -1; |
101 | 102 | ||
102 | this.addIntersection( plane, t, deltaVis ); | 103 | this.addIntersection( plane, t, deltaVis ); |
103 | } | 104 | } |
104 | else if (contains == MathUtils.ON) | 105 | else if (contains == MathUtils.ON) |
105 | { | 106 | { |
106 | if (MathUtils.fpCmp(t,1.0) < 0) | 107 | if (MathUtils.fpCmp(t,1.0) < 0) |
107 | { | 108 | { |
108 | // take the dot product between the line and the normal to the plane | 109 | // determine if the intersection is on a front side (no intersection) of the polygons |
109 | // to determine the change in visibility | 110 | //var ctr = [ 0.5*(boundaryPts[0][0] + boundaryPts[2][0]), 0.5*(boundaryPts[0][1] + boundaryPts[2][1]), 0.5*(boundaryPts[0][2] + boundaryPts[2][2]) ]; |
110 | var vec = vecUtils.vecSubtract( 3, pt1, pt0 ); | 111 | //var vec = vecUtils.vecSubtract(3, pt, ctr ); |
111 | var dot = vecUtils.vecDot( 3, vec, plane.getPlaneEq() ); | 112 | if ( !this.edgeIsFrontFacing(boundaryPts, planeEq, plane.isBackFacing(), onEdge[0], onEdge[1]) ) |
112 | var sign = MathUtils.fpSign( dot ); | 113 | { |
113 | if (sign == 0) | 114 | // take the dot product between the line and the normal to the plane |
114 | throw new Error( "coplanar intersection being treated as not coplanar" ); | 115 | // to determine the change in visibility |
115 | if (!plane.isBackFacing()) | 116 | var vec = vecUtils.vecSubtract( 3, pt1, pt0 ); |
116 | { | 117 | var dot = vecUtils.vecDot( 3, vec, planeEq ); |
117 | if (sign < 0) | 118 | var sign = MathUtils.fpSign( dot ); |
118 | this.addIntersection( plane, t, 1 ); | 119 | if (sign == 0) |
119 | } | 120 | throw new Error( "coplanar intersection being treated as not coplanar" ); |
120 | else | 121 | if (!plane.isBackFacing()) |
121 | { | 122 | { |
122 | if (sign > 0) | 123 | if (sign < 0) |
123 | this.addIntersection( plane, t, -1 ); | 124 | this.addIntersection( plane, t, 1 ); |
124 | } | 125 | } |
125 | } | 126 | else |
126 | } | 127 | { |
127 | } | 128 | if (sign > 0) |
128 | } | 129 | this.addIntersection( plane, t, -1 ); |
129 | else | 130 | } |
130 | { | 131 | } |
131 | // the line must be parallel to the plane. If the line is in the plane, | 132 | } |
132 | // we need to do some special processing | 133 | } |
133 | var d0 = vecUtils.vecDot(3, planeEq, pt0) + planeEq[3], | 134 | } |
134 | d1 = vecUtils.vecDot(3, planeEq, pt1) + planeEq[3]; | 135 | } |
135 | if ((MathUtils.fpSign(d0) == 0) && (MathUtils.fpSign(d1) == 0)) | 136 | else |
136 | this.doCoplanarIntersection( plane ); | 137 | { |
137 | } | 138 | // the line must be parallel to the plane. If the line is in the plane, |
139 | // we need to do some special processing | ||
140 | var d0 = vecUtils.vecDot(3, planeEq, pt0) + planeEq[3], | ||
141 | d1 = vecUtils.vecDot(3, planeEq, pt1) + planeEq[3]; | ||
142 | if ((MathUtils.fpSign(d0) == 0) && (MathUtils.fpSign(d1) == 0)) | ||
143 | this.doCoplanarIntersection( plane ); | ||
144 | } | ||
138 | 145 | ||
139 | // intersect with the 4 planes formed by the edges of the plane, going back in Z | 146 | // intersect with the 4 planes formed by the edges of the plane, going back in Z |
140 | var bPt1 = boundaryPts[3]; | 147 | var bPt1 = boundaryPts[3]; |
141 | for (var i=0; i<4; i++) | 148 | for (var i=0; i<4; i++) |
142 | { | 149 | { |
143 | // get the 2 points that define the front edge of the plane | 150 | // get the 2 points that define the front edge of the plane |
144 | var bPt0 = bPt1; | 151 | var bPt0 = bPt1; |
145 | var bPt1 = boundaryPts[i]; | 152 | var bPt1 = boundaryPts[i]; |
146 | 153 | ||
147 | // calculate the plane equation. The normal should point towards the OUTSIDE of the boundary | 154 | // calculate the plane equation. The normal should point towards the OUTSIDE of the boundary |
148 | //var vec = bPt1.subtract( bPt0 ); | 155 | //var vec = bPt1.subtract( bPt0 ); |
149 | var vec = vecUtils.vecSubtract(3, bPt1, bPt0); | 156 | var vec = vecUtils.vecSubtract(3, bPt1, bPt0); |
150 | if (plane.isBackFacing()) | 157 | if (plane.isBackFacing()) |
151 | MathUtils.negate( vec ); | 158 | MathUtils.negate( vec ); |
152 | planeEq = [-vec[1], vec[0], 0]; | 159 | planeEq = [-vec[1], vec[0], 0]; |
153 | var normal = [planeEq[0], planeEq[1], planeEq[2]]; | 160 | var normal = [planeEq[0], planeEq[1], planeEq[2]]; |
154 | // var d = -planeEq.dot(bPt0); | 161 | // var d = -planeEq.dot(bPt0); |
155 | var d = -vecUtils.vecDot(3, planeEq, bPt0); | 162 | var d = -vecUtils.vecDot(3, planeEq, bPt0); |
156 | planeEq[3] = d; | 163 | planeEq[3] = d; |
157 | 164 | ||
158 | t = MathUtils.vecIntersectPlaneForParam( pt0, lineDir, planeEq ); | 165 | t = MathUtils.vecIntersectPlaneForParam( pt0, lineDir, planeEq ); |
159 | if (t) | 166 | if (t) |
160 | { | 167 | { |
161 | if ((MathUtils.fpSign(t) > 0) && (MathUtils.fpCmp(t,1.0) <= 0)) // the strict vs not-strict inequality comparisons are IMPORTANT! | 168 | if ((MathUtils.fpSign(t) > 0) && (MathUtils.fpCmp(t,1.0) <= 0)) // the strict vs not-strict inequality comparisons are IMPORTANT! |
162 | { | 169 | { |
163 | // get the intersection point | 170 | // get the intersection point |
164 | var pt = MathUtils.interpolateLine3D( pt0, pt1, t ); | 171 | var pt = MathUtils.interpolateLine3D( pt0, pt1, t ); |
165 | 172 | ||
166 | // we need to get the parameter on the edge of the projection | 173 | // we need to get the parameter on the edge of the projection |
167 | // of the intersection point onto the line. | 174 | // of the intersection point onto the line. |
168 | var index = (Math.abs(vec[0]) > Math.abs(vec[1])) ? 0 : 1; | 175 | var index = (Math.abs(vec[0]) > Math.abs(vec[1])) ? 0 : 1; |
169 | var tEdge = (pt[index] - bPt0[index])/(bPt1[index] - bPt0[index]); | 176 | var tEdge = (pt[index] - bPt0[index])/(bPt1[index] - bPt0[index]); |
170 | if ((MathUtils.fpSign(tEdge) > 0) && (MathUtils.fpCmp(tEdge,1.0) <= 0)) | 177 | if ((MathUtils.fpSign(tEdge) > 0) && (MathUtils.fpCmp(tEdge,1.0) <= 0)) |
171 | { | 178 | { |
172 | var edgePt = MathUtils.interpolateLine3D( bPt0, bPt1, tEdge ); | 179 | var edgePt = MathUtils.interpolateLine3D( bPt0, bPt1, tEdge ); |
173 | if (MathUtils.fpCmp(pt[2],edgePt[2]) < 0) | 180 | if (MathUtils.fpCmp(pt[2],edgePt[2]) < 0) |
174 | { | 181 | { |