Added a global variable to allow skipping the default mouse move listener: skipDefaultMouseMoveListener.

Changed  the Vector.cross function to be like the rest, added a cross2 for the old usage.
Made most Vector functions return _this_ to allow chaining.

Author: Raymond Hulha

lib/src/input.dart

@@ -7,22 +7,26 @@ int clientX=0;
 int clientY=0;
 int mouseX=0;
 int mouseY=0;
+bool skipDefaultMouseMoveListener = false;
 
 
 void setUpCapture()
 {
   HTML.document.onKeyDown.listen( (HTML.KeyboardEvent e) { currentlyPressedKeys[e.keyCode] = true; });
   HTML.document.onKeyUp.listen( (HTML.KeyboardEvent e) { currentlyPressedKeys[e.keyCode] = null; });
 
-  HTML.document.onMouseMove.listen( (HTML.MouseEvent e) {
-    e.preventDefault();
-    
-    clientX = e.client.x; 
-    clientY = HTML.window.innerHeight - e.client.y; 
-    mouseX = e.client.x-(HTML.window.innerWidth~/2);
-    mouseY = -(e.client.y-(HTML.window.innerHeight~/2));
-    
-  });
+  if( ! skipDefaultMouseMoveListener )
+  {
+    HTML.document.onMouseMove.listen( (HTML.MouseEvent e) {
+      e.preventDefault();
+      
+      clientX = e.client.x; 
+      clientY = HTML.window.innerHeight - e.client.y; 
+      mouseX = e.client.x-(HTML.window.innerWidth~/2);
+      mouseY = -(e.client.y-(HTML.window.innerHeight~/2));
+      
+    });
+  }
 
   HTML.document.onMouseDown.listen( (HTML.MouseEvent e) {
     e.preventDefault();

lib/src/matrix4.dart

@@ -289,7 +289,7 @@ class Matrix4 {
   }
 
   // dest = Vector4
-  void multiplyVec4( List<num> vec4) {
+  void multiplyVec4( List<double> vec4) {
     var x = vec4[0], y = vec4[1], z = vec4[2], w = vec4[3];
 
     vec4[0] = array[0] * x + array[4] * y + array[8] * z + array[12] * w;
@@ -347,9 +347,9 @@ class Matrix4 {
     // vec3.direction goes from argument2 to argument1 and normalizes
     // as we want a back vector, we want from target to this spatial position
     newBack.direction( eye, target );
-    newRight.cross( up, newBack);
+    newRight.cross2( up, newBack);
     newRight.normalize();
-    newUp.cross(newBack, newRight);
+    newUp.cross2(newBack, newRight);
 
     array[ 0] = newRight[0];
     array[ 1] = newUp[0];

lib/src/shapes/torusknot.dart

@@ -29,8 +29,8 @@ MeshData createTorusKnotInternal(  {double radius:20.0, double tube:4.0, int seg
     n.y = p2.y + p1.y;
     n.z = p2.z + p1.z; 
 
-    bitan.cross( tang, n).normalize();
-    n.cross( bitan, tang ).normalize();
+    bitan.cross2( tang, n).normalize();
+    n.cross2( bitan, tang ).normalize();
 
     for ( int j = 0; j < segmentsT; ++ j ) {
       double v = j / segmentsT * 2 * Math.PI;

lib/src/vector.dart

@@ -15,7 +15,7 @@ class Vector {
 
   Vector.fromList( this.array);
 
-  Vector( [num x=0.0, num y=0.0, num z=0.0])
+  Vector( [double x=0.0, double y=0.0, double z=0.0])
   {
     array[0] = x;
     array[1] = y;
@@ -31,37 +31,42 @@ class Vector {
     array[index] = value;
   }
 
-  void set( Vector v) {
+  Vector set( Vector v) {
       array[0] = v[0];
       array[1] = v[1];
       array[2] = v[2];
+      return this;
   }
 
-  void add( Vector v) {
+  Vector add( Vector v) {
       array[0] += v[0];
       array[1] += v[1];
       array[2] += v[2];
+      return this;
   }
 
-  void subtract( Vector v) {
+  Vector subtract( Vector v) {
       array[0] -= v[0];
       array[1] -= v[1];
       array[2] -= v[2];
+      return this;
   }
 
-  void scale( num val) {
+  Vector scale( num val) {
       array[0] *= val;
       array[1] *= val;
       array[2] *= val;
+      return this;
   }
 
-  void negate() {
+  Vector negate() {
     array[0] = -array[0];
     array[1] = -array[1];
     array[2] = -array[2];
+    return this;
   }
 
-  void normalize() {
+  Vector normalize() {
     double x = array[0], y = array[1], z = array[2];
     double len = Math.sqrt(x * x + y * y + z * z);
 
@@ -79,12 +84,13 @@ class Vector {
       array[1] = y * len;
       array[2] = z * len;
     }
+    return this;
   }
 
   // I think the from and to is swapped, but it's the same in glmatrix...
-  void direction( Vector from, Vector to)
+  Vector direction( Vector from, Vector to)
   {
-    num x = from[0] - to[0],
+    double x = from[0] - to[0],
         y = from[1] - to[1],
         z = from[2] - to[2],
         len = Math.sqrt(x * x + y * y + z * z);
@@ -99,11 +105,15 @@ class Vector {
       array[1] = y * len;
       array[2] = z * len;
     }
-
+    return this;
   }
 
-  Vector cross(Vector vec1, Vector vec2) {
-    num x = vec1[0], y = vec1[1], z = vec1[2],
+  Vector cross( Vector vec2) {
+    return cross2( this, vec2);
+  }
+
+  Vector cross2( Vector vec1, Vector vec2) {
+    double x = vec1[0], y = vec1[1], z = vec1[2],
         x2 = vec2[0], y2 = vec2[1], z2 = vec2[2];
 
     array[0] = y * z2 - z * y2;
@@ -116,10 +126,11 @@ class Vector {
     return array[0] * vec2[0] + array[1] * vec2[1] + array[2] * vec2[2];
   }
 
-  void lerp( Vector v, double lerp) {
+  Vector lerp( Vector v, double lerp) {
     array[0] += lerp * (v[0] - array[0]);
     array[1] += lerp * (v[1] - array[1]);
     array[2] += lerp * (v[2] - array[2]);
+    return this;
   }
 
   double dist( Vector to) {
@@ -130,35 +141,45 @@ class Vector {
     return Math.sqrt(x*x + y*y + z*z);
   }
 
+  double lengthSquared() {
+    double x = array[0],
+           y = array[1],
+           z = array[2];
+    return (x*x + y*y + z*z);
+  }
+
+  double length() {
+    return Math.sqrt(lengthSquared());
+  }
+
   // if we initialize the matrix here we get an endless loop
   // because Matrix also creates a new Vector...
   Matrix4 m = null;
-  List<num> v = new List<num>(4);
+  List<double> _v = new List<double>(4);
 
-  bool unproject( Matrix4 view, Matrix4 proj, List<num> viewport) {
+  bool unproject( Matrix4 view, Matrix4 proj, List<double> viewport) {
 
     if( m == null)
       m = new Matrix4(); 
 
-    v[0] = (array[0] - viewport[0]) * 2.0 / viewport[2] - 1.0;
-    v[1] = (array[1] - viewport[1]) * 2.0 / viewport[3] - 1.0;
-    v[2] = 2.0 * array[2] - 1.0;
-    v[3] = 1.0;
+    _v[0] = (array[0] - viewport[0]) * 2.0 / viewport[2] - 1.0;
+    _v[1] = (array[1] - viewport[1]) * 2.0 / viewport[3] - 1.0;
+    _v[2] = 2.0 * array[2] - 1.0;
+    _v[3] = 1.0;
 
     m.setElements(proj);
     m.multiplyWith( view );
     if(!m.invert()) { return false; }
 
-    m.multiplyVec4( v);
-    if(v[3] == 0.0) { return false; }
+    m.multiplyVec4( _v);
+    if(_v[3] == 0.0) { return false; }
 
-    array[0] = v[0] / v[3];
-    array[1] = v[1] / v[3];
-    array[2] = v[2] / v[3];
+    array[0] = _v[0] / _v[3];
+    array[1] = _v[1] / _v[3];
+    array[2] = _v[2] / _v[3];
   }
 
   String toString() {
     return array.toString();
   }
-
-}
+}