Moving WIP geometries to examples/js/wip.

examples/js/wip/CircleGeometry2.js

@@ -0,0 +1,75 @@
+/**
+ * @author hughes
+ * @author mrdoob / http://mrdoob.com/
+ */
+
+THREE.CircleGeometry2 = function ( radius, segments, thetaStart, thetaLength ) {
+
+	this.parameters = {
+		radius: radius,
+		segments: segments,
+		thetaStart: thetaStart,
+		thetaLength: thetaLength
+	};
+
+	radius = radius || 50;
+	segments = segments !== undefined ? Math.max( 3, segments ) : 8;
+
+	thetaStart = thetaStart !== undefined ? thetaStart : 0;
+	thetaLength = thetaLength !== undefined ? thetaLength : Math.PI * 2;
+
+	//
+
+	var elements = segments + 2;
+
+	var indices = new Uint16Array( segments * 3 );
+	var vertices = new Float32Array( elements * 3 );
+	var normals = new Float32Array( elements * 3 );
+	var uvs = new Float32Array( elements * 2 );
+
+	// center
+
+	normals[ 2 ] = 1;
+
+	uvs[ 0 ] = 0.5;
+	uvs[ 1 ] = 0.5;
+
+	var offset = 0, offset2 = 2, offset3 = 3;
+
+	for ( var i = 0; i <= segments; i ++ ) {
+
+		var segment = thetaStart + i / segments * thetaLength;
+
+		var x = radius * Math.cos( segment );
+		var y = radius * Math.sin( segment );
+
+		vertices[ offset3     ] = x;
+		vertices[ offset3 + 1 ] = y;
+
+		normals[ offset3 + 2 ] = 1;
+
+		uvs[ offset2     ] = ( x / radius + 1 ) / 2;
+		uvs[ offset2 + 1 ] = ( y / radius + 1 ) / 2;
+
+		offset2 += 2;
+		offset3 += 3;
+
+		//
+
+		indices[ offset     ] = 0;
+		indices[ offset + 1 ] = i + 1;
+		indices[ offset + 2 ] = i + 2;
+
+		offset  += 3;
+
+	}
+
+	THREE.IndexedGeometry2.call( this );
+
+	this.setArrays( indices, vertices, normals, uvs );
+
+	this.boundingSphere = new THREE.Sphere( new THREE.Vector3(), radius );
+
+};
+
+THREE.CircleGeometry.prototype = Object.create( THREE.IndexedGeometry2.prototype );

examples/js/wip/Geometry2.js

@@ -6,14 +6,116 @@ THREE.Geometry2 = function ( size ) {
 
 	THREE.BufferGeometry.call( this );
 
-	this.vertices = new THREE.Float32Attribute( size, 3 );
-	this.normals = new THREE.Float32Attribute( size, 3 );
-	this.uvs = new THREE.Float32Attribute( size, 2 );
+	if ( size !== undefined ) {
 
-	this.addAttribute( 'position', this.vertices );
-	this.addAttribute( 'normal', this.normals );
-	this.addAttribute( 'uv', this.uvs );
+		this.vertices = new Float32Array( size * 3 * 3 );
+		this.normals = new Float32Array( size * 3 * 3 );
+		this.uvs = new Float32Array( size * 3 * 2 );
+
+		this.attributes[ 'position' ] = { array: this.vertices, itemSize: 3 };
+		this.attributes[ 'normal' ] = { array: this.normals, itemSize: 3 };
+		this.attributes[ 'uv' ] = { array: this.uvs, itemSize: 2 };
+
+	}
+
+};
+
+THREE.Geometry2.prototype = Object.create( THREE.BufferGeometry.prototype );
+
+THREE.Geometry2.prototype.setArrays = function ( vertices, normals, uvs ) {
+
+	this.vertices = vertices;
+	this.normals = normals;
+	this.uvs = uvs;
+
+	this.attributes[ 'position' ] = { array: vertices, itemSize: 3 };
+	this.attributes[ 'normal' ] = { array: normals, itemSize: 3 };
+	this.attributes[ 'uv' ] = { array: uvs, itemSize: 2 };
+
+	return this;
 
 };
 
