<code>

// load a texture, set wrap mode to repeat

texture.wrapS = THREE.RepeatWrapping;

texture.wrapT = THREE.RepeatWrapping;

texture.repeat.set( 4, 4 );

<div>

The default is THREE.ClampToEdgeWrapping, where the edge is clamped to the outer edge texels. The other two choices are THREE.RepeatWrapping and THREE.MirroredRepeatWrapping.

</div>

<div>

NOTE: tiling of images in textures only functions if image dimensions are powers of two (2, 4, 8, 16, 32, 64, 128, 256, 512, 1024, 2048, ...) in terms of pixels. Individual dimensions need not be equal, but each must be a power of two. This is a limitation of WebGL, not Three.js.

</div>

return {

none : null,

};

var geometry = new THREE.SphereGeometry( 100, 14, 7 );

var materials = [

new THREE.MeshBasicMaterial( { color: 0x00ffff, wireframe: true, side: THREE.DoubleSide } ),

new THREE.MeshBasicMaterial( { color: 0xff0000, blending: THREE.AdditiveBlending } ),

new THREE.MeshNormalMaterial( { overdraw: 0.5 } ),

];

geometry.computeVertexNormals();

scene.add( mesh );

} );

geometry = new THREE.IcosahedronGeometry( 100, 1 );

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

return ++i >= self.rand.length ? self.rand[i = 1] : self.rand[i];

}

self.particleNoiseTex.wrapS = self.particleNoiseTex.wrapT = THREE.RepeatWrapping;

self.particleSpriteTex.wrapS = self.particleSpriteTex.wrapT = THREE.RepeatWrapping;

self.particleShaderMat = new THREE.ShaderMaterial({

}

}

}

this.update = function ( delta ) {

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

textures[ i ].name = textureUrls[ i ];

}

mesh.materialTexture = materialTexture;

mesh.materialWireframe = materialWireframe;

return mesh;

}

var textures = [];

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

textures[ i ].name = textureUrls[ i ];

}

THREE.UCSCharacter = function() {

var scope = this;

var mesh;

this.scale = 1;

this.root = new THREE.Object3D();

this.numSkins;

this.numMorphs;

this.skins = [];

this.materials = [];

this.morphs = [];

this.mixer = new THREE.AnimationMixer( this.root );

this.onLoadComplete = function () {};

this.loadCounter = 0;

this.loadParts = function ( config ) {

this.numSkins = config.skins.length;

this.numMorphs = config.morphs.length;

// Character geometry + number of skins

this.loadCounter = 1 + config.skins.length;

// SKINS

this.skins = loadTextures( config.baseUrl + "skins/", config.skins );

this.materials = createMaterials( this.skins );

// MORPHS

this.morphs = config.morphs;

// CHARACTER

var loader = new THREE.JSONLoader();

console.log( config.baseUrl + config.character );

loader.load( config.baseUrl + config.character, function( geometry ) {

geometry.computeBoundingBox();

geometry.computeVertexNormals();

mesh = new THREE.SkinnedMesh( geometry, new THREE.MeshFaceMaterial() );

mesh.name = config.character;

scope.root.add( mesh );

var bb = geometry.boundingBox;

scope.root.scale.set( config.s, config.s, config.s );

scope.root.position.set( config.x, config.y - bb.min.y * config.s, config.z );

mesh.receiveShadow = true;

scope.mixer.clipAction( geometry.animations[0], mesh ).play();

scope.setSkin( 0 );

scope.checkLoadComplete();

} );

};

this.setSkin = function( index ) {

if ( mesh && scope.materials ) {

}

};

this.updateMorphs = function( influences ) {

if ( mesh ) {

}

};

function loadTextures( baseUrl, textureUrls ) {

var mapping = THREE.UVMapping;

var textures = [];

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

textures[ i ].name = textureUrls[ i ];

}

function createMaterials( skins ) {

var materials = [];

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

materials[ i ] = new THREE.MeshLambertMaterial( {

} );

}

return materials;

}