kopia lustrzana https://github.com/robhawkes/vizicities
545 wiersze
12 KiB
JavaScript
545 wiersze
12 KiB
JavaScript
/**
|
|
* @author mrdoob / http://mrdoob.com/
|
|
* @author alteredq / http://alteredqualia.com/
|
|
*/
|
|
|
|
THREE.JSONLoader = function ( showStatus ) {
|
|
|
|
THREE.Loader.call( this, showStatus );
|
|
|
|
this.withCredentials = false;
|
|
|
|
};
|
|
|
|
THREE.JSONLoader.prototype = Object.create( THREE.Loader.prototype );
|
|
|
|
THREE.JSONLoader.prototype.load = function ( url, callback, texturePath ) {
|
|
|
|
var scope = this;
|
|
|
|
// todo: unify load API to for easier SceneLoader use
|
|
|
|
texturePath = texturePath && ( typeof texturePath === 'string' ) ? texturePath : this.extractUrlBase( url );
|
|
|
|
this.onLoadStart();
|
|
this.loadAjaxJSON( this, url, callback, texturePath );
|
|
|
|
};
|
|
|
|
THREE.JSONLoader.prototype.loadAjaxJSON = function ( context, url, callback, texturePath, callbackProgress ) {
|
|
|
|
var xhr = new XMLHttpRequest();
|
|
|
|
var length = 0;
|
|
|
|
xhr.onreadystatechange = function () {
|
|
|
|
if ( xhr.readyState === xhr.DONE ) {
|
|
|
|
if ( xhr.status === 200 || xhr.status === 0 ) {
|
|
|
|
if ( xhr.responseText ) {
|
|
|
|
var json = JSON.parse( xhr.responseText );
|
|
|
|
if ( json.metadata !== undefined && json.metadata.type === 'scene' ) {
|
|
|
|
console.error( 'THREE.JSONLoader: "' + url + '" seems to be a Scene. Use THREE.SceneLoader instead.' );
|
|
return;
|
|
|
|
}
|
|
|
|
var result = context.parse( json, texturePath );
|
|
callback( result.geometry, result.materials );
|
|
|
|
} else {
|
|
|
|
console.error( 'THREE.JSONLoader: "' + url + '" seems to be unreachable or the file is empty.' );
|
|
|
|
}
|
|
|
|
// in context of more complex asset initialization
|
|
// do not block on single failed file
|
|
// maybe should go even one more level up
|
|
|
|
context.onLoadComplete();
|
|
|
|
} else {
|
|
|
|
console.error( 'THREE.JSONLoader: Couldn\'t load "' + url + '" (' + xhr.status + ')' );
|
|
|
|
}
|
|
|
|
} else if ( xhr.readyState === xhr.LOADING ) {
|
|
|
|
if ( callbackProgress ) {
|
|
|
|
if ( length === 0 ) {
|
|
|
|
length = xhr.getResponseHeader( 'Content-Length' );
|
|
|
|
}
|
|
|
|
callbackProgress( { total: length, loaded: xhr.responseText.length } );
|
|
|
|
}
|
|
|
|
} else if ( xhr.readyState === xhr.HEADERS_RECEIVED ) {
|
|
|
|
if ( callbackProgress !== undefined ) {
|
|
|
|
length = xhr.getResponseHeader( 'Content-Length' );
|
|
|
|
}
|
|
|
|
}
|
|
|
|
};
|
|
|
|
xhr.open( 'GET', url, true );
|
|
xhr.withCredentials = this.withCredentials;
|
|
xhr.send( null );
|
|
|
|
};
|
|
|
|
THREE.JSONLoader.prototype.parse = function ( json, texturePath ) {
|
|
|
|
var scope = this,
|
|
geometry = new THREE.Geometry(),
|
|
scale = ( json.scale !== undefined ) ? 1.0 / json.scale : 1.0;
|
|
|
|
parseModel( scale );
|
|
|
|
parseSkin();
|
|
parseMorphing( scale );
|
|
|
|
geometry.computeFaceNormals();
|
|
geometry.computeBoundingSphere();
|
|
|
|
function parseModel( scale ) {
|
|
|
|
function isBitSet( value, position ) {
|
|
|
|
return value & ( 1 << position );
|
|
|
|
}
|
|
|
|
var i, j, fi,
|
|
|
|
offset, zLength,
|
|
|
|
colorIndex, normalIndex, uvIndex, materialIndex,
|
|
|
|
type,
|
|
isQuad,
|
|
hasMaterial,
|
|
hasFaceVertexUv,
|
|
hasFaceNormal, hasFaceVertexNormal,
|
|
hasFaceColor, hasFaceVertexColor,
|
|
|
|
vertex, face, faceA, faceB, color, hex, normal,
|
|
|
|
uvLayer, uv, u, v,
|
|
|
|
faces = json.faces,
|
|
vertices = json.vertices,
|
|
normals = json.normals,
|
|
colors = json.colors,
|
|
|
|
nUvLayers = 0;
|
|
|
|
if ( json.uvs !== undefined ) {
|
|
|
|
// disregard empty arrays
|
|
|
|
for ( i = 0; i < json.uvs.length; i ++ ) {
|
|
|
|
if ( json.uvs[ i ].length ) nUvLayers ++;
|
|
|
|
}
|
|
|
|
for ( i = 0; i < nUvLayers; i ++ ) {
|
|
|
|
geometry.faceVertexUvs[ i ] = [];
|
|
|
|
}
|
|
|
|
}
|
|
|
|
offset = 0;
|
|
zLength = vertices.length;
|
|
|
|
while ( offset < zLength ) {
|
|
|
|
vertex = new THREE.Vector3();
|
|
|
|
vertex.x = vertices[ offset ++ ] * scale;
|
|
vertex.y = vertices[ offset ++ ] * scale;
|
|
vertex.z = vertices[ offset ++ ] * scale;
|
|
|
|
geometry.vertices.push( vertex );
|
|
|
|
}
|
|
|
|
offset = 0;
|
|
zLength = faces.length;
|
|
|
|
while ( offset < zLength ) {
|
|
|
|
type = faces[ offset ++ ];
|
|
|
|
|
|
isQuad = isBitSet( type, 0 );
|
|
hasMaterial = isBitSet( type, 1 );
|
|
hasFaceVertexUv = isBitSet( type, 3 );
|
|
hasFaceNormal = isBitSet( type, 4 );
|
|
hasFaceVertexNormal = isBitSet( type, 5 );
|
|
hasFaceColor = isBitSet( type, 6 );
|
|
hasFaceVertexColor = isBitSet( type, 7 );
|
|
|
|
// console.log("type", type, "bits", isQuad, hasMaterial, hasFaceVertexUv, hasFaceNormal, hasFaceVertexNormal, hasFaceColor, hasFaceVertexColor);
|
|
|
|
if ( isQuad ) {
|
|
|
|
faceA = new THREE.Face3();
|
|
faceA.a = faces[ offset ];
|
|
faceA.b = faces[ offset + 1 ];
|
|
faceA.c = faces[ offset + 3 ];
|
|
|
|
faceB = new THREE.Face3();
|
|
faceB.a = faces[ offset + 1 ];
|
|
faceB.b = faces[ offset + 2 ];
|
|
faceB.c = faces[ offset + 3 ];
|
|
|
|
offset += 4;
|
|
|
|
if ( hasMaterial ) {
|
|
|
|
materialIndex = faces[ offset ++ ];
|
|
faceA.materialIndex = materialIndex;
|
|
faceB.materialIndex = materialIndex;
|
|
|
|
}
|
|
|
|
// to get face <=> uv index correspondence
|
|
|
|
fi = geometry.faces.length;
|
|
|
|
if ( hasFaceVertexUv ) {
|
|
|
|
for ( i = 0; i < nUvLayers; i ++ ) {
|
|
|
|
uvLayer = json.uvs[ i ];
|
|
|
|
geometry.faceVertexUvs[ i ][ fi ] = [];
|
|
geometry.faceVertexUvs[ i ][ fi + 1 ] = []
|
|
|
|
for ( j = 0; j < 4; j ++ ) {
|
|
|
|
uvIndex = faces[ offset ++ ];
|
|
|
|
u = uvLayer[ uvIndex * 2 ];
|
|
v = uvLayer[ uvIndex * 2 + 1 ];
|
|
|
|
uv = new THREE.Vector2( u, v );
|
|
|
|
if ( j !== 2 ) geometry.faceVertexUvs[ i ][ fi ].push( uv );
|
|
if ( j !== 0 ) geometry.faceVertexUvs[ i ][ fi + 1 ].push( uv );
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if ( hasFaceNormal ) {
|
|
|
|
normalIndex = faces[ offset ++ ] * 3;
|
|
|
|
faceA.normal.set(
|
|
normals[ normalIndex ++ ],
|
|
normals[ normalIndex ++ ],
|
|
normals[ normalIndex ]
|
|
);
|
|
|
|
faceB.normal.copy( faceA.normal );
|
|
|
|
}
|
|
|
|
if ( hasFaceVertexNormal ) {
|
|
|
|
for ( i = 0; i < 4; i ++ ) {
|
|
|
|
normalIndex = faces[ offset ++ ] * 3;
|
|
|
|
normal = new THREE.Vector3(
|
|
normals[ normalIndex ++ ],
|
|
normals[ normalIndex ++ ],
|
|
normals[ normalIndex ]
|
|
);
|
|
|
|
|
|
if ( i !== 2 ) faceA.vertexNormals.push( normal );
|
|
if ( i !== 0 ) faceB.vertexNormals.push( normal );
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
if ( hasFaceColor ) {
|
|
|
|
colorIndex = faces[ offset ++ ];
|
|
hex = colors[ colorIndex ];
|
|
|
|
faceA.color.setHex( hex );
|
|
faceB.color.setHex( hex );
|
|
|
|
}
|
|
|
|
|
|
if ( hasFaceVertexColor ) {
|
|
|
|
for ( i = 0; i < 4; i ++ ) {
|
|
|
|
colorIndex = faces[ offset ++ ];
|
|
hex = colors[ colorIndex ];
|
|
|
|
if ( i !== 2 ) faceA.vertexColors.push( new THREE.Color( hex ) );
|
|
if ( i !== 0 ) faceB.vertexColors.push( new THREE.Color( hex ) );
|
|
|
|
}
|
|
|
|
}
|
|
|
|
geometry.faces.push( faceA );
|
|
geometry.faces.push( faceB );
|
|
|
|
} else {
|
|
|
|
face = new THREE.Face3();
|
|
face.a = faces[ offset ++ ];
|
|
face.b = faces[ offset ++ ];
|
|
face.c = faces[ offset ++ ];
|
|
|
|
if ( hasMaterial ) {
|
|
|
|
materialIndex = faces[ offset ++ ];
|
|
face.materialIndex = materialIndex;
|
|
|
|
}
|
|
|
|
// to get face <=> uv index correspondence
|
|
|
|
fi = geometry.faces.length;
|
|
|
|
if ( hasFaceVertexUv ) {
|
|
|
|
for ( i = 0; i < nUvLayers; i ++ ) {
|
|
|
|
uvLayer = json.uvs[ i ];
|
|
|
|
geometry.faceVertexUvs[ i ][ fi ] = [];
|
|
|
|
for ( j = 0; j < 3; j ++ ) {
|
|
|
|
uvIndex = faces[ offset ++ ];
|
|
|
|
u = uvLayer[ uvIndex * 2 ];
|
|
v = uvLayer[ uvIndex * 2 + 1 ];
|
|
|
|
uv = new THREE.Vector2( u, v );
|
|
|
|
geometry.faceVertexUvs[ i ][ fi ].push( uv );
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if ( hasFaceNormal ) {
|
|
|
|
normalIndex = faces[ offset ++ ] * 3;
|
|
|
|
face.normal.set(
|
|
normals[ normalIndex ++ ],
|
|
normals[ normalIndex ++ ],
|
|
normals[ normalIndex ]
|
|
);
|
|
|
|
}
|
|
|
|
if ( hasFaceVertexNormal ) {
|
|
|
|
for ( i = 0; i < 3; i ++ ) {
|
|
|
|
normalIndex = faces[ offset ++ ] * 3;
|
|
|
|
normal = new THREE.Vector3(
|
|
normals[ normalIndex ++ ],
|
|
normals[ normalIndex ++ ],
|
|
normals[ normalIndex ]
|
|
);
|
|
|
|
face.vertexNormals.push( normal );
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
if ( hasFaceColor ) {
|
|
|
|
colorIndex = faces[ offset ++ ];
|
|
face.color.setHex( colors[ colorIndex ] );
|
|
|
|
}
|
|
|
|
|
|
if ( hasFaceVertexColor ) {
|
|
|
|
for ( i = 0; i < 3; i ++ ) {
|
|
|
|
colorIndex = faces[ offset ++ ];
|
|
face.vertexColors.push( new THREE.Color( colors[ colorIndex ] ) );
|
|
|
|
}
|
|
|
|
}
|
|
|
|
geometry.faces.push( face );
|
|
|
|
}
|
|
|
|
}
|
|
|
|
};
|
|
|
|
function parseSkin() {
|
|
var influencesPerVertex = ( json.influencesPerVertex !== undefined ) ? json.influencesPerVertex : 2;
|
|
|
|
if ( json.skinWeights ) {
|
|
|
|
for ( var i = 0, l = json.skinWeights.length; i < l; i += influencesPerVertex ) {
|
|
|
|
var x = json.skinWeights[ i ];
|
|
var y = ( influencesPerVertex > 1 ) ? json.skinWeights[ i + 1 ] : 0;
|
|
var z = ( influencesPerVertex > 2 ) ? json.skinWeights[ i + 2 ] : 0;
|
|
var w = ( influencesPerVertex > 3 ) ? json.skinWeights[ i + 3 ] : 0;
|
|
|
|
geometry.skinWeights.push( new THREE.Vector4( x, y, z, w ) );
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if ( json.skinIndices ) {
|
|
|
|
for ( var i = 0, l = json.skinIndices.length; i < l; i += influencesPerVertex ) {
|
|
|
|
var a = json.skinIndices[ i ];
|
|
var b = ( influencesPerVertex > 1 ) ? json.skinIndices[ i + 1 ] : 0;
|
|
var c = ( influencesPerVertex > 2 ) ? json.skinIndices[ i + 2 ] : 0;
|
|
var d = ( influencesPerVertex > 3 ) ? json.skinIndices[ i + 3 ] : 0;
|
|
|
|
geometry.skinIndices.push( new THREE.Vector4( a, b, c, d ) );
|
|
|
|
}
|
|
|
|
}
|
|
|
|
geometry.bones = json.bones;
|
|
|
|
if ( geometry.bones && geometry.bones.length > 0 && ( geometry.skinWeights.length !== geometry.skinIndices.length || geometry.skinIndices.length !== geometry.vertices.length ) ) {
|
|
|
|
console.warn( 'When skinning, number of vertices (' + geometry.vertices.length + '), skinIndices (' +
|
|
geometry.skinIndices.length + '), and skinWeights (' + geometry.skinWeights.length + ') should match.' );
|
|
|
|
}
|
|
|
|
|
|
// could change this to json.animations[0] or remove completely
|
|
|
|
geometry.animation = json.animation;
|
|
geometry.animations = json.animations;
|
|
|
|
};
|
|
|
|
function parseMorphing( scale ) {
|
|
|
|
if ( json.morphTargets !== undefined ) {
|
|
|
|
var i, l, v, vl, dstVertices, srcVertices;
|
|
|
|
for ( i = 0, l = json.morphTargets.length; i < l; i ++ ) {
|
|
|
|
geometry.morphTargets[ i ] = {};
|
|
geometry.morphTargets[ i ].name = json.morphTargets[ i ].name;
|
|
geometry.morphTargets[ i ].vertices = [];
|
|
|
|
dstVertices = geometry.morphTargets[ i ].vertices;
|
|
srcVertices = json.morphTargets [ i ].vertices;
|
|
|
|
for ( v = 0, vl = srcVertices.length; v < vl; v += 3 ) {
|
|
|
|
var vertex = new THREE.Vector3();
|
|
vertex.x = srcVertices[ v ] * scale;
|
|
vertex.y = srcVertices[ v + 1 ] * scale;
|
|
vertex.z = srcVertices[ v + 2 ] * scale;
|
|
|
|
dstVertices.push( vertex );
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if ( json.morphColors !== undefined ) {
|
|
|
|
var i, l, c, cl, dstColors, srcColors, color;
|
|
|
|
for ( i = 0, l = json.morphColors.length; i < l; i ++ ) {
|
|
|
|
geometry.morphColors[ i ] = {};
|
|
geometry.morphColors[ i ].name = json.morphColors[ i ].name;
|
|
geometry.morphColors[ i ].colors = [];
|
|
|
|
dstColors = geometry.morphColors[ i ].colors;
|
|
srcColors = json.morphColors [ i ].colors;
|
|
|
|
for ( c = 0, cl = srcColors.length; c < cl; c += 3 ) {
|
|
|
|
color = new THREE.Color( 0xffaa00 );
|
|
color.setRGB( srcColors[ c ], srcColors[ c + 1 ], srcColors[ c + 2 ] );
|
|
dstColors.push( color );
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
};
|
|
|
|
if ( json.materials === undefined || json.materials.length === 0 ) {
|
|
|
|
return { geometry: geometry };
|
|
|
|
} else {
|
|
|
|
var materials = this.initMaterials( json.materials, texturePath );
|
|
|
|
if ( this.needsTangents( materials ) ) {
|
|
|
|
geometry.computeTangents();
|
|
|
|
}
|
|
|
|
return { geometry: geometry, materials: materials };
|
|
|
|
}
|
|
|
|
};
|