Add cameras es6 unit tests

test/unit/src/cameras/ArrayCamera.tests.js

@@ -0,0 +1,35 @@
+/**
+ * @author TristanVALCKE / https://github.com/Itee
+ */
+/* global QUnit */
+
+import { ArrayCamera } from '../../../../src/cameras/ArrayCamera';
+
+export default QUnit.module( 'Cameras', () => {
+
+	QUnit.module.todo( 'ArrayCamera', () => {
+
+		// INHERITANCE
+		QUnit.test( "Extending", ( assert ) => {
+
+			assert.ok( false, "everything's gonna be alright" );
+
+		} );
+
+		// INSTANCING
+		QUnit.test( "Instancing", ( assert ) => {
+
+			assert.ok( false, "everything's gonna be alright" );
+
+		} );
+
+		// PUBLIC STUFF
+		QUnit.test( "isArrayCamera", ( assert ) => {
+
+			assert.ok( false, "everything's gonna be alright" );
+
+		} );
+
+	} );
+
+} );

test/unit/src/cameras/Camera.tests.js

@@ -0,0 +1,84 @@
+/**
+ * @author simonThiele / https://github.com/simonThiele
+ * @author TristanVALCKE / https://github.com/Itee
+ */
+/* global QUnit */
+
+import { Camera } from '../../../../src/cameras/Camera';
+import { Vector3 } from '../../../../src/math/Vector3';
+
+export default QUnit.module( 'Cameras', () => {
+
+	QUnit.module.todo( 'Camera', () => {
+
+		// INHERITANCE
+		QUnit.test( "Extending", ( assert ) => {
+
+			assert.ok( false, "everything's gonna be alright" );
+
+		} );
+
+		// INSTANCING
+		QUnit.test( "Instancing", ( assert ) => {
+
+			assert.ok( false, "everything's gonna be alright" );
+
+		} );
+
+		// PUBLIC STUFF
+		QUnit.test( "isCamera", ( assert ) => {
+
+			assert.ok( false, "everything's gonna be alright" );
+
+		} );
+
+		QUnit.test( "copy", ( assert ) => {
+
+			assert.ok( false, "everything's gonna be alright" );
+
+		} );
+
+		QUnit.test( "getWorldDirection", ( assert ) => {
+
+			assert.ok( false, "everything's gonna be alright" );
+
+		} );
+
+		QUnit.test( "updateMatrixWorld", ( assert ) => {
+
+			assert.ok( false, "everything's gonna be alright" );
+
+		} );
+
+		QUnit.test( "clone", ( assert ) => {
+
+			var cam = new Camera();
+
+			// fill the matrices with any nonsense values just to see if they get copied
+			cam.matrixWorldInverse.set( 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16 );
+			cam.projectionMatrix.set( 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16 );
+
+			var clonedCam = cam.clone();
+
+			// TODO: Uuuummmhhh DO NOT relie equality on object methods !
+			// TODO: What's append if matrix.equal is wrongly implemented ???
+			// TODO: this MUST be check by assert
+			assert.ok( cam.matrixWorldInverse.equals( clonedCam.matrixWorldInverse ), "matrixWorldInverse is equal" );
+			assert.ok( cam.projectionMatrix.equals( clonedCam.projectionMatrix ), "projectionMatrix is equal" );
+
+		} );
+
+		// OTHERS
+		// TODO: this should not be here !!! This is Object3D stuff !!!
+		QUnit.test( "lookAt", ( assert ) => {
+
+			var cam = new Camera();
+			cam.lookAt( new Vector3( 0, 1, - 1 ) );
+
+			assert.numEqual( cam.rotation.x * ( 180 / Math.PI ), 45, "x is equal" );
+
+		} );
+
+	} );
+
+} );

test/unit/src/cameras/CubeCamera.tests.js

@@ -0,0 +1,28 @@
+/**
+ * @author TristanVALCKE / https://github.com/Itee
+ */
+/* global QUnit */
+
+import { CubeCamera } from '../../../../src/cameras/CubeCamera';
+
+export default QUnit.module( 'Cameras', () => {
+
+	QUnit.module.todo( 'CubeCamera', () => {
+
+		// INHERITANCE
+		QUnit.test( "Extending", ( assert ) => {
+
+			assert.ok( false, "everything's gonna be alright" );
+
+		} );
+
+		// INSTANCING
+		QUnit.test( "Instancing", ( assert ) => {
+
+			assert.ok( false, "everything's gonna be alright" );
+
+		} );
+
+	} );
+
+} );

test/unit/src/cameras/OrthographicCamera.tests.js