-THREE.Geometry2.prototype = Object.create( THREE.BufferGeometry.prototype );
+THREE.Geometry2.prototype.merge = ( function () {
+
+	var offset = 0;
+	var normalMatrix = new THREE.Matrix3();
+
+	return function ( geometry, matrix, startOffset ) {
+
+		if ( startOffset !== undefined ) offset = startOffset;
+
+		var offset2 = offset * 2;
+		var offset3 = offset * 3;
+
+		var vertices = this.attributes[ 'position' ].array;
+		var normals = this.attributes[ 'normal' ].array;
+		var uvs = this.attributes[ 'uv' ].array;
+
+		if ( geometry instanceof THREE.Geometry2 ) {
+
+			var vertices2 = geometry.attributes[ 'position' ].array;
+			var normals2 = geometry.attributes[ 'normal' ].array;
+			var uvs2 = geometry.attributes[ 'uv' ].array;
+
+			for ( var i = 0, l = vertices2.length; i < l; i += 3 ) {
+
+				vertices[ i + offset3     ] = vertices2[ i     ];
+				vertices[ i + offset3 + 1 ] = vertices2[ i + 1 ];
+				vertices[ i + offset3 + 2 ] = vertices2[ i + 2 ];
+
+				normals[ i + offset3     ] = normals2[ i     ];
+				normals[ i + offset3 + 1 ] = normals2[ i + 1 ];
+				normals[ i + offset3 + 2 ] = normals2[ i + 2 ];
+
+				uvs[ i + offset2     ] = uvs2[ i     ];
+				uvs[ i + offset2 + 1 ] = uvs2[ i + 1 ];
+
+			}
+
+		} else if ( geometry instanceof THREE.IndexedGeometry2 ) {
+
+			var indices2 = geometry.attributes[ 'index' ].array;
+			var vertices2 = geometry.attributes[ 'position' ].array;
+			var normals2 = geometry.attributes[ 'normal' ].array;
+			var uvs2 = geometry.attributes[ 'uv' ].array;
+
+			for ( var i = 0, l = indices2.length; i < l; i ++ ) {
+
+				var index = indices2[ i ];
+
+				var index3 = index * 3;
+				var i3 = i * 3;
+
+				vertices[ i3 + offset3 ] = vertices2[ index3 ];
+				vertices[ i3 + offset3 + 1 ] = vertices2[ index3 + 1 ];
+				vertices[ i3 + offset3 + 2 ] = vertices2[ index3 + 2 ];
+
+				normals[ i3 + offset3 ] = normals2[ index3 ];
+				normals[ i3 + offset3 + 1 ] = normals2[ index3 + 1 ];
+				normals[ i3 + offset3 + 2 ] = normals2[ index3 + 2 ];
+
+				var index2 = index * 2;
+				var i2 = i * 2;
+
+				uvs[ i2 + offset2 ] = uvs2[ index2 ];
+				uvs[ i2 + offset2 + 1 ] = uvs2[ index2 + 1 ];
+
+			}
+
+			if ( matrix !== undefined ) {
+
+				matrix.applyToVector3Array( vertices, offset3, indices2.length * 3 );
+
+				normalMatrix.getNormalMatrix( matrix );
+				normalMatrix.applyToVector3Array( normals, offset3, indices2.length * 3 );
+
+			}
+
+			offset += indices2.length;
+
+		}
+
+	};
+
+} )();

examples/js/wip/PlaneGeometry2.js

