texture.repeat.set( repeat[ 0 ], repeat[ 1 ] );

if ( repeat[ 0 ] > 1 ) texture.wrapS = THREE.RepeatWrapping;

if ( repeat[ 1 ] > 1 ) texture.wrapT = THREE.RepeatWrapping;

texture.offset.set( offset[ 0 ], offset[ 1 ] );

json.map = loadTexture( value, json.mapDiffuseRepeat, json.mapDiffuseOffset, json.mapDiffuseWrap, json.mapDiffuseAnisotropy );

json.lightMap = loadTexture( value, json.mapLightRepeat, json.mapLightOffset, json.mapLightWrap, json.mapLightAnisotropy );

json.aoMap = loadTexture( value, json.mapAORepeat, json.mapAOOffset, json.mapAOWrap, json.mapAOAnisotropy );

json.bumpMap = loadTexture( value, json.mapBumpRepeat, json.mapBumpOffset, json.mapBumpWrap, json.mapBumpAnisotropy );

json.normalMap = loadTexture( value, json.mapNormalRepeat, json.mapNormalOffset, json.mapNormalWrap, json.mapNormalAnisotropy );

json.specularMap = loadTexture( value, json.mapSpecularRepeat, json.mapSpecularOffset, json.mapSpecularWrap, json.mapSpecularAnisotropy );

json.alphaMap = loadTexture( value, json.mapAlphaRepeat, json.mapAlphaOffset, json.mapAlphaWrap, json.mapAlphaAnisotropy );

var scope = this;

var loader = new THREE.ImageLoader( scope.manager );

var texture = loader.load( url, function ( texture ) {

if ( onLoad ) onLoad( texture );

}, undefined, onError );

texture.sourceFile = url;

loadTextureCube: function ( array, mapping, onLoad, onError ) {

var images = [];

var loader = new THREE.ImageLoader();

loader.crossOrigin = this.crossOrigin;

var texture = new THREE.CubeTexture( images, mapping );

var loaded = 0;

function loadTexture( i ) {

loader.load( array[ i ], function ( image ) {

texture.images[ i ] = image;

loaded += 1;

if ( loaded === 6 ) {

texture.needsUpdate = true;

if ( onLoad ) onLoad( texture );

}

}, undefined, onError );

}

for ( var i = 0, il = array.length; i < il; ++ i ) {

loadTexture( i );

}

},

getNormalMap: function ( image, depth ) {

// Adapted from http://www.paulbrunt.co.uk/lab/heightnormal/

function cross( a, b ) {

return [ a[ 1 ] * b[ 2 ] - a[ 2 ] * b[ 1 ], a[ 2 ] * b[ 0 ] - a[ 0 ] * b[ 2 ], a[ 0 ] * b[ 1 ] - a[ 1 ] * b[ 0 ] ];

}

function subtract( a, b ) {

return [ a[ 0 ] - b[ 0 ], a[ 1 ] - b[ 1 ], a[ 2 ] - b[ 2 ] ];

}

function normalize( a ) {

var l = Math.sqrt( a[ 0 ] * a[ 0 ] + a[ 1 ] * a[ 1 ] + a[ 2 ] * a[ 2 ] );

return [ a[ 0 ] / l, a[ 1 ] / l, a[ 2 ] / l ];

}

depth = depth | 1;

var width = image.width;

var height = image.height;

var canvas = document.createElement( 'canvas' );

canvas.width = width;

canvas.height = height;

var context = canvas.getContext( '2d' );

context.drawImage( image, 0, 0 );

var data = context.getImageData( 0, 0, width, height ).data;

var imageData = context.createImageData( width, height );

var output = imageData.data;

for ( var x = 0; x < width; x ++ ) {

for ( var y = 0; y < height; y ++ ) {

var ly = y - 1 < 0 ? 0 : y - 1;

var uy = y + 1 > height - 1 ? height - 1 : y + 1;

var lx = x - 1 < 0 ? 0 : x - 1;

var ux = x + 1 > width - 1 ? width - 1 : x + 1;

var points = [];

var origin = [ 0, 0, data[ ( y * width + x ) * 4 ] / 255 * depth ];

points.push( [ - 1, 0, data[ ( y * width + lx ) * 4 ] / 255 * depth ] );

points.push( [ - 1, - 1, data[ ( ly * width + lx ) * 4 ] / 255 * depth ] );

points.push( [ 0, - 1, data[ ( ly * width + x ) * 4 ] / 255 * depth ] );

points.push( [ 1, - 1, data[ ( ly * width + ux ) * 4 ] / 255 * depth ] );

points.push( [ 1, 0, data[ ( y * width + ux ) * 4 ] / 255 * depth ] );

points.push( [ 1, 1, data[ ( uy * width + ux ) * 4 ] / 255 * depth ] );

points.push( [ 0, 1, data[ ( uy * width + x ) * 4 ] / 255 * depth ] );

points.push( [ - 1, 1, data[ ( uy * width + lx ) * 4 ] / 255 * depth ] );

var normals = [];

var num_points = points.length;

for ( var i = 0; i < num_points; i ++ ) {

var v1 = points[ i ];

var v2 = points[ ( i + 1 ) % num_points ];

v1 = subtract( v1, origin );

v2 = subtract( v2, origin );

normals.push( normalize( cross( v1, v2 ) ) );

}

var normal = [ 0, 0, 0 ];

for ( var i = 0; i < normals.length; i ++ ) {

normal[ 0 ] += normals[ i ][ 0 ];

normal[ 1 ] += normals[ i ][ 1 ];

normal[ 2 ] += normals[ i ][ 2 ];

}

normal[ 0 ] /= normals.length;

normal[ 1 ] /= normals.length;

normal[ 2 ] /= normals.length;

var idx = ( y * width + x ) * 4;

output[ idx ] = ( ( normal[ 0 ] + 1.0 ) / 2.0 * 255 ) | 0;

output[ idx + 1 ] = ( ( normal[ 1 ] + 1.0 ) / 2.0 * 255 ) | 0;

output[ idx + 2 ] = ( normal[ 2 ] * 255 ) | 0;

output[ idx + 3 ] = 255;

}

}

context.putImageData( imageData, 0, 0 );

return canvas;

},

generateDataTexture: function ( width, height, color ) {

var size = width * height;

var data = new Uint8Array( 3 * size );

var r = Math.floor( color.r * 255 );

var g = Math.floor( color.g * 255 );

var b = Math.floor( color.b * 255 );

for ( var i = 0; i < size; i ++ ) {

data[ i * 3 ] = r;

data[ i * 3 + 1 ] = g;

data[ i * 3 + 2 ] = b;

}

var texture = new THREE.DataTexture( data, width, height, THREE.RGBFormat );

texture.needsUpdate = true;

return texture;