@@ -0,0 +1,102 @@
+/**
+ * @author simonThiele / https://github.com/simonThiele
+ * @author TristanVALCKE / https://github.com/Itee
+ */
+/* global QUnit */
+
+import { OrthographicCamera } from '../../../../src/cameras/OrthographicCamera';
+
+export default QUnit.module( 'Cameras', () => {
+
+	QUnit.module.todo( 'OrthographicCamera', () => {
+
+		// INHERITANCE
+		QUnit.test( "Extending", ( assert ) => {
+
+			assert.ok( false, "everything's gonna be alright" );
+
+		} );
+
+		// INSTANCING
+		QUnit.test( "Instancing", ( assert ) => {
+
+			assert.ok( false, "everything's gonna be alright" );
+
+		} );
+
+		// PUBLIC STUFF
+		QUnit.test( "isOrthographicCamera", ( assert ) => {
+
+			assert.ok( false, "everything's gonna be alright" );
+
+		} );
+
+		QUnit.test( "copy", ( assert ) => {
+
+			assert.ok( false, "everything's gonna be alright" );
+
+		} );
+
+		QUnit.test( "setViewOffset", ( assert ) => {
+
+			assert.ok( false, "everything's gonna be alright" );
+
+		} );
+
+		QUnit.test( "clearViewOffset", ( assert ) => {
+
+			assert.ok( false, "everything's gonna be alright" );
+
+		} );
+
+		QUnit.test( "updateProjectionMatrix", ( assert ) => {
+
+			var left = - 1, right = 1, top = 1, bottom = - 1, near = 1, far = 3;
+			var cam = new OrthographicCamera( left, right, top, bottom, near, far );
+
+			// updateProjectionMatrix is called in contructor
+			var pMatrix = cam.projectionMatrix.elements;
+
+			// orthographic projection is given my the 4x4 Matrix
+			// 2/r-l		0			 0		-(l+r/r-l)
+			//   0		2/t-b		 0		-(t+b/t-b)
+			//   0			0		-2/f-n	-(f+n/f-n)
+			//   0			0			 0				1
+
+			assert.ok( pMatrix[ 0 ] === 2 / ( right - left ), "m[0,0] === 2 / (r - l)" );
+			assert.ok( pMatrix[ 5 ] === 2 / ( top - bottom ), "m[1,1] === 2 / (t - b)" );
+			assert.ok( pMatrix[ 10 ] === - 2 / ( far - near ), "m[2,2] === -2 / (f - n)" );
+			assert.ok( pMatrix[ 12 ] === - ( ( right + left ) / ( right - left ) ), "m[3,0] === -(r+l/r-l)" );
+			assert.ok( pMatrix[ 13 ] === - ( ( top + bottom ) / ( top - bottom ) ), "m[3,1] === -(t+b/b-t)" );
+			assert.ok( pMatrix[ 14 ] === - ( ( far + near ) / ( far - near ) ), "m[3,2] === -(f+n/f-n)" );
+
+		} );
+
+		QUnit.test( "toJSON", ( assert ) => {
+
+			assert.ok( false, "everything's gonna be alright" );
+
+		} );
+
+		// OTHERS
+		// TODO: no no no clone is a camera methods that relied to copy method
+		QUnit.test( "clone", ( assert ) => {
+
+			var left = - 1.5, right = 1.5, top = 1, bottom = - 1, near = 0.1, far = 42;
+			var cam = new OrthographicCamera( left, right, top, bottom, near, far );
+
+			var clonedCam = cam.clone();
+
+			assert.ok( cam.left === clonedCam.left, "left is equal" );
+			assert.ok( cam.right === clonedCam.right, "right is equal" );
+			assert.ok( cam.top === clonedCam.top, "top is equal" );
+			assert.ok( cam.bottom === clonedCam.bottom, "bottom is equal" );
+			assert.ok( cam.near === clonedCam.near, "near is equal" );
+			assert.ok( cam.far === clonedCam.far, "far is equal" );
+			assert.ok( cam.zoom === clonedCam.zoom, "zoom is equal" );
+
+		} );
+
+	} );
+
+} );

test/unit/src/cameras/PerspectiveCamera.tests.js

