zincjs 2.4.0 → 2.4.1-beta.1

package/src/loaders/JSONLoader.js

@@ -1,17 +1,15 @@
-import * as THREE from 'three';
-import { Face3 } from '../three/Geometry';
-import { Geometry } from '../three/Geometry';
+import * as THREE from 'three/webgpu';
 import { Loader } from '../three/Loader';
 import { VideoHandler } from '../videoHandler';
+import { getColorsRGB } from '../utilities';
 
-const AnimationClip = THREE.AnimationClip;
+const BufferAttribute = THREE.BufferAttribute;
+const BufferGeometry = THREE.BufferGeometry;
 const Color = THREE.Color;
 const DefaultLoadingManager = THREE.DefaultLoadingManager;
 const FileLoader = THREE.FileLoader;
+const Float32BufferAttribute = THREE.Float32BufferAttribute;
 const LoaderUtils = THREE.LoaderUtils;
-const Vector2 = THREE.Vector2;
-const Vector3 = THREE.Vector3;
-const Vector4 = THREE.Vector4;
 
 /**
  * @author mrdoob / http://mrdoob.com/
@@ -116,556 +114,403 @@ Object.assign( JSONLoader.prototype, {
 
 	parse: ( function () {
 
-		function parseModel( json, geometry ) {
+		function isBitSet( value, position ) {
 
-			function isBitSet( value, position ) {
+			return value & ( 1 << 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, hex, normal,
-
-				uvLayer, uv, u, v,
-
-				faces = json.faces,
-				vertices = json.vertices,
-				normals = json.normals,
-				colors = json.colors,
-
-				scale = json.scale,
+		}
 
-				nUvLayers = 0;
+		//Walks json.faces once, decoding each triangle (quads are split into two)
+		//into a flat vertex-index list plus a parallel per-triangle materialIndex,
+		//in exactly the order the legacy Face3-based parser used to push faces -
+		//that order is what computeGroups() below depends on.
+		function parseFaces( json ) {
 
+			const faces = json.faces;
 
+			let nUvLayers = 0;
 			if ( json.uvs !== undefined ) {
 
-				// disregard empty arrays
-
-				for ( i = 0; i < json.uvs.length; i ++ ) {
+				for ( let 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 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;
-
-      if (json.uvs) {
-
-        for ( i = 0; i < json.uvs.length; i ++ ) {
-
-          geometry.uvs[i] = [];
-
-          for ( let k = 0; k < json.uvs[i].length ; k++ ) {
-
-            geometry.uvs[i][k] = json.uvs[i][k];
-
-          }
-
-        }
-
-      }
-
-      if (normals) {
-
-        for ( i = 0; i < normals.length; i ++ ) {
-
-          geometry.normals[i] = normals[i];
-
-        }
-
-      }
-
-      if (colors) {
-
-        for ( i = 0; i < colors.length; i ++ ) {
-
-          geometry.colors[i] = colors[i];
-
-        }
-
-      }
+			const indices = [];
+			const materialIndices = [];
 
+			let offset = 0;
+			const zLength = faces.length;
 
 			while ( offset < zLength ) {
 
-				type = faces[ offset ++ ];
+				const 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 );
+				const isQuad = isBitSet( type, 0 );
+				const hasMaterial = isBitSet( type, 1 );
+				const hasFaceVertexUv = isBitSet( type, 3 );
+				const hasFaceNormal = isBitSet( type, 4 );
+				const hasFaceVertexNormal = isBitSet( type, 5 );
+				const hasFaceColor = isBitSet( type, 6 );
+				const hasFaceVertexColor = isBitSet( type, 7 );
 
-				// console.log("type", type, "bits", isQuad, hasMaterial, hasFaceVertexUv, hasFaceNormal, hasFaceVertexNormal, hasFaceColor, hasFaceVertexColor);
+				let a, b, c;
 
 				if ( isQuad ) {
 
-					faceA = new Face3();
-					faceA.a = faces[ offset ];
-					faceA.b = faces[ offset + 1 ];
-					faceA.c = faces[ offset + 3 ];
-
-					faceB = new Face3();
-					faceB.a = faces[ offset + 1 ];
-					faceB.b = faces[ offset + 2 ];
-					faceB.c = faces[ offset + 3 ];
+					const v0 = faces[ offset ];
+					const v1 = faces[ offset + 1 ];
+					const v2 = faces[ offset + 2 ];
+					const v3 = faces[ offset + 3 ];
 
 					offset += 4;
 
+					let materialIndex = 0;
 					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 Vector2( u, v );
-
-								if ( j !== 2 ) geometry.faceVertexUvs[ i ][ fi ].push( uv );
-								if ( j !== 0 ) geometry.faceVertexUvs[ i ][ fi + 1 ].push( uv );
-
-							}
-
-						}
+						offset += nUvLayers * 4;
 
 					}
 
-					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;
+					if ( hasFaceNormal ) offset += 1;
+					if ( hasFaceVertexNormal ) offset += 4;
+					if ( hasFaceColor ) offset += 1;
+					if ( hasFaceVertexColor ) offset += 4;
 
-							normal = new Vector3(
-								normals[ normalIndex ++ ],
-								normals[ normalIndex ++ ],
-								normals[ normalIndex ]
-							);
+					indices.push( v0, v1, v3 );
+					materialIndices.push( materialIndex );
 
+					indices.push( v1, v2, v3 );
+					materialIndices.push( materialIndex );
 
-							if ( i !== 2 ) faceA.vertexNormals.push( normal );
-							if ( i !== 0 ) faceB.vertexNormals.push( normal );
+					continue;
 
-						}
+				}
 
-					}
+				a = faces[ offset ++ ];
+				b = faces[ offset ++ ];
+				c = faces[ offset ++ ];
 
+        //A hack to get things going
+        if (!b) b = a;
+        if (!c) c = b;
 
-					if ( hasFaceColor ) {
+				let materialIndex = 0;
+				if ( hasMaterial ) {
 
-						colorIndex = faces[ offset ++ ];
-						hex = colors[ colorIndex ];
+					materialIndex = faces[ offset ++ ];
 
-						faceA.color.setHex( hex );
-						faceB.color.setHex( hex );
+				}
 
-					}
+				if ( hasFaceVertexUv ) {
 
+					offset += nUvLayers * 3;
 
-					if ( hasFaceVertexColor ) {
+				}
 
-						for ( i = 0; i < 4; i ++ ) {
+				if ( hasFaceNormal ) offset += 1;
+				if ( hasFaceVertexNormal ) offset += 3;
+				if ( hasFaceColor ) offset += 1;
+				if ( hasFaceVertexColor ) offset += 3;
 
-							colorIndex = faces[ offset ++ ];
-							hex = colors[ colorIndex ];
+				indices.push( a, b, c );
+				materialIndices.push( materialIndex );
 
-							if ( i !== 2 ) faceA.vertexColors.push( new Color( hex ) );
-							if ( i !== 0 ) faceB.vertexColors.push( new Color( hex ) );
+			}
 
-						}
+			return { indices, materialIndices };
 
-					}
+		}
 
-					geometry.faces.push( faceA );
-					geometry.faces.push( faceB );
+		//Material-index run-length groups over the triangle list, matching
+		//the legacy Geometry.prototype.computeGroups() this replaced.
+		function computeGroups( materialIndices ) {
 
-				} else {
+			const groups = [];
+			let group;
+			let materialIndex = undefined;
 
-					face = new Face3();
-					face.a = faces[ offset ++ ];
-					face.b = faces[ offset ++ ];
-					face.c = faces[ offset ++ ];
+			for ( let i = 0; i < materialIndices.length; i ++ ) {
 
-          //A hack to get things going
-          if (!face.b) face.b = face.a;
-          if (!face.c) face.c = face.b;
+				if ( materialIndices[ i ] !== materialIndex ) {
 
+					materialIndex = materialIndices[ i ];
 
-					if ( hasMaterial ) {
+					if ( group !== undefined ) {
 
-						materialIndex = faces[ offset ++ ];
-						face.materialIndex = materialIndex;
+						group.count = ( i * 3 ) - group.start;
+						groups.push( group );
 
 					}
 
-					// to get face <=> uv index correspondence
-
-					fi = geometry.faces.length;
-
-					if ( hasFaceVertexUv ) {
-
-						for ( i = 0; i < nUvLayers; i ++ ) {
+					group = { start: i * 3, materialIndex: materialIndex };
 
-							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 ];
+			if ( group !== undefined ) {
 
-								uv = new Vector2( u, v );
+				group.count = ( materialIndices.length * 3 ) - group.start;
+				groups.push( group );
 
-								geometry.faceVertexUvs[ i ][ fi ].push( uv );
+			}
 
-							}
+			return groups;
 
-						}
+		}
 
-					}
+		//Computes per-vertex normals for a morph target's position set by
+		//reusing the shared index and the standard BufferGeometry algorithm,
+		//instead of hand-rolling face/vertex normal averaging.
+		function computeMorphNormalAttribute( positionAttribute, indices ) {
 
-					if ( hasFaceNormal ) {
+			const scratch = new BufferGeometry();
+			scratch.setIndex( indices );
+			scratch.setAttribute( 'position', positionAttribute );
+			scratch.computeVertexNormals();
 
-						normalIndex = faces[ offset ++ ] * 3;
+			const normalAttribute = scratch.getAttribute( 'normal' );
+			normalAttribute.name = positionAttribute.name;
+			return normalAttribute;
 
-						face.normal.set(
-							normals[ normalIndex ++ ],
-							normals[ normalIndex ++ ],
-							normals[ normalIndex ]
-						);
+		}
 
-					}
+		function parseMorphTargets( json, scale ) {
 
-					if ( hasFaceVertexNormal ) {
+			const morphPositions = [];
 
-						for ( i = 0; i < 3; i ++ ) {
+			if ( json.morphTargets !== undefined ) {
 
-							normalIndex = faces[ offset ++ ] * 3;
+				for ( let i = 0, l = json.morphTargets.length; i < l; i ++ ) {
 
-							normal = new Vector3(
-								normals[ normalIndex ++ ],
-								normals[ normalIndex ++ ],
-								normals[ normalIndex ]
-							);
+					const srcVertices = json.morphTargets[ i ].vertices;
+					const array = new Float32Array( srcVertices.length );
 
-							face.vertexNormals.push( normal );
+					for ( let v = 0, vl = srcVertices.length; v < vl; v ++ ) {
 
-						}
+						array[ v ] = srcVertices[ v ] * scale;
 
 					}
 
+					const attribute = new Float32BufferAttribute( array, 3 );
+					attribute.name = json.morphTargets[ i ].name;
+					morphPositions.push( attribute );
 
-					if ( hasFaceColor ) {
+				}
 
-						colorIndex = faces[ offset ++ ];
-						face.color.setHex( colors[ colorIndex ] );
+			}
 
-					}
+			const morphNormals = [];
 
+			if ( json.morphNormals !== undefined ) {
 
-					if ( hasFaceVertexColor ) {
+				for ( let i = 0, l = json.morphNormals.length; i < l; i ++ ) {
 
-						for ( i = 0; i < 3; i ++ ) {
+					if ( morphPositions[ i ] ) {
 
-							colorIndex = faces[ offset ++ ];
-							face.vertexColors.push( new Color( colors[ colorIndex ] ) );
+						const srcNormals = json.morphNormals[ i ].normals;
+						const array = Float32Array.from( srcNormals );
 
-						}
+						const attribute = new Float32BufferAttribute( array, 3 );
+						attribute.name = morphPositions[ i ].name;
+						morphNormals[ i ] = attribute;
 
 					}
 
-					geometry.faces.push( face );
-
 				}
 
 			}
 
+			return { morphPositions, morphNormals };
+
 		}
 
-		function parseSkin( json, geometry ) {
+		//Reproduces copyMorphColorsToIndexedBufferGeometry()/getColorsRGB() from
+		//src/utilities.js exactly (that path has no test coverage today, so the
+		//arithmetic - odd as some of it looks - is ported unchanged rather than
+		//redesigned here).
+		function parseMorphColors( json ) {
 
-			var influencesPerVertex = ( json.influencesPerVertex !== undefined ) ? json.influencesPerVertex : 2;
+			if ( json.morphColors === undefined ) return undefined;
 
-			if ( json.skinWeights ) {
+			const morphAttributes = [];
 
-				for ( var i = 0, l = json.skinWeights.length; i < l; i += influencesPerVertex ) {
+			for ( let i = 0, l = json.morphColors.length; i < l; i ++ ) {
 
-					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;
+				const srcColors = json.morphColors[ i ].colors;
+				const colors = [];
 
-					geometry.skinWeights.push( new Vector4( x, y, z, w ) );
+				for ( let c = 0, cl = srcColors.length; c < cl; c += 3 ) {
 
-				}
+					const color = new Color( 0xffaa00 );
+					color.setRGB( srcColors[ c ], srcColors[ c + 1 ], srcColors[ c + 2 ] );
+					colors.push( color );
 
-			}
-
-			if ( json.skinIndices ) {
+				}
 
-				for ( var i = 0, l = json.skinIndices.length; i < l; i += influencesPerVertex ) {
+				const colorArray = [];
 
-					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;
+				for ( let j = 0, jl = colors.length * 3; j < jl; j ++ ) {
 
-					geometry.skinIndices.push( new Vector4( a, b, c, d ) );
+					const rgb = getColorsRGB( colors, j );
+					colorArray.push( rgb[ 0 ], rgb[ 1 ], rgb[ 2 ] );
 
 				}
 
-			}
-
-			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.' );
+				const attribute = new Float32BufferAttribute( colorArray, 3 );
+				attribute.name = json.morphColors[ i ].name;
+				morphAttributes.push( attribute );
 
 			}
 
-		}
-
-		function parseMorphing( json, geometry ) {
-
-			var scale = json.scale;
+			return morphAttributes;
 
-			if ( json.morphTargets !== undefined ) {
+		}
 
-				for ( var i = 0, l = json.morphTargets.length; i < l; i ++ ) {
+		return function parse( json, texturePath ) {
 
-					geometry.morphTargets[ i ] = {};
-					geometry.morphTargets[ i ].name = json.morphTargets[ i ].name;
-					geometry.morphTargets[ i ].vertices = [];
+			if ( json.data !== undefined ) {
 
-					var dstVertices = geometry.morphTargets[ i ].vertices;
-					var srcVertices = json.morphTargets[ i ].vertices;
+				// Geometry 4.0 spec
+				json = json.data;
 
-					for ( var v = 0, vl = srcVertices.length; v < vl; v += 3 ) {
+			}
 
-						var vertex = new Vector3();
-						vertex.x = srcVertices[ v ] * scale;
-						vertex.y = srcVertices[ v + 1 ] * scale;
-						vertex.z = srcVertices[ v + 2 ] * scale;
+			const scale = ( json.scale !== undefined ) ? 1.0 / json.scale : 1.0;
 
-						dstVertices.push( vertex );
+			const srcVertices = json.vertices;
+			const vertexCount = srcVertices.length / 3;
 
-					}
+			const positions = new Float32Array( srcVertices.length );
+			for ( let i = 0, l = srcVertices.length; i < l; i ++ ) {
 
-				}
+				positions[ i ] = srcVertices[ i ] * scale;
 
 			}
 
-			if ( json.morphNormals !== undefined ) {
-
-				for ( var i = 0, l = json.morphNormals.length; i < l; i ++ ) {
+			const geometry = new BufferGeometry();
+			geometry.setAttribute( 'position', new BufferAttribute( positions, 3 ) );
 
-          if (geometry.morphTargets[ i ]) {
+			if ( json.normals !== undefined && json.normals.length > 0 ) {
 
-            geometry.morphTargets[ i ].normals = [];
+				geometry.setAttribute( 'normal', new BufferAttribute( Float32Array.from( json.normals ), 3 ) );
 
-            var dstNormals = geometry.morphTargets[ i ].normals;
-            var srcNormals = json.morphNormals[ i ].normals;
+			}
 
-            for ( var v = 0, vl = srcNormals.length; v < vl; v += 3 ) {
+			if ( json.uvs !== undefined ) {
 
-              var normals = new Vector3();
-              normals.x = srcNormals[ v ];
-              normals.y = srcNormals[ v + 1 ] ;
-              normals.z = srcNormals[ v + 2 ] ;
+				if ( json.uvs[ 0 ] && json.uvs[ 0 ].length > 0 ) {
 
-              dstNormals.push( normals );
+					geometry.setAttribute( 'uv', new BufferAttribute( Float32Array.from( json.uvs[ 0 ] ), 2 ) );
 
-            }
+				}
 
-            geometry.morphNormalsReady = true;
+				if ( json.uvs[ 1 ] && json.uvs[ 1 ].length > 0 ) {
 
-          }
+					geometry.setAttribute( 'uv2', new BufferAttribute( Float32Array.from( json.uvs[ 1 ] ), 2 ) );
 
 				}
 
 			}
 
-			if ( json.morphColors !== undefined ) {
-
-				var i, l, c, cl, dstColors, srcColors, color;
+			if ( json.colors !== undefined && json.colors.length > 0 ) {
 
-				for ( i = 0, l = json.morphColors.length; i < l; i ++ ) {
+				const colorArray = new Float32Array( json.colors.length * 3 );
 
-					geometry.morphColors[ i ] = {};
-					geometry.morphColors[ i ].name = json.morphColors[ i ].name;
-					geometry.morphColors[ i ].colors = [];
+				for ( let i = 0, l = json.colors.length; i < l; i ++ ) {
 
-					dstColors = geometry.morphColors[ i ].colors;
-					srcColors = json.morphColors[ i ].colors;
+					const color = new Color( json.colors[ i ] );
+					colorArray[ i * 3 ] = color.r;
+					colorArray[ i * 3 + 1 ] = color.g;
+					colorArray[ i * 3 + 2 ] = color.b;
 
-					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 );
+				geometry.setAttribute( 'color', new BufferAttribute( colorArray, 3 ) );
 
-					}
+			} else {
 
-				}
+				const colorArray = new Float32Array( vertexCount * 3 ).fill( 1.0 );
+				geometry.setAttribute( 'color', new BufferAttribute( colorArray, 3 ) );
 
 			}
 
-		}
-
-		function parseAnimations( json, geometry ) {
+			const { indices, materialIndices } = parseFaces( json );
 
-			var outputAnimations = [];
+			if ( indices.length > 0 ) {
 
-			// parse old style Bone/Hierarchy animations
-			var animations = [];
+				geometry.setIndex( indices );
+				geometry.groups = computeGroups( materialIndices );
 
-			if ( json.animation !== undefined ) {
+			}
 
-				animations.push( json.animation );
+			const { morphPositions, morphNormals } = parseMorphTargets( json, scale );
 
-			}
+			if ( morphPositions.length > 0 ) {
 
-			if ( json.animations !== undefined ) {
+				geometry.morphAttributes.position = morphPositions;
 
-				if ( json.animations.length ) {
+				const resolvedMorphNormals = [];
 
-					animations = animations.concat( json.animations );
+				for ( let i = 0; i < morphPositions.length; i ++ ) {
 
-				} else {
+					if ( morphNormals[ i ] ) {
 
-					animations.push( json.animations );
+						resolvedMorphNormals.push( morphNormals[ i ] );
 
-				}
+					} else if ( indices.length > 0 ) {
 
-			}
+						resolvedMorphNormals.push( computeMorphNormalAttribute( morphPositions[ i ], indices ) );
 
-			for ( var i = 0; i < animations.length; i ++ ) {
+					}
 
-				var clip = AnimationClip.parseAnimation( animations[ i ], geometry.bones );
-				if ( clip ) outputAnimations.push( clip );
+				}
 
-			}
+				if ( resolvedMorphNormals.length > 0 ) {
 
-			// parse implicit morph animations
-			if ( geometry.morphTargets ) {
+					geometry.morphAttributes.normal = resolvedMorphNormals;
 
-				// TODO: Figure out what an appropraite FPS is for morph target animations -- defaulting to 10, but really it is completely arbitrary.
-				var morphAnimationClips = AnimationClip.CreateClipsFromMorphTargetSequences( geometry.morphTargets, 10 );
-				outputAnimations = outputAnimations.concat( morphAnimationClips );
+				}
 
 			}
 
-			if ( outputAnimations.length > 0 ) geometry.animations = outputAnimations;
+			const morphColorAttributes = parseMorphColors( json );
 
-		}
+			if ( morphColorAttributes !== undefined ) {
 
-		return function parse( json, texturePath ) {
+				geometry.morphAttributes.color = morphColorAttributes;
 
-			if ( json.data !== undefined ) {
+				//Support cases where only morphColorAttributes is available
+        //without morphPositionAttributes
+				if ( geometry.morphAttributes.position === undefined ) {
 
-				// Geometry 4.0 spec
-				json = json.data;
+					const basePosition = geometry.getAttribute( 'position' );
 
-			}
+					geometry.morphAttributes.position = morphColorAttributes.map( ( colorAttribute ) => {
 
-			if ( json.scale !== undefined ) {
+						const positionAttribute = new BufferAttribute( basePosition.array, basePosition.itemSize );
 
-				json.scale = 1.0 / json.scale;
+						positionAttribute.name = colorAttribute.name;
 
-			} else {
+						return positionAttribute;
 
-				json.scale = 1.0;
+					} );
 
-			}
+				}
 
-			var geometry = new Geometry();
-			geometry.morphColors = [];
-			parseModel( json, geometry );
-			parseSkin( json, geometry );
-			parseMorphing( json, geometry );
-			parseAnimations( json, geometry );
+			}
 
-			geometry.computeFaceNormals();
+			geometry.computeBoundingBox();
 			geometry.computeBoundingSphere();
 
 			if ( json.materials === undefined || json.materials.length === 0 ) {