6 files changed, 245 insertions, 32 deletions

diff --git a/assets/shaders/radialBlur.frag.glsl b/assets/shaders/radialBlur.frag.glsl
new file mode 100644
index 00000000..953e6f07
--- /dev/null
+++ b/assets/shaders/radialBlur.frag.glsl
@@ -0,0 +1,75 @@
+
+/* <copyright>
+Copyright (c) 2012, Motorola Mobility LLC.
+All Rights Reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice,
+  this list of conditions and the following disclaimer.
+
+* Redistributions in binary form must reproduce the above copyright notice,
+  this list of conditions and the following disclaimer in the documentation
+  and/or other materials provided with the distribution.
+
+* Neither the name of Motorola Mobility LLC nor the names of its
+  contributors may be used to endorse or promote products derived from this
+  software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGE.
+</copyright> */
+
+#ifdef GL_ES
+precision highp float;
+#endif
+
+uniform vec2 u_resolution;
+uniform float u_time;
+uniform float u_speed;
+uniform sampler2D u_tex0;
+
+
+void main(void)
+{
+    vec2 p = -1.0 + 2.0 * gl_FragCoord.xy / u_resolution.xy;
+    vec2 s = p;
+
+        float time = u_time * u_speed;
+    float c1 = 1.1*time,  c2 = 1.2*time,  c3 = 0.6+1.1*time;
+    float sc3 = sin(c3),  st = sin(time);
+
+    const float iterCount = 40.0;
+    const int iIterCount = int( iterCount );
+    
+    vec3 sum = vec3(0.0);
+    vec2 delta = -p/iterCount;
+    vec2 uv;
+    for( int i=0; i<iIterCount; i++ )
+    {
+        vec2 q = vec2( sin(c1 + s.x), sin(c2 + s.y) );
+        float a = atan(q.y,q.x);
+        float rsq = abs(dot(q,q)) + 1.0;
+        uv.x =  st + s.x*rsq;
+        uv.y = sc3 + s.y*rsq;
+        vec3 res = texture2D(u_tex0, uv*.5).xyz;
+
+        res = smoothstep(0.1,1.0,res*res);
+        sum += res;
+        s += delta;
+    }
+    sum /= iterCount;
+    float r = 1.5/(1.0+dot(p,p));
+
+    gl_FragColor = vec4( sum*r, 1.0);
+}
\ No newline at end of file
diff --git a/js/helper-classes/3D/StageLine.js b/js/helper-classes/3D/StageLine.js
index 5aaa325a..f9abc5ce 100755
--- a/js/helper-classes/3D/StageLine.js
+++ b/js/helper-classes/3D/StageLine.js
@@ -34,6 +34,7 @@ POSSIBILITY OF SUCH DAMAGE.
 //      The line class represents a line intersected with all planes on the scene
 ///////////////////////////////////////////////////////////////////////
 var vecUtils = require("js/helper-classes/3D/vec-utils").VecUtils;