@@ -0,0 +1,164 @@
+/**
+ * @author simonThiele / https://github.com/simonThiele
+ * @author TristanVALCKE / https://github.com/Itee
+ */
+/* global QUnit */
+
+import { PerspectiveCamera } from '../../../../src/cameras/PerspectiveCamera';
+import { Matrix4 } from '../../../../src/math/Matrix4';
+
+export default QUnit.module( 'Cameras', () => {
+
+	QUnit.module.todo( 'PerspectiveCamera', () => {
+
+		// see e.g. math/Matrix4.js
+		var matrixEquals4 = function ( a, b, tolerance ) {
+
+			tolerance = tolerance || 0.0001;
+			if ( a.elements.length != b.elements.length ) {
+
+				return false;
+
+			}
+			for ( var i = 0, il = a.elements.length; i < il; i ++ ) {
+
+				var delta = a.elements[ i ] - b.elements[ i ];
+				if ( delta > tolerance ) {
+
+					return false;
+
+				}
+
+			}
+
+			return true;
+
+		};
+
+		// INHERITANCE
+		QUnit.test( "Extending", ( assert ) => {
+
+			assert.ok( false, "everything's gonna be alright" );
+
+		} );
+
+		// INSTANCING
+		QUnit.test( "Instancing", ( assert ) => {
+
+			assert.ok( false, "everything's gonna be alright" );
+
+		} );
+
+		// PUBLIC STUFF
+		QUnit.test( "isPerspectiveCamera", ( assert ) => {
+
+			assert.ok( false, "everything's gonna be alright" );
+
+		} );
+
+		QUnit.test( "copy", ( assert ) => {
+
+			assert.ok( false, "everything's gonna be alright" );
+
+		} );
+
+		QUnit.test( "setFocalLength", ( assert ) => {
+
+			assert.ok( false, "everything's gonna be alright" );
+
+		} );
+
+		QUnit.test( "getFocalLength", ( assert ) => {
+
+			assert.ok( false, "everything's gonna be alright" );
+
+		} );
+
+		QUnit.test( "getEffectiveFOV", ( assert ) => {
+
+			assert.ok( false, "everything's gonna be alright" );
+
+		} );
+
+		QUnit.test( "getFilmWidth", ( assert ) => {
+
+			assert.ok( false, "everything's gonna be alright" );
+
+		} );
+
+		QUnit.test( "getFilmHeight", ( assert ) => {
+
+			assert.ok( false, "everything's gonna be alright" );
+
+		} );
+
+		QUnit.test( "setViewOffset", ( assert ) => {
+
+			assert.ok( false, "everything's gonna be alright" );
+
+		} );
+
+		QUnit.test( "clearViewOffset", ( assert ) => {
+
+			assert.ok( false, "everything's gonna be alright" );
+
+		} );
+
+		QUnit.test( "updateProjectionMatrix", ( assert ) => {
+
+			var cam = new PerspectiveCamera( 75, 16 / 9, 0.1, 300.0 );
+
+			// updateProjectionMatrix is called in contructor
+			var m = cam.projectionMatrix;
+
+			// perspective projection is given my the 4x4 Matrix
+			// 2n/r-l		0			l+r/r-l				 0
+			//   0		2n/t-b	t+b/t-b				 0
+			//   0			0		-(f+n/f-n)	-(2fn/f-n)
+			//   0			0				-1					 0
+
+			// this matrix was calculated by hand via glMatrix.perspective(75, 16 / 9, 0.1, 300.0, pMatrix)
+			// to get a reference matrix from plain WebGL
+			var reference = new Matrix4().set(
+				0.7330642938613892, 0, 0, 0,
+				0, 1.3032253980636597, 0, 0,
+				0, 0, - 1.000666856765747, - 0.2000666856765747,
+				0, 0, - 1, 0
+			);
+
+			// assert.ok( reference.equals(m) );
+			assert.ok( matrixEquals4( reference, m, 0.000001 ) );
+
+		} );
+
+		QUnit.test( "toJSON", ( assert ) => {
+
+			assert.ok( false, "everything's gonna be alright" );
+
+		} );
+
+		// OTHERS
+		// TODO: no no no clone is a camera methods that relied to copy method
+		QUnit.test( "clone", ( assert ) => {
+
+			var near = 1,
+				far = 3,
+				aspect = 16 / 9,
+				fov = 90;
+
+			var cam = new PerspectiveCamera( fov, aspect, near, far );
+
+			var clonedCam = cam.clone();
+
+			assert.ok( cam.fov === clonedCam.fov, "fov is equal" );
+			assert.ok( cam.aspect === clonedCam.aspect, "aspect is equal" );
+			assert.ok( cam.near === clonedCam.near, "near is equal" );
+			assert.ok( cam.far === clonedCam.far, "far is equal" );
+			assert.ok( cam.zoom === clonedCam.zoom, "zoom is equal" );
+			assert.ok( cam.projectionMatrix.equals( clonedCam.projectionMatrix ), "projectionMatrix is equal" );
+
+		} );
+
+	} );
+
+} );

test/unit/src/cameras/StereoCamera.tests.js

@@ -0,0 +1,28 @@
+/**
+ * @author TristanVALCKE / https://github.com/Itee
+ */
+/* global QUnit */
+
+import { StereoCamera } from '../../../../src/cameras/StereoCamera';
+
+export default QUnit.module( 'Cameras', () => {
+
+	QUnit.module.todo( 'StereoCamera', () => {
+
+		// INSTANCING
+		QUnit.test( "Instancing", ( assert ) => {
+
+			assert.ok( false, "everything's gonna be alright" );
+
+		} );
+
+		// PUBLIC STUFF
+		QUnit.test( "update", ( assert ) => {
+
+			assert.ok( false, "everything's gonna be alright" );
+
+		} );
+
+	} );
+
+} );