Skip to content

Commit

Permalink
Updated builds.
Browse files Browse the repository at this point in the history
  • Loading branch information
@mrdoob
mrdoob committed Mar 15, 2016
1 parent f405240 commit 81304af
Show file tree
Hide file tree
Showing 2 changed files with 177 additions and 95 deletions.
190 changes: 135 additions & 55 deletions build/three.js
View file
Original file line number Diff line number Diff line change
Expand Up @@ -30212,10 +30212,6 @@ THREE.WebGLShadowMap = function ( _renderer, _lights, _objects ) {

}

// We must call _renderer.resetGLState() at the end of each iteration of
// the light loop in order to force material updates for each light.
_renderer.resetGLState();

}

// Restore GL state.
Expand All @@ -30231,8 +30227,6 @@ THREE.WebGLShadowMap = function ( _renderer, _lights, _objects ) {

}

_renderer.resetGLState();

scope.needsUpdate = false;

};
Expand Down Expand Up @@ -37147,26 +37141,24 @@ THREE.ShapeGeometry.prototype.addShape = function ( shape, options ) {

};

// File:src/extras/geometries/LatheGeometry.js
// File:src/extras/geometries/LatheBufferGeometry.js

/**
* @author astrodud / http://astrodud.isgreat.org/
* @author zz85 / https://github.com/zz85
* @author bhouston / http://clara.io
* @author Mugen87 / https://github.com/Mugen87
*/

// points - to create a closed torus, one must use a set of points
// like so: [ a, b, c, d, a ], see first is the same as last.
// segments - the number of circumference segments to create
// phiStart - the starting radian
// phiLength - the radian (0 to 2*PI) range of the lathed section
// 2*pi is a closed lathe, less than 2PI is a portion.
// points - to create a closed torus, one must use a set of points
// like so: [ a, b, c, d, a ], see first is the same as last.
// segments - the number of circumference segments to create
// phiStart - the starting radian
// phiLength - the radian (0 to 2PI) range of the lathed section
// 2PI is a closed lathe, less than 2PI is a portion.

