Merge pull request #19 from snowkit/ray-fixes

Ray infinite state fixes

Author: ruby0x1

differ/sat/SAT2D.hx

@@ -242,7 +242,13 @@ class SAT2D {
             var t1 = (-b - d) / (2 * a);
             var t2 = (-b + d) / (2 * a);
 
-            if (ray.infinite || (t1 <= 1.0 && t1 >= 0.0)) {
+            var valid = switch(ray.infinite) {
+                case not_infinite: t1 >= 0.0 && t1 <= 1.0;
+                case infinite_from_start: t1 >= 0.0;
+                case infinite: true;
+            }
+
+            if (valid) {
 
                 into = (into == null) ? new RayCollision() : into.reset();
 
@@ -265,7 +271,7 @@ class SAT2D {
     public static function testRayVsPolygon( ray:Ray, polygon:Polygon, ?into:RayCollision ) : RayCollision {
 
         var min_u = Math.POSITIVE_INFINITY;
-        var max_u = 0.0;
+        var max_u = Math.NEGATIVE_INFINITY;
 
         var startX = ray.start.x;
         var startY = ray.start.y;
@@ -280,12 +286,12 @@ class SAT2D {
         var ua = rayU(ud, startX, startY, v1.x, v1.y, v2.x - v1.x, v2.y - v1.y);
         var ub = rayU(ud, startX, startY, v1.x, v1.y, deltaX, deltaY);
 
-        if (ud != 0.0 && ub >= 0.0 && ub <= 1.0) {
-            if (ua < min_u) min_u = ua;
-            if (ua > max_u) max_u = ua;
+        if(ud != 0.0 && ub >= 0.0 && ub <= 1.0) {
+            if(ua < min_u) min_u = ua;
+            if(ua > max_u) max_u = ua;
         }
 
-        for (i in 1...verts.length) {
+        for(i in 1...verts.length) {
 
             v1 = verts[i - 1];
             v2 = verts[i];
@@ -294,14 +300,20 @@ class SAT2D {
             ua = rayU(ud, startX, startY, v1.x, v1.y, v2.x - v1.x, v2.y - v1.y);
             ub = rayU(ud, startX, startY, v1.x, v1.y, deltaX, deltaY);
 
-            if (ud != 0.0 && ub >= 0.0 && ub <= 1.0) {
-                if (ua < min_u) min_u = ua;
-                if (ua > max_u) max_u = ua;
+            if(ud != 0.0 && ub >= 0.0 && ub <= 1.0) {
+                if(ua < min_u) min_u = ua;
+                if(ua > max_u) max_u = ua;
             }
 
         } //each vert
 
-        if(ray.infinite || (min_u <= 1.0 && min_u >= 0.0) ) {
+        var valid = switch(ray.infinite) {
+            case not_infinite: min_u >= 0.0 && min_u <= 1.0;
+            case infinite_from_start: min_u != Math.POSITIVE_INFINITY && min_u >= 0.0;
+            case infinite: (min_u != Math.POSITIVE_INFINITY);
+        }
+
+        if(valid) {
             into = (into == null) ? new RayCollision() : into.reset();
                 into.shape = polygon;
                 into.ray = ray;
@@ -329,15 +341,32 @@ class SAT2D {
 
         var u1 = (delta2X * diffY - delta2Y * diffX) / ud;
         var u2 = (delta1X * diffY - delta1Y * diffX) / ud;
+    
+            //:todo: ask if ray hit condition difference is intentional (> 0 and not >= 0 like other checks)
+        var valid1 = switch(ray1.infinite) {
+            case not_infinite: (u1 > 0.0 && u1 <= 1.0);
+            case infinite_from_start: u1 > 0.0;
+            case infinite: true;
+        }
+
+        var valid2 = switch(ray2.infinite) {
+            case not_infinite: (u2 > 0.0 && u2 <= 1.0);
+            case infinite_from_start: u2 > 0.0;
+            case infinite: true;
+        }
 
-        if ((ray1.infinite || (u1 > 0.0 && u1 <= 1.0)) && (ray2.infinite || (u2 > 0.0 && u2 <= 1.0))) {
+        if(valid1 && valid2) {
+            
             into = (into == null) ? new RayIntersection() : into.reset();
-                into.ray1 = ray1;
-                into.ray2 = ray2;
-                into.u1 = u1;
-                into.u2 = u2;
+
+            into.ray1 = ray1;
+            into.ray2 = ray2;
+            into.u1 = u1;
+            into.u2 = u2;
+
             return into;
-        }
+        
+        } //both valid 
 
         return null;
 

differ/shapes/Polygon.hx

@@ -5,10 +5,9 @@ import differ.shapes.*;
 import differ.data.*;
 import differ.sat.*;
 
-/** A polygon collision shape */
+/** A polygonal collision shape */
 class Polygon extends Shape {
 
-
         /** The transformed (rotated/scale) vertices cache */
     public var transformedVertices ( get, never ) : Array<Vector>;
         /** The vertices of this shape */

differ/shapes/Ray.hx

@@ -4,6 +4,8 @@ import differ.math.*;
 import differ.shapes.*;
 import differ.data.*;
 
+/** A ray with a start, end, direction 
+    and infinite state for collision queries. */
 class Ray {
 
         /** The start point of the ray. */
@@ -15,16 +17,16 @@ class Ray {
             Updates only when the dir value is accessed. */
     public var dir (get, never):Vector;
         /** Whether or not the ray is infinite. */
-    public var infinite:Bool;
+    public var infinite:InfiniteState;
 
         /** Create a new ray with the start and end point,
             which determine the direction of the ray, and optionally specifying
-            that this ray is an infinite one. */
-    public function new(_start:Vector, _end:Vector, _infinite:Bool = true) {
+            that this ray is infinite in some way. */
+    public function new(_start:Vector, _end:Vector, ?_infinite:InfiniteState) {
 
         start = _start;
         end = _end;
-        infinite = _infinite;
+        infinite = _infinite == null ? not_infinite : _infinite;
 
         //internal
         dir_cache = new Vector(end.x - start.x, end.y - start.y);
@@ -40,4 +42,19 @@ class Ray {
         return dir_cache;
     }
 
-}
+}
+
+    /** A flag for the infinite state of a Ray. */
+enum InfiniteState {
+
+        /** The line is a fixed length 
+            between the start and end points. */
+    not_infinite;
+        /** The line is infinite 
+            from it's starting point. */
+    infinite_from_start;
+        /** The line is infinite in both 
+            directions from it's starting point. */
+    infinite;
+
+} //InfiniteState

tests/usage0/assets/.keep

@@ -5,6 +5,7 @@ import luxe.Text;
 
 import differ.shapes.Shape;
 import differ.shapes.Ray;
+import differ.math.Util;
 import phoenix.Batcher;
 
 class Main extends luxe.Game {
@@ -44,13 +45,13 @@ class Main extends luxe.Game {
         rays = [];
 
         desc = new Text({
-            pos: new Vector(10,10),
+            pos: new Vector(10, 10),
             point_size: 18,
             text: 'differ usage examples, press 9 or 0 to cycle'
         });
 
         disp = new Text({
-            pos: new Vector(10, 30),
+            pos: new Vector(10, 40),
             point_size: 15,
             text: 'usage text goes here'
         });
@@ -98,9 +99,42 @@ class Main extends luxe.Game {
 
     } //onkeyup
 
+    inline static var big_number : Int = 0xFFFFFF;
+
     override function onrender() {
         for(shape in shapes) drawer.drawShape(shape);
-        for(ray in rays) drawer.drawLine(ray.start.x, ray.start.y, ray.end.x, ray.end.y);
+        for(ray in rays) {
+            var start_x = ray.start.x;
+            var start_y = ray.start.y;
+            var end_x   = ray.end.x;
+            var end_y   = ray.end.y;
+
+                //get the direction of the ray
+            var dir_x = end_x - start_x;
+            var dir_y = end_y - start_y;
+                //normalize it
+            var len = Util.vec_length(dir_x, dir_y);
+                dir_x = Util.vec_normalize(len, dir_x);
+                dir_y = Util.vec_normalize(len, dir_y);
+                //scale it way up
+            dir_x *= big_number;
+            dir_y *= big_number;
+
+            switch(ray.infinite) {                    
+                case infinite:
+                    start_x -= dir_x;
+                    start_y -= dir_y;
+                    end_x += dir_x;
+                    end_y += dir_y;
+                case infinite_from_start:
+                    end_x += dir_x;
+                    end_y += dir_y;
+                case not_infinite:
+                    //do nothing, the line is fixed
+            }
+
+            drawer.drawLine(start_x, start_y, end_x, end_y);
+        }
     }
 
 } //Main

tests/usage0/src/Main.hx

@@ -35,15 +35,18 @@ class Polygons extends luxe.States.State {
 
 
         moverA = Polygon.square(10, 100, 50);
-        moverB = new Circle(10, 100, 30);
+        moverB = new Circle(100, 100, 30);
         mover = moverA;
 
         for(fix in fixed) Main.shapes.push(fix);
         Main.shapes.push(moverA);
         Main.shapes.push(moverB);
 
-        var text =  '\nThe white polygon is the position the separation would result in.\n';
-            text += 'Hold down left or right mouse to rotate the box.';
+        var text =  'The white polygon is the position the separation would result in.\n';
+            text += 'The dim polygon is the alternate position based on the unit normal.\n';
+            text += 'Colored collisions is when there are multiple collisions.\n\n';
+            text += 'Hold down left or right mouse to rotate the box.\n';
+            text += 'Press M to toggle the shape on the mouse';
 
         Main.display(text);
 

tests/usage0/src/states/Polygons.hx

@@ -20,18 +20,24 @@ class RayAndShape extends luxe.States.State {
     var intersect:LineGeometry;
     var before:LineGeometry;
     var after:LineGeometry;
+    var colors:Array<Color>;
 
     override function onenter<T>(_:T) {
 
-        Main.display('pink = ray\ngreen = before hit\nwhite = intersection\npurple = after hit');
+        Main.display('press space to toggle infinite state\npress 1 to move the beam start');
 
-        beam = new Ray( new V(450,300), new V(400,100), false );
+        beam = new Ray( new V(420,300), new V(400,100), not_infinite );
 
         Main.rays.push(beam);
         Main.shapes.push(new Circle(600,400,50));
         Main.shapes.push(new Circle(200,400,50));
-        Main.shapes.push( Polygon.rectangle(600,200,50,50));
-        Main.shapes.push( Polygon.rectangle(200,200,50,50));
+        Main.shapes.push(Polygon.rectangle(600,200,50,50));
+        Main.shapes.push(Polygon.rectangle(200,200,50,50));
+
+        colors = [
+            new Color().rgb(0xffffff),
+            new Color(1,1,1,0.5)
+        ];
 
         intersect = Luxe.draw.line({ depth:100, batcher: Main.thicker, p0:new Vector(), p1:new Vector(), color:new Color().rgb(0xffffff) });
         before = Luxe.draw.line({ depth:100, batcher: Main.thicker, p0:new Vector(), p1:new Vector(), color:new Color().rgb(0x00f67b) });
@@ -54,15 +60,32 @@ class RayAndShape extends luxe.States.State {
 
      override function onkeyup(e:KeyEvent) {
 
+        if(e.keycode == Key.key_1) {
+            if(beam.start.y == 300) {
+                beam.start.y = 200;
+            } else if(beam.start.y == 200) {
+                beam.start.y = 380;
+            } else {
+                beam.start.y = 300;
+            }
+        }
+
         if(e.keycode == Key.space) {
-            if(beam != null) beam.infinite = !beam.infinite;
+            if(beam != null) {
+                    //cycle infinite mode
+                beam.infinite = switch(beam.infinite) {
+                    case not_infinite: infinite_from_start;
+                    case infinite_from_start: infinite;
+                    case infinite: not_infinite;
+                }
+            }
         }
 
     } //onkeyup
 
     override function onmousemove( e:MouseEvent ) {
         if(beam != null) {
-            if(beam.infinite) {
+            if(beam.infinite == infinite || beam.infinite == infinite_from_start) { //:todo: check later if correct behaviour
                 var end = new Vector(e.pos.x, e.pos.y);
                 end.subtract_xyz(beam.start.x, beam.start.y);
                 end.normalize();
@@ -98,14 +121,27 @@ class RayAndShape extends luxe.States.State {
             var hitendx = c.hitEndX();
             var hitendy = c.hitEndY();
 
-            intersect.p0 = new Vector(hitstartx, hitstarty);
-            intersect.p1 = new Vector(hitendx, hitendy);
-
-            before.p0 = new Vector(c.ray.start.x, c.ray.start.y);
-            before.p1 = new Vector(hitstartx, hitstarty);
-
-            after.p0 = new Vector(hitendx, hitendy);
-            after.p1 = new Vector(c.ray.end.x, c.ray.end.y);
+            Luxe.draw.ring({ immediate:true, x:hitstartx, y:hitstarty, r:4, color:colors[1] });
+            Luxe.draw.ring({ immediate:true, x:hitendx, y:hitendy, r:4, color:colors[1] });
+
+            if(c.end >= 1.0) {
+                Luxe.draw.line({
+                    p0: new Vector(hitstartx, hitstarty),
+                    p1: new Vector(c.ray.end.x, c.ray.end.y),
+                    color: colors[0],
+                    batcher: Main.thicker,
+                    immediate: true
+                });
+            } else {
+                Luxe.draw.line({
+                    p0: new Vector(hitstartx, hitstarty),
+                    p1: new Vector(hitendx, hitendy),
+                    color: colors[0],
+                    batcher: Main.thicker,
+                    immediate: true
+                });
+            }
+            
 
             Luxe.draw.text({
                 point_size:13,

tests/usage0/src/states/RayAndShape.hx

@@ -28,13 +28,18 @@ class Rays extends luxe.States.State {
             new Color().rgb(0xa0e300)
         ];
 
-        Main.display('move the mouse around');
+        var message = 'press F to flip start point\n';
+            message += 'press 1 to toggle the beam infinite state\n';
+            message += 'press 2 to toggle the other infinite states\n';
+            message += 'press 3 to toggle the first infinite state\n';
 
-        beam = new Ray( new V(50,300), new V(600,400), false );
+        Main.display(message);
+
+        beam = new Ray( new V(50,300), new V(600,400), not_infinite );
 
         for(i in 0 ... colors.length) {
             var sx = (i+1) * 120;
-            var ray = new Ray( new V(sx, 100), new V(sx, 500), false );
+            var ray = new Ray( new V(sx, 100), new V(sx, 500), not_infinite );
             others.push(ray);
             Main.rays.push(ray);
         }
@@ -55,24 +60,56 @@ class Rays extends luxe.States.State {
 
     override function onmousemove( e:MouseEvent ) {
         if(beam != null) {
-            if(beam.infinite) {
-                var end = new Vector(e.pos.x, e.pos.y);
-                end.subtract_xyz(beam.start.x, beam.start.y);
-                end.normalize();
-                end.multiplyScalar(9999);
-                beam.end.x = end.x;
-                beam.end.y = end.y;
-            } else {
-                beam.end.x = e.pos.x;
-                beam.end.y = e.pos.y;
+            beam.end.x = e.pos.x;
+            beam.end.y = e.pos.y;
+        }
+    }
+
+    function print_infinite(label:String, ray:Ray) {
+        switch(ray.infinite) {
+            case not_infinite: 
+                trace('`$label` infinite: nope');
+            case infinite_from_start: 
+                trace('`$label` infinite: from start');
+            case infinite: 
+                trace('`$label` infinite: in both directions');
+        }
+    }
+
+    function toggle_infinite(ray:Ray) {
+        if(ray != null) {
+            ray.infinite = switch(ray.infinite) {
+                case not_infinite: 
+                    infinite_from_start;
+                case infinite_from_start: 
+                    infinite;
+                case infinite: 
+                    not_infinite;
             }
         }
     }
 
     override function onkeyup(e:KeyEvent) {
 
-        if(e.keycode == Key.space) {
-            if(beam != null) beam.infinite = !beam.infinite;
+        if(e.keycode == Key.key_1) {
+            toggle_infinite(beam);
+            print_infinite('beam', beam);
+        }
+
+        if(e.keycode == Key.key_2) {
+            var first = true;
+            for(o in others) {
+                toggle_infinite(o);
+                if(first) {
+                    print_infinite('others', others[0]);
+                    first = false;
+                }
+            }
+        }
+
+        if(e.keycode == Key.key_3) {
+            toggle_infinite(others[0]);
+            print_infinite('others', others[0]);
         }
 
         if(e.keycode == Key.key_f) {