review and unity point/vector API (close #861)

all.hxml

@@ -6,6 +6,7 @@
 --macro include('hxsl',true,['hxsl.Macros','hxsl.CacheFile','hxsl.CacheFileBuilder','hxsl.Checker'])
 --macro include('hxd',true,['hxd.res.FileTree','hxd.Res','hxd.impl.BitsBuilder','hxd.impl.Air3File','hxd.fmt.pak.Build','hxd.net.SteamHost','hxd.snd.efx','hxd.snd.openal','hxd.res.Config'])
 --no-output
+-D apicheck
 --each
 
 -js heaps.js

h2d/col/IPoint.hx

@@ -1,18 +1,30 @@
 package h2d.col;
 import hxd.Math;
 
-class IPoint {
+class IPoint #if apicheck implements h2d.impl.PointApi.IPointApi<IPoint> #end {
 
 	public var x : Int;
 	public var y : Int;
 
+	// -- gen api
+
 	public inline function new(x = 0, y = 0) {
 		this.x = x;
 		this.y = y;
 	}
 
-	public inline function toPoint( scale = 1. ) {
-		return new Point(x * scale, y * scale);
+	public inline function load( p : IPoint ) {
+		this.x = p.x;
+		this.y = p.y;
+	}
+
+	public inline function scale( v : Int ) {
+		x *= v;
+		y *= v;
+	}
+
+	public inline function multiply( v : Int ) {
+		return new IPoint(x * v, y * v);
 	}
 
 	public inline function distanceSq( p : IPoint ) {
@@ -53,7 +65,7 @@ class IPoint {
 		return Math.sqrt(lengthSq());
 	}
 
-	public inline function set(x,y) {
+	public inline function set(x=0,y=0) {
 		this.x = x;
 		this.y = y;
 	}
@@ -62,4 +74,14 @@ class IPoint {
 		return new IPoint(x, y);
 	}
 
+	public inline function cross( p : IPoint ) {
+		return x * p.y - y * p.x;
+	}
+
+	// -- end gen api
+
+	public inline function toPoint( scale = 1. ) {
+		return new Point(x * scale, y * scale);
+	}
+
 }

h2d/col/Point.hx

@@ -1,20 +1,18 @@
 package h2d.col;
 import hxd.Math;
 
-class Point {
+class Point #if apicheck implements h2d.impl.PointApi<Point,Matrix> #end {
 
 	public var x : Float;
 	public var y : Float;
 
+	// -- gen api
+
 	public inline function new(x = 0., y = 0.) {
 		this.x = x;
 		this.y = y;
 	}
 
-	public inline function toIPoint( scale = 1. ) {
-		return new IPoint(Math.round(x * scale), Math.round(y * scale));
-	}
-
 	public inline function distanceSq( p : Point ) {
 		var dx = x - p.x;
 		var dy = y - p.y;
@@ -37,6 +35,10 @@ class Point {
 		return new Point(x + p.x, y + p.y);
 	}
 
+	public inline function multiply( v : Float ) {
+		return new Point(x * v, y * v);
+	}
+
 	public inline function equals( other : Point ) : Bool {
 		return x == other.x && y == other.y;
 	}
@@ -45,15 +47,6 @@ class Point {
 		return x * p.x + y * p.y;
 	}
 
-	public inline function rotate( angle : Float ) {
-		var c = Math.cos(angle);
-		var s = Math.sin(angle);
-		var x2 = x * c - y * s;
-		var y2 = x * s + y * c;
-		x = x2;
-		y = y2;
-	}
-
 	public inline function lengthSq() {
 		return x * x + y * y;
 	}
@@ -62,21 +55,20 @@ class Point {
 		return Math.sqrt(lengthSq());
 	}
 
-	public function normalize() {
+	public inline function normalize() {
 		var k = lengthSq();
 		if( k < Math.EPSILON ) k = 0 else k = Math.invSqrt(k);
 		x *= k;
 		y *= k;
 	}
 
-	public inline function normalizeFast() {
+	public inline function normalized() {
 		var k = lengthSq();
-		k = Math.invSqrt(k);
-		x *= k;
-		y *= k;
+		if( k < Math.EPSILON ) k = 0 else k = Math.invSqrt(k);
+		return new h2d.col.Point(x*k,y*k);
 	}
 
-	public inline function set(x,y) {
+	public inline function set(x=0.,y=0.) {
 		this.x = x;
 		this.y = y;
 	}
@@ -89,11 +81,61 @@ class Point {
 	public inline function scale( f : Float ) {
 		x *= f;
 		y *= f;
-		return this;
 	}
 
 	public inline function clone() {
 		return new Point(x, y);
 	}
 
+	public inline function cross( p : Point ) {
+		return x * p.y - y * p.x;
+	}
+
+	public inline function lerp( a : Point, b : Point, k : Float ) {
+		x = hxd.Math.lerp(a.x, b.x, k);
+		y = hxd.Math.lerp(a.y, a.y, k);
+	}
+
+	public inline function transform( m : Matrix ) {
+		var mx = m.a * x + m.c * y + m.c;
+		var my = m.b * x + m.d * y + m.d;
+		this.x = mx;
+		this.y = my;
+	}
+
+	public inline function transformed( m : Matrix ) {
+		var mx = m.a * x + m.c * y + m.c;
+		var my = m.b * x + m.d * y + m.d;
+		return new Point(mx,my);
+	}
+
+	public inline function transform2x2( m : Matrix ) {
+		var mx = m.a * x + m.c * y;
+		var my = m.b * x + m.d * y;
+		this.x = mx;
+		this.y = my;
+	}
+
+	public inline function transformed2x2( m : Matrix ) {
+		var mx = m.a * x + m.c * y;
+		var my = m.b * x + m.d * y;
+		return new Point(mx,my);
+	}
+
+
+	// -- end
+
+	public inline function toIPoint( scale = 1. ) {
+		return new IPoint(Math.round(x * scale), Math.round(y * scale));
+	}
+
+	public inline function rotate( angle : Float ) {
+		var c = Math.cos(angle);
+		var s = Math.sin(angle);
+		var x2 = x * c - y * s;
+		var y2 = x * s + y * c;
+		x = x2;
+		y = y2;
+	}
+
 }

h2d/impl/PointApi.hx

@@ -0,0 +1,43 @@
+package h2d.impl;
+
+interface GenPointApi<Point,Unit> {
+
+	function clone() : Point;
+	function load( p : Point ) : Void;
+	function add( p : Point ) : Point;
+	function sub( p : Point ) : Point;
+	function multiply( v : Unit ) : Point;
+
+	function scale( v : Unit ) : Void;
+	function lengthSq() : Unit;
+	function length() : Float;
+
+	function distance( p : Point ) : Float;
+	function distanceSq( p : Point ) : Unit;
+
+	function equals( other : Point ) : Bool;
+	function dot( p : Point ) : Unit;
+
+	function toString() : String;
+
+	// function set(x=0., y=0., z=0.) : Void;
+	// function cross( p : Point ) : Point (3D)
+	// function cross( p : Point ) : Unit (2D)
+
+}
+
+interface PointApi<Point,M> extends GenPointApi<Point,Float> {
+
+	function lerp( p1 : Point, p2 : Point, k : Float ) : Void;
+
+	function normalize() : Void;
+	function normalized() : Point;
+	function transform( m : M ) : Void;
+	function transformed( m : M ) : Point;
+	// function transform3x3( m : Matrix ) : Void (3D)
+	// function transform2x2( m : Matrix ) : Void (2D)
+
+}
+
+interface IPointApi<Point> extends GenPointApi<Point,Int> {
+}

h3d/Camera.hx

@@ -211,7 +211,7 @@ class Camera {
 	public function lostUp() {
 		var p2 = pos.clone();
 		p2.normalize();
-		return Math.abs(p2.dot3(up)) > 0.999;
+		return Math.abs(p2.dot(up)) > 0.999;
 	}
 
 	public function getViewDirection( dx : Float, dy : Float, dz = 0. ) {
@@ -260,10 +260,10 @@ class Camera {
 		// this way we make sure that our [ax,ay,-az] matrix follow the same handness as our world
 		// We build a transposed version of Matrix.lookAt
 		var az = target.sub(pos);
-		if( rightHanded ) az.scale3(-1);
-		az.normalizeFast();
+		if( rightHanded ) az.scale(-1);
+		az.normalize();
 		var ax = up.cross(az);
-		ax.normalizeFast();
+		ax.normalize();
 		if( ax.length() == 0 ) {
 			ax.x = az.y;
 			ax.y = az.z;
@@ -282,9 +282,9 @@ class Camera {
 		m._32 = ay.z;
 		m._33 = az.z;
 		m._34 = 0;
-		m._41 = -ax.dot3(pos);
-		m._42 = -ay.dot3(pos);
-		m._43 = -az.dot3(pos);
+		m._41 = -ax.dot(pos);
+		m._42 = -ay.dot(pos);
+		m._43 = -az.dot(pos);
 		m._44 = 1;
 	}
 

h3d/Matrix.hx

@@ -476,19 +476,19 @@ class Matrix {
 
 	public inline function front() {
         var v = new h3d.Vector(_11, _12, _13);
-        v.normalizeFast();
+        v.normalize();
         return v;
     }
 
     public inline function right() {
         var v = new h3d.Vector(_21, _22, _23);
-        v.normalizeFast();
+        v.normalize();
         return v;
     }
 
     public inline function up() {
         var v = new h3d.Vector(_31, _32, _33);
-        v.normalizeFast();
+        v.normalize();
         return v;
     }
 
@@ -770,8 +770,8 @@ class Matrix {
 	public static function lookAtX( dir : Vector, ?up : Vector, ?m : Matrix ) {
 		if( up == null ) up = new Vector(0, 0, 1);
 		if( m == null ) m = new Matrix();
-		var ax = dir.getNormalized();
-		var ay = up.cross(ax).getNormalized();
+		var ax = dir.normalized();
+		var ay = up.cross(ax).normalized();
 		if( ay.lengthSq() < Math.EPSILON ) {
 			ay.x = ax.y;
 			ay.y = ax.z;

h3d/Quat.hx

@@ -65,8 +65,8 @@ class Quat {
 
 	public function initDirection( dir : Vector ) {
 		// inlined version of initRotationMatrix(Matrix.lookAtX(dir))
-		var ax = dir.clone().getNormalized();
-		var ay = new Vector(-ax.y, ax.x, 0).getNormalized();
+		var ax = dir.clone().normalized();
+		var ay = new Vector(-ax.y, ax.x, 0).normalized();
 		if( ay.lengthSq() < Math.EPSILON ) {
 			ay.x = ax.y;
 			ay.y = ax.z;

h3d/Vector.hx

@@ -4,14 +4,15 @@ using hxd.Math;
 /**
 	A 4 floats vector. Everytime a Vector is returned, it means a copy is created.
 **/
-@:noDebug
-class Vector {
+class Vector #if apicheck implements h2d.impl.PointApi<Vector,Matrix> #end {
 
 	public var x : Float;
 	public var y : Float;
 	public var z : Float;
 	public var w : Float;
 
+	// -- gen api
+
 	public inline function new( x = 0., y = 0., z = 0., w = 1. ) {
 		this.x = x;
 		this.y = y;
@@ -38,22 +39,22 @@ class Vector {
 		return new Vector(x + v.x, y + v.y, z + v.z, w + v.w);
 	}
 
-	// note : cross product is left-handed
-	public inline function cross( v : Vector ) {
-		return new Vector(y * v.z - z * v.y, z * v.x - x * v.z,  x * v.y - y * v.x, 1);
+	public inline function multiply( v : Float ) {
+		// multiply only affects length
+		return new Vector(x * v, y * v, z * v, w);
 	}
 
-	public inline function reflect( n : Vector ) {
-		var k = 2 * this.dot3(n);
-		return new Vector(x - k * n.x, y - k * n.y, z - k * n.z, 1);
+	public inline function equals( v : Vector ) {
+		return x == v.x && y == v.y && z == v.z && w == v.w;
 	}
 
-	public inline function dot3( v : Vector ) {
-		return x * v.x + y * v.y + z * v.z;
+	public inline function cross( v : Vector ) {
+		// note : cross product is left-handed
+		return new Vector(y * v.z - z * v.y, z * v.x - x * v.z,  x * v.y - y * v.x, 1);
 	}
 
-	public inline function dot4( v : Vector ) {
-		return x * v.x + y * v.y + z * v.z + w * v.w;
+	public inline function dot( v : Vector ) {
+		return x * v.x + y * v.y + z * v.z;
 	}
 
 	public inline function lengthSq() {
@@ -64,7 +65,7 @@ class Vector {
 		return lengthSq().sqrt();
 	}
 
-	public function normalize() {
+	public inline function normalize() {
 		var k = lengthSq();
 		if( k < hxd.Math.EPSILON ) k = 0 else k = k.invSqrt();
 		x *= k;
@@ -72,14 +73,7 @@ class Vector {
 		z *= k;
 	}
 
-	public inline function normalizeFast() {
-		var k = lengthSq().invSqrt();
-		x *= k;
-		y *= k;
-		z *= k;
-	}
-
-	public inline function getNormalized() {
+	public inline function normalized() {
 		var k = lengthSq();
 		if( k < hxd.Math.EPSILON ) k = 0 else k = k.invSqrt();
 		return new Vector(x * k, y * k, z * k);
@@ -99,32 +93,36 @@ class Vector {
 		this.w = v.w;
 	}
 
-	public inline function scale3( f : Float ) {
+	public inline function scale( f : Float ) {
 		x *= f;
 		y *= f;
 		z *= f;
 	}
 
-	public inline function project( m : Matrix ) {
+	public inline function lerp( v1 : Vector, v2 : Vector, k : Float ) {
+		this.x = Math.lerp(v1.x, v2.x, k);
+		this.y = Math.lerp(v1.y, v2.y, k);
+		this.z = Math.lerp(v1.z, v2.z, k);
+		this.w = Math.lerp(v1.w, v2.w, k);
+	}
+
+	public inline function transform( m : Matrix ) {
 		var px = x * m._11 + y * m._21 + z * m._31 + w * m._41;
 		var py = x * m._12 + y * m._22 + z * m._32 + w * m._42;
 		var pz = x * m._13 + y * m._23 + z * m._33 + w * m._43;
-		var iw = 1 / (x * m._14 + y * m._24 + z * m._34 + w * m._44);
-		x = px * iw;
-		y = py * iw;
-		z = pz * iw;
-		w = 1;
+		var pw = x * m._14 + y * m._24 + z * m._34 + w * m._44;
+		x = px;
+		y = py;
+		z = pz;
+		w = pw;
 	}
 
-	public inline function lerp( v1 : Vector, v2 : Vector, k : Float ) {
-		var x = Math.lerp(v1.x, v2.x, k);
-		var y = Math.lerp(v1.y, v2.y, k);
-		var z = Math.lerp(v1.z, v2.z, k);
-		var w = Math.lerp(v1.w, v2.w, k);
-		this.x = x;
-		this.y = y;
-		this.z = z;
-		this.w = w;
+	public inline function transformed( m : Matrix ) {
+		var px = x * m._11 + y * m._21 + z * m._31 + w * m._41;
+		var py = x * m._12 + y * m._22 + z * m._32 + w * m._42;
+		var pz = x * m._13 + y * m._23 + z * m._33 + w * m._43;
+		var pw = x * m._14 + y * m._24 + z * m._34 + w * m._44;
+		return new Vector(x,y,z,w);
 	}
 
 	public inline function transform3x4( m : Matrix ) {
@@ -136,6 +134,13 @@ class Vector {
 		z = pz;
 	}
 
+	public inline function transformed3x4( m : Matrix ) {
+		var px = x * m._11 + y * m._21 + z * m._31 + w * m._41;
+		var py = x * m._12 + y * m._22 + z * m._32 + w * m._42;
+		var pz = x * m._13 + y * m._23 + z * m._33 + w * m._43;
+		return new Vector(px,py,pz);
+	}
+
 	public inline function transform3x3( m : Matrix ) {
 		var px = x * m._11 + y * m._21 + z * m._31;
 		var py = x * m._12 + y * m._22 + z * m._32;
@@ -145,15 +150,11 @@ class Vector {
 		z = pz;
 	}
 
-	public inline function transform( m : Matrix ) {
-		var px = x * m._11 + y * m._21 + z * m._31 + w * m._41;
-		var py = x * m._12 + y * m._22 + z * m._32 + w * m._42;
-		var pz = x * m._13 + y * m._23 + z * m._33 + w * m._43;
-		var pw = x * m._14 + y * m._24 + z * m._34 + w * m._44;
-		x = px;
-		y = py;
-		z = pz;
-		w = pw;
+	public inline function transformed3x3( m : Matrix ) {
+		var px = x * m._11 + y * m._21 + z * m._31;
+		var py = x * m._12 + y * m._22 + z * m._32;
+		var pz = x * m._13 + y * m._23 + z * m._33;
+		return new Vector(px,py,pz);
 	}
 
 	public inline function clone() {
@@ -168,6 +169,28 @@ class Vector {
 		return '{${x.fmt()},${y.fmt()},${z.fmt()},${w.fmt()}}';
 	}
 
+	// --- end
+
+	public inline function reflect( n : Vector ) {
+		var k = 2 * this.dot(n);
+		return new Vector(x - k * n.x, y - k * n.y, z - k * n.z, 1);
+	}
+
+	public inline function dot4( v : Vector ) {
+		return x * v.x + y * v.y + z * v.z + w * v.w;
+	}
+
+	public inline function project( m : Matrix ) {
+		var px = x * m._11 + y * m._21 + z * m._31 + w * m._41;
+		var py = x * m._12 + y * m._22 + z * m._32 + w * m._42;
+		var pz = x * m._13 + y * m._23 + z * m._33 + w * m._43;
+		var iw = 1 / (x * m._14 + y * m._24 + z * m._34 + w * m._44);
+		x = px * iw;
+		y = py * iw;
+		z = pz * iw;
+		w = 1;
+	}
+
 	/// ----- COLOR FUNCTIONS
 
 	public var r(get, set) : Float;
@@ -241,7 +264,7 @@ class Vector {
 		else {
 			var d = max - min;
 			s = l > 0.5 ? d / (2 - max - min) : d / (max + min);
-			if(max == r) 
+			if(max == r)
 				h = (g - b) / d + (g < b ? 6.0 : 0.0);
 			else if(max == g)
 				h = (b - r) / d + 2.0;
@@ -267,4 +290,18 @@ class Vector {
 		return r;
 	}
 
+	// deprecated (but not yet warnings)
+
+	@:noCompletion public inline function scale3( v : Float ) {
+		scale(v);
+	}
+
+	@:noCompletion public inline function dot3( v : Vector ) {
+		return dot(v);
+	}
+
+	@:noCompletion public inline function normalizeFast() {
+		normalize();
+	}
+
 }

h3d/col/IPoint.hx

@@ -1,12 +1,14 @@
 package h3d.col;
 using hxd.Math;
 
-class IPoint {
+class IPoint #if apicheck implements h2d.impl.PointApi.IPointApi<IPoint> #end {
 
 	public var x : Int;
 	public var y : Int;
 	public var z : Int;
 
+	// -- gen api
+
 	public inline function new(x=0,y=0,z=0) {
 		this.x = x;
 		this.y = y;
@@ -17,7 +19,11 @@ class IPoint {
 		return 'IPoint{$x,$y,$z}';
 	}
 
-	public inline function set(x, y, z) {
+	public inline function multiply( v : Int ) {
+		return new IPoint(x * v, y * v, z * v);
+	}
+
+	public inline function set(x=0, y=0, z=0) {
 		this.x = x;
 		this.y = y;
 		this.z = z;
@@ -33,4 +39,49 @@ class IPoint {
 		this.z = p.z;
 	}
 
+	public inline function distanceSq( p : IPoint ) {
+		var dx = p.x - x;
+		var dy = p.y - y;
+		var dz = p.z - z;
+		return dx * dx + dy * dy + dz * dz;
+	}
+
+	public inline function distance( p : IPoint ) {
+		return Math.sqrt(distanceSq(p));
+	}
+
+	public inline function lengthSq() {
+		return x * x + y * y + z * z;
+	}
+
+	public inline function length() {
+		return Math.sqrt(x * x + y * y + z * z);
+	}
+
+	public inline function clone() {
+		return new IPoint(x,y,z);
+	}
+
+	public inline function scale( v : Int ) {
+		x *= v;
+		y *= v;
+		z *= v;
+	}
+
+	public inline function add( p : IPoint ) {
+		return new IPoint(x + p.x, y + p.y, z + p.z);
+	}
+
+	public inline function sub( p : IPoint ) {
+		return new IPoint(x - p.x, y - p.y, z - p.z);
+	}
+
+	public inline function dot( p : IPoint ) {
+		return x * p.x + y * p.y + z * p.z;
+	}
+
+	public inline function cross( p : IPoint ) {
+		return new IPoint(y * p.z - z * p.y, z * p.x - x * p.z,  x * p.y - y * p.x);
+	}
+
 }

h3d/col/Point.hx

@@ -1,12 +1,14 @@
 package h3d.col;
 using hxd.Math;
 
-class Point {
+class Point #if apicheck implements h2d.impl.PointApi<Point,Matrix> #end {
 
 	public var x : Float;
 	public var y : Float;
 	public var z : Float;
 
+	// -- gen api ---
+
 	public inline function new(x=0.,y=0.,z=0.) {
 		this.x = x;
 		this.y = y;
@@ -19,20 +21,12 @@ class Point {
 		z *= v;
 	}
 
-	public inline function inFrustum( f : Frustum, ?m : h3d.Matrix ) {
-		return f.hasPoint(this);
-	}
-
-	public inline function set(x, y, z) {
+	public inline function set(x=0., y=0., z=0.) {
 		this.x = x;
 		this.y = y;
 		this.z = z;
 	}
 
-	public inline function multiply( f : Float ) {
-		return new Point(x * f, y * f, z * f);
-	}
-
 	public inline function sub( p : Point ) {
 		return new Point(x - p.x, y - p.y, z - p.z);
 	}
@@ -41,6 +35,10 @@ class Point {
 		return new Point(x + p.x, y + p.y, z + p.z);
 	}
 
+	public inline function multiply( v : Float ) {
+		return new Point(x * v, y * v, z * v);
+	}
+
 	public inline function cross( p : Point ) {
 		return new Point(y * p.z - z * p.y, z * p.x - x * p.z,  x * p.y - y * p.x);
 	}
@@ -53,13 +51,6 @@ class Point {
 		return x * x + y * y + z * z;
 	}
 
-	public inline function setLength(len:Float) {
-		normalizeFast();
-		x *= len;
-		y *= len;
-		z *= len;
-	}
-
 	public inline function length() {
 		return lengthSq().sqrt();
 	}
@@ -79,22 +70,18 @@ class Point {
 		return distanceSq(p).sqrt();
 	}
 
-	public function normalize() {
+	public inline function normalize() {
 		var k = x * x + y * y + z * z;
 		if( k < hxd.Math.EPSILON ) k = 0 else k = k.invSqrt();
 		x *= k;
 		y *= k;
 		z *= k;
-		return this;
 	}
 
-	public inline function normalizeFast() {
+	public inline function normalized() {
 		var k = x * x + y * y + z * z;
-		k = k.invSqrt();
-		x *= k;
-		y *= k;
-		z *= k;
-		return this;
+		if( k < hxd.Math.EPSILON ) k = 0 else k = k.invSqrt();
+		return new Point(x*k,y*k,z*k);
 	}
 
 	public inline function lerp( p1 : Point, p2 : Point, k : Float ) {
@@ -115,6 +102,13 @@ class Point {
 		z = pz;
 	}
 
+	public inline function transformed( m : Matrix ) {
+		var px = x * m._11 + y * m._21 + z * m._31 + m._41;
+		var py = x * m._12 + y * m._22 + z * m._32 + m._42;
+		var pz = x * m._13 + y * m._23 + z * m._33 + m._43;
+		return new Point(px,py,pz);
+	}
+
 	public inline function transform3x3( m : Matrix ) {
 		var px = x * m._11 + y * m._21 + z * m._31;
 		var py = x * m._12 + y * m._22 + z * m._32;
@@ -124,8 +118,11 @@ class Point {
 		z = pz;
 	}
 
-	public inline function toVector() {
-		return new Vector(x, y, z);
+	public inline function transformed3x3( m : Matrix ) {
+		var px = x * m._11 + y * m._21 + z * m._31;
+		var py = x * m._12 + y * m._22 + z * m._32;
+		var pz = x * m._13 + y * m._23 + z * m._33;
+		return new Point(px,py,pz);
 	}
 
 	public inline function clone() {
@@ -142,4 +139,15 @@ class Point {
 		return 'Point{${x.fmt()},${y.fmt()},${z.fmt()}}';
 	}
 
+	// ----
+
+	public inline function inFrustum( f : Frustum, ?m : h3d.Matrix ) {
+		return f.hasPoint(this);
+	}
+
+	public inline function toVector() {
+		return new Vector(x, y, z);
+	}
+
+
 }

h3d/parts/GpuParticles.hx

@@ -335,7 +335,7 @@ class GpuPartGroup {
 			v.x = srand();
 			v.y = srand();
 			v.z = srand();
-			v.normalizeFast();
+			v.normalize();
 			var r = g.emitStartDist + g.emitDist * rand();
 			p.x = v.x * r;
 			p.y = v.y * r;
@@ -363,7 +363,7 @@ class GpuPartGroup {
 			v.y = Math.sin(phi) * Math.sin(theta);
 			v.z = Math.cos(phi);
 
-			v.normalizeFast();
+			v.normalize();
 			var r = g.emitStartDist + g.emitDist * (emitOnBorder ? 1 : Math.sqrt(rand()));
 			p.x = Math.cos(theta) * r;
 			p.y = Math.sin(theta) * r;
@@ -410,7 +410,7 @@ class GpuPartGroup {
 			v.x = srand();
 			v.y = srand();
 			v.z = srand();
-			v.normalizeFast();
+			v.normalize();
 
 		}
 

h3d/prim/BigPrimitive.hx

@@ -241,7 +241,7 @@ class BigPrimitive extends Primitive {
 				if(mat != null) {
 					var pt = new h3d.col.Point(nx, ny, nz);
 					pt.transform3x3(mat);
-					pt.normalizeFast();
+					pt.normalize();
 					add(pt.x);
 					add(pt.y);
 					add(pt.z);
@@ -265,7 +265,7 @@ class BigPrimitive extends Primitive {
 					var pt = new h3d.col.Point(tx, ty, tz);
 					var len = pt.lengthSq();
 					pt.transform3x3(mat);
-					pt.normalizeFast();
+					pt.normalize();
 					if( len < 0.5 ) pt.scale(0.5);
 					add(pt.x);
 					add(pt.y);

h3d/scene/pbr/DirLight.hx

@@ -23,9 +23,9 @@ class DirLight extends Light {
 
 	override function emit(ctx:RenderContext) {
 		pbr.lightColor.load(_color);
-		pbr.lightColor.scale3(power * power);
+		pbr.lightColor.scale(power * power);
 		pbr.lightDir.load(absPos.front());
-		pbr.lightDir.scale3(-1);
+		pbr.lightDir.scale(-1);
 		pbr.lightDir.normalize();
 		pbr.occlusionFactor = occlusionFactor;
 		super.emit(ctx);

h3d/scene/pbr/PointLight.hx

@@ -46,7 +46,7 @@ class PointLight extends Light {
 		var range = hxd.Math.max(range, 1e-10);
 		var size = hxd.Math.min(size, range);
 		var power = power * 10; // base scale
-		pbr.lightColor.scale3(power * power);
+		pbr.lightColor.scale(power * power);
 		pbr.lightPos.set(absPos.tx, absPos.ty, absPos.tz);
 		pbr.invLightRange4 = 1 / (range * range * range * range);
 		pbr.pointSize = size;

h3d/scene/pbr/SpotLight.hx

@@ -106,7 +106,7 @@ class SpotLight extends Light {
 
 		pbr.lightColor.load(_color);
 		var power = power;
-		pbr.lightColor.scale3(power * power);
+		pbr.lightColor.scale(power * power);
 		pbr.lightPos.set(absPos.tx, absPos.ty, absPos.tz);
 		pbr.spotDir.load(absPos.front());
 		pbr.angle = hxd.Math.cos(hxd.Math.degToRad(angle/2.0));
@@ -137,7 +137,7 @@ class SpotLight extends Light {
 			throw "Rendering a pbr light require a PBR compatible scene renderer";
 
 		d.load(absPos.front());
-		d.scale3(range / 2.0);
+		d.scale(range / 2.0);
 		s.x = absPos.tx + d.x;
 		s.y = absPos.ty + d.y;
 		s.z = absPos.tz + d.z;