THREE.LatheGeometry = function ( points, segments, phiStart, phiLength ) {
THREE.LatheBufferGeometry = function ( points, segments, phiStart, phiLength ) {

THREE.Geometry.call( this );
THREE.BufferGeometry.call( this );

this.type = 'LatheGeometry';
this.type = 'LatheBufferGeometry';

this.parameters = {
points: points,
Expand All @@ -37175,81 +37167,169 @@ THREE.LatheGeometry = function ( points, segments, phiStart, phiLength ) {
phiLength: phiLength
};

segments = segments || 12;
segments = Math.floor( segments ) || 12;
phiStart = phiStart || 0;
phiLength = phiLength || 2 * Math.PI;
phiLength = phiLength || Math.PI * 2;

// clamp phiLength so it's in range of [ 0, 2PI ]
phiLength = THREE.Math.clamp( phiLength, 0, Math.PI * 2 );

// these are used to calculate buffer length
var vertexCount = ( segments + 1 ) * points.length;
var indexCount = segments * points.length * 2 * 3;

// buffers
var indices = new THREE.BufferAttribute( new ( indexCount > 65535 ? Uint32Array : Uint16Array )( indexCount ) , 1 );
var vertices = new THREE.BufferAttribute( new Float32Array( vertexCount * 3 ), 3 );
var uvs = new THREE.BufferAttribute( new Float32Array( vertexCount * 2 ), 2 );

// helper variables
var index = 0, indexOffset = 0, base;
var inversePointLength = 1.0 / ( points.length - 1 );
var inverseSegments = 1.0 / segments;
var vertex = new THREE.Vector3();
var uv = new THREE.Vector2();
var i, j;

// generate vertices and uvs

for ( var i = 0, il = segments; i <= il; i ++ ) {
for ( i = 0; i <= segments; i ++ ) {

var phi = phiStart + i * inverseSegments * phiLength;

var sin = Math.sin( phi );
var cos = Math.cos( phi );

for ( var j = 0, jl = points.length; j < jl; j ++ ) {
for ( j = 0; j <= ( points.length - 1 ); j ++ ) {

var point = points[ j ];

var vertex = new THREE.Vector3();
// vertex
vertex.x = points[ j ].x * sin;
vertex.y = points[ j ].y;
vertex.z = points[ j ].x * cos;
vertices.setXYZ( index, vertex.x, vertex.y, vertex.z );

vertex.x = point.x * sin;
vertex.y = point.y;
vertex.z = point.x * cos;
// uv
uv.x = i / segments;
uv.y = j / ( points.length - 1 );
uvs.setXY( index, uv.x, uv.y );

this.vertices.push( vertex );
// increase index
index ++;

}

}

var np = points.length;
// generate indices

for ( i = 0; i < segments; i ++ ) {

for ( var i = 0, il = segments; i < il; i ++ ) {
for ( j = 0; j < ( points.length - 1 ); j ++ ) {

for ( var j = 0, jl = points.length - 1; j < jl; j ++ ) {
base = j + i * points.length;

var base = j + np * i;
// indices
var a = base;
var b = base + np;
var c = base + 1 + np;
var b = base + points.length;
var c = base + points.length + 1;
var d = base + 1;

var u0 = i * inverseSegments;
var v0 = j * inversePointLength;
var u1 = u0 + inverseSegments;
var v1 = v0 + inversePointLength;
// face one
indices.setX( indexOffset, a ); indexOffset++;
indices.setX( indexOffset, b ); indexOffset++;
indices.setX( indexOffset, d ); indexOffset++;

this.faces.push( new THREE.Face3( a, b, d ) );
// face two
indices.setX( indexOffset, b ); indexOffset++;
indices.setX( indexOffset, c ); indexOffset++;
indices.setX( indexOffset, d ); indexOffset++;

this.faceVertexUvs[ 0 ].push( [
}

new THREE.Vector2( u0, v0 ),
new THREE.Vector2( u1, v0 ),
new THREE.Vector2( u0, v1 )
}

] );
// build geometry

this.faces.push( new THREE.Face3( b, c, d ) );
this.setIndex( indices );
this.addAttribute( 'position', vertices );
this.addAttribute( 'uv', uvs );

this.faceVertexUvs[ 0 ].push( [
// generate normals

new THREE.Vector2( u1, v0 ),
new THREE.Vector2( u1, v1 ),
new THREE.Vector2( u0, v1 )
this.computeVertexNormals();

] );
// if the geometry is closed, we need to average the normals along the seam.
// because the corresponding vertices are identical (but still have different UVs).

if( phiLength === Math.PI * 2 ) {

}
var normals = this.attributes.normal.array;
var n1 = new THREE.Vector3();
var n2 = new THREE.Vector3();
var n = new THREE.Vector3();

// this is the buffer offset for the last line of vertices
base = segments * points.length * 3;

for( i = 0, j = 0; i < points.length; i ++, j += 3 ) {

// select the normal of the vertex in the first line
n1.x = normals[ j + 0 ];
n1.y = normals[ j + 1 ];
n1.z = normals[ j + 2 ];

// select the normal of the vertex in the last line
n2.x = normals[ base + j + 0 ];
n2.y = normals[ base + j + 1 ];
n2.z = normals[ base + j + 2 ];

// average normals
n.addVectors( n1, n2 ).normalize();

// assign the new values to both normals
normals[ j + 0 ] = normals[ base + j + 0 ] = n.x;
normals[ j + 1 ] = normals[ base + j + 1 ] = n.y;
normals[ j + 2 ] = normals[ base + j + 2 ] = n.z;

} // next row

}

};

THREE.LatheBufferGeometry.prototype = Object.create( THREE.BufferGeometry.prototype );
THREE.LatheBufferGeometry.prototype.constructor = THREE.LatheBufferGeometry;

// File:src/extras/geometries/LatheGeometry.js

/**
* @author astrodud / http://astrodud.isgreat.org/
* @author zz85 / https://github.com/zz85
* @author bhouston / http://clara.io
*/

// points - to create a closed torus, one must use a set of points
// like so: [ a, b, c, d, a ], see first is the same as last.
// segments - the number of circumference segments to create
// phiStart - the starting radian
// phiLength - the radian (0 to 2PI) range of the lathed section
// 2PI is a closed lathe, less than 2PI is a portion.

THREE.LatheGeometry = function ( points, segments, phiStart, phiLength ) {

THREE.Geometry.call( this );

this.type = 'LatheGeometry';

this.parameters = {
points: points,
segments: segments,
phiStart: phiStart,
phiLength: phiLength
};

this.fromBufferGeometry( new THREE.LatheBufferGeometry( points, segments, phiStart, phiLength ) );
this.mergeVertices();
this.computeFaceNormals();
this.computeVertexNormals();

};

Expand Down
Loading

0 comments on commit 81304af

Please sign in to comment.