@@ -5,71 +5,87 @@
 
 THREE.PlaneGeometry2 = function ( width, height, widthSegments, heightSegments ) {
 
-	THREE.Geometry2.call( this, ( widthSegments * heightSegments ) * 2 * 3 );
+	this.parameters = {
+		width: width,
+		height: height,
+		widthSegments: widthSegments,
+		heightSegments: heightSegments
+	};
 
-	var vertices = this.vertices.array;
-	var normals = this.normals.array;
-	var uvs = this.uvs.array;
+	var width_half = width / 2;
+	var height_half = height / 2;
 
-	this.width = width;
-	this.height = height;
+	var gridX = widthSegments || 1;
+	var gridY = heightSegments || 1;
 
-	this.widthSegments = widthSegments || 1;
-	this.heightSegments = heightSegments || 1;
+	var gridX1 = gridX + 1;
+	var gridY1 = gridY + 1;
 
-	var widthHalf = width / 2;
-	var heightHalf = height / 2;
+	var segment_width = width / gridX;
+	var segment_height = height / gridY;
 
-	var gridX = this.widthSegments;
-	var gridY = this.heightSegments;
-
-	var segmentWidth = this.width / gridX;
-	var segmentHeight = this.height / gridY;
+	var vertices = new Float32Array( gridX1 * gridY1 * 3 );
+	var normals = new Float32Array( gridX1 * gridY1 * 3 );
+	var uvs = new Float32Array( gridX1 * gridY1 * 2 );
 
 	var offset = 0;
+	var offset2 = 0;
 
-	for ( var iy = 0; iy < gridY; iy ++ ) {
+	for ( var iy = 0; iy < gridY1; iy ++ ) {
 
-		var y1 = iy * segmentHeight - heightHalf;
-		var y2 = ( iy + 1 ) * segmentHeight - heightHalf;
+		var y = iy * segment_height - height_half;
 
-		for ( var ix = 0; ix < gridX; ix ++ ) {
+		for ( var ix = 0; ix < gridX1; ix ++ ) {
+
+			var x = ix * segment_width - width_half;
 
-			var x1 = ix * segmentWidth - widthHalf;
-			var x2 = ( ix + 1 ) * segmentWidth - widthHalf;
+			vertices[ offset     ] = x;
+			vertices[ offset + 1 ] = - y;
 
-			vertices[ offset + 0 ] = x1;
-			vertices[ offset + 1 ] = y1;
+			normals[ offset + 2 ] = 1;
 
-			vertices[ offset + 3 ] = x2;
-			vertices[ offset + 4 ] = y1;
+			uvs[ offset2     ] = ix / gridX;
+			uvs[ offset2 + 1 ] = 1 - ( iy / gridY );
 
-			vertices[ offset + 6 ] = x1;
-			vertices[ offset + 7 ] = y2;
+			offset += 3;
+			offset2 += 2;
 
-			normals[ offset + 2 ] = 1;
-			normals[ offset + 5 ] = 1;
-			normals[ offset + 8 ] = 1;
+		}
+
+	}
+
+	offset = 0;
+
+	var indices = new ( vertices.length > 65535 ? Uint32Array : Uint16Array )( gridX * gridY * 6 );
+
+	for ( var iy = 0; iy < gridY; iy ++ ) {
 
-			vertices[ offset + 9 ] = x2;
-			vertices[ offset + 10 ] = y1;
+		for ( var ix = 0; ix < gridX; ix ++ ) {
 
-			vertices[ offset + 12 ] = x2;
-			vertices[ offset + 13 ] = y2;
+			var a = ix + gridX1 * iy;
+			var b = ix + gridX1 * ( iy + 1 );
+			var c = ( ix + 1 ) + gridX1 * ( iy + 1 );
+			var d = ( ix + 1 ) + gridX1 * iy;
 
-			vertices[ offset + 15 ] = x1;
-			vertices[ offset + 16 ] = y2;
+			indices[ offset     ] = a;
+			indices[ offset + 1 ] = b;
+			indices[ offset + 2 ] = d;
 
-			normals[ offset + 11 ] = 1;
-			normals[ offset + 13 ] = 1;
-			normals[ offset + 17 ] = 1;
+			indices[ offset + 3 ] = b;
+			indices[ offset + 4 ] = c;
+			indices[ offset + 5 ] = d;
 
-			offset += 18;
+			offset += 6;
 
 		}
 
 	}
 
+	THREE.IndexedGeometry2.call( this );
+
+	this.setArrays( indices, vertices, normals, uvs );
+	this.computeBoundingSphere();
+
 };
 
-THREE.PlaneGeometry2.prototype = Object.create( THREE.Geometry2.prototype );
+THREE.PlaneGeometry.prototype = Object.create( THREE.IndexedGeometry2.prototype );

examples/js/wip/benchmark/Geometry2.js

@@ -0,0 +1,19 @@
+/**
+ * @author mrdoob / http://mrdoob.com/
+ */
+
+THREE.Geometry2 = function ( size ) {
+
+	THREE.BufferGeometry.call( this );
+
+	this.vertices = new THREE.Float32Attribute( size, 3 );
+	this.normals = new THREE.Float32Attribute( size, 3 );
+	this.uvs = new THREE.Float32Attribute( size, 2 );
+
+	this.addAttribute( 'position', this.vertices );
+	this.addAttribute( 'normal', this.normals );
+	this.addAttribute( 'uv', this.uvs );
+
+};
+
+THREE.Geometry2.prototype = Object.create( THREE.BufferGeometry.prototype );

examples/js/wip/benchmark/PlaneGeometry2.js

@@ -0,0 +1,75 @@
+/**
+ * @author mrdoob / http://mrdoob.com/
+ * based on http://papervision3d.googlecode.com/svn/trunk/as3/trunk/src/org/papervision3d/objects/primitives/Plane.as
+ */
+
+THREE.PlaneGeometry2 = function ( width, height, widthSegments, heightSegments ) {
+
+	THREE.Geometry2.call( this, ( widthSegments * heightSegments ) * 2 * 3 );
+
+	var vertices = this.vertices.array;
+	var normals = this.normals.array;
+	var uvs = this.uvs.array;
+
+	this.width = width;
+	this.height = height;
+
+	this.widthSegments = widthSegments || 1;
+	this.heightSegments = heightSegments || 1;
+
+	var widthHalf = width / 2;
+	var heightHalf = height / 2;
+
+	var gridX = this.widthSegments;
+	var gridY = this.heightSegments;
+
+	var segmentWidth = this.width / gridX;
+	var segmentHeight = this.height / gridY;
+
+	var offset = 0;
+
+	for ( var iy = 0; iy < gridY; iy ++ ) {
+
+		var y1 = iy * segmentHeight - heightHalf;
+		var y2 = ( iy + 1 ) * segmentHeight - heightHalf;
+
+		for ( var ix = 0; ix < gridX; ix ++ ) {
+
+			var x1 = ix * segmentWidth - widthHalf;
+			var x2 = ( ix + 1 ) * segmentWidth - widthHalf;
+
+			vertices[ offset + 0 ] = x1;
+			vertices[ offset + 1 ] = y1;
+
+			vertices[ offset + 3 ] = x2;
+			vertices[ offset + 4 ] = y1;
+
+			vertices[ offset + 6 ] = x1;
+			vertices[ offset + 7 ] = y2;
+
+			normals[ offset + 2 ] = 1;
+			normals[ offset + 5 ] = 1;
+			normals[ offset + 8 ] = 1;
+
+			vertices[ offset + 9 ] = x2;
+			vertices[ offset + 10 ] = y1;
+
+			vertices[ offset + 12 ] = x2;
+			vertices[ offset + 13 ] = y2;
+
+			vertices[ offset + 15 ] = x1;
+			vertices[ offset + 16 ] = y2;
+
+			normals[ offset + 11 ] = 1;
+			normals[ offset + 13 ] = 1;
+			normals[ offset + 17 ] = 1;
+
+			offset += 18;
+
+		}
+
+	}
+
+};
+
+THREE.PlaneGeometry2.prototype = Object.create( THREE.Geometry2.prototype );

src/core/Geometry2.js

@@ -1,121 +0,0 @@
-/**
- * @author mrdoob / http://mrdoob.com/
- */
-
-THREE.Geometry2 = function ( size ) {
-
-	THREE.BufferGeometry.call( this );
-
-	if ( size !== undefined ) {
-
-		this.vertices = new Float32Array( size * 3 * 3 );
-		this.normals = new Float32Array( size * 3 * 3 );
-		this.uvs = new Float32Array( size * 3 * 2 );
-
-		this.attributes[ 'position' ] = { array: this.vertices, itemSize: 3 };
-		this.attributes[ 'normal' ] = { array: this.normals, itemSize: 3 };
-		this.attributes[ 'uv' ] = { array: this.uvs, itemSize: 2 };
-
-	}
-
-};
-
-THREE.Geometry2.prototype = Object.create( THREE.BufferGeometry.prototype );
-
-THREE.Geometry2.prototype.setArrays = function ( vertices, normals, uvs ) {
-
-	this.vertices = vertices;
-	this.normals = normals;
-	this.uvs = uvs;
-
-	this.attributes[ 'position' ] = { array: vertices, itemSize: 3 };
-	this.attributes[ 'normal' ] = { array: normals, itemSize: 3 };
-	this.attributes[ 'uv' ] = { array: uvs, itemSize: 2 };
-
-	return this;
-
-};
-
-THREE.Geometry2.prototype.merge = ( function () {
-
-	var offset = 0;
-	var normalMatrix = new THREE.Matrix3();
-
-	return function ( geometry, matrix, startOffset ) {
-
-		if ( startOffset !== undefined ) offset = startOffset;
-
-		var offset2 = offset * 2;
-		var offset3 = offset * 3;
-
-		var vertices = this.attributes[ 'position' ].array;
-		var normals = this.attributes[ 'normal' ].array;
-		var uvs = this.attributes[ 'uv' ].array;
-
-		if ( geometry instanceof THREE.Geometry2 ) {
-
-			var vertices2 = geometry.attributes[ 'position' ].array;
-			var normals2 = geometry.attributes[ 'normal' ].array;
-			var uvs2 = geometry.attributes[ 'uv' ].array;
-
-			for ( var i = 0, l = vertices2.length; i < l; i += 3 ) {
-
-				vertices[ i + offset3     ] = vertices2[ i     ];
-				vertices[ i + offset3 + 1 ] = vertices2[ i + 1 ];
-				vertices[ i + offset3 + 2 ] = vertices2[ i + 2 ];
-
-				normals[ i + offset3     ] = normals2[ i     ];
-				normals[ i + offset3 + 1 ] = normals2[ i + 1 ];
-				normals[ i + offset3 + 2 ] = normals2[ i + 2 ];
-
-				uvs[ i + offset2     ] = uvs2[ i     ];
-				uvs[ i + offset2 + 1 ] = uvs2[ i + 1 ];
-
-			}
-
-		} else if ( geometry instanceof THREE.IndexedGeometry2 ) {
-
-			var indices2 = geometry.attributes[ 'index' ].array;
-			var vertices2 = geometry.attributes[ 'position' ].array;
-			var normals2 = geometry.attributes[ 'normal' ].array;
-			var uvs2 = geometry.attributes[ 'uv' ].array;
-
-			for ( var i = 0, l = indices2.length; i < l; i ++ ) {
-
-				var index = indices2[ i ];
-
-				var index3 = index * 3;
-				var i3 = i * 3;
-
-				vertices[ i3 + offset3 ] = vertices2[ index3 ];
-				vertices[ i3 + offset3 + 1 ] = vertices2[ index3 + 1 ];
-				vertices[ i3 + offset3 + 2 ] = vertices2[ index3 + 2 ];
-
-				normals[ i3 + offset3 ] = normals2[ index3 ];
-				normals[ i3 + offset3 + 1 ] = normals2[ index3 + 1 ];
-				normals[ i3 + offset3 + 2 ] = normals2[ index3 + 2 ];
-
-				var index2 = index * 2;
-				var i2 = i * 2;
-
-				uvs[ i2 + offset2 ] = uvs2[ index2 ];
-				uvs[ i2 + offset2 + 1 ] = uvs2[ index2 + 1 ];
-
-			}
-
-			if ( matrix !== undefined ) {
-
-				matrix.applyToVector3Array( vertices, offset3, indices2.length * 3 );
-
-				normalMatrix.getNormalMatrix( matrix );
-				normalMatrix.applyToVector3Array( normals, offset3, indices2.length * 3 );
-
-			}
-
-			offset += indices2.length;
-
-		}
-
-	};
-
-} )();

utils/build/includes/common.json

@@ -28,18 +28,7 @@
 	"src/core/Face4.js",
 	"src/core/BufferAttribute.js",
 	"src/core/BufferGeometry.js",
-	"src/core/Geometry2.js",
-	"src/core/IndexedGeometry2.js",
 	"src/core/Geometry.js",
-	"src/core/GeometryEditor.js",
-	"src/core/ProxyGeometry.js",
-	"src/core/proxies/MultiColor.js",
-	"src/core/proxies/MultiVector3.js",
-	"src/core/proxies/ProxyColor.js",
-	"src/core/proxies/ProxyVector2.js",
-	"src/core/proxies/ProxyVector3.js",
-	"src/core/proxies/ProxyVector4.js",
-	"src/core/proxies/ProxyFace3.js",
 	"src/cameras/Camera.js",
 	"src/cameras/OrthographicCamera.js",
 	"src/cameras/PerspectiveCamera.js",