+var viewUtils = require( "js/helper-classes/3D/view-utils").ViewUtils;
 var LinePlaneIntersectRec = require("js/helper-classes/3D/LinePlaneIntersectRec").LinePlaneIntersectRec;
 
 var StageLine = exports.StageLine = Object.create(Object.prototype, {
@@ -96,7 +97,7 @@ var StageLine = exports.StageLine = Object.create(Object.prototype, {
             if (minPt[2] > plane.getZMax())           return;
 
             // get the boundary points for the plane
-            var boundaryPts = plane.getBoundaryPoints();
+            var boundaryPts = plane.getBoundaryPoints().slice();
 
             // get the points and direction vector for the current line
             var pt0 = this.getPoint0(),  pt1 = this.getPoint1();
@@ -115,7 +116,8 @@ var StageLine = exports.StageLine = Object.create(Object.prototype, {
 
                     // see if the intersection point is contained in the bounds
                     //var contains = this.boundaryContainsPoint( boundaryPts, plane.isBackFacing(), pt );
-                    var contains = MathUtils.boundaryContainsPoint( boundaryPts, pt, plane.isBackFacing() );
+                    var onEdge = [];
+                    var contains = MathUtils.boundaryContainsPoint( boundaryPts, pt, plane.isBackFacing(), onEdge );
                     if (contains == MathUtils.INSIDE)
                     {
                         // add the intersection
@@ -130,23 +132,40 @@ var StageLine = exports.StageLine = Object.create(Object.prototype, {
                     {
                         if (MathUtils.fpCmp(t,1.0) < 0)
                         {
-                            // take the dot product between the line and the normal to the plane
-                            // to determine the change in visibility
-                            var vec = vecUtils.vecSubtract( 3, pt1, pt0 );
-                            var dot = vecUtils.vecDot( 3, vec, plane.getPlaneEq() );
-                            var sign = MathUtils.fpSign( dot );
-                            if (sign == 0)
-                                throw new Error( "coplanar intersection being treated as not coplanar" );
-                            if (!plane.isBackFacing())
+                            // determine if the intersection is on a front side (no intersection) of the polygons
+                            //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]) ];
+                            //var vec = vecUtils.vecSubtract(3, pt, ctr );
+                            if (this.edgeGoesBehindPlane( plane, boundaryPts, onEdge[0], onEdge[1],  pt0, pt1  ))
                             {
-                                if (sign < 0)
-                                    this.addIntersection( plane, t, 1 );
+                                this.addIntersection( plane, t, 1 );
                             }
-                            else
+                            else if (this.edgeGoesBehindPlane( plane, boundaryPts, onEdge[0], onEdge[1],  pt1, pt0  ))
                             {
-                                if (sign > 0)
-                                    this.addIntersection( plane, t, -1 );
+                                this.addIntersection( plane, t, -1 );
+                            }
+
+                            /*
+                            if ( !this.edgeIsFrontFacing(boundaryPts, planeEq, plane.isBackFacing(), onEdge[0], onEdge[1]) )
+                            {
+                                // take the dot product between the line and the normal to the plane
+                                // to determine the change in visibility
+                                var vec = vecUtils.vecSubtract( 3, pt1, pt0 );
+                                var dot = vecUtils.vecDot( 3, vec, planeEq );
+                                var sign = MathUtils.fpSign( dot );
+                                if (sign == 0)
+                                    throw new Error( "coplanar intersection being treated as not coplanar" );
+                                if (!plane.isBackFacing())
+                                {
+                                    if (sign < 0)
+                                        this.addIntersection( plane, t, 1 );
+                                }
+                                else
+                                {
+                                    if (sign > 0)
+                                        this.addIntersection( plane, t, -1 );
+                                }
                             }
+                            */
                         }
                     }
                 }
@@ -208,18 +227,122 @@ var StageLine = exports.StageLine = Object.create(Object.prototype, {
         }
     },
 
+    edgeGoesBehindPlane:
+    {
+        value: function( plane, boundaryPts, iEdge, t,  lPt0, lPt1 )
+        {
+            var rtnVal = false;
+
+            if ( MathUtils.fpCmp(t,1.0) == 0 )
+            {
+                iEdge = (iEdge + 1) % 4;
+                t = 0.0;
+            }
+
+            // boundary points (line points: lPt0, lPt1)
+            var bPt0, bPt1, bPt2, bVec, bVec0, bVec1, lVec, d;
+
+            var planeEq = plane.getPlaneEq();
+            if (MathUtils.fpSign(t) == 0)
+            {
+                // get the 3 relevant points.  The line goes through pt1.
+                bPt0  = boundaryPts[(iEdge+3)%4].slice();
+                bPt1  = boundaryPts[iEdge].slice();
+                bPt2  = boundaryPts[(iEdge+1)%4].slice();
+                bVec0 = vecUtils.vecSubtract(2, bPt0, bPt1);
+                bVec1 = vecUtils.vecSubtract(2, bPt2, bPt1);
+                lVec  = vecUtils.vecSubtract(2, lPt1, bPt1);
+
+                var c0 = vecUtils.vecCross(2, bVec1, lVec),
+                    c1 = vecUtils.vecCross(2, lVec, bVec0);
+//                if ((MathUtils.fpSign(c0) < 0) && (MathUtils.fpSign(c1) < 0))
+//                    rtnVal = true;
+                                if (!plane.isBackFacing() && (MathUtils.fpSign(c0) < 0) && (MathUtils.fpSign(c1) < 0))
+                                        rtnVal = true;
+                                else if (plane.isBackFacing() && (MathUtils.fpSign(c0) > 0) && (MathUtils.fpSign(c1) > 0))
+                                        rtnVal = true;
+
+                d = vecUtils.vecDot(3, lPt1, planeEq) + planeEq[3];
+                if (rtnVal && (MathUtils.fpSign(d) > 0))  rtnVal = false;
+            }
+            else
+            {
+                bPt0 = boundaryPts[iEdge].slice();
+                bPt1 = boundaryPts[(iEdge+1)%4].slice();
+                bVec = vecUtils.vecSubtract(3, bPt1, bPt0);
+                lVec = vecUtils.vecSubtract(3, lPt1, lPt0);
+
+                var backFacing = plane.isBackFacing();
+                var bNormal = vecUtils.vecCross(3, [0,0,1], bVec);
+                var dot = vecUtils.vecDot(3, bNormal, lVec);