// Clamp value to range <a, b>

clamp: function ( x, a, b ) {

return ( x < a ) ? a : ( ( x > b ) ? b : x );

},

// Clamp value to range <a, inf)

clampBottom: function ( x, a ) {

return x < a ? a : x;

this.bends = [];

// Returns min and max coordinates

THREE.CurvePath.prototype.getBoundingBox = function () {

var points = this.getPoints();

var maxX, maxY, maxZ;

var minX, minY, minZ;

maxX = maxY = Number.NEGATIVE_INFINITY;

minX = minY = Number.POSITIVE_INFINITY;

var v3 = points[ 0 ] instanceof THREE.Vector3;

var sum = v3 ? new THREE.Vector3() : new THREE.Vector2();

for ( var i = 0, l = points.length; i < l; i ++ ) {

var p = points[ i ];

if ( p.x > maxX ) maxX = p.x;

else if ( p.x < minX ) minX = p.x;

if ( p.y > maxY ) maxY = p.y;

else if ( p.y < minY ) minY = p.y;

if ( v3 ) {

if ( p.z > maxZ ) maxZ = p.z;

else if ( p.z < minZ ) minZ = p.z;

}

sum.add( p );

}

var ret = {

minX: minX,

minY: minY,

maxX: maxX,

maxY: maxY

};

if ( v3 ) {

ret.maxZ = maxZ;

ret.minZ = minZ;

}

return ret;

};

/**************************************************************

* Bend / Wrap Helper Methods

**************************************************************/

// Wrap path / Bend modifiers?

THREE.CurvePath.prototype.addWrapPath = function ( bendpath ) {

this.bends.push( bendpath );

};

THREE.CurvePath.prototype.getTransformedPoints = function( segments, bends ) {

var oldPts = this.getPoints( segments ); // getPoints getSpacedPoints

if ( ! bends ) {

bends = this.bends;

}

for ( var i = 0, l = bends.length; i < l; i ++ ) {

oldPts = this.getWrapPoints( oldPts, bends[ i ] );

}

return oldPts;

};

THREE.CurvePath.prototype.getTransformedSpacedPoints = function( segments, bends ) {

var oldPts = this.getSpacedPoints( segments );

if ( ! bends ) {

bends = this.bends;

}

for ( var i = 0, l = bends.length; i < l; i ++ ) {

oldPts = this.getWrapPoints( oldPts, bends[ i ] );

}

return oldPts;

};

// This returns getPoints() bend/wrapped around the contour of a path.

// Read http://www.planetclegg.com/projects/WarpingTextToSplines.html

THREE.CurvePath.prototype.getWrapPoints = function ( oldPts, path ) {

var bounds = this.getBoundingBox();

for ( var i = 0, l = oldPts.length; i < l; i ++ ) {

var p = oldPts[ i ];

var oldX = p.x;

var oldY = p.y;

var xNorm = oldX / bounds.maxX;

// If using actual distance, for length > path, requires line extrusions

//xNorm = path.getUtoTmapping(xNorm, oldX); // 3 styles. 1) wrap stretched. 2) wrap stretch by arc length 3) warp by actual distance

xNorm = path.getUtoTmapping( xNorm, oldX );

// check for out of bounds?

var pathPt = path.getPoint( xNorm );

var normal = path.getTangent( xNorm );

normal.set( - normal.y, normal.x ).multiplyScalar( oldY );

p.x = pathPt.x + normal.x;

p.y = pathPt.y + normal.y;

}

return oldPts;

};

if ( this.useSpacedPoints ) {

return this.getSpacedPoints( divisions, closedPath );

}

holesPts[ i ] = this.holes[ i ].getTransformedPoints( divisions, this.bends );

}

return holesPts;

};

// Get points of holes (spaced by regular distance)

THREE.Shape.prototype.getSpacedPointsHoles = function ( divisions ) {

var holesPts = [];

for ( var i = 0, l = this.holes.length; i < l; i ++ ) {

holesPts[ i ] = this.holes[ i ].getTransformedSpacedPoints( divisions, this.bends );

shape: this.getTransformedPoints( divisions ),

if ( this.useSpacedPoints ) {

return this.extractAllSpacedPoints( divisions );

}

/*

THREE.Shape.prototype.extractAllPointsWithBend = function ( divisions, bend ) {

return {

shape: this.transform( bend, divisions ),

holes: this.getPointsHoles( divisions, bend )

};

};

*/

// Get points of shape and holes (spaced by regular distance)

THREE.Shape.prototype.extractAllSpacedPoints = function ( divisions ) {

return {

shape: this.getTransformedSpacedPoints( divisions ),

holes: this.getSpacedPointsHoles( divisions )

};

};

scope.faces.push( new THREE.Face3( a, b, c ) );

scope.faces.push( new THREE.Face3( a, b, d ) );

scope.faces.push( new THREE.Face3( b, c, d ) );