Add tests

src/renderers/webgl/WebGLRenderLists.js

@@ -228,4 +228,4 @@ function WebGLRenderLists() {
 }
 
 
-export { WebGLRenderLists };
+export { WebGLRenderLists, WebGLRenderList };

test/unit/src/renderers/webgl/WebGLRenderLists.tests.js

@@ -3,7 +3,9 @@
  */
 /* global QUnit */
 
-import { WebGLRenderLists } from '../../../../../src/renderers/webgl/WebGLRenderLists';
+import { WebGLRenderLists, WebGLRenderList } from '../../../../../src/renderers/webgl/WebGLRenderLists';
+import { Camera } from '../../../../../src/cameras/Camera';
+import { Scene } from '../../../../../src/scenes/Scene';
 
 export default QUnit.module( 'Renderers', () => {
 
@@ -11,23 +13,253 @@ export default QUnit.module( 'Renderers', () => {
 
 		QUnit.module( 'WebGLRenderLists', () => {
 
-			// INSTANCING
-			QUnit.todo( "Instancing", ( assert ) => {
+			// PUBLIC STUFF
+			QUnit.test( "get", ( assert ) => {
+
+				var renderLists = new WebGLRenderLists();
+				var sceneA = new Scene();
+				var sceneB = new Scene();
+				var cameraA = new Camera();
+				var cameraB = new Camera();
+
+				var listAA = renderLists.get( sceneA, cameraA );
+				var listAB = renderLists.get( sceneA, cameraB );
+				var listBA = renderLists.get( sceneB, cameraA );
 
-				assert.ok( false, "everything's gonna be alright" );
+				assert.propEqual( listAA, new WebGLRenderList(), "listAA is type of WebGLRenderList." );
+				assert.propEqual( listAB, new WebGLRenderList(), "listAB is type of WebGLRenderList." );
+				assert.ok( listAA !== listAB, "Render lists for camera A and B with same scene are different." );
+				assert.ok( listAA !== listBA, "Render lists for scene A and B with same camera are different." );
+				assert.ok( listAA === renderLists.get( sceneA, cameraA ), "The same list is returned when called with the same scene, camera." );
 
 			} );
 
-			// PUBLIC STUFF
-			QUnit.todo( "get", ( assert ) => {
+			QUnit.test( "dispose", ( assert ) => {
+
+				var renderLists = new WebGLRenderLists();
+				var scene = new Scene();
+				var camera = new Camera();
+
+				var list1 = renderLists.get( scene, camera );
+
+				scene.dispose()
+
+				var list2 = renderLists.get( scene, camera );
+
+				assert.ok( list1 !== list2, "New list should be different after disposing of the scene." );
+
+			} );
+
+		} );
+
+
+		QUnit.module( 'WebGLRenderList', () => {
+
+			QUnit.test( 'init', ( assert ) => {
+
+				var list = new WebGLRenderList();
+
+				assert.ok( list.transparent.length === 0, 'Transparent list defaults to length 0.' );
+				assert.ok( list.opaque.length === 0, 'Opaque list defaults to length 0.' );
+
+				list.push( {}, {}, { transparent: true }, 0, 0, {} );
+				list.push( {}, {}, { transparent: false }, 0, 0, {} );
+
+				assert.ok( list.transparent.length === 1, 'Transparent list is length 1 after adding transparent item.' );
+				assert.ok( list.opaque.length === 1, 'Opaque list list is length 1 after adding opaque item.' );
+
+				list.init();
 
-				assert.ok( false, "everything's gonna be alright" );
+				assert.ok( list.transparent.length === 0, 'Transparent list is length 0 after calling init.' );
+				assert.ok( list.opaque.length === 0, 'Opaque list list is length 0 after calling init.' );
 
 			} );
 
-			QUnit.todo( "dispose", ( assert ) => {
+			QUnit.todo( 'push', ( assert ) => {
+
+				var list = new WebGLRenderList();
+				var objA = { id: 'A' };
+				var matA = { transparent: true, program: { id: 1 } };
+				var geoA = {};
+
+				var objB = { id: 'B' };
+				var matB = { transparent: true, program: { id: 2 } };
+				var geoB = {};
+
+				var objC = { id: 'C' };
+				var matC = { transparent: false, program: { id: 3 } };
+				var geoC = {};
+
+				var objD = { id: 'D' };
+				var matD = { transparent: false, program: { id: 4 } };
+				var geoD = {};
+
+				list.push( objA, geoA, matA, 0, 0.5, {} );
+				assert.ok( list.transparent.length === 1, 'Transparent list is length 1 after adding transparent item.' );
+				assert.ok( list.opaque.length === 0, 'Opaque list list is length 0 after adding transparent item.' );
+				assert.deepEqual(
+					list.transparent[ 0 ],
+					{
+						id: 'A',
+						object: objA,
+						geometry: geoA,
+						material: matA,
+						program: matA.program,
+						groupOrder: 0,
+						z: 0.5,
+						group: {}
+					},
+					'The first transparent render list item is structured correctly.'
+				);
+
+				list.push( objB, geoB, matB, 1, 1.5, {} );
+				assert.ok( list.transparent.length === 2, 'Transparent list is length 2 after adding second transparent item.' );
+				assert.ok( list.opaque.length === 0, 'Opaque list list is length 0 after adding second transparent item.' );
+				assert.deepEqual(
+					list.transparent[ 1 ],
+					{
+						id: 'B',
+						object: objB,
+						geometry: geoB,
+						material: matB,
+						program: matB.program,
+						groupOrder: 1,
+						z: 1.5,
+						group: {}
+					},
+					'The second transparent render list item is structured correctly.'
+				);
+
+				list.push( objC, geoC, matC, 2, 2.5, {} );
+				assert.ok( list.transparent.length === 2, 'Transparent list is length 2 after adding first opaque item.' );
+				assert.ok( list.opaque.length === 1, 'Opaque list list is length 1 after adding first opaque item.' );
+				assert.opaque(
+					list.opaque[ 0 ],
+					{
+						id: 'C',
+						object: objC,
+						geometry: geoC,
+						material: matC,
+						program: matC.program,
+						groupOrder: 2,
+						z: 2.5,
+						group: {}
+					},
+					'The first opaque render list item is structured correctly.'
+				);
+
+				list.push( objD, geoD, matD, 3, 3.5, {} );
+				assert.ok( list.transparent.length === 2, 'Transparent list is length 2 after adding second opaque item.' );
+				assert.ok( list.opaque.length === 2, 'Opaque list list is length 2 after adding second opaque item.' );
+				assert.opaque(
+					list.opaque[ 1 ],
+					{
+						id: 'D',
+						object: objD,
+						geometry: geoD,
+						material: matD,
+						program: matD.program,
+						groupOrder: 3,
+						z: 3.5,
+						group: {}
+					},
+				);
+
+			} );
+
+			QUnit.todo( 'unshift', ( assert ) => {
+
+				var list = new WebGLRenderList();
+				var objA = { id: 'A' };
+				var matA = { transparent: true, program: { id: 1 } };
+				var geoA = {};
+
+				var objB = { id: 'B' };
+				var matB = { transparent: true, program: { id: 2 } };
+				var geoB = {};
+
+				var objC = { id: 'C' };
+				var matC = { transparent: false, program: { id: 3 } };
+				var geoC = {};
+
+				var objD = { id: 'D' };
+				var matD = { transparent: false, program: { id: 4 } };
+				var geoD = {};
+
+				list.unshift( objA, geoA, matA, 0, 0.5, {} );
+				assert.ok( list.transparent.length === 1, 'Transparent list is length 1 after adding transparent item.' );
+				assert.ok( list.opaque.length === 0, 'Opaque list list is length 0 after adding transparent item.' );
+				assert.deepEqual(
+					list.transparent[ 0 ],
+					{
+						id: 'A',
+						object: objA,
+						geometry: geoA,
+						material: matA,
+						program: matA.program,
+						groupOrder: 0,
+						z: 0.5,
+						group: {}
+					},
+					'The first transparent render list item is structured correctly.'
+				);
+
+				list.unshift( objB, geoB, matB, 1, 1.5, {} );
+				assert.ok( list.transparent.length === 2, 'Transparent list is length 2 after adding second transparent item.' );
+				assert.ok( list.opaque.length === 0, 'Opaque list list is length 0 after adding second transparent item.' );
+				assert.deepEqual(
+					list.transparent[ 0 ],
+					{
+						id: 'B',
+						object: objB,
+						geometry: geoB,
+						material: matB,
+						program: matB.program,
+						groupOrder: 1,
+						z: 1.5,
+						group: {}
+					},
+					'The second transparent render list item is structured correctly.'
+				);
+
+				list.unshift( objC, geoC, matC, 2, 2.5, {} );
+				assert.ok( list.transparent.length === 2, 'Transparent list is length 2 after adding first opaque item.' );
+				assert.ok( list.opaque.length === 1, 'Opaque list list is length 1 after adding first opaque item.' );
+				assert.opaque(
+					list.opaque[ 0 ],
+					{
+						id: 'C',
+						object: objC,
+						geometry: geoC,
+						material: matC,
+						program: matC.program,
+						groupOrder: 2,
+						z: 2.5,
+						group: {}
+					},
+					'The first opaque render list item is structured correctly.'
+				);
+
+				list.unshift( objD, geoD, matD, 3, 3.5, {} );
+				assert.ok( list.transparent.length === 2, 'Transparent list is length 2 after adding second opaque item.' );
+				assert.ok( list.opaque.length === 2, 'Opaque list list is length 2 after adding second opaque item.' );
+				assert.opaque(
+					list.opaque[ 0 ],
+					{
+						id: 'D',
+						object: objD,
+						geometry: geoD,
+						material: matD,
+						program: matD.program,
+						groupOrder: 3,
+						z: 3.5,
+						group: {}
+					},
+				);
+
+			} );
 
-				assert.ok( false, "everything's gonna be alright" );
+			QUnit.todo( 'finish', ( assert ) => {
 
 			} );